What is the exact difference between a 'terminal', a 'shell', a 'tty' and a 'console'?

Question

I think these terms almost refer to the same thing, when used loosely:

• terminal
• shell
• tty
• console

What exactly does each of these terms refer to?

Solution 1

A terminal is at the end of an electric wire, a shell is the home of a turtle, tty is a strange abbreviation and a console is a kind of cabinet.

Well, etymologically speaking, anyway.

In unix terminology, the short answer is that

• terminal = tty = text input/output environment
• console = physical terminal
• shell = command line interpreter

---

Console, terminal and tty are closely related. Originally, they meant a piece of equipment through which you could interact with a computer: in the early days of unix, that meant a teleprinter-style device resembling a typewriter, sometimes called a teletypewriter, or “tty” in shorthand. The name “terminal” came from the electronic point of view, and the name “console” from the furniture point of view. Very early in unix history, electronic keyboards and displays became the norm for terminals.

In unix terminology, a tty is a particular kind of device file which implements a number of additional commands (ioctls) beyond read and write. In its most common meaning, terminal is synonymous with tty. Some ttys are provided by the kernel on behalf of a hardware device, for example with the input coming from the keyboard and the output going to a text mode screen, or with the input and output transmitted over a serial line. Other ttys, sometimes called pseudo-ttys, are provided (through a thin kernel layer) by programs called terminal emulators, such as Xterm (running in the X Window System), Screen (which provides a layer of isolation between a program and another terminal), Ssh (which connects a terminal on one machine with programs on another machine), Expect (for scripting terminal interactions), etc.

The word terminal can also have a more traditional meaning of a device through which one interacts with a computer, typically with a keyboard and display. For example an X terminal is a kind of thin client, a special-purpose computer whose only purpose is to drive a keyboard, display, mouse and occasionally other human interaction peripherals, with the actual applications running on another, more powerful computer.

A console is generally a terminal in the physical sense that is by some definition the primary terminal directly connected to a machine. The console appears to the operating system as a (kernel-implemented) tty. On some systems, such as Linux and FreeBSD, the console appears as several ttys (special key combinations switch between these ttys); just to confuse matters, the name given to each particular tty can be “console”, ”virtual console”, ”virtual terminal”, and other variations.

See also Why is a Virtual Terminal “virtual”, and what/why/where is the “real” Terminal?.

---

A shell is the primary interface that users see when they log in, whose primary purpose is to start other programs. (I don't know whether the original metaphor is that the shell is the home environment for the user, or that the shell is what other programs are running in.)

In unix circles, shell has specialized to mean a command-line shell, centered around entering the name of the application one wants to start, followed by the names of files or other objects that the application should act on, and pressing the Enter key. Other types of environments don't use the word “shell”; for example, window systems involve “window managers” and “desktop environments”, not a “shell”.

There are many different unix shells. Popular shells for interactive use include Bash (the default on most Linux installations), zsh (which emphasizes power and customizability) and fish (which emphasizes simplicity).

Command-line shells include flow control constructs to combine commands. In addition to typing commands at an interactive prompt, users can write scripts. The most common shells have a common syntax based on the Bourne_shell. When discussing “shell programming”, the shell is almost always implied to be a Bourne-style shell. Some shells that are often used for scripting but lack advanced interactive features include the Korn shell (ksh) and many ash variants. Pretty much any Unix-like system has a Bourne-style shell installed as /bin/sh, usually ash, ksh or bash.

In unix system administration, a user's shell is the program that is invoked when they log in. Normal user accounts have a command-line shell, but users with restricted access may have a restricted shell or some other specific command (e.g. for file-transfer-only accounts).

---

The division of labor between the terminal and the shell is not completely obvious. Here are their main tasks.

• Input: the terminal converts keys into control sequences (e.g. Left → \e[D). The shell converts control sequences into commands (e.g. \e[D → backward-char).
• Line editing, input history and completion are provided by the shell.
  • The terminal may provide its own line editing, history and completion instead, and only send a line to the shell when it's ready to be executed. The only common terminal that operates in this way is M-x shell in Emacs.
• Output: the shell emits instructions such as “display foo”, “switch the foreground color to green”, “move the cursor to the next line”, etc. The terminal acts on these instructions.
• The prompt is purely a shell concept.
• The shell never sees the output of the commands it runs (unless redirected). Output history (scrollback) is purely a terminal concept.
• Inter-application copy-paste is provided by the terminal (usually with the mouse or key sequences such as Ctrl+Shift+V or Shift+Insert). The shell may have its own internal copy-paste mechanism as well (e.g. Meta+W and Ctrl+Y).
• Job control (launching programs in the background and managing them) is mostly performed by the shell. However, it's the terminal that handles key combinations like Ctrl+C to kill the foreground job and Ctrl+Z to suspend it.

Solution 2

A terminal or a console is a piece of hardware, using which a user can interact with a host. Basically a keyboard coupled with a text screen.
Nowadays nearly all terminals and consoles represent "virtual" ones.

The file that represents a terminal is, traditionally, called a tty file. If you look under the "/dev" directory of a UNIX system, you'll find a lot of tty files connected to virtual consoles (e.g. tty1 on linux), virtual terminals (e.g. pts/0) or physically connected hardware (e.g. ttyS0 is the physical serial terminal, if any, attached on first serial port of the host).

A console must be a piece of hardware physically connected to (or part of) the host. It has a special role in the system: it is the main point to access a system for maintenance and some special operation can be done only from a console (e.g. see single user mode). A terminal can be, and usually is, a remote piece of hardware.

Last, but not the least, a shell is a special program that interacts with a user through a controlling tty and offers, to the user, the way of launching other programs (e.g. bash, csh, tcsh).

A terminal emulator is a program that emulates a physical terminal (e.g. xterm, gnome-terminal, minicom).

So when you look to a "text window" on your linux system (under X11) you are looking to: a terminal emulator, connected to a virtual terminal, identified by a tty file, inside which runs a shell.

Solution 3

SHORT explanation:

The console is a terminal. A system has got one console and potentially multiple terminals. The console is typically the primary interface for managing a computer, eg while it is still booting up.

A terminal is a session which can receive and send input and output for command-line programs. The console is a special case of these.

A TTY is essentially a pseudo device, call it a kernel resource, which is used by processes to access a specific terminal. TTYs can be tied to hardware such as a serial port, or can be virtual, eg created when a user logs in via a network

The shell is a program which is used for controlling and running programs. It is often used interactively, via a terminal. Several Shell programs exist, Bash being arguably the most commonly used shell today. Other shells, in no particular order, includes Bourne Shell, C-shell, Dash, Tsch, Ksh, and the increasingly popular zsh. There are many more.

When you have a GUI, you can use a terminal program to draw a nice resizeable border, add scroll bars, and format the text, and so on, for a terminal session. Often these are called terminal emulators, and sometimes they can handle multiple sessions via a TAB concept. A Terminal Emulator often starts a Shell to allow you to interactively work on a command line.

Solution 4

A TTY (i.e. TeleTYpewriter) is a special device that lets people who are deaf, hard of hearing, or speech-impaired use the telephone to communicate, by allowing them to type text messages. A TTY is required at both ends of the conversation in order to communicate.
OR
TTY is terminal which is used to type text message.

---

Shell :the outside protective covering part of a seed i.e. kernel.
OR
framework or exterior structure to central or essential part of a system.

---

Console means the keyboard and monitor physically attachements to a computer.

Solution 5

There are already two great answers, but I'd like to add information about the phrase “virtual terminal”. Generally, it means something that provides appearance/functionality of a terminal, i. e. a terminal-emulator in a broad sense. But in the early days of Linux (1994–95) it was used synonymously with “virtual console” (several unrelated user interfaces), by some developers. This usage persists in documentation; two different terms were (and are) used to refer to tty1, tty2… thingies. Nowadays (since ≈ 1996) “virtual terminal” may also refer to pty-based terminal emulators.

Linux’s vt (the driver of text mode system console) was the first piece of its kernel. It was initially used for connection to mainframes and in this sense it’s a “virtual terminal”, hence the name. The code controlling virtual consoles resides in vt.c as well. Linux kernel engineers consistently use the word “consoles” to denote tty1, tty2… and used “vc_” prefix for them. For example, there is a vc_allocate function. On the other hand, developers of such user-space tools as kbd and console-tools used “virtual console” (VC) and “virtual terminal” (VT) interchangeably. I've contacted Andries E. Brouwer and asked him to clarify terminology used by early developers (1994–95). Andries kindly provided some answers. He states that VT and VC are synonymous and “indivisible” abbreviations.

In general, a virtual console is a virtual terminal, but the converse isn’t true. Those “virtual terminals” that are not virtual consoles are indeed pseudoterminals (as Andries states, these are not VT). Unlike virtual consoles, where the kernel provides terminal functionality for a console application, pseudoterminals use PTY “devices” to arrange communication between console applications and the terminal-making program that runs in userspace. Examples are X-based terminal emulators and sshd, that allocates a pseudotty for each login session. A pseudotty may not be called “console” – it’s a mistake.

View more solutions

Comments

[firo]

The TTY demystified

[teeks99]

I'd like to add 'command line' to that :-)

[Marty Fried]

The command line is simply the language used to send commands to the command-line interpreter running in a shell from the terminal/terminal emulator.

[Serge Stroobandt]

The teletypewriter (TTY) was first put in operation and exhibited at the Mechanics Institute in New York in 1844. en.wikipedia.org/wiki/Teleprinter

[Nishant]

TTYs and X Windows, Linux terminals, tty, pty and shell.

[Chris Johnsen]

Only quibble: I would say that both kinds of ttys are “provided by” the kernel. The difference I would emphasize is that hardware ttys (e.g. serial lines and the built-in, text-mode console) have one end connected to hardware and one end connected to software (e.g. login programs and/or shells) while pseudo-ttys have both ends connected to software (e.g. a terminal emulator on one end and shell on the other).

[phunehehe]

I read in a book (forget the name, sorry), that the shell is supposed to protect the kernel: the user interacts with the shell, instead of directly with the kernel.

[Gilles 'SO- stop being evil']

@phunehehe: Right, that's a different meaning of “shell”, in common use in operating system design: the shell is the outer part of the kernel. It's not unix terminology: Unix kernels don't tend to have a component that one could call a shell.

[ændrük]

This is the image in my mind for the shell metaphor.

[Chris Page]

“…the terminal…handles key combinations like Ctrl+C to kill the foreground job and Ctrl+Z to suspend it” Not quite: the terminal still merely sends control characters, it’s the tty device that decides how to handle them, and it’s configurable. By default the tty device converts the control characters into signals sent to the shell (and other processes).

[Srinivas Cheruku]

The shell is indeed the outer shell of the kernel (protection or none), it deals with user<-->kernel interaction. The shell allows the user to perform kernel calls; primarily the focus here is on the ability to execute other programs interactively, because once you can execute programs you may run editors and compilers to produce programs to deal with the rest of the kernel calls. Generally file browsers like Nautilus are also shells, although perhaps not in full right, as they mostly don't support supplying custom arguments, but they are shells none the less.

[vonbrand]

A quibble: The tty driver (through its cooked mode, more space for endless quips :) handles line editing (i.e., if I write something and erase it by backspacing, this is done by the tty. That is, unless readline or some such newfangled stuff handles it, with the tty in raw mode). The shell receives the line only after I press ENTER.

[Baard Kopperud]

"The console" is actually the terminal (keyboard+screen-combo, though originally a teletypewriter) directly connected to the actual computer. It was usually in the (locked) computer-room, and only a few had access. It was also the only terminal working in single-user mode. All other users, used terminals connected by serial-lines. These days with PCs; "the console" is your PC's keyboard & screen, and you'll do most of your work on it directly.

[Jimmy]

minor quibble with "Other types of environments don't use the word “shell”". Modern window systems do use the word "shell" and even have simplified "equivalents" of unix shells: e.g. powershell in Windows>=XP, and bash in Mac>=OSX

[Gilles 'SO- stop being evil']

@hobs By “other types of environment”, I meant window-based GUIs as opposed to CLI. The whole paragraph is about unix. Windows does use the word “shell” for its GUI shell, which is Explorer by default (Windows also uses the word “shell” in the name “Powershell”, but not much as a type of program).

[Jimmy]

@Gilles the "shell" in "PowerShell" is indeed referring to a type of program, because that's what it is. And GUI window-managers for linux do use the word "shell" to describe a type of program that inhabits terminals within some windows... I must be missing something about the usage of the word "shell" that you're intending to inform us of in that quoted statement... If you're just saying that windows and GUIs aren't shells then I agree. That's like asserting that roads aren't the same as cars. If you're saying something more, like, metaphorically, roadsigns never mention cars, I don't agree.

[Gilles 'SO- stop being evil']

@hobs In general, a shell can be any type of front-end program that allows users to run other programs. In the unix world, it's specialized to command line shells, but elsewhere, there are other types of programs that are called shells, such as GUI shells like Windows's task bar.

[Jimmy]

@Gilles, thanks. I didn't realize that task bars were considered to be shells on Windows/Mac and perhaps on Linux/Unix window managers.

[umeboshi]

@Gilles, I have way to look at shell. Long ago, we have master control program (MCP). MCP is responsible for loading program into memory and xferring control to program. MCP is big C prgm with mainloop that accepts keybrd input to call functions in MCP. The function called is first word entered and args are remaining words. MCP has lot of little functions to help with managing files and stuff. Funcs need fix/update. We already have .o files that we link together. Relinking MCP freqly, no good. Put file loader & path search funcs in MCP. Take other funcs out & put it path. Shell remains.

[Luciano]

PTY is a pseudo TTY. TTY can be, but ins't essentially virtual (either pseudo) terminal.

[G-Man Says 'Reinstate Monica']

@Gilles: FYI, see this.

[Incnis Mrsi]

Any desktop computer has system console (in my 2015 or poster’s 2010, don’t matter). As it was correctly stated, it’s a piece of hardware. But stating “Nowadays nearly all… consoles represent "virtual" ones” is nearly contradictory and obviously not good.

[labyrinth]

Great answer. But what is the difference between a virtual terminal and a pseudo-terminal?

[Alex W]

I think the term "shell" came from the metaphor that it is an outer layer or interface to the inner kernel.

[confused00]

"The prompt is purely a shell concept." This confuses me a bit: is the terminal not responsible for displaying the prompt?

[Gilles 'SO- stop being evil']

@confused00 The prompt is of course displayed by the terminal, but all it does is interpret the order to display characters at a certain position in a certain color. The terminal doesn't know “this is a prompt”, “this is command output”, etc., it only knows “I've been asked to display this”.

[PrashanD]

I would argue that explorer.exe is a shell for Windows as much as it's a window manager or a desktop environment. It is one of the three shells in Windows, the other two being cmd.exe (Command Prompt) and powershell.exe (Windows PowerShell)

[Gilles 'SO- stop being evil']

@PrashanD Yes, Explorer is a graphical shell. But in the Unix world, “shell” usually means “command line shell”. There is a Unix graphical shell called Gnome Shell, but other than that the terminology hasn't really caught on.

[Webwoman]

"A terminal or a console is a piece of hardware, using which a user can interact with a host. Basically a keyboard coupled with a text screen." awesome explication by its concrete aspect

[Webwoman]

thanks but basically if the terminal exist, why exist still tty also in ubuntu system for personal computers, accessible with alt + f-1/6 please, I can't figure out their utility above the fact they can be accessed without graphics system usage if I have well understood

[Motivated]

@andcoz - What do you mean by "text window"? Isn't a terminal emulator a virtual terminal? If i run at the command tty in a terminal emulator such as KDE's Konsole, the output is /dev/pts/0.

[Motivated]

@IncnisMrsi - Isn't a desktop computer the console? If not, what do you mean by it has a system console?

[serb]

@Motivated X11 is an alias for X Windows System Protocol version 11. XOrg is only one of many implementation of X11.

[serb]

@Motivated, in a desktop computer, the console is part of the desktop hardware. Usually, in non desktop computer, the console is a separate piece of hardware.

[serb]

@Motivated /dev/pts/0 is a tty file, an handler to a programmatic interface exposed by the kernel. Through this handler, a program (e.g. the shell) can interact with a terminal (real or virtual). A terminal emulator is a software that emulates a terminal. The emulator asks the kernel to create an handler to let programs to interact with itself (see man openpty). So information flows from the terminal (emulator) to the kernel tty handler, to the program (and vice versa). Programs and terminals do not talk each other directly but only through the tty file (the handler).

[Motivated]

Let us continue this discussion in chat.

[Motivated]

@andcoz - My understanding is that X11 is a network protocol to enable communication between X Window System clients.

[Motivated]

@andcoz - Do you mean to say that when a terminal emulator is launched it utilizes one of tty files to communicate with the shell and other programs?

[Incnis Mrsi]

@Motivated: unsure what did andcoz mean, but a terminal emulator uses the PTY interface not a tty – it’s namely the distinguishing feature of emulators.

[GeisterKampf]

@Webwoman - I have my system configured to only allow access to the root account through sudo or through a console login. Consoles often have a special place privilege-wise as someone who has access to them necessarily has physical access to the computer they communicate with. They are also the access method of last resort. If the OS is in a partially broken state (like the ethernet driver is broken) you can still access the console. It's the one human interface device that should ALWAYS be available, no matter what state the system is in.

[GeisterKampf]

@Webwoman - The defining feature of a console is that it has a direct connection to the hardware that's running the operating system. This idea is somewhat blurred with modern 'virtual machines', but that's the basic idea.

[GeisterKampf]

@Webwoman - This was getting long and complicated enough that I just wrote it up in an answer: unix.stackexchange.com/a/529934/8068

[Webwoman]

@Omnifarious thanks for this very interesting answer and having taken the time to elaborate :).

[darklord]

Generally speaking tty is just a kind of terminal device, but in unix tty is the only terminal device, is that right?

[Shuzheng]

Does the shell also emit an instruction to display command output? What do you mean by inter-application?

[Gilles 'SO- stop being evil']

@Shuzheng The shell is not involved in displaying the output of another command. Each program that displays on a terminal talks directly to the terminal. While this is happening, the shell sits there and waits for the command to finish. By inter-application copy-paste, I mean when you copy text in one application and it's visible to other applications, as opposed to copy-paste mechanisms that may exists inside one application.

[Shuzheng]

@Gilles, so the shell just executed the command (program) and connects its stdin/stdout/stderr to the terminal? Is this accomplished using /dev/tty?

[dotbit]

while a shell is often CLI , it can be GUI also, as in KDE plasmashell and liquidshell . The above definitions are not 100% accurate.