Terminal Emulator

A terminal emulator is a program that allows the user to interact with the computer through a command-line interface. It is a software application that provides a text-based interface for users to input commands and receive output from the system. Terminal emulators are commonly used by developers, system administrators, and power users to perform tasks that aren’t easily achieved through a graphical user interface.

In Unix terminology, we can understand this as:

• 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 that implements several 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 a 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. 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. Besides 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 such as the KornShell (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 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).

• The shell provides Line editing, input history, and completion. The terminal may provide its own line editing, history, and completion and only send a line to the shell when it's ready to be executed. The only common terminals that operate in this way are 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.

• The terminal provides inter-application copy-paste (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).

• The shell mostly performs Job control (launching programs in the background and managing them). However, it's the terminal that handles key combinations like Ctrl+C to kill the foreground job and Ctrl+Z to suspend it.

Source