Emacs

Emacs /ˈiːmæks/ ^ⓘ, originally named EMACS (an acronym for "Editor Macros"),^[1][2][3] is a family of text editors that are characterized by their extensibility.^[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] and work on GNU Emacs, directly descended from the original, is ongoing; its latest version is 29.2, released January 2024.^[8]

Emacs has over 10,000 built-in commands and its

The original EMACS was written in 1976 by David A. Moon and Guy L. Steele Jr. as a set of macros for the TECO editor.^{[13][1][2][3][14]} It was inspired by the ideas of the TECO-macro editors TECMAC and TMACS.^[15]

The most popular, and most ported, version of Emacs is GNU Emacs, which was created by Richard Stallman for the GNU Project.^[16] XEmacs is a variant that branched 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 inactive.

Emacs development began during the 1970s at the

By the 1970s, TECO was already an old program, initially released in 1962.

Stallman saw a problem in too much customization and de facto forking and set certain conditions for usage.^[citation needed] He later wrote:^[24]

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, like TECO, 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 McMahon ported Emacs from ITS to the TENEX and TOPS-20 operating systems. Other contributors to early versions of Emacs include Kent Pitman, Earl Killian, and Eugene Ciccarelli. By 1979, Emacs was the main editor used in MIT's AI lab and its Laboratory for Computer Science.^[25]

Implementations

Early implementations

In the following years, programmers wrote a variety of Emacs-like editors for other computer systems. These included

Early Ads for Computer Corporation of America's CCA EMACS (Steve Zimmerman)^[28] appeared in 1984.^[29] 1985 comparisons to GNU Emacs, when it came out, mentioned free vs. $2,400.^{[30][irrelevant citation]}

GNU Emacs

Richard Stallman began work on GNU Emacs in 1984 to produce a free 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 in C and provides Emacs 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 as 1.x.x, with the initial digit denoting the version of the C core. The 1 was dropped after version 1.12, as it was thought that the major number would never change, and thus the numbering skipped from 1 to 13.^[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 the de facto Unix Emacs editor. Markus Hess exploited a security flaw in GNU Emacs' email subsystem in his 1986 cracking spree in which he gained superuser access to Unix computers.^[33]

Most of GNU Emacs functionality is implemented through a scripting language called Emacs 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 the Cathedral development style in

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.

committers throughout its history.^[39]

XEmacs

Main article: XEmacs

Lucid Emacs, based on an early alpha version of GNU Emacs 19, was developed beginning in 1991 by

better source needed

Other forks of GNU Emacs

Other notable forks include:

• Aquamacs – based on GNU Emacs (Aquamacs 3.2 is based on GNU Emacs version 24 and Aquamacs 3.3 is based on GNU Emacs version 25) which focuses on integrating with the Apple Macintosh user interface
• Meadow – a Japanese version for Microsoft Windows^[42]

Various Emacs editors

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 

• MicroEMACS, which was originally written by Dave Conroy and further developed by Daniel Lawrence and which exists in many variations.
• mg, originally called MicroGNUEmacs and, later, mg2a, a public-domain offshoot of MicroEMACS intended to more closely resemble GNU Emacs. Now installed by default on OpenBSD.
• UNIX-like
  systems.
• MINCE (MINCE Is Not Complete Emacs), a version for CP/M and later DOS, from Mark of the Unicorn. MINCE evolved into Final Word, which eventually became the Borland Sprint word processor.
• Perfect Writer, a CP/M implementation derived from MINCE that was included circa 1982 as the default word processor with the very earliest releases of the Kaypro II and Kaypro IV. It was later provided with the Kaypro 10 as an alternative to WordStar.
• KiB
  flat memory limit.
• ZetaLisp
  .
• Epsilon,^[45] an Emacs clone by Lugaru Software. Versions for DOS, Windows, Linux, FreeBSD, Mac OS X and OS/2 are bundled in the release. It uses a non-Lisp extension language with C syntax and used a very early concurrent command shell buffer implementation under the single-tasking MS-DOS.
• PceEmacs is the Emacs-based editor for SWI-Prolog.
• Hemlock, originally written in Spice Lisp, then Common Lisp. A part of CMU Common Lisp. Influenced by Zmacs. Later forked by Lucid Common Lisp (as Helix), LispWorks and Clozure CL projects. There is also a Portable Hemlock project, which aims to provide a Hemlock, which runs on several Common Lisp implementations.
• edwin, an Emacs-like text editor included with MIT/GNU Scheme.

Editors with Emacs emulation

• The Cocoa text system uses some of the same terminology and understands many Emacs navigation bindings. This is possible because the native UI uses the Command key (equivalent to Super) instead of the Control key.^[46]
• Eclipse (IDE) provides a set of Emacs keybindings.
• Epsilon (text editor) Defaults to Emacs emulation and supports a vi mode.
• GNOME Builder has an emulation mode for Emacs.
• GNU Readline is a line editor that understands the standard Emacs navigation keybindings. It also has a vi emulation mode.
• IntelliJ IDEA provides a set of Emacs keybindings.
• JED has an emulation mode for Emacs.
• Joe's Own Editor emulates Emacs keybindings when invoked as jmacs.
• MATLAB provides Emacs keybindings for its editor.^[47]
• KornShell has an Emacs line editing mode that predates Gnu Readline.^[48]
• Visual Studio Code has multiple extensions available to emulate Emacs keybindings.
• Oracle SQL Developer can save and load alternative keyboard-shortcut layouts. One of the built-in layouts provides Emacs-like keybindings, including using different commands to achieve closer behavior.

Features

Emacs is primarily a

GNU Emacs is a real-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 as

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-called symbolic expressions (or sexprs), which can act as both evaluatable code expressions and as a data serialisation format akin to, but simpler and more general than, well known ones such as XML, JSON, and YAML. 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 instance such as VS 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 the git 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.

Interactive data

The main text editing data structure is the buffer, a memory region containing data (usually text) with associated attributes. The most important of these are:

• The point: the editing cursor;
• The mark: a settable location which, along with the point, enables selection of
• The region: a conceptually contiguous collection of text to which editing commands will be applied;
• The name and inode of the file the buffer is visiting (if any);
• The default directory, where any
  OS-level commands will be executed from
  by default;
• The buffer's modes, including a major mode possibly several minor modes
• The buffer encoding, the method by which Emacs represents buffer data to the user;
• and a variety of buffer local variables and Emacs Lisp state.

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 with git, etc.), and minor modes define subsidiary collections of functionality applicable across many major modes (such as auto-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 simply focussing 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 a command, 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 of eval- functions, operating on the buffer, region, or individual expression). Even the simplest user inputs (such a printable characters) are effectuated as Emacs Lisp functions, such as the self-insert-command , bound by default to most keyboard keys in a typical text editing buffer, which parameterises itself with the locale-defined character associated with the key used to call it.

For example, pressing the f key in a buffer that accepts text input evaluates the code (self-insert-command 1 ?f), which inserts one copy of the character constant ?f at point. The 1, in this case, is determined by what Emacs terms the universal 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 prefices, such as Control+u 7 f, or more compactly Meta+7 f, which expands to (self-insert-command 7 ?f). When no prefix is supplied, the universal argument is 1: 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 the sign 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).

Command language

Because of its relatively large vocabulary of commands, Emacs features a long-established command 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, and Hyper. 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-, and H-. Keys whose names are only printable with more than one character are enclosed in angle brackets. Thus, a keyboard shortcut such as Ctrl+Alt+⇧ Shift+F9 (check dependent formulas and calculate all cells in all open workbooks in Excel) would be rendered in Emacs command language as C-A-S-<f9>, while an Emacs command like Meta+s f Ctrl+Meta+s (incremental file search by filename-matching regexp), would be expressed as M-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 command scratch-buffer (which initialises a buffer in memory for temporary text storage and manipulation), when invoked by the user, will be reported back as M-x scra <return>, with Emacs scanning the namespace of contextually available commands to return the shortest sequence of keystrokes which uniquely lexicate it.

Dynamic display

Because Emacs predates modern standard terminology for graphical user interfaces, it uses somewhat divergent names for familiar interface elements. Buffers, the data that Emacs users interact with, are displayed to the user inside windows, which are tiled portions of the terminal screen or the GUI window, which Emacs refers to as frames; in modern terminology, an Emacs frame would be a window and an Emacs window would be a split. Depending on configuration, windows can include their own scroll bars, line numbers, sometimes a 'header line' typically to ease navigation, and a mode 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 a multi-monitor setup, or a terminal frame connected via

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 an editing server: running it as a headless daemon 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's EDITOR or VISUAL variable. Such a server continues to run in the background, managing any child processes, accumulating stdin 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 like screen and tmux.

Because of its separation of display concerns from editing functionality, Emacs can display roughly similarly on any device more complex than a

• User actions can be recorded into macros and replayed to automate complex, repetitive tasks. This is often done on an ad-hoc basis, with each macro discarded after use, although macros can be saved and invoked later.
  • Because of the uniformity of Emacs' features' definition in terms of Emacs Lisp, what counts as a "user action" for the purposes of macro-automation is flexible: macros may include, e.g., keypresses, commands, mouse clicks, other macros, and anything that can be effectuated via these. Macros can thus be recursive, and can be defined and invoked inside of macros.
• At startup, Emacs executes an Emacs Lisp script named ~/.emacs (recent versions also look for ~/emacs.el, ~/.emacs.d/init.el, and ~/.config/emacs/init.el;,[49] as well as similar variations on ~/.config/emacs/early-init.el.^[50] Emacs reads early-init.el first if it exists, and it can be used to configure or short-circuit core Emacs features before they load, such as the graphical display system or package manager. It will then execute the first version .emacs or init.el that it finds, ignoring the rest. This personal customization file can be arbitrarily long and complex, but typical content includes:
  • Setting global variables or invoking functions to customize Emacs behaviour, for example (set-default-coding-systems 'utf-8)
  • Key bindings to override standard ones and to add shortcuts for commands that the user finds convenient but don't have a key binding by default. Example: (global-set-key (kbd "C-x C-b") 'ibuffer)
  • Loading, enabling and initializing extensions (Emacs comes with many extensions, but only a few are loaded by default.)
  • Configuring event hooks to run arbitrary code at specific times, for example to automatically recompile source code after saving a buffer (after-save-hook)
  • Executing arbitrary files, usually to split an overly long configuration file into manageable and homogeneous parts (~/.emacs.d/ and ~/elisp/ are traditional locations for these personal scripts)
• The customize extension allows the user to set configuration properties such as the color scheme interactively, from within Emacs, in a more user-friendly way than by setting variables in .emacs: it offers search, descriptions and help text, multiple choice inputs, reverting to defaults, modification of the running Emacs instance without reloading, and other conveniences similar to the
  preferences
  functionality of other programs. The customized values are saved in .emacs (or another designated file) automatically.
• Themes, affecting the choice of fonts and colours, are defined as Emacs Lisp files and chosen through the customize extension.
• Modes, which support editing a range of programming languages (e.g., emacs-lisp-mode, c-mode, java-mode, ESS for R) by changing fonts to highlight the code and keybindings modified (foreword-function vs. forward-page). Other modes include ones that support editing spreadsheets (dismal) and structured text.

Self-documenting

The first Emacs contained a help library that included documentation for every command, variable and internal function. Because of this, Emacs proponents described the software as self-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 including

Emacs also has a built-in tutorial. 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.

Culture

Church of Emacs

Main article:

newsgroup, alt.religion.emacs,^[53]

that has posts purporting to support this parody religion. Supporters of vi have created an opposing Cult of vi.

Stallman has jokingly referred to himself as St I GNU cius, a saint in the Church of Emacs.^[54] This is in reference to Ignatius of Antioch, an early Church father venerated in Christianity.

Emacs pinky

There is folklore attributing a repetitive strain injury colloquially called Emacs pinky to Emacs' strong dependence on modifier keys,^[55] although there have not been any studies done to show Emacs causes more such problems than other keyboard-heavy computer programs.

Users have addressed this through various approaches. Some users recommend simply using the two Control keys on typical PC keyboards like Shift keys while touch typing to avoid overly straining the left pinky, a proper use of the keyboard will reduce the RSI.^[56] Software-side methods include:^[57]

• Customizing the key layout so that the Ctrl key is transposed with the ⇪ Caps Lock key.^[58] Similar techniques include defining the ⇪ Caps Lock key as an additional Control key or transposing the Control and Meta keys. However, as these keys are still often pressed with the same finger, they may still contribute to Emacs pinky.
• Software, such as xwrits or the built-in type-break-mode in Emacs, that reminds the user to take regularly scheduled breaks.
• Using the ErgoEmacs keybindings (with minor mode ergoemacs-mode).^[59]
• Customizing the whole keyboard layout to move statistically frequent Emacs keys to more appropriate places.^[60]
• Packages such as ace-jump-mode^[61] or Emacs Lisp extensions that provide similar functionality of tiered navigation, first asking for a character then replacing occurrences of the character with access keys for cursor movement.
• evil-mode, an advanced Vim emulation layer.
• god-mode, which provides an approach similar to vim's with a mode for entering Emacs commands without modifier keys.
• Using customized key layout offered by Spacemacs and Doom Emacs, projects where space bar key is used as the main key for initiating control sequences. These projects also heavily incorporate both evil-mode and the latter god-mode.^[62]
• StickyKeys, which turns key sequences into key combinations.^[63]
• Emacs' built-in viper-mode that allows use of the vi key layout for basic text editing and the Emacs scheme for more advanced features.^[64]
• Giving a dual role to a more-comfortably accessed key such as the
  Ergonomic keyboards or keyboards with a greater number of keys adjacent to the space bar, such as Japanese keyboards, allow thumb control of other modifier keys too like Meta or Shift.^[65]
• Using a limited ergonomic subset of keybindings, and accessing other functionality by typing M-x <command-name>. M-x itself can also be rebound.
• Driving Emacs through voice input.

Hardware solutions include special keyboards such as

Microsoft Natural keyboard, whose large modifier keys are placed symmetrically on both sides of the keyboard and can be pressed with the palm of the hand.^[55]

Foot pedals can also be used.

The Emacs pinky is a relatively recent development. The Space-cadet keyboard on which Emacs was developed had oversized Control keys that were adjacent to the space bar and were easy to reach with the thumb.^[66]

Terminology

The word emacs is sometimes pluralized as emacsen, by phonetic analogy with boxen and VAXen, referring to different varieties of Emacs.^[67]

See also

• Comparison of text editors
• Conkeror
• GNU TeXmacs
• List of text editors
• List of Unix commands
• Integrated development environment

References

1. ^ ^{a b} Greenberg, Bernard S. (1979). Multics Emacs: The History, Design and Implementation.
2. ^ ^{a b c} "GNU Emacs FAQ".
3. ^ ^{a b c d} Adrienne G. Thompson. "MACSimizing TECO". Archived from the original on 2013-10-24. Retrieved 2012-02-26.
4. ^ "A Tutorial Introduction to GNU Emacs". 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.
5. ^ "GNU Emacs Pocket Reference". GNU Emacs is the most popular and widespread of the Emacs family of editors.
6. ^ "GNU Emacs Manual". FSF. Retrieved 24 November 2012.
7. ^ Zawinski, Jamie (2007-10-29). "Emacs Timeline". www.jwz.org. Retrieved 2023-07-31.
8. ^ "Emacs 29.2 released". lists.gnu.org. Retrieved 2024-01-18.
9. ^ "Tramp User Manual". Free Software Foundation. Retrieved 2009-04-04.
10. ^ "Introducing Elfeed, an Emacs Web Feed Reader".
11. ^ "Collaborative editing using Conflict-free Replicated Data Types".
12. ^ "Amusements". Finally, if you find yourself frustrated, try describing your problems to the famous psychotherapist Eliza. Just do M-x doctor.
13. ^ Zawinski, Jamie (2005-06-21) [1999]. "Emacs Timeline". Retrieved 11 August 2015.
14. ^ Richard Stallman is often credited as another co-creator, but as Daniel Weinreb wrote, "The original (TECO-based) Emacs was created and designed by Guy L. Steele Jr. and David Moon. After they had it working, and it had become established as the standard text editor at the AI lab, Stallman took over its maintenance." Moon himself responded "All true, so far as I can remember. But in all fairness I have to say that Stallman greatly improved Emacs after he “liberated” it from Guy and me." See Weinreb, Dan (November 11, 2007), "Rebuttal to Stallman's Story About The Formation of Symbolics and LMI", Dan Weinreb's blog: software and innovation, archived from the original on January 1, 2009.
15. ^ "A history of Emacs". XEmacs Internals Manual. 2006-12-11. Retrieved 2007-08-22.
16. ^ Allombert, Bill. "Debian Popularity Contest". Editors report. Debian. Retrieved 22 November 2011.
17. ZDNet
    .
18. ISBN 1-56592-152-6
    .
19. ISBN 0-596-00287-4
    .
20. ^ Arthur Samuel (March 1980). "Essential E" (PDF). Retrieved 2020-04-19.
21. ^ "EMACS vs. vi: The endless geek 'holy war'". Archived from the original on 2014-11-26. Retrieved 2014-05-30. "EMACS as such actually started out as a standards project," emails Guy Steele
22. ^ Stallman, Richard M. (1987). "The EMACS Full-Screen Editor". GARB. No. Maj 1987. Lysator, Linköping University. pp. 8–11. Retrieved 2007-09-14.
23. ^ Reynolds, Craig (1992-02-10). Wiseman, David G. (ed.). "The Emac Bolio Name Koan". David G. Wiseman: Stories of Computer Folklore. Archived from the original on January 16, 2003. 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.'
24. ^ ^{a b} Stallman, Richard (March 26, 1981). EMACS: The Extensible, Customizable, Self-Documenting, Display Editor (PDF) (Technical report). MIT AI Lab. AI Memo 519a. Retrieved 2011-01-07.
25. ^ Leigh Klotz (2007-08-29). "email quoted in "Be Careful What You Joke About"". The New York Times. Retrieved 2010-05-01.
26. ^ "Comment by ZWEI's author Dan Weinreb". 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.
27. ^ Owen Theodore Anderson (January 1979). "The Design and Implementation of a Display-Oriented Editor Writing System" (PDF). Retrieved 2012-09-09.
28. ^ Christopher Kelty; Mario Biagioli; Peter Jaszi; Martha Woodmansee (2015). Making and Unmaking Intellectual Property. Computer Corporation of America (CCA) EMACS, written by Steve Zimmerman
29. ^ "Emacs". December 17, 2017.
30. ^ "Differences between GNU Emacs and CCA Emacs".
31. ^ "A History of Emacs".
32. ^ "emacs-devel msg 00872 (2014-09-29)". 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.
33. S2CID 6956966
    .
34. ^ "GNU Emacs". Open Hub. Retrieved 2017-11-25.
35. ^ Raymond, Eric (2014-11-12). "New Git repository is up". Retrieved 2017-11-25.
36. ^ Stallman, Richard (2008-02-22). "Re: Looking for a new Emacs maintainer or team". gnu.org Mailing List. Retrieved 2017-11-25.
37. Network World. Archived from the original
    on 2008-05-23. Retrieved 2017-11-25.
38. ^ Chirgwin, Richard (2015-11-05). "Emacs gets new maintainer as Richard Stallman signs off". The Register. Retrieved 2017-11-25.
39. ^ Raymond, Eric (2014-03-29). "Ugliest…repository…conversion…ever". Retrieved 2017-11-25. twenty-nine years of continuous development by no fewer than 579 people
40. ^ Stephen J., Turnbull. "XEmacs vs. GNU Emacs". Retrieved 2012-10-02.
41. ^ "XEmacs is Dead. Long Live XEmacs!".
42. ^ FrontPage - Meadow Wiki Archived 2012-02-16 at the Wayback Machine
43. ^ "My Lisp Experiences and the Development of GNU Emacs". 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.
44. ^ "GNU Zile (Zile is Lossy Emacs) - Summary". 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.
45. ^ "Lugaru Software Homepage".
46. ^ "Cocoa text system".
47. ^ "Setting up keybindings for the Command Window and Editor". Mathworks Blogs. 2007-05-11. Retrieved 2019-08-18.
48. ISBN 0-13-516972-0
    .
49. ^ "Init file".
50. ^ "Early Init file".
51. ^ "Saint IGNUcius - Richard Stallman". Retrieved 29 January 2015.
52. ^ "The unabridged selective transcript of Richard M Stallman's talk at the ANU". Archived from the original on 4 October 2011. Retrieved 29 January 2015.
53. ^ alt.religion.emacs newsgroup
54. ^ "Saint IGNUcius - Richard Stallman". www.stallman.org. Retrieved 27 March 2018.
55. ^ ^{a b} "How To Avoid The Emacs Pinky Problem". Xahlee.org. Retrieved 2009-11-08.
56. ^ "Emacs: Why You Should Not Swap {Caps Lock, Control} Keys". In touch typing, modifiers comes in pairs, such as ⇧ Shift key. The accepted ergonomic way to press modifier combinations is using one hand to press the modifier key and the other to press the letter key. Using 2 hands avoids single-hand straining its muscle.
57. ^ "EmacsWiki: Repeated Strain Injury". Retrieved 29 January 2015.
58. ^ "Moving The Ctrl Key". EmacsWiki. Retrieved 2009-11-08.
59. ^ "ErgoEmacs Homepage". Retrieved 2018-09-01.
60. ^ "Keymacs layout". GitHub. 15 September 2022.
61. ^ "EmacsWiki: Ace Jump". Retrieved 29 January 2015.
62. ^ "Spacemacs". GitHub. Retrieved 2015-04-20.
63. ^ BayleShanks (2009-10-07). "Sticky Modifiers". EmacsWiki. Retrieved 2009-11-08.
64. ^ "Viper Mode". EmacsWiki. Retrieved 2009-11-08.
65. ^ "At Home Modifier by Evdev". Retrieved 2015-04-14.
66. ^ "Why Emacs's Keyboard Shortcuts are Painful".
67. ^ "VAXen". Catb.org. Retrieved 2009-11-08.

Bibliography

• Ciccarelli, Eugene (1978). An Introduction to the Emacs Editor. Cambridge, Massachusetts: MIT Artificial Intelligence Laboratory. AIM-447. PDF
• Stallman, Richard M. (1981) [1979]. EMACS: The Extensible, Customizable, Self-Documenting Display Editor. Cambridge Massachusetts: MIT Artificial Intelligence Laboratory. AIM-519A. PDF HTML
• ISBN 1-882114-85-X
  .
• Stallman, Richard M. (2002). "My Lisp Experiences and the Development of GNU Emacs". Retrieved 2007-02-01.
• ISBN 1-882114-56-6
  .
• Glickstein, Bob (April 1997). Writing GNU Emacs Extensions. O'Reilly & Associates.
  ISBN 1-56592-261-1
  .
• Cameron, Debra; Elliott, James; Loy, Marc; Raymond, Eric; Rosenblatt, Bill (December 2004). Learning GNU Emacs, 3rd Edition. O'Reilly & Associates.
  ISBN 0-596-00648-9
  .
• Finseth, Craig A. (1991). The Craft of Text Editing -or- Emacs for the Modern World. Springer-Verlag & Co.
  ISBN 978-1-4116-8297-9
  .
• Thompson, Adrienne G. (2009). "MACSimizing TECO". Retrieved 2012-02-26.

External links

Wikiquote has quotations related to Emacs.

Wikimedia Commons has media related to Emacs.

Wikibooks has more on the topic of: Emacs

• Official website
• List of Emacs implementations
• Architectural overview