A History of Emacs.

Emacs is a family of text editors with a shared history and shared characteristics. A family with a remarkable longevity in the history of software. The name Emacs was indeed introduced by Richard Stallman et Guy Steele in 1976. And you have to go a decade further in time to encounter the first common ancestor of the family: TECO — a set of commands developed in 1962 in MIT to edit source code. It served as a foundation for creating the first interactive editors, but also as a beneficial repellent that allowed Lisp to come on stage. After 1976, Emacs gave rise to dozens of descendants, one in particular remaining widely used today: GNU Emacs.

These programs were developed to meet a number of requirements that, for the most part, seem obvious to us today: text display, real-time modification display (What You See Is What You Get — WYSIWYG ), editing efficiency (insertion, selection, search…). One characteristic nevertheless guided the pioneers of Emacs and persists today: extensibility. Software of the Emacs family is highly configurable; some even say that GNU Emacs can make coffee.

The history of Emacs is interesting for several reasons. Beyond the evolution of the software family, it reflects challenges in computer science. From the constraints of the PDP-1 punched tape to the birth of free software, through portability demands and reflections on language choice, the development of text editors resonates with the stakes of their time. The history of Emacs also intertwines with actors, institutions, or major projects in computing: James Gosling, Richard Stallman, the MIT, Multics, Unix or GNU , to name but a few. Another interesting point: Emacs’ history does not seem to have known any disruptive innovation. It appears rather as a continuum of developments inspired by preceding ones.

This article aims to cover the history of the Emacs family, from the birth of TECO to the development of GNU Emacs as practiced today. We will see that the Emacs landscape is abundant, with a large number of variants developed over time. We will focus here on the most significant ones.

The starting point: TECO

At the origin of Emacs, there is TECO. Developed in 1962 by Dan Murphy, a MIT student, TECO is a set of interpreted commands intended to modify source code. The Digital Equipment Corporation (DEC) PDP-1 at MIT used punched tape as the main means of reading code. In case of errors, users had two options: punch a new tape or use the PDP-1 editor, which only allowed modification of an entire line and had to be used during the computer’s rare available time.

Frustrated by this line-by-line editor, Dan Murphy invented a “Tape Editor and Corrector”, allowing finer (character-fine) source code editing. Initially, this system was far from interactive. TECO Instructions for modifying a punched tape were edited on another punched tape. The latter was provided to the PDP-1, which read the punched tape containing the instructions and punched a new one.

TECO quickly became interactive. TECO was loaded into memory, and commands were issued directly via the PDP-1 typewriter. Commands consisted of letters and numbers, each character representing a command. For example, “5d” deleted 5 characters, “3c” moved forward 3 characters, “-10l” moved back 10 lines, and “iTEXT <term>” inserted TEXT starting at position i (with “<term>” being a special termination character). The desire to add features like text copying or expression searching led to making TECO a more complete language with variables and conditional structures. Programmers created TECO programs (“macros”) performing various reusable actions. When TECO was ported to other media than punched tapes, the acronym meaning evolved from “Tape Editor and Corrector” to “Text Editor and Corrector”.

TECO was implemented on other machines at MIT, notably the PDP-6 in the Artificial Intelligence lab headed by Marvin Minsky. Digital Equipment Corporation included TECO on the PDP-10 and new PDP-6 versions.

TECO was never patented. As Dan Murphy explains, “For an undergraduate like myself, having people use and like [the programs we had written] was the reward. Besides nobody had any idea how or whether software could be copyrighted or otherwise protected” (MURPHY, Dan. The Beginnings of TECO. IEEE Annals of the History of Computing, october-december 2009, p.114. Available here (visited on 04/04/2026)). This allowed various versions of TECO to develop, but also the birth of more sophisticated text editors.

“You Asked For It, You Got It”

Although versions of TECO had visual display from the mid-1960s, it did not correspond to a “what you see is what you get” (WYSIWYG) display, where the user sees the document as it would be published. With TECO, part of the source code to modify is loaded into a buffer. Modifications may be made there before the rest of the code is loaded into the buffer. On versions allowing visual display, it is this buffer that is shown. However, modifications made to the code are not displayed immediately. Peter Samson describes the typical procedure in a 1965 article: “the user gets TECO into the computer; types in commands to describe where the material to be edited (the “input”) is (either on paper tape or on DECtape as named file). By further commands, he reads the first page into the buffer; inspects it on the display and makes changes by typing in commands; outputs the page onto paper tape of DECtape, and reads in the next page; etc, […]” (SAMSON, Peter. PSP-6 TECO (july 1965). Massachusetts Institute of Technology, Project MAC, Memorandum MAC-M-250. 23 july 1965. p.2. Available here (visited on 04/04/2026)).

As can be read in this excerpt, display and modification operations are separated. In the satirical essay “Real Programmers Don’t Use PASCAL”, where the author describes how a “Real Programmer” (actually a programmer resistant to change) should behave, we can read: “The problem with these editors is that Real Programmers consider “what you see is what you get” to be just as bad a concept in text editors as it is in women. No, the Real Programmer wants a “you asked for it, you got it” text editor — complicated, cryptic, powerful, unforgiving, dangerous. TECO, to be precise” (POST, Ed. Real Programmers Don’t Use PASCAL. 1982. Available here (visited on 04/04/2026)).

At MIT, a researcher in the Artificial Intelligence Laboratory, Carl Mikkelsen, developed a mode on TECO allowing the text displayed on the screen to be directly modified by the user by pressing keys or key combinations. This mode was named “Control R” or “Real-Time edit mode”. For example, control-D deleted a character, with the deletion immediately visible on the screen. A cursor indicated the position of the pointer on the text and characters could also be inserted directly into the visible text on the screen.

Richard Stallman improved it and added the possibility to associate with each key a program written in TECO. In 1976, according to Bernard S. Greenberg, many macro packages coexisted (TMACS and TECMAC notably) and use of TECO outside the “Control R” mode had almost ceased. The ease of developing and running macros in TECO made the program highly extensible and modular — a characteristic that persists today in the Emacs family software.

In 1976, Richard Stallman and Guy Steele created a unified set of commands which they named “Emacs “ (for “Editor Macros”) and structured a way of considering extensibility, documentation, and integration of program functionalities. As Bernard S. Greenberg notes, Emacs users no longer dealt with TECO commands directly: they interacted only with macros defined in Emacs. Thus, Emacs could be considered an editor written in TECO. Using EMACS was much easier than TECO, and it quickly became the standard editor on the ITS operating system (Incompatible Timesharing System, developed at MIT and a pun on Compatible Timesharing System). Hence, this version of Emacs is often called ITS Emacs.

EINE, ZWEI, and Multics Emacs: Lisp Comes on Stage

At the end of the 1970s, two initiatives introduced Lisp into the Emacs landscape. Invented in 1958 by John McCarthy, Lisp (List Processing) is a language primarily designed for functional programming. This programming paradigm tries to minimize side effects by mostly using functions nested within each other to produce results. Many versions of Lisp have been developed over time. Standardization took place in the 1990s, giving rise to Common Lisp. Common Lisp, Scheme, Clojure, Emacs Lisp, and AutoLisp are examples of Lisp variants still in use today.

The first implementation of software written in Lisp with features similar to Emacs was EINE , whose recursive acronym stands for “Eine Is Not Emacs”. Developed by Daniel Weinreb and Mike McMahon, it used the Lisp Machine Lisp variant, a language used on Lisp machines, computers specially designed to run this language. EINE was followed by a second version named ZWEI (“ZWEI Was Eine Initially”). During its development, Daniel Weinreb wrote an undergraduate thesis published in January 1979. In it, the author notes that the user interface of ZWEI is compatible with that of ITS Emacs, that real-time display of modifications occurs on the Lisp machine screen, and that the mouse can be used to move the cursor or select text areas. It seems it was not the choice of Lisp that led to developing ZWEI on a Lisp machine, but rather the reverse: “since everything is written in Lisp on the Lisp machine, the choice was clear” (WEINREB Daniel. A Real-Time Display-oriented Editor for the LISP Machine. Undergraduate thesis. MIT. January 1979. “u/EdwardCoffin” get the thesis and made a summary available here (visited on 11/10/2025). The quotes in this document are not taken from the original document but from the notes from “u/EdwardCoffin”).

The Multics developers decided, after debate, to create a text editor with Emacs-like features. Not wishing to base their work on TECO, which they deemed unsuitable for software implementation, a reflection on the language to use ensued. Unlike EINE and ZWEI, the developers’ choice was not driven by machine specifics but by the requirement to maintain Emacs’ extensibility and modularity. PL/I, developed by IBM and used for Multics, presented several drawbacks (compiled language, maintenance and readability issues when adding many features, costly external module calls performance-wise). The choice then turned to Lisp, which, according to the future Multics Emacs developers, allowed the expected modularity. Furthermore, the Lisp interpreter enabled easy debugging. Bernard S. Greenberg wrote: “The choice of Lisp turned out to be a very wise choice, for the incremental creation of the editor, through its “extensibility,” could have been done in no other language” (GREENBERG, Bernard S.. Multics Emacs: The History, Design and Implementation. 1979. Available here (visited on 04/04/2026)).

GNU Emacs and Free Software

At the beginning of the 1980s, James Gosling developed a text editor for Unix: Unix Emacs (more commonly called Gosling Emacs). This editor was written in C but used a Lisp variant, MockLisp, as an extension language. The fact that programs like Multics Emacs were entirely implemented in Lisp presented a portability problem. Multics Emacs required both a Lisp compiler for the core of the program (basic features) and an interpreter for user-written extensions. However, performant Lisp compilers were not common at the time. Interpreting all the code would also have been too resource-intensive. The hybrid nature of Gosling’s Emacs, with core code in C and a MockLisp interpreter for reading extensions, solved this problem.

While developing his free operating system GNU, Richard Stallman modified Gosling Emacs. He criticized MockLisp for being too poor in data structures to implement the features he wanted. He therefore rewrote an interpreter for the language that would become Emacs Lisp and adapted the internal data structures to be compatible with it. This led to the release of the first version of GNU Emacs in 1985.

In the meantime, Gosling Emacs had been bought by the company Unipress, which marketed it under the name Unipress Emacs. Unipress demanded that Richard Stallman no longer distribute software using part of their code. Stallman therefore completely rewrote his version of Emacs and protected it with a license guaranteeing free use of the source code. This episode, among others, led him to draft what became known from 1988 as the “GNU General Public Licence” (GNU GPL).

With GNU GPL, the protected software must be usable, modifiable, and redistributable (including commercially) freely. It also supports the principle of “copyleft” (opposite of “copyright”): when the code is redistributed, it must be under the same license terms, including for modified versions. The GNU GPL has had a significant impact on the development of free software. To promote these principles, Stallman created the Free Software Foundation (FSF) in 1985. The development project of GNU Emacs was then attached to it.

Emacs from the 1990s to Today

At the end of the 1980s, the company Lucid Inc. wanted to develop an IDE (Integrated Development Environment) based on GNU Emacs for the C and C++ languages. This project, named Energizer, required adding a number of features to the FSF software, particularly a graphical user interface (GUI). Lucid Inc. hired the FSF programmer in charge of Emacs development. This departure caused a significant delay in publishing a new version of GNU Emacs, as the replacement took time to familiarize themselves with the project. Lucid Inc. offered Stallman to integrate its modifications into the FSF-developed program. However, due to disagreements over which code to include in GNU Emacs, Lucid Inc. continued development independently, while the FSF incorporated some of Lucid Inc.’s code into its program. Lucid Emacs was released in 1991, more than a year before the new version of Emacs (19.0).

Later, Lucid Inc. and Sun Microsystems joined forces to develop a text editor. They integrated the code of Epoch, an Emacs variant developed at the University of Illinois, into Lucid Emacs. In 1994, they renamed Lucid Emacs to XEmacs to avoid giving prominence to one company over the other. The same year, Lucid went bankrupt. Developers from the project continued working on XEmacs.

GNU Emacs and XEmacs have benefited from collaborative development that continues to this day. Contributors are volunteers who propose improvements to the programs, accepted or not by “maintainers.” Within the GNU Emacs project, Monnier and Sperber describe a hierarchy among developers, with some able to directly modify the code and accept external contributions. In case of conflicts, a “maintainer” can accept or reject changes. Mailing lists facilitate communication. Today, the collaborative tool used for Emacs is git. Although maintainers could be paid by the Free Software Foundation, this is no longer the case. According to Monnier and Sperber, Emacs development does not follow a defined strategy: participants propose improvements they find appealing.

Bibliography

GREENBERG, Bernard S.. Multics Emacs: The History, Design and Implementation. 1979. Available here (visited on 04/04/2026).

MONNIER, Stefan and SPERBER Michael. Evolution of Emacs Lisp. Proc. ACM Program.

Lang. 4, HOPL. June 2020. Available here (visited on 04/04/2026).

MURPHY, Dan. The Beginnings of TECO. IEEE Annals of the History of Computing, October — December 2009. Available here (visited on 04/04/2026).

POST, Ed. Real Programmers Don’t Use PASCAL. 1982. Available here (visited on 04/04/2026).

SAMSON, Peter. PSP-6 TECO (July 1965). Massachusetts Institute of Technology, Project MAC, Memorandum MAC-M-250. July 23, 1965. Available here (visited on 04/04/2026).

STALLMAN, Richard. My Lisp Experiences and the Development of GNU Emacs. Transcript of Richard Stallman’s speech at the International Lisp Conference. October 28, 2002. Available here (visited on 04/04/2026).

STALLMAN, Richard. The Origin of XEmacs. September 20, 2005. Available here (visited on 04/04/2026).

TAI, Li-Cheng. The History of the GPL. July 4, 2001. Available here (visited on 04/04/2026).

ZAWINSKI, Jamie. Emacs Timeline. March 8, 1999. Updated: October 29, 2007. Available here (visited on 04/04/2026).

ZAWINSKI, Jamie. The Lemacs/FSFmacs Schism. 2000. Available here (visited on 04/04/2026).