In the early days of UNIX, a terminal was a physical device — a keyboard and a display (usually a CRT screen) connected to the computer through a serial line (RS-232). The user typed on the keyboard; characters appeared on the screen; the computer processed them.

Even earlier than CRTs, terminals were teletype (TTY) machines — electromechanical typewriters that printed output on paper rolls. That is where the abbreviation tty comes from, and it is still used throughout Linux today.

Serial lines were also used to connect printers, modems, and even to link two computers together. On early UNIX, each terminal line was represented as a character device at /dev/tty1, /dev/tty2, etc. On modern Linux, /dev/ttyn refers to virtual consoles — the text-mode screens you switch between with Ctrl+Alt+F1, Ctrl+Alt+F2, and so on.

In the early UNIX era, each terminal manufacturer used different control sequences for things like:

• Moving the cursor to the top-left of the screen
• Clearing the screen
• Moving to a specific row/column

Writing a program like a text editor (vi) that needed to control the cursor was a nightmare — you had to know which terminal the user had, and write different code for each.

The solution came in two layers:

• termcap / terminfo databases — a big lookup table that maps capability names (like “move cursor to position X,Y”) to the actual byte sequences for hundreds of terminal types.
• curses library — a programming library that sits on top of terminfo and lets you write screen-oriented programs portably. The ncurses library you use in Linux today is a direct descendant.

Eventually Digital Equipment Corporation’s VT-100 terminal became so popular that its escape sequences became a de facto standard, and later an official ANSI standard. Most terminal emulators today (xterm, GNOME Terminal, etc.) emulate a VT-100/VT-220.

Today, nobody uses a physical CRT terminal connected via RS-232. Instead:

• The computer has a graphical display managed by the X Window System (or Wayland).
• You run a terminal emulator application — like xterm, GNOME Terminal, Konsole, or Alacritty.
• The terminal emulator draws a window, handles keyboard input, and talks to the kernel through a pseudoterminal (PTY) device.

From the kernel’s perspective, a terminal emulator window is almost identical to an old physical terminal. The same TTY driver code handles both. The only real difference is the underlying device: a real RS-232 line vs. a pseudoterminal.

Chapter 64 of TLPI covers pseudoterminals in detail. For now, just understand that the terminal driver (TTY driver) is always in the middle — between the user-facing side (physical terminal or emulator window) and the application.

Embedded Linux engineers encounter TTY/terminal concepts in several real scenarios:

You can check what terminal device is associated with a file descriptor using the ttyname() function or the tty command.

/* Check if a file descriptor refers to a terminal and get its name */
#include <stdio.h>
#include <unistd.h>

int main(void)
{
    /* isatty() returns 1 if fd refers to a terminal, 0 otherwise */
    if (isatty(STDIN_FILENO)) {
        printf("stdin is a terminal: %s\n", ttyname(STDIN_FILENO));
    } else {
        printf("stdin is NOT a terminal (maybe a pipe or file)\n");
    }

    if (isatty(STDOUT_FILENO)) {
        printf("stdout is a terminal: %s\n", ttyname(STDOUT_FILENO));
    } else {
        printf("stdout is NOT a terminal\n");
    }

    return 0;
}

Sample output when run in a terminal emulator:

stdin is a terminal: /dev/pts/3
stdout is a terminal: /dev/pts/3

Sample output when stdout is redirected to a file (./a.out > out.txt):

stdin is a terminal: /dev/pts/3
stdout is NOT a terminal

Notice that stdin is /dev/pts/3 — a pseudoterminal slave created by the terminal emulator (xterm, GNOME Terminal, etc.). Real serial ports would show up as /dev/ttyS0, USB-to-serial adapters as /dev/ttyUSB0, and virtual consoles as /dev/tty1.

The isatty() check is important in real programs. Many programs (like ls) behave differently depending on whether stdout is a terminal — for example, ls shows colored output when talking to a terminal, but plain text when output is piped.

Linux provides a special device file /dev/tty which always refers to the controlling terminal of the calling process. This is useful when you want to read from or write to the terminal even if stdin/stdout are redirected.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    char password[128];

    /* Open controlling terminal directly, bypassing stdin redirection */
    int tty_fd = open("/dev/tty", O_RDWR);
    if (tty_fd == -1) {
        perror("open /dev/tty");
        return 1;
    }

    write(tty_fd, "Enter password: ", 16);
    int n = read(tty_fd, password, sizeof(password) - 1);
    if (n > 0) {
        password[n] = '\0';
        /* Remove trailing newline */
        if (password[n-1] == '\n') password[n-1] = '\0';
    }

    write(tty_fd, "\nPassword received.\n", 20);
    close(tty_fd);
    return 0;
}

This is exactly how programs like sudo prompt for a password even when stdin is a pipe.