Cdtjkyj

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.

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.

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.

There are already two great answers, but Ī̲’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 broad sense. But in early days of Linux (1994–95) is 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. Ī̲ 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 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 key board for input to a shell session .




• Shell = Interpreter that executes commands typed as string



• 
  

  Console: Actually two types of console we use

  
  
  
  
  

  • Physical console=The hardware display and keyboard used to interact with a system

  
  

  • Virtual console= One of multiple logical consoles that can each support an independent login session.

  
  
  
  



• tty(teletype ie terminal). = A terminal is a basically just a user interface device that uses text for input and output.message.

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:

• Use it as "engine to report errors and status": Linux console. If you pass console=/dev/ttyS0 to kernel it will use something connected to COM1 as console, and if you do not it will use PC console.


• Use it to emulate terminal, so called virtual terminal (vty).

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:

• terminal: Something with real user sitting behind it. Could be physical terminal (rare) or pseudo terminal (xterm, ssh) or virtual terminal (vty in Linux)


• shell: application (bash, tcsh, etc) that helps user to interact with system.


• tty: either terminal or kernel subsystem to support terminals.


• console: something where status and errors are reported (/dev/console) or physical keyboard and video display connected to computer.

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 stty

The long detailed answer is here - Terminal, Console, Shell, Kernel, Commands - Different parts of a Computer

Apart from the accepted answer and The TTY demystified article, I really loved reading these two 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.