Emacs (/ˈiːmæks/ ⓘ), originally namedEMACS (an acronym for "Editor Macros"),[1][2][3] is a family oftext editors that are characterized by theirextensibility.[4] The manual for the most widely used variant,[5]GNU Emacs, describes it as "the extensible, customizable, self-documenting, real-time display editor".[6] Development of the first Emacs began in the mid-1970s,[7][8] and work on GNU Emacs, directly descended from the original, is ongoing; its latest version is 30.2[9] 
, released 14 August 2025.
Emacs has over 10,000 built-in commands and itsuser interface allows the user to combine these commands intomacros to automate work. Implementations of Emacs typically feature adialect of theLisp programming language, allowing users and developers to write new commands and applications for the editor. Extensions have been written to, among other things, managefiles,remote access,[10]e-mail,outlines, multimedia,Git integration,RSS feeds,[11] andcollaborative editing,[12] as well as implementations ofELIZA,Pong,Conway's Life,Snake,Dunnet, andTetris.[13]
The original EMACS was written in 1976 byDavid A. Moon andGuy L. Steele Jr. as a set of macros for theTECO editor.[14][1][2][3][15] It was inspired by the ideas of the TECO-macro editors TECMAC and TMACS.[16]
The most popular, and most ported, version of Emacs is GNU Emacs, which was created byRichard Stallman for theGNU Project.[17]XEmacs is a variant thatbranched from GNU Emacs in 1991. GNU Emacs and XEmacs use similar Lisp dialects and are, for the most part, compatible with each other. XEmacs development is currently very slow.
GNU Emacs is, along withvi, one of the two main contenders in the traditionaleditor wars ofUnix culture. GNU Emacs is among the oldestfree and open source projects still under development.[18]
Emacs development began during the 1970s at theMIT AI Lab, whosePDP-6 andPDP-10 computers used theIncompatible Timesharing System (ITS)operating system that featured a defaultline editor known asText Editor and Corrector (TECO). Unlike most modern text editors, TECO used separate modes in which the user would either add text, edit existing text, or display the document. One could not place characters directly into a document by typing them into TECO, but would instead enter a character ('i') in the TECO command language telling it to switch to input mode, enter the required characters, during which time the edited text was not displayed on the screen, and finally enter a character (<esc>) to switch the editor back to command mode. (A similar technique was used to allow overtyping.) This behavior is similar to that of the programed.
By the 1970s, TECO was already an old program, initially released in 1962.Richard Stallman visited theStanford AI Lab in 1976[20] and saw the lab'sE editor, written by Fred Wright.[21] He was impressed by the editor's intuitiveWYSIWYG (What You See Is What You Get) behavior, which has since become the default behavior of most modern text editors. He returned to MIT where Carl Mikkelsen, ahacker at the AI Lab, had added to TECO a combined display/editing mode calledControl-R that allowed the screen display to be updated each time the user entered a keystroke. Stallman reimplemented this mode to run efficiently and then added amacro feature to the TECO display-editing mode that allowed the user to redefine any keystroke to run a TECO program.[3]
E had another feature that TECO lacked: random-access editing. TECO was a page-sequential editor that was designed for editingpaper tape on thePDP-1 at a time when computer memory was generally small due to cost, and it was a feature of TECO that allowed editing on only one page at a time sequentially in the order of the pages in the file. Instead of adopting E's approach of structuring the file for page-random access on disk, Stallman modified TECO to handle large buffers more efficiently and changed its file-management method to read, edit, and write the entire file as a single buffer. Almost all modern editors use this approach.
The new version of TECO quickly became popular at the AI Lab and soon accumulated a large collection of custom macros whose names often ended inMAC orMACS, which stood formacro. Two years later,Guy Steele took on the project of unifying the diverse macros into a single set.[22] Steele and Stallman's finished implementation included facilities for extending and documenting the new macro set.[3] The resulting system was called EMACS, which stood forEditing MACroS or, alternatively,E with MACroS. Later, the use of EMACS as a recursive acronym forEMACS Makes All Computing Simple became popular; this fit in with the growing use of recursive acronyms for other versions of EMACS. (See below.) Stallman picked the name Emacs "because <E> was not in use as an abbreviation on ITS at the time."[23] Anapocryphalhacker koan alleges that the program was named afterEmack & Bolio's, a popularBoston ice cream store.[24] The first operational EMACS system existed in late 1976.[25]
Stallman saw a problem in too much customization andde facto forking and set certain conditions for usage.[citation needed] He later wrote:[25]
EMACS was distributed on a basis of communal sharing, which means all improvements must be given back to me to be incorporated and distributed.
The original Emacs ran only on the PDP-10 running ITS. Its behavior was sufficiently different from that of TECO that it could be considered a text editor in its own right, and it quickly became the standard editing program on ITS. Mike McMahonported Emacs from ITS to theTENEX andTOPS-20 operating systems. Other contributors to early versions of Emacs includeKent Pitman,Earl Killian, andEugene Ciccarelli. By 1979, Emacs was the main editor used in MIT's AI lab and its Laboratory for Computer Science.[26]
In the following years, programmers wrote a variety of Emacs-like editors for other computer systems. These includedEINE (EINE Is Not EMACS) andZWEI[27] (ZWEI Was EINE Initially), which were written for theLisp machine by Mike McMahon andDaniel Weinreb, and Sine (Sine Is Not Eine),[28] which was written by Owen Theodore Anderson. Weinreb'sEINE was the first Emacs written in Lisp. In 1978,Bernard Greenberg wroteMultics Emacs almost entirely in Multics Lisp atHoneywell's Cambridge Information Systems Lab. Multics Emacs was later maintained byRichard Soley, who went on to develop the NILE Emacs-like editor for the NIL Project, and by Barry Margolin. Many versions of Emacs, including GNU Emacs, would later adopt Lisp as an extension language.
James Gosling, who would later inventNeWS and theJava programming language, wroteGosling Emacs in 1981. The first Emacs-like editor to run onUnix[citation needed], Gosling Emacs was written inC and usedMocklisp, a language with Lisp-like syntax, as an extension language.
Early ads forComputer Corporation of America'sCCA EMACS (Steve Zimmerman) appeared in 1984.[29] CCA EMACS was originally based on Warren Montgomery's EMACS, but was gradually rewritten so that by the time of its commercial release in 1983, none of Montgomery's code was present anymore.[30] CCA EMACS was written to emulate the original PDP-10 EMACS (written byRichard Stallman) as closely as possible, while adding many new commands as well. In 1984, in a competition with other versions of Emacs, it won a site license from MIT for their Project Athena.
Richard Stallman began work on GNU Emacs in 1984 to produce afree software alternative to the proprietary Gosling Emacs. GNU Emacs was initially based on Gosling Emacs, but Stallman's replacement of its Mocklisp interpreter with a true Lisp interpreter required that nearly all of its code be rewritten. This became the first program released by the nascent GNU Project. GNU Emacs is written inC and providesEmacs Lisp, also implemented in C, as an extension language. Version 13, the first public release, was made on March 20, 1985. The first widely distributed version of GNU Emacs was version 15.34, released later in 1985. Early versions of GNU Emacs were numbered as1.x.x, with the initial digit denoting the version of the C core. The1 was dropped after version 1.12, as it was thought that the major number would never change, and thus the numbering skipped from1 to13.[31] In September 2014, it was announced on the GNU emacs-devel mailing list that GNU Emacs would adopt a rapid release strategy and version numbers would increment more quickly in the future.[32]
GNU Emacs offered more features than Gosling Emacs, in particular a full-featured Lisp as its extension language, and soon replaced Gosling Emacs as thede facto Unix Emacs editor.Markus Hess exploited a security flaw in GNU Emacs' email subsystem in his 1986 cracking spree in which he gainedsuperuser access to Unix computers.[33]
Most of GNU Emacs functionality is implemented through ascripting language calledEmacs Lisp. Because about 70% of GNU Emacs is written in the Emacs Lisp extension language,[34] one only needs to port the C core which implements the Emacs Lisp interpreter. This makes porting Emacs to a new platform considerably less difficult than porting an equivalent project consisting of native code only.
GNU Emacs development was relatively closed until 1999 and was used as an example of theCathedral development style inThe Cathedral and the Bazaar. The project has since adopted a public development mailing list and anonymousCVS access. Development took place in a single CVS trunk until 2008 and was then switched to the BazaarDVCS. On November 11, 2014, development was moved toGit.[35]
Richard Stallman has remained the principal maintainer of GNU Emacs, but he has stepped back from the role at times. Stefan Monnier and Chong Yidong were maintainers from 2008 to 2015.[36][37] John Wiegley was named maintainer in 2015 after a meeting with Stallman at MIT.[38] Wiegley stepped down in 2018,[39] leaving Eli Zaretskii as lead maintainer. Stefan Kangas was appointed as co-maintainer in 2023,[40] and Andrea Corallo joined Zaretskii and Kangas in 2024.[41]
As of 2025, GNU Emacs has had 1,608 individualcommitters throughout its history.[42]
Lucid Emacs, based on an early alpha version of GNU Emacs 19, was developed beginning in 1991 byJamie Zawinski and others atLucid Inc. One of the best-known early forks infree software development occurred when the codebases of the two Emacs versions diverged and the separate development teams ceased efforts to merge them back into a single program.[43] Lucid Emacs has since been renamedXEmacs. Its development is currently very slow, with the most recent stable version 21.4.22 released in January 2009, and the most recent beta released in June 2025;[44] meanwhile, GNU Emacs has implemented many formerly XEmacs-only features.[45][better source needed]
Other notable forks include:
In the past, projects aimed at producing small versions of Emacs proliferated. GNU Emacs was initially targeted at computers with a 32-bit flat address space and at least 1 MiB of RAM.[47] Such computers were high endworkstations andminicomputers in the 1980s, and this left a need for smaller reimplementations that would run on commonpersonal computer hardware. Today's computers have more than enough power and capacity to eliminate these restrictions, but small clones have more recently been designed to fit on software installation disks or for use on less capable hardware.[48]
Other projects aim to implement Emacs in a different dialect of Lisp or a different programming language altogether. Although not all are still actively maintained, these clones include:
Emacs is primarily atext editor and is designed for manipulating pieces of text, although it is capable of formatting and printing documents like aword processor by interfacing with external programs such asLaTeX,Ghostscript or aweb browser. Emacs provides commands to manipulate anddifferentially displaysemantic units of text such aswords,sentences,paragraphs andsource code constructs such asfunctions. It also featureskeyboard macros for performing user-defined batches of editing commands.
GNU Emacs is areal-time display editor, as its edits are displayed onscreen as they occur. This is standard behavior for modern text editors but EMACS was among the earliest to implement this. The alternative is having to issue a distinct command to display text, (e.g. before or after modifying it). This was common in earlier (or merely simpler) line and context editors, such asQED (BTS, CTSS, Multics),ed (Unix), ED (CP/M), andEdlin (DOS).
Almost all of the functionality in Emacs, including basic editing operations such as the insertion of characters into a file, is achieved throughfunctions written in a dialect of theLisp programming language. The dialect used in GNU Emacs is known asEmacs Lisp (Elisp), and was developed expressly to port Emacs toGNU andUnix. The Emacs Lisp layer sits atop a stable core of basic services and platform abstraction written in theC programming language, which enables GNU Emacs to be ported to a wide variety of operating systems and architectures without modifying the implementation semantics of the Lisp system where most of the editor lives. In this Lisp environment,variables andfunctions can be modified with no need to rebuild or restart Emacs, with even newly redefined versions of core editor features being asynchronously compiled and loaded into the live environment to replace existing definitions. Modern GNU Emacs features bothbytecode andnative code compilation for Emacs Lisp.
All configuration is stored in variables, classes, and data structures, and changed by simply updating these live. The use of a Lisp dialect in this case is a key advantage, as Lisp syntax consists of so-calledsymbolic expressions (or sexprs), which can act as both evaluatable code expressions and as adata serialisation format akin to, but simpler and more general than, well known ones such asXML,JSON, andYAML. In this way there is little difference in practice between customising existing features and writing new ones, both of which are accomplished in the same basic way. This is operatively different from most modern extensible editors, for instanceVS Code, in which separate languages are used to implement the interface and features of the editor and to encode its user-defined configuration and options. The goal of Emacs' open design is to transparently expose Emacs' internals to the Emacs user during normal use in the same way that they would be exposed to the Emacs developer working on thegit tree, and to collapse as much as possible of the distinction between using Emacs and programming Emacs, while still providing a stable, practical, and responsive editing environment for novice users.
The main text editingdata structure is thebuffer, a memory region containing data (usually text) with associated attributes. The most important of these are:
Modes, in particular, are an important concept in Emacs, providing a mechanism to disaggregate Emacs' functionality into sets of behaviours and keybinds relevant to specific buffers' data.Major modes provide a general package of functions and commands relevant to a buffer's data and the way users might be interacting with it (e.g. editing source code in a specific language,editing hex, viewing the filesystem, interacting withgit, etc.), andminor modes define subsidiary collections of functionality applicable across many major modes (such asauto-save-mode). Minor modes can be toggled on or off both locally to each buffer as well as globally across all buffers, while major modes can only be toggled per-buffer. Any other data relevant to a buffer but not bundled into a mode can be handled by simplyfocussing that buffer and live modifying the relevant data directly.
Any interaction with the editor (like key presses or clicking a mouse button) is realized by evaluating Emacs Lisp code, typically acommand, which is a function explicitly designed for interactive use. Keys can be arbitrarily redefined and commands can also be accessed by name; some commands evaluate arbitrary Emacs Lisp code provided by the user in various ways (e.g. a family ofeval- functions, operating on thebuffer,region, or individualexpression). Even the simplest user inputs (such aprintable characters) are effectuated as Emacs Lisp functions, such as theself-insert-command, bound by default to most keyboard keys in a typical text editing buffer, mapping the key used to call it into the associatedlocale-defined character.
For example, pressing thef key in a buffer that accepts text input evaluates the code(self-insert-command1?f), which inserts one copy of the character constant?fat point. The1, in this case, is determined by what Emacs terms theuniversal argument: all Emacs command code accepts a numeric value which, in its simplest usage, indicates repetition of an action, but in more complex cases (where repetition doesn't make sense) can yield other behaviours. These arguments may be supplied via command prefixes, such asControl+u7f, or more compactlyMeta+7f, which expands to(self-insert-command7?f). When no prefix is supplied, the universal argument is1: every command implicitly runs once, but may be called multiply, or in a different way, when supplied with such a prefix. Such arguments may also be non-positive where it makes sense for them to be so - it is up to the function accepting the argument to determine, according to its own semantics, what a given number means to it. One common usage is for functions to perform actions in reverse simply by checking thesign of the universal argument, such as a sort command which sorts in obverse by default and in reverse when called with a negative argument, using the absolute value of its argument as the sorting key (e.g.-7 sorting in reverse by column index (or delimiter) 7), or undo/redo, which are simply negatives of each other (traversing forward and backward through a recursive history of diffs by some number of steps at a time).
Because of its relatively large vocabulary of commands, Emacs features a long-establishedcommand language, to concisely express the keystrokes necessary to perform an action. This command language recognises the following shift and modifier keys:Ctrl,Alt,⇧ Shift,Meta,Super, andHyper. Not all of these may be present on an IBM-style keyboard, though they can usually be configured as desired. These are represented in command language as the respective prefices:C-,A-,S-,M-,s-, andH-. Keys whose names are only printable with more than one character are enclosed in angle brackets. Thus, a keyboard shortcut such asCtrl+Alt+⇧ Shift+F9 (check dependent formulas and calculate all cells in all open workbooks inExcel) would be rendered in Emacs command language asC-A-S-<f9>, while an Emacs command likeMeta+sfCtrl+Meta+s (incremental file search by filename-matchingregexp), would be expressed asM-s f C-M-s. Command language is also used to express the actions needed to invoke commands with no assigned shortcut: for example, the commandscratch-buffer (which initialises a buffer in memory for temporary text storage and manipulation), when invoked by the user, will be reported back asM-x scra <return>, with Emacs scanning the namespace of contextually available commands to return the shortest sequence of keystrokes which uniquely lexicate it.
Because Emacs predates modern standard terminology forgraphical user interfaces, it uses somewhat divergent names for familiar interface elements. Buffers, the data that Emacs users interact with, are displayed to the user insidewindows, which aretiled portions of the terminal screen or the GUI window, which Emacs refers to asframes; in modern terminology, an Emacsframe would be a window and an Emacswindow would be a panel or split. Depending on configuration, windows can include their own scroll bars, line numbers, sometimes a 'header line' typically to ease navigation, and amode line at the bottom (usually displaying buffer name, the active modes and point position of the buffer among others). The bottom of every frame is used for output messages (then called 'echo area') and text input for commands (then called 'minibuffer').
In general, Emacs display elements (windows, frames, etc.) do not belong to any specific data or process. Buffers are not associated with windows, and multiple windows can be opened onto the same buffer, for example to track different parts of a long text side-by-side without scrolling back and forth, and multiple buffers can share the same text, for example to take advantage of different major modes in a mixed-language file. Similarly, Emacs instances are not associated with particular frames, and multiple frames can be opened displaying a single running Emacs process, e.g. a frame per screen in amulti-monitor setup, or a terminal frame connected viassh from a remote system and a graphical frame displaying the same Emacs process via the local system's monitor.
Just as buffers don't require windows, running Emacs processes do not require any frames, and one common usage pattern is to deploy Emacs as anediting server: running it as aheadlessdaemon and connecting to it via a frame-spawning client. This server can then be made available in any situation where an editor is required, simply by declaring the client program to be the user'sEDITOR orVISUAL variable. Such a server continues to run in the background, managing any child processes, accumulatingstdin from open pipes, ports, or fifos, performing periodic or pre-programmed actions, and remembering buffer undo history, saved text snippets, command history, and other user state between editing sessions. In this mode of operation, Emacs overlaps the functionality of programs likescreen andtmux.
Because of its separation of display concerns from editing functionality, Emacs can display roughly similarly on any device more complex than adumb terminal, including providing typical graphicalWIMP elements on sufficiently featureful text terminals - though graphical frames are the preferred mode of display, providing a strict superset of the features of text terminal frames.
(set-default-coding-systems 'utf-8)(global-set-key(kbd"C-x C-b")'ibuffer)after-save-hook)The first Emacs contained ahelp library that included documentation for every command, variable and internal function. Because of this, Emacs proponents described the software asself-documenting in that it presents the user with information on its normal features and its current state. Each function includes a documentation string that is displayed to the user on request, a practice that subsequently spread to programming languages includingLisp,Java,Perl, andPython. This help system can take users to the actual code for each function, whether from a built-in library or an added third-party library.
Emacs also has a built-intutorial. Emacs displays instructions for performing simple editing commands and invoking the tutorial when it is launched with no file to edit. The tutorial is by Stuart Cracraft and Richard Stallman.
TheChurch of Emacs, formed byRichard Stallman, is aparody religion created for Emacs users.[56] While it refers tovi as theeditor of the beast (vi-vi-vi being6-6-6 in Roman numerals), it does not oppose the use of vi; rather, it calls itproprietary softwareanathema. ("Using afree version of vi is not a sin but apenance."[57]) The Church of Emacs has its ownnewsgroup,alt.religion.emacs,[58] that has posts purporting to support this parody religion. Supporters of vi have created an opposingCult of vi.
The church of Emacs has the following hierarchy:[59]
Stallman has jokingly referred to himself asSt I GNU cius, a saint in the Church of Emacs.[60] This is in reference toIgnatius of Antioch, an early Church father venerated in Christianity.
The wordemacs is sometimes pluralized asemacsen, by phonetic analogy withboxen andVAXen, referring to different varieties of Emacs.[61]
For an editor to be called "emacs" the main requirement is that it be fully extensible with a real programming language, not just a macro language.
GNU Emacs is the most popular and widespread of the Emacs family of editors.
Finally, if you find yourself frustrated, try describing your problems to the famous psychotherapist Eliza. Just do M-x doctor.
"EMACS as such actually started out as a standards project," emails Guy Steele
A cocky novice once said to Stallman: 'I can guess why the editor is called Emacs, but why is the justifier called Bolio?'. Stallman replied forcefully, Names are but names, Emack & Bolio's is the name of a popular ice cream shop in Boston town. Neither of these men had anything to do with the software.' His question answered, yet unanswered, the novice turned to go, but Stallman called to him, 'Neither Emacs nor Bolio had anything to do with the ice cream shop, either.'
I wrote the second Emacs ever: the Lisp machine implementation, whose spec was "do what Stallman's PDP-10 (original) Emacs does", and then progressed from there. There's just a whole LOT of it. It took me and Mike McMahon endless hours to implement so many commands to make ZWEI/Zmacs.
In retrospect 24.3 should have been named 25.1 and 24.4 should have been named 26.1. The.N thingy should really be kept only for bug-fix releases and neither of 24.3, 24.4, nor the previously planned 24.5 are bug-fix releases.
There were people in those days, in 1985, who had one-megabyte machines without virtual memory. They wanted to be able to use GNU Emacs. This meant I had to keep the program as small as possible.
Modern computers have more than enough resources to start and run a full Emacs in a fraction of a second, and Emacs is probably what you want. Zile is a small, fast, and powerful Emacs clone. It is useful for small footprint installations (e.g. on floppy disk), machines with little memory, or quick editing sessions, especially on remote machines or as a different user, e.g. root.
| Implementations |
|  | ||||
|---|---|---|---|---|---|---|
| Modes | ||||||
| Internals | ||||||
| Community |
| |||||
| Other | ||||||
