aemakeye@term:~$ cat welcome.txt

The Terminal

A short history of Unix & Linux terminals, the managers that tame them, and how to edit files without ever leaving the keyboard.

a-brief-history

Before there were screens, there were teletypes. In the 1960s, users talked to mainframes through machines like the Teletype Model 33 ASR — electromechanical typewriters that printed a computer's output onto rolls of paper and sent keystrokes back as electrical signals. Unix itself, born in 1969 at Bell Labs, was designed around this idea: a stream of characters in, a stream of characters out. That abstraction never left us.

When video display terminals (VDTs) replaced paper — the DEC VT100 being the most influential — they kept the same contract, and the escape-code language it spoke is still the reason your terminal today can draw colors, move the cursor, and clear the screen. Every terminal emulator you use in 2026 still pretends, at some level, to be a VT100 or its descendants.

1969 Unix begins at Bell Labs; the shell and pipe philosophy takes shape.
1978 DEC ships the VT100, whose ANSI escape sequences become the de-facto standard.
1984 xterm is written for the X Window System, bringing terminals to graphical desktops.
1985 GNU Emacs 1.0 released; GNU project begins building a free Unix toolchain.
1991 Linus Torvalds announces Linux; a free, Unix-like kernel anyone could run at home.
1993 Bram Moolenaar releases Vim, an improved clone of the classic Unix vi.
2007 tmux is released, offering a modern, BSD-licensed alternative to GNU Screen.
2019 GPU-accelerated emulators like Alacritty and Kitty gain mainstream popularity.
2020s Neovim, Helix, and Rust-based tools (starship, zellij, ripgrep) reshape the terminal ecosystem.

What's remarkable is how little the core idea changed. The terminal is still a text stream; the shell is still a program that reads commands and runs other programs. Everything since has been about making that loop faster, prettier, and easier to compose.

terminal-vs-shell

These two words get used interchangeably, but they're different layers:

Terminal (emulator)

The window/app that renders text, handles keyboard input, and speaks the old VT100 escape-code language. Examples: GNOME Terminal, iTerm2, Alacritty, Kitty, WezTerm.

Shell

The program running inside the terminal that interprets your commands. Examples: bash, zsh, fish, dash.

TTY / PTY

The kernel-level plumbing — a pseudo-terminal device — that connects the emulator to the shell process, a direct descendant of the physical teletype line.

terminal-emulators

A terminal emulator is the graphical program that stands in for a physical terminal.

EmulatorPlatformNotable for
xtermX11 / LinuxThe original, still the reference implementation
GNOME Terminal / KonsoleLinux desktopsDefault terminals for GNOME and KDE
AlacrittyLinux, macOS, WindowsGPU-accelerated, minimalist, config in YAML/TOML
KittyLinux, macOSGPU rendering, ligatures, built-in multiplexing
WezTermLinux, macOS, WindowsRust-based, scriptable in Lua, cross-platform
iTerm2macOSSplit panes, search, shell integration
Windows TerminalWindowsModern tabs/panes for WSL, PowerShell, cmd

terminal-managers

"Terminal managers" usually means multiplexers — tools that let a single terminal session host multiple windows and panes, and crucially, keep running even after you disconnect. This is essential on remote servers: start a long job over SSH, detach, close your laptop, and reattach later to find it still running.

GNU Screen (1987)

The original multiplexer. Detach/reattach sessions, split windows. Nearly universal on older Unix systems.

tmux (2007)

The modern standard. Scriptable config, sane defaults, panes, sessions, plugin ecosystem (tmux-resurrect, tpm).

Zellij

A Rust-based multiplexer with a discoverable UI, built-in layouts, and a friendlier learning curve than tmux.

byobu

A configuration layer on top of tmux or screen, adding status bars and easier keybindings out of the box.

Minimal tmux cheat-sheet

tmux new -s work        # start a new named session
tmux attach -t work      # reattach to a session
tmux ls                  # list sessions

Inside tmux: Ctrl+b then c new window, Ctrl+b then % split vertically, Ctrl+b then d detach.

editing-files

Editing text without a mouse is the terminal's oldest party trick. Two philosophies have dominated for decades, plus a wave of modern challengers.

vi / Vim / Neovim

Modal editing — separate modes for navigating and inserting text — makes complex edits fast once the muscle memory sets in. vi shipped with Unix since 1976; Vim (1991) and Neovim (2015) are its modern heirs.

Emacs

A single, deeply extensible environment (Emacs Lisp) that can be a text editor, mail client, file manager, and shell all at once. First released 1976, GNU Emacs in 1985.

nano

Simple, non-modal, keybindings shown on screen. The default "just let me edit this config file" editor for beginners and sysadmins alike.

Helix

A 2021 Rust-based modal editor with selection-first editing and built-in LSP support, no plugins required to feel modern.

Bare-minimum vi survival kit

i        # enter insert mode
Esc      # back to normal mode
:wq      # save and quit
:q!      # quit without saving
dd       # delete a line
/text    # search forward for "text"

Bare-minimum nano survival kit

Ctrl+O   # write out (save)
Ctrl+X   # exit
Ctrl+K   # cut line
Ctrl+U   # paste line
Ctrl+W   # search

essential-habits