Update 2026
This post is now well over a decade old. And my understanding of these topics has since improved, and deepened. What I wrote previosuly still largely holds-up but some further clarifications could be added, so I’m adding those in an updated “tl;dr” style glossary here at the top:
Glossary
| Noun | Definition | Examples |
|---|---|---|
| Terminal | Collection of Remote Hardware I/O components for a user to control/interact with a Computer System. | DEC VT100, Teletype Model 33, HP t5700, Bloomberg Terminal |
| Terminal Emulator | A comptuer program that can behave like a physical Terminal, but runs on a computer. Some are desinged to connect to the local machine, and others to remote computers, or both. | xterm, macOS Terminal, PuTTY, Minicom |
| Hardware Terminal | Synonym for Terminal, but which helps disambiguate from Terminal Emulators (which are now more commonly used). | See “Terminal” |
| Console | General term for both Terminals and I/O components directly attached to a computer. Sometimes used in other analogous contexts, for programs that provide low-level back-channel controls to other programs. | Your Monitor, Keyboard, and other peripherials attached to your computer, or a remote Hardware Terminal. |
| Video Terminal | A type of Terminal with a video screen for displaying output (as well as for echoing input). | DEC VT100 |
| Teletype | Old typewriter-style Terminal which preceded Video Terminals and used paper for displaying output (as well as echoing input). | Teletype Model 33 |
| TTY | Abbreviation of “Teletype” which is used for the Operating System’s abstract representation of a “Console” session. | The session within which your OS’s User Interface shell is running right now, or used by a Hardware Terminal. |
| Pseudo Terminal (pty/pts) | A type of TTY created for Terminal Emulator connection on the local system, or some other non-hardware I/O abstraction. Also called a Pseudo Teletype. | The sessions displayed within Terminal Emulators |
| Virtual Teletype (vty) | Similar to a Pseudo Teletype (pty) but on light weight embedded systems like network hardware. | Session used when connecting to a router via Telnet. |
| Terminal Multiplexer | A Terminal Emulator program that display multiple emulator sessions using a single emulator display. While many emulators support multiple sessions, a Multiplexer differs by not relying on the features of the shell that launched it (such as tabs or window splits) to handle displaying or switching between multiple sessions. | GNU Screen, tmux |
| Dumb Terminal | A kind of Hardware Terminal with no local processing power | DEC VT100 |
| Thin Client | A kind of Hardware Terminal with minimal local processing power | HP t5700 |
| Thick/Fat/Rich Client | A kind of Hardware Terminal with ample local processing power, often this is a regular desktop workstation running specialized software which may be synonymous with the client. | Various Ctrix Desktop as a Service Products |
| Shell | A computer program meant to facilitate user interaction with the Computer’s Operating System and other programs. Provides the User Interface (either Graphical or Text based). | Bourne Shell (sh), X11 |
| Remote Shell | A shell programming running on a remote computer, connected to over a remote/network transport protocol (e.g. telnet, ssh, vnc, rdp) |
Any shell running over a remote protocol |
Original Post
> “OK, now open up your Command Prompt.”
> “My what? You want me to edit my PS1 Variable?”
> “No… open up the console…”
> “What? How did this become a hardware issue? I don’t have a screw driver.”
> “No! Open up the terminal program you use to access your Operating System’s Command Line Interface!!”
> “Oooh, the Terminal? You mean my Terminal Emulator?”
> “Yeah, whatever.”
Console, Terminal, Terminal Emulator, Command Prompt, Shell, CLI, and maybe others I haven’t heard of. All of these are terms people try to use for the little window that opens up where you can type commands to your Operating System and other programs. The problem is: most of these terms have multiple meanings, and end up getting used interchangeably; causing a bit of confusion.
The purpose of this post is to ‘try’ and clear up some of the confusion that surrounds these terms.
To start off, it’s important to understand a few basic things about Operating Systems. An Operating System is usually a term that carries it’s own level of ambiguity, but for the sake of this post we will define it as such:
Operating System: A governing program (or collection of programs) which make raw hardware usable for other programs. Primarily comprised of ‘The Kernel’
Layered on top of the Operating System are other programs, including those which allow a user to interact with the Operating System. These are called “Shells”. The term Shell is usually associated with text only user interfaces (or Command Line Interfaces) such as the Bourne Shell (sh); the Bourne Again Shell (bash); the C Shell (csh); the Korn Shell (ksh) and others, but also appropriately apply to Graphical User Interfaces (GUIs) such as Aero & Metro (Windows), Aqua (OS X), and Gnome, KDE, XFCE, and etc. (Linux).
In early computing, before Graphical Shells became common, most computers would boot straight into a text based shell (which many users remember from the days of DOS), and that is still common for Unix/Linux based servers today.
However, due to the inherent power and flexibility which can be found in CLI shells, most GUI shells come prepackaged with a program that can provide access to a CLI shell (from within a window). The name for these programs is where the ambiguity really sets in.
In the Windows world, this confusion doesn’t really exist (to the same extent, at least). The program is called the Command Prompt (though some people mistakenly call it DOS). The exact details of it (or Windows in general) don’t really interest me. So let’s move on.
In the Unix world, the Operating System usually supports about 7 shell nodes, called TTY’s, and nearly unlimited virtual TTYs (or vTTY’s). What TTY precisely stands for has it’s own share of debate, but originally meant Teletype (and today is generally called Terminal Type). The this term dates back to when computers were very large and usually accessed from machines not physically attached to the computer, called Teletype machines (which resembled glorified Typewriters). These machines were “Terminals” through which users could interact with the computer. Eventually these teletype machines were replaced with more advanced Terminals which had screens. These terminals were either classified as “Dumb” or “Smart” depending on whether they had any computing power of their own, or only facilitated basic communication with the main computer.
The term Console became associated with these terminals as well, although it more precisely refers to the physical input and output devices which the user sits at (whether directly attached to the computer or belonging to a terminal).
As computers became smaller and cheaper, however, the need for sharing a single machine slowly gave way to the idea of workstations and personal computers. This eventually lead to the demise of the physical terminal. (While consoles continued to still be attached directly to the machines)
On today’s modern *Nixes your main shell (GUI or CLI) still runs in a TTY, and you can usually access the other true TTY’s via holding Ctrl+Alt and the corresponding Function Key. However when using a GUI shell in your primary TTY, it’s usually considered a bit of a hassel to switch back and forth between TTY’s to access a CLI shell. Additionally you are also limited to the number of true TTYs available on your system. In order to overcome this challenge, Terminal Emulators were implemented.
A Terminal Emulator is a program which runs inside of a GUI shell which emulates a physical terminal attached to the computer. Instead of using TTY’s these emulators attach at vTTY’s and can leverage all the features of the GUI to manage multiple CLI sessions. Due to their power and flexibility these have naturally become the main way in which people interact with CLI shells on their computers.
A lot of the confusion in these terms stems from the fact that most users are unfamiliar with the history of these terms and so use the terms which fits best with their understanding. Additionally confusion has crept in due to the names given to some programs on the system (for instance, most Terminal Emulator programs are just called ‘Terminal’, and OS X’s log viewer is called ‘Console’).
There are also other programs which can be used to access a shell on a computer using a TCP or UDP network connection. These programs are often use specific protocols and can sometimes even be run from within a Terminal Emulator. Most notable among these are: SSH (Secure Shell), Telnet, & NoMachine (for GUI shells).
Finally I should point out that the Windows Command Prompt has also contributed to its own fair share of confusion. The term Command Prompt appropriately refers to the actual text on the screen prompting the user that the shell is ready to accept a command. In the *Nix world this also known as the PS1 Variable.
I’ll conclude with a quick recap of terms:
- Operating System: A governing program (or collection of programs) which make raw hardware usable for other programs. Primarily comprised of ‘The Kernel’
- Shell: A program which allows a user to interact with the Operating System as well as launch other programs. Can either be graphical (GUI) or text based (CLI).
- Command Prompt: The text in a CLI shell which prompts the user that it is ready receive a command. Known as the PS1 Variable in *Nixes.
- TTY: Teletype or Terminal Type. A “device” (physical or virtual) to which a user connects and in which a shell runs.
- Console: The Input/Output device(s) at which a user sits to interact with a computer.
- Terminal: A physical device, which is not a part of the computer itself, which provides a console through which a user can interact with the computer.
- Terminal Emulator: A program which runs inside of a GUI shell and emulates the functions of a physical terminal.
But you don’t have to take my word for it.
~LeVar Burton