# Terminal, the app that lends your keyboard to the shell

> Measured on a live Mac: a 2.4 MB app that has hosted six shells for a month, the login middleman between them, the zsh engine, and the one Apple note that says don't delete it.

Source: https://www.ribbonmac.com/guides/terminal-mac · Updated 2026-11-19

It is the app people point at when they say "the command line", and it is also the most misunderstood app on the Mac, because the thing people think it is, the part that answers back, is not inside it. Terminal is the window. The answering is done by a shell it starts for you. The difference matters the first time something goes wrong, and it takes one command to see.

This page is a measurement of Terminal on a Mac running macOS 27.0.1 with 30 days of uptime, 10 cores, 32 GB of memory. Every fact below was read off the system, and the app happened to be running, which made it measurable live. Nothing was installed, nothing was killed, no setting was written.

## Apple's one-line answer, and the part under it

There is a whole user guide book for this app, twenty-four articles with titles like Execute commands and run tools and Intro to shell scripts, and its first real page is called What is Terminal on Mac. Its definition:

> "Terminal is an app for advanced users and developers that lets you communicate with the Mac operating system using a command-line interface (CLI). You enter commands and scripts (called shell scripts) to perform tasks on your Mac."

The same page draws the line this page is about. A typical Mac app gives you buttons and menus, a graphical user interface. Terminal gives you a prompt, and "these code commands (and multiple commands sent as scripts) are executed by a shell, which is a user interface to the UNIX operating system." Terminal supplies excellent access to the input and output of UNIX shells, in the guide's own words, including BASH and ZSH. Note what that sentence does not do: name a default. Which shell you actually get is not in the guide at all. It is in your account record, three sections down.

## One tab, one teletype, proven live

The app was running on the measured Mac, pid 1644, and its family tree is the whole story in one picture:

```
1644  Terminal.app          (the window)
 1814  login   ttys000      (the middleman)
 1825  -zsh    ttys000      (the engine)
 1817  login   ttys001
 1874  -zsh    ttys001
 1818  login   ttys002
 1875  -zsh    ttys002
 1819  login   ttys003
 1876  -zsh    ttys003
 3590  login   ttys004
 3591  -zsh    ttys004
 3604  login   ttys009
       -zsh    ttys009
```

Six tabs, six shells. Four of them were started in the same minute, thirty days before the reading, which is the minute Terminal itself was launched. Two more arrived nine days later. Every tab gets its own login process, and every login gets its own teletype, the ttys000-style name in the middle column. A teletype is a pretend paper terminal, and it is a real object in the system: programs ask the question "am I talking to a teletype" and change behaviour on the answer. The shell doing the measuring for this page was not given one, which is why `tty` answered "not a tty" and `ps` printed a bare question mark where the six real ones print names.

The dash in front of `-zsh` is data too. It is how ps writes a login shell, one that ran the system's login profiles on the way up, and those profiles are small readable files: /etc/profile at 189 bytes, /etc/zprofile at 304, /etc/zshrc at 3,191. The zprofile's whole job, verbatim from the file, is to set a fallback language and hand your PATH to `/usr/libexec/path_helper`, which is why every fresh tab knows where the standard commands live.

So when a tab prints your prompt and waits, that is zsh waiting, not Terminal. When a command floods the screen with output, the app is doing the scrolling and the shell is doing the flooding. And when someone says "the terminal is using all my CPU", the process to read is usually the one it is parenting.

## The birth certificate

The bundle facts, all read from the app itself:

| Fact | Value |
|---|---|
| Path | /System/Applications/Utilities/Terminal.app |
| Binary size | 2,401,664 bytes (2.4 MB) |
| Whole bundle | 3.5 MB, 90 items in Resources |
| Bundle id | com.apple.Terminal |
| Version | 2.15 (488) |
| Architectures | arm64e only, no Intel slice |
| Minimum system | macOS 27.0 |
| Copyright | (c) 1991-2026 Apple Inc. |

That copyright string is the oldest measured in this series. The Dock's reads 2000-2010, Time Machine's reads 2007-2025, and Terminal's starts in 1991, nine years before the Dock's string even picks up. The app has been rewritten many times since; the string is inherited, the way family names are. Forty-three language folders ship beside it, and the binary is signed by Apple with a platform identifier, part of the OS image, which is the technical reason there is no download: the App Store has nothing to sell that the system volume does not already contain.

## The engine, and the six it could have used

Which shell answers your prompt is an account setting, not a Terminal setting:

```
$ dscl . -read /Users/chethankumar UserShell
UserShell: /bin/zsh
```

zsh 5.9, built for arm64-apple-darwin26.0. The list of alternatives sits in /etc/shells, seven of them: /bin/bash, /bin/csh, /bin/dash, /bin/ksh, /bin/sh, /bin/tcsh, /bin/zsh. Bash is the interesting one. It is still shipped, still works, and reports itself as GNU bash version 3.2.57, a line whose second row still prints "Copyright (C) 2007 Free Software Foundation, Inc." A shell frozen in the late 2000s sitting beside one built for this decade's hardware is the whole default-shell story compressed into two version strings.

None of these are languages, which answers a question the autocomplete keeps asking. A command line is zsh reading a line, finding a program in /bin or /usr/bin, and starting it. The programs are the vocabulary: on the measured Mac, /usr/bin/caffeinate is 217,632 bytes and its manual line is "prevent the system from sleeping on behalf of a utility". Type `man caffeinate` and the same manual system this series uses for Mac internals opens for you, no website needed.

## It volunteers for anything you double-click

Inside the app's Info.plist is a document-type table, and Terminal registers as a handler for some unusual file types:

- "Terminal session" and "Terminal settings", the .term and .terminal files that save window setups
- "Terminal shell script", with the role Shell
- public.unix-executable, also with the role Shell

That last row is the one with consequences. Any file marked as a raw Unix executable, the kind that has no owning app, can be handed to Terminal, which will open a window and run it. It is why some downloaded tools "just open in Terminal" when double-clicked, and why a file that arrives as an executable should be read before it is clicked. The app is not judging. The role table says it accepts, and it does.

## The font it carries for itself

The autocomplete also asks what font Terminal uses, and the answer ships inside the bundle: SF Mono, its own copy, twelve OpenType cuts from Light through Heavy plus two TrueType terminals-only variants, in a Fonts folder the Info.plist points at by name. The app does not depend on your font library. It brings the typewriter.

On the measured Mac the preferences add a small human detail. The default and startup profile is set to "Clear Dark", and one key records LastTerminalStartTime as 2026-10-20 07:27:42, the last time the app was launched, a month before this reading. The four tabs from the launch minute are the same session, still open, still holding their shells.

## A door other apps can knock on

Beside the fonts sits Terminal.sdef, the app's scripting dictionary, and its headline command is literally named "do script": tell Terminal to open a window and type. This is how automation tools, build scripts and other apps drive the command line without borrowing your keyboard. Apple gives it a guide page of its own, Automate tasks using AppleScript and Terminal, which is the polite public face of the same dictionary.

## What the guide says, and what it leaves to the system

The twenty-four-article book is a good one, and unusually candid for an app manual: it explains redirection, window groups, scrollback limits, making a file executable, even running scripts under launchd. Its What is Terminal page also carries the note quoted in the FAQ above, recommending you not delete the app, which is not something a manual says about an app you could simply re-download.

For all that, the machinery stays under the water line. The book never says which shell is the default, never mentions a process id, never shows you the family tree this page opened with. All of that is real and readable, one `ps` away, which is the bet this whole series makes.

## The bill

| Reading | Value |
|---|---|
| Memory (RSS) | 18,256 KB |
| CPU right now | 0.0 percent |
| Uptime | 30 days 1 hour, six tabs |
| Processor time | 13 minutes 41 seconds |
| Per day | about 27 seconds, across all six shells |
| User | the account, not root |
| Parent | pid 1, launchd, like every app |

Twenty-seven seconds a day to keep six command lines alive is close to free, and the memory is a rounding error. When the app's numbers climb, look at its children first: the six shells, and whatever they are running, are billed upstairs but paid downstairs. And treat the sessions gently. The Dock can be killed and bounces back; Terminal's tabs are the work itself, and closing the app closes the shells, the running commands and the scrollback with them. The window is an app. The shells are the machine.

## FAQ

### What is Terminal on my Mac?

An app, the same kind of thing as Safari or Notes, that lives in the Utilities folder inside your Applications folder and shows a window you type lines of text into. On the measured Mac it is pid 1644, a 2,401,664 byte binary inside a 3.5 MB bundle at /System/Applications/Utilities/Terminal.app, running as the ordinary user account, not root. The important distinction is that Terminal does not run your commands itself. It draws the window, and starts a shell under each tab, and the shell reads what you type. Apple's own user guide opens with the same split: Terminal is an app for communicating with the Mac through a command line, and the commands are executed by a shell, which Apple describes as a user interface to the UNIX operating system.

### What shell does my Mac use, and what language do I type?

The default shell is zsh, version 5.9 on the measured Mac, and the fact lives in your own account record: dscl reads UserShell: /bin/zsh. The file /etc/shells lists all seven Apple ships: bash, csh, dash, ksh, sh, tcsh and zsh. Bash is still there at version 3.2.57, and its own banner still carries a 2007 copyright line, which is the quiet story of why zsh took over as the default. What you type is not one language: commands are separate programs in /bin and /usr/bin. Caffeinate, for instance, is a 217 KB program whose manual line reads prevent the system from sleeping on behalf of a utility. To read any of their manuals you type man followed by the name, which is the same manual system this series measures Mac internals with.

### How do I open Terminal on a Mac, or download it?

You open it, you never download it. It ships inside macOS itself, on the sealed system volume, and the copy in /System/Applications/Utilities is the only copy. The two ordinary routes are the Utilities folder and Spotlight: press Command-Space, type Terminal, press Return. Apple's user guide has a page called Open or quit Terminal covering the same routes. There is no installer, no separate download and no in-app purchase, and the app declares a minimum system version of 27.0, which is just the OS restating that it comes with the OS.

### Is Terminal safe, and can I delete it?

The app is safe and signed by Apple as part of the system; what it runs is whatever you or a script you paste tells it to, with the full rights of your account, which is why the honest answer is that Terminal is exactly as safe as the commands given to it. On deleting it, Apple's user guide carries a note verbatim: Terminal is also useful when troubleshooting issues with your Mac with Apple Support. It's recommended that you do not delete it. The costume check is the same as for every process in this series: the genuine app runs from /System/Applications/Utilities/Terminal.app, and anything named Terminal running from a downloads folder or a temp folder is not this app.

### Why is Terminal using memory, and can it slow my Mac?

The measured bill is small: the app held 18,256 KB of memory, 0.0 percent CPU at the moment of reading, and 13 minutes 41 seconds of processor time across 30 days, which works out to about 27 seconds a day. Each tab adds one shell, which costs a few more megabytes, so a person with six tabs is running six shells, and that is still rounding-error territory on any Mac made this decade. When Terminal shows real CPU, the app is almost never the cause: the column is charging it for the command running in the tab, a build, a sync loop, a script that never exits. Read the tab, not the app. And unlike the Dock, which restarts harmlessly, quitting Terminal ends its shells and their histories, so close the tab you are done with instead.
