I think these terms almost refer to the same thing, when used loosely:
What exactly does each of these terms refer to?
Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. It only takes a minute to sign up.Sign up to join this community
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
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.
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.
\e[D). The shell converts control sequences into commands (e.g.
M-x shellin Emacs.
foo”, “switch the foreground color to green”, “move the cursor to the next line”, etc. The terminal acts on these instructions.
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.
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.
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.
TTY is terminal which is used to type text message.
Console means the keyboard and monitor physically attachements to a computer.
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.
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
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.
Terminal = An interface that provides a display for output and a keyboard for input to a shell session.
Shell = Interpreter that executes commands typed as strings
Console: Actually two types of console we use:
tty (teletype i.e., terminal) = A terminal is a basically just a user interface device that uses text for input and output messages.
Here is the short answer -
Kernel - the innermost part of any modern operating system which directly talks to actual hardware.
Shell - wrapper around the actual Kernel. Whenever we run command, we actually talk to shell which in turn invokes appropriate Kernel instructions. Apart from this, the shell is capable of performing some other stuffs like finding appropriate program while having commands, some file name short hand, piping commands etc.
Terminal - in the era of earlier computing, computers (known as Mainframe) were giant. So, it was easy to have a single processing unit and connect it from many places. Terminal is the actual hardware with keyboard and output devices connected to mainframe.
Console - Special type of terminal which is directly connected to Mainframe for the purpose of OS Administration.
tty - TeleTypewriter used to send and receive data to and from Mainframe. Used before Video Terminals were available. But conventionally it has been still named as tty. Even the coommand
The long detailed answer is here - Terminal, Console, Shell, Kernel, Commands - Different parts of a Computer
You need to dive into history.
There were typewriter-like devices with paper and keyboard. They were called teletypes (which means "type remotely," since "tele" means "remote") or ttys for short. In the 70s they were obsoleted by devices with CRT monitor called glass ttys.
Any computer need some way to report its status and errors (and, probably, accept commands). It is done through console which is almost always connected directly to the computer. So, there are 2 meanings for console: something that is used to report status and something that is connected directly.
UNIX is an interactive system: several users may connect to it and start applications. First computers used teletypes (tty) for that: each user had teletype connected to machine with serial line connection. Such teletype is called terminal. UNIX also got special subsystem to handle "users sitting behind terminals" which is also called tty because first terminals were teletypes. Each process could be connected to tty in Unix. That means there is a user somewhere sitting near terminal. See http://www.linusakesson.net/programming/tty/ for more info.
Users need some way to tell kernel to run application. shell (sh, bash, csh, ksh, etc.) is used for that. shell runs on tty, accepts commands from user and asks kernel to run some app.
But terminals are not always physically connected to the machine. There may be some application that "emulates" terminal accepting keystrokes from user and sending them somewhere (xterm and ssh are good examples). There is an API in Kernel called pseudo terminal for that. So your tty may really be connected to some application instead of real terminal. Xterm uses X11 to display text and ssh uses network connection for it.
IBM PC has keyboard and video card (they are also called console sometimes). Linux can do different things with it:
It also may stop emulating terminal on console and give it to some app. App may switch its video mode and use it exclusively (X11 or svgalib may do that).
So, here are modern meanings:
/dev/console) or physical keyboard and video display connected to computer.
Apart from the accepted answer and The TTY demystified article, I really loved reading these articles:
This one is based on NetBSD.
Back in the stone ages of Unix, computer systems consisted of a mainframe, a big box of blinking lights which had memory, mass storage and computing units, and that run processes started by users or operators. As the hardware was very expensive, the systems were used as true multiuser systems, with many people interacting with the system at the same time. What it usually didn't have - unlike today's Unix workstations - was a fixed monitor and keyboard. Instead, issuing commands to the machine and retrieving output was done over serial lines, using teletypers first, and CRT (cathode ray tube) terminals later. Teletypers - that's where the "ttys" in Unix come from - are electronic typewriters that send keys pressed over the serial line to the host, and replies were sent back to the teletyper char by char over the serial line, with the built-in printer putting the reply on paper, much like a typewriter.
This one is based on Linux.
Terminals are devices that provide enhanced input/output capabilities beyond what could be achieved with only regular files, pipes, and sockets. These features are designed to make it easier for humans to interact with computers, and are useless for programs trying to talk to each other.
This one is based on Linux.
Generally speaking a terminal is a relatively dumb electro-mechanical device with an input interface (like a keyboard) and an output interface (like a display or sheet of paper).
There is also an introductory playlist on terminals and shells by Brian Will on YouTube.
I will use Unix and Linux more or less synonymously in this. If I'm referring to something historical that predates the existence of Linux, I will usually write "Unix", and if I'm talking about something more recent, or something specific to the Linux flavor of Unix, I will usually write "Linux".
The only thing in your list that is a discrete concept that has no overlap with the others is the 'shell'. The shell is a program whose purpose is to communicate with a user and carry out operating system operations on their behalf.
The most common shells use a technique called a 'command line', which consists of sending the user some sort of prompt, waiting for the user to type out a text command, and then carrying out that command. But there are menu-based shells and even graphical shells (like Windows File Explorer), though no self-respecting Unix person would ever call such a thing a 'shell'.
In Unix, if someone calls something a 'shell', they almost certainly mean some form of command line interface as I just described. And it is very odd in the Unix world to refer to anything as a 'shell' if it isn't communicating to a user using the tty model I describe further on.
This is a confusing one because it can refer to a few different kinds of things.
In Linux, there is a kind of device called a 'tty'. It is an abstract device that is expected to be used for bi-directional communication with something that either is a user, or is taking input from a user in some way. Sometimes that abstract device may correspond directly to some physical device. Sometimes it may be a program that is presenting someone with a window in which the communication appears and into which the user can type.
But the reason this abstract device exists and the reason it is called a 'tty' is that 'tty' is short for 'teletype', which was an actual physical device that had a printer that printed on paper, combined with a keyboard. The model that the abstract 'tty' device presents to programs that are using it is basically that there is a teletype on the other end. You send it characters and those characters appear on the teletype. When you read characters from it, those characters represent keys that were typed on a keyboard.
The old paper-printer based ttys were quickly supplanted with video ttys. On those, of course, there is no roll of paper. And, in fact, it is (almost always) possible to overwrite any character on the screen. But, rather than present some kind of abstract 'screen' interface to programs, programs are instead expected to send special streams of characters called escape sequences that accomplish a variety of tasks. Usually, there is an abstract thing called a 'cursor' that can be moved around the screen, and any character sent will replace whatever is at the cursor, and the cursor will move one character position further on (i.e., to the right, when using a left-to-right language). Special characters like Tab, Backspace, Carriage Return and Line Feed can (fairly obviously) move the cursor in ways other than one-space-further; many devices support escape sequences that move the cursor in more complex ways. Often you can change the color of a character that's about to be printed with escape sequences as well.
There are 'glass ttys' that do not follow this model and consequently are handled poorly in the Unix world. The IBM 3270 family of video terminals falls into this category.
What Linux/Unix people typically call a 'shell window' is an emulation of a glass tty using a graphical user interface. Internally, programs running inside a shell window are talking to a virtual tty device that is sometimes called a pseudo-tty or pseudo-terminal (a.k.a. a 'pty').
A terminal is just a place where computer and human are supposed to interface. Terminals may be completely graphical and not follow the tty model in any way, even though a program may use their capabilities to emulate this. All actual physical ttys (glass or otherwise) are terminals.
A console is a special kind of terminal that is generally supposed to be attached in some direct secure way to the hardware the operating system is running on.
In Linux, the console is virtualized in a small way which allows you to use a special keystroke to switch between the virtual consoles. But this virtualization is done with a real piece of hardware by software in the kernel.
There are ways to use Linux through what's called a 'serial console', which is a console that's attached to the computer through a serial port like a USB port (or, on some very small and/or very old computers, an RS-232 port of some kind) and follows the old teletype model in a fairly strict way.
Again, the idea is that this console is connected in a direct physical way to the computer instead of through some sort of network that might allow anybody to connect.