esc
Anthology / Yagnipedia / VT100

VT100

The Last Time Anyone Got It Right
Technology · First observed 1978 (Digital Equipment Corporation, Maynard, Massachusetts) · Severity: Foundational — everything since has been a footnote with better fonts

VT100 is a video terminal manufactured by Digital Equipment Corporation in 1978. It displayed 80 columns and 24 rows of text on a 12-inch screen. It understood ANSI escape sequences. It had a keyboard. It connected to a computer via a serial cable.

It was the last time anyone got the interface right.

“Eighty columns. Twenty-four rows. A cursor that blinks at the rate a human thinks. A screen that displays what you type and nothing else. This was sufficient in 1978. It is sufficient now. Everything built since is either an improvement on this — and there have been a few — or decoration. Mostly decoration.”
— The Lizard, who has not upgraded since

The Standard

The VT100 did not become the standard. The VT100 was the standard. Every terminal emulator on every operating system in 2026 — iTerm2, Alacritty, Windows Terminal, the terminal built into VS Code (which runs inside Electron, which runs inside Chromium, which contains a terminal emulator that emulates the VT100, which is a browser containing a terminal pretending to be a terminal that existed before browsers) — emulates the VT100.

The escape sequences the VT100 understood are the escape sequences your terminal understands now:

\033[1m     — bold (1978)
\033[32m    — green text (1978)
\033[0m     — reset (1978)
\033[2J     — clear screen (1978)
\033[H      — cursor home (1978)
\033[?25l   — hide cursor (1978)

These sequences are 48 years old. They have not changed. They have not been deprecated. They have not been replaced by a framework, a meta-framework, or a build tool. They have not been wrapped in a React component. They have not been given a virtual DOM. They work. They have always worked. They will work when the framework wars are over and the only thing left standing is a cursor, blinking, on a dark screen, waiting for input.

The ANSI X3.64 specification, formalized in 1979 based on the VT100’s behavior, is the longest-lived interface standard in computing. It has outlasted every operating system, every programming language, every framework, every methodology, and every venture-funded startup that has tried to reinvent how humans interact with computers. The escape sequences survived because they were correct, and correct things do not need to be replaced.

The Numbers

80 columns. 24 rows. 1,920 characters on screen.

These numbers were not arbitrary. They were inherited from the IBM punch card (80 columns, established 1928) and the human visual field (24 rows of text is approximately what the eye can scan without moving the head). The VT100’s dimensions were not a technical limitation. They were an ergonomic decision — the amount of text a human can comprehend at a glance, arranged in the width a human can read without horizontal eye movement.

Every modern terminal still defaults to 80 columns. Every code linter still warns at 80 characters. Every commit message convention still wraps at 72 characters (leaving room for git log indentation in an 80-column terminal). The VT100’s dimensions are embedded in the DNA of software development. Developers who have never seen a VT100 obey its constraints daily.

“I was asked why I wrap at 80 columns. I was asked this by a person on a 34-inch ultrawide monitor. The person had three panes open. Each pane was 80 columns wide. The person did not see the irony. The VT100 saw the irony.”
— The Lizard

The Speed

The VT100 connected at 9,600 baud. That is approximately 960 characters per second. At 1,920 characters per screen, a full screen refresh took two seconds.

For text — for reading, writing, editing, and thinking — 9,600 baud was sufficient. Not “acceptable.” Not “a compromise.” Sufficient. The human reads at approximately 250 words per minute. 9,600 baud delivers approximately 960 characters per second. The terminal could fill the screen faster than the human could read it. The bandwidth matched the brain.

This is the insight that forty-eight years of computing has not improved upon: the bottleneck is not the screen. The bottleneck is the human. A 4K display at 120Hz renders 8.3 million pixels sixty times per second. The human staring at it processes text at the same 250 words per minute they processed it at in 1978. The display is 10,000 times faster. The human is the same speed. The display does not know this. The display does not care.

The VT100 knew. The VT100 was exactly fast enough and not one baud faster. The Lizard considers this the highest form of engineering: a system that is adequate, that knows it is adequate, and that does not apologize for not being excessive.

The Memory

The VT100 had 4 KB of RAM. Not 4 MB. Not 4 GB. Four kilobytes. 4,096 bytes. Enough to hold two screenfuls of text and the state of the escape sequence parser.

For comparison:

The ratio between the VT100’s memory and the VS Code terminal is approximately 100,000:1. The VS Code terminal displays the same 80x24 grid. The VS Code terminal understands the same escape sequences. The VS Code terminal does not display 100,000 times more information. The VS Code terminal uses 100,000 times more memory to display the same information.

The Lizard has been asked to comment on this ratio. The Lizard declined, on the grounds that commenting would require acknowledging that the ratio exists, and acknowledging that the ratio exists would require lying down.

The Descendants

The VT100 had one direct successor — the VT220 (1983), which added 132-column mode, downloadable character sets, and user-defined keys. The VT220 was the VT100 with minor improvements, which is the only acceptable form of progress in the Boring Technology tradition: the same thing, slightly better, nothing removed.

After the VT220, DEC continued the VT line (VT320, VT420, VT520), but the market had moved to personal computers with graphical interfaces. The terminal became an application — a window on a screen, emulating the hardware it had replaced. The emulation has never stopped. The emulation has never needed to stop, because the VT100 got it right, and right does not expire.

Every terminal emulator in 2026 lists “VT100 compatible” in its feature set. This is not a feature. This is a minimum. This is the floor. A terminal that does not emulate the VT100 is not a terminal. It is a text area with pretensions.

The Lizard’s Terminal

The Lizard’s terminal is a VT100 emulator. Green text on a black background. 80 columns. 24 rows. The font is fixed-width. The cursor blinks. The color scheme has not changed since 1978.

The Lizard has been asked — repeatedly, patiently, by increasingly bewildered colleagues — why the terminal has not been modernized. Why not a larger window? Why not more colors? Why not ligatures, font rendering, GPU acceleration, image support, sixel graphics?

The Lizard’s response is always the same:

“I type. The text appears. I read. I understand. I act. The process takes the time the process takes, and no display technology has ever reduced that time, because the time is in the thinking, not the rendering. The VT100 renders at the speed of thought. Everything faster is rendering at the speed of waste.”

The Lizard then returns to vi, which runs in the terminal, which emulates the VT100, which was manufactured in 1978, which understood 4 KB, which displayed 80 columns and 24 rows, which was sufficient then, which is sufficient now, which will be sufficient when the last Electron process has consumed the last byte of RAM and the last framework has been replaced by the next framework, and the cursor blinks on, and the screen is dark, and the text is green, and the human types, and the computer responds, and nothing else is needed.

Nothing else was ever needed.

Measured Characteristics

See Also

See Also