If you’ve been using Linux for a while but still feel confused about terms like Console, Terminal, TTY, and Shell, you’re not alone. These concepts carry historical baggage, and their meanings have evolved over time. Let’s demystify them once and for all.

TTY (Teletypewriter)

  • Origin:
    • Physical TTY: Early terminals were electromechanical teletypewriters (TTYs) that printed input/output on paper.
    • Modern TTY: In Linux/Unix, TTY now refers to terminal devices managed by the kernel (e.g., /dev/tty1).
  • Key Roles:
    • Handles low-level input (keyboard) and output (display).
    • Manages session control, line buffering, and signals (e.g., Ctrl+C).
  • Examples:
    • In Ubuntu, pressing Ctrl+Alt+F1 switches to tty1, a virtual terminal.
    • Legacy physical TTYs (rare today) vs. virtual TTYs (e.g., /dev/tty2).

Terminal

  • Historical Terminal:
    • A physical device (e.g., VT100) with limited processing power, connected via serial ports to share a mainframe.
    • Users typed commands into the terminal, which relayed them to the computer and displayed results.
  • Modern Terminal:
    • Terminal Emulator: Software like gnome-terminal or Konsole that mimics hardware terminals.
    • Uses pseudo-terminals (PTY) (e.g., /dev/pts/0) to interact with the system.
  • Terminal Window: A GUI-based terminal emulator (e.g., Ubuntu’s default terminal).

Console

  • Physical Console:
    • A dedicated input/output device directly attached to a computer (e.g., a server’s keyboard and monitor).
    • Displays low-level system output (e.g., BIOS messages, kernel logs).
  • Virtual Console:
    • Software-based “full-screen” terminals accessible via shortcuts like Ctrl+Alt+F1 in Linux.
    • Ubuntu provides 7 virtual consoles:
      • tty1–tty6: Text-based consoles.
      • tty7: Reserved for the graphical interface (Xorg/Wayland).

Virtual Terminal vs. Virtual Console

  • Same Concept: Both refer to software-emulated terminals.
  • Purpose: Allow multiple independent sessions on a single physical device.
    • Example: In Ubuntu, tty1 to tty6 are virtual terminals, each acting like a separate physical terminal.

Shell

  • Role:
    • A command interpreter that bridges user input and the OS kernel.
    • Manages process creation (e.g., running your hello_world program), scripting, and environment variables.
  • Common Shells:
    • sh:
      • Thompson shell (1971): The first Unix shell.
      • Bourne shell (1977): Replaced Thompson shell, added scripting capabilities.
    • csh/tcsh:
      • C Shell (1970s): Syntax inspired by C, developed by Bill Joy.
      • tcsh: Enhanced version with command-line editing.
    • bash:
      • Bourne-Again SHell (1989): Default on Linux/macOS, combines Bourne shell syntax with features from ksh and csh.

How They Work Together

  1. Terminal Emulator (e.g., gnome-terminal) launches and creates a PTY (e.g., /dev/pts/0).
  2. The terminal starts a Shell (e.g., bash) bound to the PTY.
  3. You type ls → Terminal sends input to Shell via PTY.
  4. Shell parses the command, executes it, and returns output to the terminal.

Key Differences

Concept Role Example
TTY Low-level I/O device/abstraction /dev/tty1, physical serial port
Terminal User-facing I/O interface VT100, gnome-terminal
Console Dedicated system terminal Server’s physical keyboard/monitor
Shell Command interpreter bash, zsh, fish

Common Confusions Clarified

  • Terminal ≠ Shell:
    • The terminal is the interface (handles input/output).
    • The shell is the interpreter (executes commands).
  • Console vs. Terminal:
    • A console is a type of terminal used for system-level tasks.
  • TTY vs. PTY:
    • TTY: General term for terminal devices.
    • PTY: Virtual TTY pair used by terminal emulators.

Virtual Terminals (TTYs) in Linux

In Linux systems like Ubuntu, virtual terminals (also called virtual consoles) are text-based interfaces accessible via keyboard shortcuts (Ctrl+Alt+F1 to Ctrl+Alt+F7). Here’s how they typically work:

Virtual Terminal Assignments

  • tty1:
    • Traditionally a text-based console, not the graphical interface.
    • In some modern systems (e.g., Ubuntu with Wayland), tty1 may display the login prompt for the graphical session, but the actual GUI runs on a separate server (e.g., tty7 for Xorg).
  • tty2 to tty6:
    • Text-based consoles for multi-user logins. Each can host an independent session.
    • Example: Log in as different users on tty2, tty3, etc.
  • tty7 (Ubuntu-specific):
    • Reserved for the graphical user interface (GUI) (Xorg or Wayland).
    • Press Ctrl+Alt+F7 to return to the GUI from a text-based console.

Special Terminal Device Files

  • /dev/tty:
    • Represents the current terminal session.
    • Example: If you’re logged into tty2, /dev/tty points to tty2.
  • /dev/pts/* (Pseudo-Terminal Slaves):
    • Network/remote sessions (e.g., SSH, Telnet) or GUI terminal emulators (e.g., gnome-terminal) use pseudo-terminals (pts).
    • Example: An SSH connection creates a pts/0 device.

Total “Terminals” in Linux

  • Virtual Consoles: 6 text-based (tty1–tty6) + 1 graphical (tty7).
  • Special Terminals:
    • /dev/tty (current session).
    • Unlimited pts devices (one per remote/GUI terminal window).
  • Note: The claim of “8 terminals” is a misunderstanding. Linux supports:
    • Fixed virtual consoles (tty1–tty7).
    • Dynamic pseudo-terminals (pts/*) for remote/GUI sessions.

Key Clarifications

  1. tty1 and the GUI:

    • Older systems (Xorg): GUI runs on tty7.
    • Newer systems (Wayland): GUI uses a separate server (e.g., tty1 may show a login prompt).
    • Always check your system with sudo systemctl status display-manager.

  2. Switching Terminals:

    • Use Ctrl+Alt+F1 to F7 to toggle between terminals.
    • The GUI (if running) usually occupies the highest-numbered TTY (e.g., tty7).

  3. Remote Sessions (SSH):

    • SSH connections create pts devices (e.g., /dev/pts/0), not tty devices.
    • Verify your terminal type with the tty command: 
      $ tty
/dev/pts/0  # SSH session
/dev/tty2   # Virtual console

Why This Matters

Understanding these layers helps you:

  • Multi-User Systems: Virtual terminals allow multiple users to log in locally.
  • Troubleshooting: If the GUI crashes, switch to a text console (Ctrl+Alt+F1) to fix issues.
  • Resource Efficiency: Pseudo-terminals (pts) enable lightweight remote access without physical hardware.

Common Misconceptions

  • GUI runs on tty1: This depends on the display manager and Linux distribution. Most systems reserve tty1–tty6 for text consoles.
  • 8 terminals total: The number of tty devices is fixed (usually 7), but pts devices are dynamically created and unlimited.

Reference