Why your terminal is called a TTY (and where the teletype still hides)

A "telephone typewriter," photographed for Bell Telephone Magazine in 1922 — Internet Archive, no known restrictions. A keyboard, a printer, and a wire: AT&T was already selling the idea of typing to a machine in another city a century ago. This is the machine your terminal still claims to be.

Open a terminal and type tty. It prints something like /dev/pts/0 — your terminal's device file. The command is asking a question whose literal meaning is: which teletypewriter are you sitting at? You are not sitting at a teletypewriter. Nobody has for decades. But the word never left, and once you know what it stands for, you start seeing the ghost of a century-old electromechanical printing telegraph everywhere in modern computing — in kernel device names, in signal names, in the shape of Unix commands, and in the names of the terminal emulators people argue about today.

From telegraph to teletypewriter

The teletypewriter solved a staffing problem. A classic telegraph needed trained operators who could key and read Morse; a teleprinter replaced them with a typewriter keyboard on one end and an automatic printer on the other. You typed; characters came out, printed, somewhere far away. The idea is older than most people guess: printing telegraphs that typed their output date to the 1840s and 50s — Royal Earl House's machine, then David Hughes's — and teleprinters proper were working in telegraph service by the late 1880s. The encoding under the early machines was a 5-bit code descended from Émile Baudot's 1870s telegraph alphabet — and Baudot's name survives too, clipped into baud, the unit of symbol rate that modem-era users came to know intimately. What turned the teleprinter from a specialist's instrument into infrastructure came in the 1910s, when the Morkrum Company worked out start-stop synchronization — letting cheap machines stay in sync over a wire with no operator attention, one character at a time, each framed by its own start and stop signals. Your serial ports inherited that framing too.

Before the snappier name took over, the Bell System called the machine a "telephone typewriter" — that is what the 1922 photo above was selling, with a pitch that reads strikingly like a description of the modern internet: any subscriber's keyboard connected to any other subscriber's printer, switched like a phone call. "Teletype" itself started as a brand. Morkrum's machines became the Teletype Corporation in 1928, and AT&T bought it in 1930 to feed its TWX teletype network. Like "xerox" and "kleenex," the trademark genericized: any teletypewriter became a teletype, and teletypewriter abbreviated naturally to TTY. Newsrooms, weather services, militaries, and airlines ran on these machines for half a century — the clattering wall of teleprinters is the sound under every mid-century newsroom scene, and it is why news agencies still talk about stories coming in "on the wire."

The Model 33, the minicomputer's keyboard

The machine that carried the teletype into computing was the Teletype Model 33, introduced in 1963 — the same year as the ASCII standard it was built around. It printed ten characters per second, uppercase only, on a roll of paper, and the ASR variant added a paper-tape punch and reader for storage. It was slow and it was loud. It was also cheap — a fraction of the price of the professional-grade machines — which made it the obvious choice for the new minicomputers that small labs could suddenly afford. So the Model 33 became the standard interface to a generation of computers: you typed a line, the computer typed back, and the conversation accumulated on paper scrolling up out of the machine. There was no screen, no cursor, no editing what you'd already sent. When Ken Thompson and Dennis Ritchie built the first Unix on a PDP-7 at Bell Labs in 1969, this was the console. The standard story — repeated by people who were there — is that Unix commands are terse (ls, cp, mv, rm, ed) at least partly because every character cost real time and real noise at ten characters per second on a Model 33.

A paper machine's fossils in your shell

The teletype shaped more than command names. A surprising amount of what your terminal does today is a direct imitation of teleprinter mechanics:

• Carriage return and line feed. A teleprinter had a physical print carriage. \r (carriage return) drove the print head back to the left margin; \n (line feed) rotated the platen to advance the paper one line. Two separate mechanical operations, two separate control characters — which is why Windows line endings are still CRLF, and why the distinction keeps biting people in cross-platform diffs a hundred years after the mechanism it describes.
• The bell. \a is the BEL character. On a Teletype it rang an actual physical bell, so the machine could get a human's attention from across the room. Your terminal "bell" — now usually a beep or a screen flash — is an emulation of that bell.
• SIGHUP. Teletypes connected to remote computers over phone lines. When the line dropped, the modem signaled a hangup, and Unix delivered SIGHUP to the processes attached to that terminal. The phone is gone, the signal remains — it now means "your terminal went away" — and the nohup command exists to let a process survive it.
• Line editing. The line-oriented editor ed reads the way it does because on paper there is no cursor and no redraw: you address lines by number and print them when you want to see them. The whole modal-versus-modeless editor split descends from tools first shaped by paper terminals.

When video terminals like the VT100 arrived in the late 1970s, the early ones were dismissed as "glass TTYs" — a screen pretending to be a paper teletype, scrolling text up and off the top the way paper scrolled out of the machine. The insult was accurate. It still is: that is exactly what a terminal window does.

The kernel never stopped saying teletype

Unix abstracted the physical teletype into a device file, and the abstraction kept the name. /dev/tty is your controlling terminal. Serial terminals were /dev/tty0, /dev/tty1, and so on — on Linux today those names belong to the virtual consoles you reach with Ctrl+Alt+F3, which is why sysadmins still say "switch to a TTY" when the desktop locks up. The TTY layer in the kernel — line discipline, job control, the machinery behind Ctrl+C and Ctrl+Z — is still called the TTY subsystem.

The utilities wear the name openly. getty is literally "get tty" — the process that opens a terminal line and hands you a login prompt (modern Linux runs agetty under systemd). stty is "set tty," for configuring the terminal's settings — including its baud rate, an option that still exists for the case where the terminal really is a serial line. And when you open a terminal window, there is no serial line at all, so the kernel fabricates a pseudo-terminal — a pty — a software pair where your terminal emulator plays the teletype side and your shell can't tell the difference. That is what /dev/pts/0 means: pseudo-terminal slot zero. Your laptop manufactures imaginary teletypes on demand, and SSH allocates one on the remote machine every time you log in.

kitty, Ghostty, PuTTY: the pun that keeps on giving

Which brings us to the names. A terminal emulator is a program whose entire job is to impersonate a teletype, and developers naming them have been mining the TTY suffix for decades:

• PuTTY (1999) is the elder of the pun dynasty. Its author, Simon Tatham, has confirmed the obvious part — "tty is the Unix name for a terminal" — while pointedly declining to explain what "Pu" stands for. A quarter-century-old naming mystery, guarded on purpose.
• kitty (2017), Kovid Goyal's GPU-accelerated terminal, hides the suffix in plain sight: ki-TTY. (Confusingly, there is also an unrelated PuTTY fork named KiTTY — the pun is so good it was independently taken twice.)
• Ghostty (2024), Mitchell Hashimoto's terminal, is the most literal of the lot: a ghost TTY. The teletype is dead; the program is its ghost. As an emulator of a machine that no longer exists, it is hard to name one more honestly.
• Alacritty (2017) blends alacrity — cheerful speed — into the suffix, a name that doubles as the project's performance pitch.

The fossil record extends beyond emulator names. HTML shipped a <tt> tag — teletype text — for rendering monospace type, deprecated now but parsed by browsers to this day; monospace itself is a teletype inheritance, since a machine with a fixed mechanical character pitch cannot kern. And on your phone, accessibility settings still offer "TTY mode": real teletypewriters found a long second life as text telephones for deaf users, and the telecom world kept the name for the protocol.

A short close

TTY is teletypewriter: a printing telegraph with a keyboard, with roots in 1840s printing telegraphs and a name from 1920s wire services, that happened to be the cheapest way to talk to a 1960s minicomputer and so became the template for all computer interaction since. The physical machine left the room fifty years ago. The name stayed in /dev/tty, getty, stty, and the kernel's TTY layer; the mechanics stayed in carriage returns, line feeds, bells, and SIGHUP; the economics stayed in two-letter Unix commands. And the emulators that replaced it keep confessing the inheritance in their names — PuTTY, kitty, Alacritty, and most honestly of all, Ghostty: the ghost of a teletype, haunting a window on your screen.

Count the lineage from House's printing telegraph and it is 180 years old — which makes the terminal, by a comfortable margin, the oldest user interface still in daily use. A telegraph clerk in 1850, a wire-service operator in 1922, a Unix hacker at an ASR-33 in 1969, and you this morning are all doing exactly the same thing: pressing keys to push characters down a wire, and reading what comes back. Like grep and daemon, TTY is a name that looks like jargon and turns out to be history — just much more of it than anyone expects.