ItInsightsWorld Retrospective: EMACS Turns 50 — From TECO Macros on the PDP-1 to GNU Emacs Inside Mac OS X
Cursor placement, key-bound commands, macros that bend an editor to one person's habits: routines so ordinary that their birthday rarely gets mentioned. Editing code on a display screen rather than on a printed page is only about half a century old, and EMACS, among the first tools to make that habit normal, reaches 50 this year with a broad installed base still behind it. This IT Insights account traces the chain that produced it — the machines, the conventions, and the people at MIT who concluded that the harder engineering problem was getting everyone to press the same keys.
EMACS first ran on early video terminals at the MIT Artificial Intelligence Laboratory in 1976, and its central ideas proved durable enough to survive repeated rewrites under later operating systems: Apple distributed it with Mac OS X, and the sharing community that formed around EMACS fed the modern free software movement and GNU/Linux.
Stage One: What Programming Looked Like Before the Screen
- Plugboards, 1946. At the University of Pennsylvania, six women working on ENIAC, one of the world's first computers, built programs by moving switches, cables, and plugboards into position. No code text existed to edit in the first place.
- Paper tape at MIT. Some years afterward, engineers gave instructions to Whirlwind by punching them onto paper tape and loading that tape into memory, making it among the first “stored-program” machines. Punch cards followed, with one card standing for one line.
- The line editor, early 1960s. People on interactive computers typed code one line at a time on teletypes, bulky keyboard-and-printer devices, and stored the result on a spinning hard disk comparable in size to a modern washing machine. Full-screen editors that show and change many lines at once did not yet exist.
The Ancestry of EMACS: Three Building Blocks
| Building block | Origin | What it contributed | What it still lacked |
|---|---|---|---|
| TECO | Written in 1962 by Dan Murphy ’65 for MIT's pioneering PDP-1; originally the “Tape Editor and Corrector” | Commands as uppercase letters — “I” inserted text, “D” deleted a character — and, over time, a language in which programmers could build new editing commands called macros | No immediate visual feedback. Once files on a huge shared disk displaced tape, the “T” in the name came to mean “Text” |
| Control-R | An add-on for TECO produced in the fall of 1971 by Carl Mikkelsen ’76 | Exploited “glass teletype” terminals with video displays, so changes appeared immediately on screen and a programmer no longer had to reprint each line to inspect them | Only a few lines could be shown at once, and driving it remained awkward |
| E | A full-screen editor Richard M. Stallman, a researcher at the MIT AI Lab, encountered in 1976 during a visit to Stanford’s AI Lab | The inspiration for Stallman's improvement of Control-R, whose key structural change was that each key ran its own macro when pressed, making customization far easier | Came from another lab; MIT's own hackers needed a common command vocabulary before the idea could scale |
Lab hackers adopted Stallman's code quickly and began altering and adding commands of their own.
The Hard Problem Was Social, Not Technical
That openness created a difficulty for Guy Steele Jr., SM ’77, PhD ’80, who as a graduate student often helped other members debug programs. “I noticed that it was much harder for me to help someone who was using one of these packages rather than straight TECO,” he recalls. “Eventually, it occurred to me to try [to] broker consensus on a standard set of Control-R commands that everyone could agree to use.”
David Moon ’75 assisted, and Stallman joined and eventually led the effort. Together the group assigned a standard command set built on the Meta key carried by many early lab keyboards: Meta-F moved forward one word, Meta-B moved back one word, and similar patterns continued. They named the result EMACS, short for “Editor Macros” or “Editing Macros.” “My goal was not to construct a great new text editor,” says Steele. “I was trying to address a social problem.”
Minutes to Learn, and a Membership Fee Paid in Improvements
Even so, EMACS became a great new text editor. According to a history by Bernard S. Greenberg, SM ’74, users with “no technical experience at all” could learn to edit letters, emails, and even programs “within minutes or an hour.” The same account adds that “Experienced and sophisticated users found EMACS to be eminently more usable than any of the previous forms of editing.”
Distribution followed the logic Stallman spelled out in the 1981 manual, after sending EMACS to anyone who mailed him a magnetic tape and a postage-paid return envelope. “EMACS does not cost anything; instead, you are joining the EMACS software-sharing commune,” he wrote. “The conditions of membership are that you must send back any improvements you make to EMACS.”
Two Companies Turn Editing Macros into Merchandise
Greenberg chose to write his own version for Multics, an early operating system then owned by his employer, Honeywell. His EMACS took first prize at the International Honeywell Software Conference in 1980, and Honeywell began selling it. Honeywell was not the only company marketing a version: James Arthur Gosling, a Carnegie Mellon graduate who later led development of the Java programming language, made a version he eventually sold as a commercial product.
From a Free Editor to a Free Operating System
The shift from free to paid software eventually prompted Stallman to launch a project to build an operating system that users could freely share and improve. He modeled this effort, called the GNU Project, after the increasingly popular Unix operating system from Bell Labs. “GNU” stood for “GNU’s Not Unix,” reflecting that, unlike Unix, it would be free.
The project's first major application was GNU Emacs, now restyled in lowercase. The GNU/Linux operating system was still years away, so, despite the aim of an entirely free operating system, GNU Emacs initially ran on Unix. It later ran on many systems, including Linux and other Unix-based platforms. When Apple launched Mac OS X, the first release of its Unix-based operating system, in 2001, GNU Emacs was included.
The Fingerprints Still Visible in Apple Environments
Apple stopped shipping GNU Emacs in 2019, but it still has a program called mg (“Micro GNU Emacs”). Although mg supports most EMACS commands, it lacks an integrated programming language, making it what some call an “ersatz EMACS.”
Meanwhile, much of Apple's OS still carries hidden support for EMACS commands. The keyboard has no Meta key, but Control-Option-B moves back one word and Control-Option-F moves one forward — the very pairing the MIT lab group standardized decades ago.
Why the Fifty-Year Mark Deserves Attention
Read backwards, the EMACS line explains how editing stopped being a fixed appliance and became a personal instrument: macros that bind a key to behaviour, a command vocabulary agreed for human reasons rather than elegant ones, and a sharing rule that made returning improvements the price of entry. The hardware that started the sequence — the PDP-1, the glass teletype, the washing-machine-sized disk — is long gone, while the conventions assembled in 1976 remain reachable through keystrokes on machines their authors never saw.