From Teletype
to AI Terminal

Long before computers, the concept of a "terminal" — a device at the end of a communication line — existed in the form of the electric telegraph. Samuel Morse's 1844 system let operators tap encoded messages across copper wire. By the 1860s, the printing telegraph (later called the teletype or TTY) automated this: a keyboard at one end, a printer at the other.

The Baudot code (1870) standardized a 5-bit encoding for characters, and by 1920 the Teletype Model 15 was in wide commercial use. News wire services, military communications, and stock tickers ran on TTY networks. The entire infrastructure of asynchronous serial communication — still used in UART today — was designed for these machines.

When Ken Thompson and Dennis Ritchie created Unix at Bell Labs, they didn't have a monitor. They had a Teletype Model 33 ASR — a clunking electromechanical keyboard-printer combo at 110 baud (10 characters per second). Every command you typed printed to paper. Every response printed below it.

This physical reality shaped Unix's design forever. The concept of stdin, stdout, and stderr maps directly to paper tape in, paper tape out. Pipes were invented because you can only type one line at a time. The terse command names (ls, rm, mv, cp) exist because typing was slow and paper was finite.

The Model 33's ASCII encoding — 7-bit, 128 characters — became the foundation of all text computing. In 1969, the same year Unix was born, ARPANET sent its first message: "login". The terminal transmitted it.

The DEC VT05 (1970) was a watershed moment: a screen instead of a printer. No more burning through rolls of paper. Text appeared on a phosphor tube, scrolled, vanished. Computing felt alive for the first time.

But video terminals in this era were "dumb" — they could only display characters the host sent. Cursor control was non-standard; every terminal manufacturer did it differently. The VT50 (1974) and VT52 (1975) added escape sequences, but incompatibly.

Meanwhile, users had a choice of phosphors: P1 green (#00ff41, easiest on the eyes for long sessions), P3 amber (#ffb000, sharper but harder at distance), or P4 white (highest brightness). The green screen became iconic. It is still the default aesthetic for "hacker" in every movie made since.

The Digital Equipment Corporation VT100 shipped in August 1978 at $1,595 (≈$7,500 today). It was the first terminal to fully implement ANSI X3.64, the standard that defined escape sequences for cursor movement, color, and text attributes.

The VT100 weighed 35 lbs, displayed 24 lines × 80 columns on a 12-inch CRT, and connected at speeds from 50 to 19,200 baud. It sold over 6 million units — more than any terminal before or since. Universities, hospitals, banks, and military installations ran entire operations from VT100 terminals connected to PDP-11 and VAX minicomputers.

The ANSI escape sequences it introduced — \e[2J to clear screen, \e[H to home cursor, \e[1m for bold — are still the standard. Open your terminal right now, run printf '\e[31mRED\e[0m\n', and you are speaking the VT100's language. That's 47 years of backward compatibility.

The X Window System (MIT, 1984) brought graphical desktops to Unix. And what did every Unix user want in their graphical desktop? A terminal window. xterm was written in 1984 by Jim Gettys and Mark Vandevoorde, and it remains the reference implementation of VT100/VT220 emulation to this day.

The hardware terminal was dead. Long live the software terminal. By 1990, physical terminals were relegated to server rooms; everyone else ran xterm on a workstation. The economics shifted from $1,500 dedicated hardware to free software on a $5,000 Sun workstation.

The Linux kernel (1991) brought Unix to cheap x86 hardware. The GNU tools made it free. bash (1989, GNU Bourne-Again Shell) replaced csh as the de facto shell. The modern terminal ecosystem was taking shape.

Tatu Ylönen at Helsinki University of Technology invented SSH (Secure Shell) in 1995 after a password-sniffing attack on his university network. Before SSH, remote terminal access used Telnet — transmitting passwords in plain text across the Internet. SSH replaced it overnight.

SSH didn't just encrypt the session — it introduced public key authentication, port forwarding, agent forwarding, and SFTP. The entire practice of remote system administration changed. For the first time, a sysadmin could safely manage a server on the other side of the planet from a café.

OpenSSH (1999, Theo de Raadt / OpenBSD team) made SSH free and universal. Today, every Linux system ships with OpenSSH pre-installed. It is perhaps the most important piece of networking software ever written.

GNU Screen (1987, Oliver Laumann) solved a fundamental problem: SSH sessions die when your connection drops. Screen let you detach a session — leave processes running on the server — and reattach later from anywhere. This was revolutionary for sysadmins.

tmux (2007, Nicholas Marriott) reimagined multiplexing from scratch: clean C codebase, split panes, proper window management, scriptable sessions, and mouse support. The tmux+vim combination became the dominant development environment for a generation of backend engineers.

Today, tmux sessions are immortal. A developer can SSH into a remote server, open tmux, split it into 4 panes — editor, test runner, database shell, log tail — then disconnect and reconnect days later to find everything exactly as left. No window manager required.

Traditional terminal emulators (xterm, GNOME Terminal, Terminal.app) render text on the CPU — one glyph at a time on a software canvas. By 2013, with 4K displays and Retina screens becoming standard, this approach was showing its age. Scrolling through large log files caused dropped frames.

Alacritty (2016, Joe Wilm) was the first GPU-accelerated terminal emulator. By rendering glyphs directly on the GPU via OpenGL, it achieved sub-millisecond input latency and buttery smooth scrolling at 4K resolution. The benchmark that made everyone pay attention: 50,000 lines per second of scrolling at full speed.

Kitty (2017, Kovid Goyal) went further — GPU rendering plus a rich protocol extension for inline images, Unicode ligatures, and a plugin system. WezTerm brought Lua configuration and multiplexing built in. The new generation of terminals looked like it was designed for 2025, not 1978.

For decades, Microsoft treated the terminal as a legacy tool — the ancient cmd.exe dated to DOS 1981, and PowerShell was powerful but the window itself was ugly and limited. Then in 2019, Microsoft shipped Windows Terminal: GPU-rendered, tabbed, themed, with full Unicode, emoji, and ligature font support.

The symbolism was profound. The company that had spent 40 years trying to replace the command line with graphical interfaces — that killed DOS, invented the Start menu, built Microsoft Office — shipped a modern terminal emulator and called it the future. The terminal had won.

Windows Terminal ships by default on Windows 11. WSL2 (Windows Subsystem for Linux) lets Windows users run a full Linux environment inside their terminal. The circle is complete.

Warp (2022) reimagined the terminal from first principles for an AI-native world. Blocks instead of a scrollback buffer. Inline command suggestions. Natural language to shell command translation. The ability to share a terminal session with a URL. Built in Rust, rendered with GPU Metal on macOS.

Ghostty (2024, Mitchell Hashimoto — creator of Vagrant and co-founder of HashiCorp) took a different approach: blazing fast, native, and opinionated. The fastest terminal on macOS by benchmark, with a philosophy of "do one thing, do it perfectly."

Claude, ChatGPT, and Copilot now integrate directly into terminals — suggesting commands, explaining errors, completing shell scripts. The interface that started as a teletype is now talking back.

And yet: the core is unchanged. The prompt. The cursor. The enter key. stdin, stdout, stderr. Everything Ken Thompson designed on a PDP-7 in 1969 still runs, unchanged, inside every AI terminal in 2025.