Hubbry Logo
search
logo
Editor war avatar
Editor war
Editor war
current hub
E

Editor war

logo
Community Hub0 Subscribers

Wikipedia

Editor war
View on Wikipedia
from Wikipedia

The editor war is the rivalry between users of the Emacs and vi (now usually Vim, or more recently Neovim) text editors. The rivalry has become an endearing part of hacker culture and the free software community.

The Emacs versus vi debate was one of the original "holy wars" conducted on Usenet groups.[1] Since at least 1985, many flame wars have occurred between those insisting that their editor of choice is the paragon of editing perfection, and insulting the opposing group accordingly.[2] Related battles have been fought over operating systems, programming languages, version control systems, and even source code indent style.[3][4]

Background

[edit]
Editor choice being brought up during a presentation at a technology convention

As of 2020, both Emacs and vi can lay claim to being among the longest-lived application programs of all time,[5] as well as being the two most commonly used text editors on Linux and Unix.[6][needs update] Many operating systems, especially Linux and BSD derivatives, bundle multiple text editors with the operating system to cater to user demand. For example, a default installation of macOS contains ed, pico (nano before macOS Monterey 12.3[7]), TextEdit, and Vim.[8]

Humor

[edit]
Richard Stallman appearing as St IGNU−cius, a saint in the Church of Emacs

The Church of Emacs,[9] formed by Emacs and the GNU Project's creator Richard Stallman, is a parody religion.[10] While it refers to vi as the "editor of the beast" (vi-vi-vi being 6-6-6 in Roman numerals), it does not oppose the use of vi; rather, it calls proprietary software a case of anathema. ("Using a free version of vi is not a sin but a penance."[11]) The Church of Emacs has its own newsgroup, alt.religion.emacs, that has posts purporting to support this belief system.

Regarding vi's modal nature (a common point of frustration for new users),[12] some Emacs users joke that vi has two modes – "beep repeatedly" and "break everything." vi users enjoy joking that Emacs's key-sequences induce carpal tunnel syndrome, or mentioning one of many satirical expansions of the acronym EMACS. These include "Escape Meta Alt Control Shift" (a jab at Emacs's reliance on modifier keys),[13] "Eight Megabytes And Constantly Swapping" (in a time when that was a great amount of memory), "EMACS Makes Any Computer Slow" (a recursive acronym like those Stallman uses),[14] or "Eventually Munches All Computer Storage" in reference to Emacs's high system resource requirements. Nonetheless, key bindings from both editors are found in many other contexts. GNU EMACS has been expanded to "Generally Not Used, Except by Middle-Aged Computer Scientists" referencing its most ardent fans and its declining usage among younger programmers in comparison to more graphically oriented editors such as Atom, BBEdit, Sublime Text, Kate, TextMate, Notepad++, and Visual Studio Code.[citation needed]

As a poke at Emacs' creeping featurism, vi advocates have been known to describe Emacs as "a great operating system, lacking only a decent editor".[citation needed] Emacs advocates have been known to respond that the editor is actually very good, but the operating system could use improvement (referring to Emacs' famous lack of concurrency, which has now been added[15]).

A game among UNIX users, either to test the depth of an Emacs user's understanding of the editor or to poke fun at the complexity of Emacs, involved predicting what would happen if a user held down a modifier key (such as Ctrl or Alt) and typed their own name. This game humor originated with users of the older TECO editor, which was the implementation basis, via macros, of the original Emacs.[16]

The Google search engine also joined in on the joke by having searches for vim resulting in the question "Did you mean: emacs" prompted at the top of the page, and searches for emacs resulting in "Did you mean: vim".[17]

In the web series A Murder at the End of the World, there is a scene referencing the editor wars where a character asks a woman if she uses Vi or Emacs.[18]

See also

[edit]

References

[edit]
[edit]

Grokipedia

Editor war

View on Grokipedia
from Grokipedia
The editor war refers to the enduring rivalry and heated debates among users of the vi and Emacs text editors, a cultural phenomenon that originated in the Unix programming community during the mid-1970s and has persisted for decades as one of the oldest software controversies.[1] This "holy war," as it is often called, typically unfolds in online forums and reflects deep philosophical divides over editing paradigms, efficiency, and extensibility, with neither side achieving dominance despite the availability of modern alternatives.[1] The vi editor traces its roots to 1976, when Bill Joy, a graduate student at the University of California, Berkeley, developed it as a full-screen visual interface to the existing ex line editor, building on earlier tools like the ed editor and George Coulouris's em editor.[2][3] Joy's design prioritized efficiency for the era's constraints, including slow 300-baud modems and limited terminal hardware, introducing a modal interface with distinct modes for navigation (normal mode) and text insertion (insert mode) to minimize screen refreshes and keystrokes.[2] This approach made vi lightweight and ubiquitous in Unix distributions, influencing successors like Vim, which added features while preserving its core modal philosophy.[3] In parallel, Emacs emerged in 1976 at MIT's Artificial Intelligence Laboratory as a collection of macros for the TECO (Tape Editor and Corrector) editor, authored by Richard Stallman and Guy L. Steele to enable user extensibility through programmable commands.[4] Stallman began enhancing TECO-based Emacs as early as 1974, evolving it into a customizable display editor that emphasized flexibility over minimalism, allowing users to redefine keys and behaviors via an embedded Lisp interpreter.[5] The modern GNU Emacs, initiated by Stallman in 1984 as part of the GNU Project, formalized this vision within the free software movement, incorporating advanced features like self-documentation and integration with external tools, and remains actively developed today.[6] At the heart of the editor war lie stark contrasts in design philosophy: vi advocates praise its steep but rewarding learning curve, speed on resource-constrained systems, and "do one thing well" Unix ethos, while Emacs supporters highlight its modeless operation, vast customizability, and evolution into a comprehensive environment for coding, email, and more.[1] These differences fueled early Usenet flame wars in the 1980s and continue in contemporary discussions on platforms like Reddit and [Hacker News](/page/Hacker News), symbolizing broader tensions between simplicity and power in software design.[1] Despite convergence—such as Vim modes in Emacs and GUI enhancements—the rivalry endures as a rite of passage for programmers, underscoring the editors' lasting influence on open-source culture.[1]

Overview

Definition and Scope

The editor war denotes the enduring, often lighthearted but fiercely contested rivalry among users of modal text editors such as vi and its derivatives like Vim, and extensible editors like Emacs, primarily within Unix and open-source software communities.[7] This cultural phenomenon highlights passionate discussions over editor preferences, reflecting broader tensions in software tool selection and philosophy among developers and system administrators.[8] The scope of the editor war is confined to command-line text editors used for programming, scripting, and system administration tasks, distinguishing it from graphical word processors or comprehensive integrated development environments (IDEs), except where such tools explicitly engage with the vi-Emacs divide.[7] While modern IDEs may incorporate vi-like modes or Emacs keybindings, the core rivalry remains rooted in these foundational Unix-era tools and their minimalist versus highly customizable approaches. The debate traces its roots to the mid-1970s software development era, with vi originating in 1976 as a visual interface developed by Bill Joy at the University of California, Berkeley, building on the earlier ex line editor.[9] Similarly, Emacs emerged in 1974 as a set of macros for the TECO editor, initiated by Richard Stallman along with collaborators including Guy L. Steele and David Moon at MIT's AI Laboratory.[5] By the mid-1980s, the rivalry had coalesced into public "holy wars" on Usenet, formalizing the humorous yet divisive exchanges that continue to define hacker culture.[7]

Cultural Significance

The editor war, particularly the longstanding rivalry between vi and Emacs, stands as one of the inaugural "holy wars" in hacker culture, characterized by intense, recurring flame wars on Usenet that exemplified the tribalism emerging in early internet and free software communities. These debates transcended mere technical preferences, fostering a sense of communal identity where allegiance to one editor over the other signaled deeper philosophical stances, such as vi's emphasis on minimalism and efficiency versus Emacs's focus on extensibility and customization.[10] By embodying passionate, often humorous divisions within the open-source movement, the conflict helped establish norms for vigorous discourse in tech forums, where minor differences in tools or practices could escalate into emblematic battles. Within developer circles, selecting an editor became a rite of passage, marking initiation into the hacker ethos and reinforcing group affiliations that persisted across projects and platforms.[1] This allegiance often reflected not just practical habits but a broader worldview, with vi users prizing portability and speed in resource-constrained environments, while Emacs advocates championed an all-encompassing, programmable workspace.[10] The war's symbolic weight extended to the free software ethos, where Emacs, developed under the GNU Project, symbolized collaborative extensibility, contrasting with vi's roots in proprietary Unix traditions before its open-source adaptations.[10] The rivalry's broader cultural footprint is evident in its role as a template for subsequent tech debates, inspiring analogous "holy wars" like tabs versus spaces in code indentation, which similarly pit flexibility against uniformity in developer practices. Anecdotal evidence from the era underscores the divide's persistence; a 1991 Usenet poll revealed roughly half of respondents favoring vi, highlighting the near-even schism that fueled ongoing cultural lore in Linux and Unix communities.[11] This enduring polarization, far beyond any objective merits of the editors, cemented the editor war as a cornerstone of open-source tribalism, where tool choice became a proxy for innovation and ideology.[1]

History

Origins of vi and Emacs

The vi text editor was created in 1976 by Bill Joy, then a graduate student at the University of California, Berkeley, as a visual mode extension to the ex line editor he had co-developed with Chuck Haley, positioning it as a more intuitive alternative to the command-line ed editor used in early Unix systems.[9] Designed amid the hardware limitations of the era, vi incorporated modal editing—separating command and text-entry modes—to optimize for sluggish peripherals like the ADM-3A terminal and 300-baud modems, enabling efficient operation with minimal screen refreshes and keystrokes despite delays in display updates.[12] Within Berkeley's dynamic Unix research environment, vi was bundled into the inaugural Berkeley Software Distribution (BSD) release in 1977, facilitating its dissemination among academic users and contributing to BSD's evolution as a major Unix variant.[13][14] A pivotal advancement occurred in 1981, when Berkeley licensed vi for inclusion in AT&T's UNIX System III, marking its transition into commercial Unix distributions and accelerating its standardization across diverse systems. Concurrently, Emacs emerged in 1976 at the MIT Artificial Intelligence Laboratory, where Richard Stallman and Guy L. Steele implemented it as a suite of macros extending the TECO editor on the Incompatible Timesharing System (ITS) for PDP-10 machines, aiming to streamline complex editing tasks in a research setting.[15] Over the ensuing years, these TECO macros matured into a robust, self-documenting framework with integrated online documentation, tutorials, and help systems, while its extensible architecture allowed users to redefine commands and add functionality via custom macros during runtime.[5] Emacs embodied the MIT AI Lab's ethos of open collaboration and software sharing, which prefigured free software principles by encouraging communal modifications and redistribution. In 1985, Stallman launched GNU Emacs (initially version 1, later refined to version 13 for public release) as the cornerstone program of the GNU Project, explicitly advancing the vision of a fully free Unix-compatible operating system.[16] These parallel developments unfolded in the Unix-centric landscapes of Berkeley and MIT, with vi propagating through BSD distributions and Emacs aligning with free software advocacy, establishing both as foundational tools in early computing workflows.[14][13] vi's modal approach contrasted with the modeless paradigm that Emacs adopted, where editing commands integrate seamlessly with text input without mode switches.[9]

Emergence of the Rivalry

The rivalry between vi and Emacs crystallized in the mid-1980s amid the growing adoption of Unix systems in academic and commercial settings, where debates over text editor preferences began to escalate into community-wide conflicts. The first documented flare-ups occurred on Usenet, particularly in groups like comp.unix and net.unix-wizards during 1984 and 1985, as users launched flame wars centered on the editors' usability—such as modal versus non-modal interfaces—and philosophical underpinnings, including simplicity versus extensibility.[7] These early discussions marked the onset of what would become one of computing's most enduring "holy wars," transforming technical disagreements into passionate, ritualistic exchanges.[10] A pivotal catalyst was Richard Stallman's vigorous advocacy for Emacs within free software communities. As the founder of the GNU Project, Stallman released GNU Emacs in March 1985, positioning it as a freely modifiable, Lisp-based powerhouse that embodied the principles of open collaboration and user empowerment.[1] This push clashed directly with vi's entrenched role as the lightweight, ubiquitous default in commercial Unix distributions from vendors like Sun Microsystems and AT&T, which prioritized minimal resource use and broad compatibility over customization.[17] Stallman's efforts to promote Emacs as essential infrastructure for free software development intensified the divide, drawing vi loyalists who viewed it as an overengineered intrusion. The conflict spread rapidly through 1980s Bulletin Board Systems (BBSes) and the nascent internet, where hobbyist and professional programmers shared experiences and frustrations. Usenet threads titled "Emacs vs. vi" proliferated, reaching a peak of activity in 1987 with informal polls, user manifestos, and comparative benchmarks that fueled ongoing contention without yielding consensus.[10] These exchanges not only amplified the rivalry across geographically dispersed communities but also embedded it in hacker culture, turning editor choice into a badge of identity. From the outset, stereotypes emerged that defined the opposing camps: vi users were often portrayed as efficient minimalists who prized speed and portability in resource-constrained environments, while Emacs users were seen as power-customizers willing to invest in complex configurations for unparalleled flexibility.[1] Despite sporadic attempts at reconciliation, such as neutral tool integrations, the schism persisted unresolved, becoming firmly entrenched by 1990 as both editors influenced subsequent tools and debates in open-source ecosystems.[7]

Core Rivalries and Debates

vi/Vim vs. Emacs: Key Arguments

The rivalry between vi/Vim and Emacs centers on fundamental differences in design philosophy and user experience, with proponents of each editor advancing distinct usability arguments. Advocates for vi and its successor Vim emphasize the efficiency of modal editing, where the interface switches between insertion and command modes, allowing users to build speed through muscle memory and chord-like key combinations without lifting hands from the home row. This approach is particularly valued in resource-constrained environments like remote servers, where vi's minimal footprint enables quick startups and low overhead, making it ubiquitous on Unix-like systems.[18] Critics of Emacs from the vi camp often portray it as an overbuilt "operating system masquerading as an editor," arguing that its expansive scope leads to unnecessary complexity and bloat for straightforward text manipulation tasks.[19] In contrast, Emacs supporters highlight the intuitiveness of its modeless editing paradigm, where keys always perform insertion or navigation without mode shifts, reducing cognitive load for beginners and enabling fluid, free-form composition. The editor's profound extensibility through Emacs Lisp—a full programming language integrated at its core—allows users to embed diverse tools directly, such as email clients like RMAIL for reading and replying to messages or even simple games, transforming Emacs into a customizable workspace for complex, multi-task workflows.[18][5] From this perspective, vi appears archaic and rigidly limited, ill-suited for modern programming demands that require seamless integration beyond basic editing.[19] At the heart of the debate lies a philosophical schism: vi embodies the Unix philosophy of tools that "do one thing well," prioritizing simplicity, modularity, and interoperability with other utilities over all-encompassing functionality.[19] Emacs, conversely, represents an integrated environment where the editor evolves into a self-sufficient Lisp-based platform, encouraging deep personalization but demanding ongoing investment in configuration. Learning curve arguments further divide users, with vi's initial modal hurdle seen as a one-time barrier yielding long-term efficiency, while Emacs' gentler entry gives way to a perpetual customization process that some view as empowering and others as daunting.[18] Common refrains in the community underscore these tensions, such as vi loyalists dismissing Emacs as needlessly heavyweight, while Emacs enthusiasts proclaim it the tool of "real programmers" capable of handling any task through extension.[19] These exchanges, often laced with humor, reflect enduring loyalties formed in the early days of Unix development.

Technical Comparisons

The editing paradigms of vi and its derivative Vim differ fundamentally from those of Emacs. Vi employs a modal system with three primary modes: normal mode for navigation and command issuance, insert mode for text entry, and command mode for executing ex-style commands like substitutions.[20] This modal approach enhances efficiency for repetitive tasks by allowing users to stay in normal mode for quick edits—such as using motion commands (e.g., w for word) combined with operators (e.g., d for delete) and counts (e.g., 3dw to delete three words)—without interrupting workflow to enter text unnecessarily.[20] In contrast, Emacs uses a non-modal paradigm relying on key combinations, typically involving modifier keys like Ctrl or Meta (Alt), to invoke commands directly while editing.[21] Emacs organizes text into buffers, which are internal representations of files or scratch areas, enabling seamless switching between multiple documents without reloading.[21] This buffer-centric model supports a unified editing environment but requires memorizing chord-like sequences (e.g., C-x C-s to save), differing from vi's mode-switching via single keystrokes like Escape.[21] Extensibility in Emacs is achieved primarily through Emacs Lisp (Elisp), a dialect of Lisp integrated directly into the editor, allowing users to define custom functions, modes, and plugins that modify core behavior. For instance, Org-mode, a popular Elisp-based extension, provides structured note-taking, task management, and document authoring capabilities by leveraging buffers and dynamic key bindings. Vim, on the other hand, uses Vimscript (or its modern Vim9 variant) for scripting, along with Ex commands for configuration and automation, enabling plugin development for features like syntax highlighting or folding.[22] While both languages support variables, functions, and control structures, Elisp's homoiconic nature facilitates deeper introspection and modification of Emacs internals, whereas Vimscript emphasizes concise mappings and expressions for editor tweaks.[22] Resource-wise, Emacs configurations often consume significantly more memory due to its Lisp interpreter and loaded packages, making it less ideal for resource-constrained environments, while vi/Vim remains lighter, suiting embedded systems.[23] Performance benchmarks highlight vi/Vim's advantages in startup time and resource efficiency. Vim launches much faster than Emacs without optimizations like the daemon mode, due to vi's simpler architecture.[23] On low-end or embedded hardware, Vim exhibits lower CPU usage during operations like scrolling large files, as its modal design avoids constant event polling inherent in Emacs's extensible framework.[23] Both editors support terminal-based operation across platforms, but Emacs offers native GUI modes via toolkits like X11 or GTK, adding optional overhead for visual features.[21] An empirical study of academic writing tasks found experienced Emacs users completing edits faster than Vim users in some scenarios, though novices benefited more from vi's predictability; however, these results pertain to task completion rather than raw system performance.[24] Standardization further distinguishes the editors: vi is defined in the POSIX.1 standard, ensuring a minimal, portable implementation across Unix-like systems with required features like basic modes and commands.[20] Emacs, developed as part of the GNU Project, serves as a de facto standard for GNU/Linux environments, where it is the default extensible editor in distributions like those from the Free Software Foundation.[6]

Cultural Impact

Humor and Memes

The editor war has inspired a rich tradition of humor, originating in the flame wars of 1980s Usenet groups where users exchanged satirical jabs about their preferred editors' philosophies and capabilities.[25] Classic jokes often portrayed the rivalry in religious terms, such as the satirical "Church of Emacs," which depicts Emacs as a divine tool and vi as the "Editor of the Beast" due to "vi" representing the Roman numeral VI (6), evoking 666. Another enduring quip from vi advocates mocked Emacs's resource demands on early hardware with the backronym "EMACS: Eight Megabytes And Constantly Swapping," highlighting its extensibility at the expense of efficiency.[1] These early jests frequently appeared in Usenet signatures and posts, framing vi users as dogmatic minimalists and Emacs users as expansive innovators. As internet culture evolved, the memes transitioned from Usenet to 1990s email chains and early 2000s forum discussions, where jokes like "Emacs is a great operating system, but it lacks a decent text editor" emphasized Emacs's vast feature set.[10] In the 2000s, such humor proliferated in tech articles and online communities, including parodies in open-source literature; for instance, Eric S. Raymond's "The Cathedral and the Bazaar" references Emacs's development as a model of collaborative "bazaar-style" innovation, implicitly contrasting it with more rigid tools like vi. ASCII art "battles" depicting vi and Emacs as warring entities also emerged in forum posts and email signatures, symbolizing the modal versus modeless debate through whimsical illustrations.[26] Notable cultural artifacts include the GNU Project's "Emacs vs. Vi" filk song, a humorous ballad set to the tune of "Ghost Riders in the Sky" that chronicles the rivalry's absurdities.[27] Comics and parodies, such as those in hacker zines and early web strips titled "The Editor War," further visualized the conflict as epic clashes between minimalist warriors and extensible overlords. Modern variants continue on platforms like Twitter and Reddit, adapting classic tropes to contemporary contexts like cloud computing, but retain the core tribal banter.[1] This humor has played a key role in diffusing the editor war beyond technical circles, transforming a niche debate into enduring internet folklore that invites newcomers to engage playfully with hacker traditions.[25] By reducing technical tribalism to shareable wit, these memes ensure the rivalry remains a lighthearted staple of programming culture.[10]

Community Dynamics

The editor war profoundly shapes interactions within developer communities, manifesting in persistent discussions across online forums while prompting measures to curb disruptions. Dedicated spaces, such as subreddits for Vim and Emacs enthusiasts, foster specialized conversations on configurations and extensions, but broader platforms like Stack Overflow frequently close threads comparing the two editors as primarily opinion-based, aiming to prevent off-topic derailments that could overshadow technical queries.[28] This moderation reflects a community consensus that the rivalry, while culturally ingrained, should not impede problem-solving. Similarly, meta discussions on Stack Overflow emphasize resolving edit conflicts arising from ideological preferences in code examples, underscoring the war's potential to escalate into unproductive conflicts.[29] At conferences like FOSDEM and USENIX, the editor war contributes to informal networking and divides, with Birds-of-a-Feather (BoF) sessions often centering on one editor's advancements, such as Emacs Lisp enhancements at FOSDEM, inadvertently highlighting factional loyalties.[30] These gatherings, dating back to the 1980s when the rivalry emerged in Usenet groups, serve as venues for both collaboration and light-hearted sparring, where editor choice can spark connections among like-minded attendees or create subtle barriers in group formations.[25] Anecdotes from such events illustrate how the debate persists as a hacker culture ritual, blending technical discourse with social bonding, though it rarely dominates formal agendas. Socially, the rivalry exerts inclusion and exclusion effects, particularly for newcomers, as vi's ubiquity in Unix-like systems positions it as an informal prerequisite for sysadmin roles, fostering gatekeeping where proficiency signals competence.[31] Conversely, it creates bonding rituals among veterans, with the ongoing debate reinforcing shared cultural identity in developer circles. Surveys reveal a divided yet skewed landscape: the 2025 Stack Overflow Developer Survey reported 15.7% usage for Vim and 13.3% for Neovim among respondents, with Emacs usage remaining low at approximately 4% and not listed among the top editors, indicating Vim's dominance but a persistent, if smaller, Emacs contingent that sustains the tension into the 2020s.[32] Efforts to resolve the war include neutral defaults in Linux distributions, such as Ubuntu's promotion of nano as a beginner-friendly editor for quick configurations, explicitly designed for ease of use without the modal complexity of vi or the extensibility overhead of Emacs.[33] This choice counters gatekeeping by prioritizing accessibility, allowing newcomers to contribute without immediate immersion in the rivalry; similar shifts in Debian and Gentoo toward nano as the system default emphasize simplicity and low learning barriers to broaden participation.[34] These configurations represent a pragmatic pushback, fostering inclusive dynamics while acknowledging the war's enduring influence.

Modern Developments

Evolutions and Forks

Vim, developed by Bram Moolenaar, was first publicly released in 1991 as an improved version of the vi editor, initially ported from the Stevie editor for the Amiga platform and later adapted for Unix systems.[35] Over the following decades, Vim evolved through numerous releases, with significant enhancements including the addition of syntax highlighting in version 5.0 in 1998, which allowed for color-coded display of code elements to aid readability and error detection.[35] These developments positioned Vim as a robust, feature-rich alternative to the original vi, emphasizing modal editing while incorporating modern capabilities like multiple windows (introduced in 1994) and graphical user interfaces (in 1996).[35] In 2014, Neovim emerged as a fork of Vim, aimed at refactoring the codebase for better maintainability and extensibility to attract a new generation of developers.[36] Neovim introduced a modern plugin architecture that supports asynchronous operations, enabling non-blocking plugin execution, and integrated Lua as a primary scripting language for configuration and extensions, reducing reliance on Vimscript.[37] This fork has drawn vi traditionalists who value its compatibility with existing Vim plugins while offering improved performance for complex, async-dependent tools, such as language servers, thereby subtly shifting dynamics in the longstanding rivalry by providing vi-like efficiency with Emacs-inspired extensibility.[38] Subsequent releases, such as version 0.10 in September 2024, further enhanced Lua APIs, tree-sitter integration, and performance optimizations.[39] On the Emacs side, GNU Emacs continued its iterative development, with version 28.1 released in April 2022 introducing native compilation of Emacs Lisp code as a default feature on supported platforms, significantly boosting startup times and runtime performance through ahead-of-time compilation using libgccjit.[40] Version 29.1, released in July 2023, integrated Eglot as the built-in Language Server Protocol client, providing native IDE-like features without external packages and further bridging gaps with vi-style editors through improved customization options.[41] To bridge the modal editing gap for vi users, distributions like Spacemacs—launched in October 2014 as a community-driven Emacs configuration—integrated Evil mode, an extensible vi emulation layer that replicates vi's states and keybindings within Emacs' ecosystem.[42] Evil mode, developed as a package for seamless vi-like interaction, has allowed Emacs to incorporate vi workflows without abandoning its Lisp-centric customization model. These evolutions have influenced adoption patterns, with Vim remaining preinstalled on most Unix-like systems for its lightweight footprint and POSIX compatibility, serving as the default editor in environments like Linux distributions.[43] According to the 2023 Stack Overflow Developer Survey, Vim held approximately 22% usage among developers, Neovim around 12%, and Emacs about 5%; by 2024, these figures were Vim 17%, Neovim 14%, and Emacs 4%, with the 2025 survey indicating continued growth in Neovim's admiration (74%) and Vim's usage around 24%.[44][45][32] In the 2020s, both lineages integrated the Language Server Protocol (LSP) for IDE-like features: Neovim embedded vim.lsp support starting in version 0.5 (July 2021) for built-in client functionality, and Emacs' lsp-mode, which matured through releases like 7.0 in July 2020, provided robust server integration via community-maintained clients.[46][47] Despite these convergences, the rivalry endures in configuration-focused communities, where debates over plugin ecosystems and scripting paradigms continue to fuel distinct user loyalties.

Broader Influence

The editor war has inspired the development of hybrid text editors and integrated development environments (IDEs) that incorporate keybindings and extensibility features from both vi and Emacs traditions. Visual Studio Code, released in 2015, exemplifies this trend by offering official extensions for Vim emulation through VSCodeVim, which provides modal editing and motion commands, and for Emacs-style keymaps via the Awesome Emacs Keymap extension, allowing users to blend familiar workflows with modern GUI features.[48][49] Similarly, Atom, launched in 2014 and discontinued in 2022, drew from Emacs's extensibility model by enabling users to build custom packages in JavaScript, fostering a hackable ecosystem that echoed the Lisp-based customization central to Emacs.[50] This rivalry has left a lasting cultural legacy in software development, influencing debates around IDE customization and reinforcing open-source norms of extensibility and forking. For instance, JetBrains IDEs like IntelliJ IDEA include IdeaVim, a plugin that integrates Vim's editing modes while preserving IDE functionalities such as refactoring, highlighting how the war's emphasis on efficient keybindings permeates professional tools.[51] Within the Emacs ecosystem, packages like Magit—a Git porcelain interface—demonstrate the war's promotion of deep customization, where users fork and extend core tools to suit specialized needs, a practice that has become standard in open-source collaboration. The intensity of the editor war has diluted with the rise of GUI-based editors and AI-assisted coding tools in the 2020s, as developers increasingly prioritize integrated features over modal editing purity. Modern IDEs like Visual Studio Code, used by 59% of developers as of 2024 (and approximately 75% in 2025), offer built-in intelligence and collaboration that reduce reliance on terminal-centric editors, while AI tools such as GitHub Copilot automate routine tasks, shifting focus from editor choice to productivity enhancements.[45][52] However, the core divide persists in terminal workflows, where Vim's ubiquity on servers maintains its edge.[25] Looking ahead, the editor war's influence endures in niche domains: vi derivatives remain favored in DevOps and embedded systems for their lightweight footprint and server compatibility, with Vim used by approximately 24% of developers as of 2025.[52] Conversely, Emacs supports creative coding practices like literate programming through Org-mode's Babel, enabling seamless integration of code, documentation, and execution in a single file, appealing to researchers and complex project maintainers.[53]

References

  1. Oldest software rivalry: Emacs and Vi, two text editors used by ...
  2. Bill Joy's greatest gift to man – the vi editor
  3. vi History
  4. Origin of the term Emacs (GNU Emacs FAQ) - GNU.org
  5. EMACS: The Extensible, Customizable Display Editor - GNU.org
  6. GNU Emacs - GNU Project
  7. holy wars - catb. Org
  8. http://catb.org/jargon/html/V/vi.html
  9. The Traditional Vi
  10. EMACS vs. vi: The endless geek 'holy war' - Linux.com
  11. vi - catb. Org
  12. The vi editor story - an interview with Bill Joy - nixCraft
  13. Origins and History of Unix, 1969-1995 - catb. Org
  14. History of UNIX - Part II - Minnie.tuhs.org
  15. Emacs Historical Archive - Software Preservation Group
  16. My Lisp Experiences and the Development of GNU Emacs
  17. The Decades-Long Running Feud Between vi and EMACS users
  18. https://dl.acm.org/doi/10.1145/800045.801603
  19. Choosing an editor
  20. vi
  21. Top (GNU Emacs Manual)
  22. Vim: usr_41.txt
  23. Vim vs. Nano vs. Emacs: Three sysadmins weigh in - Red Hat
  24. Differences between Emacs and Vim [closed] - Stack Overflow
  25. An Efficiency Comparison of Text Editors Used in Academic ...
  26. Modern IDEs are magic. Why are so many coders still using Vim and ...
  27. Vim, Emacs and their forever war. Does it even matter any more?
  28. Emacs vs Vi - GNU Project - Free Software Foundation
  29. What modern editors compete with emacs/vi? [closed] - Stack Overflow
  30. How to handle edit wars? [duplicate] - Meta Stack Overflow
  31. FOSDEM 2020 - Thoughts on the Future of Emacs - Fosdem
  32. Learn Vi As A Network or Sysadmin Today?
  33. https://survey.stackoverflow.co/2024/technology#most-popular-technologies-ide-text-editor
  34. Nano - Community Help Wiki - Ubuntu Documentation
  35. More explanations: why nano is Gentoo's “default editor”
  36. [PDF] The continuing story of Vim - Bram Moolenaar
  37. News - Neovim docs
  38. Lua - Neovim docs
  39. https://github.com/neovim/neovim
  40. Native Compilation (GNU Emacs Lisp Reference Manual)
  41. Spacemacs: Emacs advanced Kit focused on Evil
  42. download : vim online
  43. https://survey.stackoverflow.co/2023#technology-text-editors-and-ides
  44. Lsp - Neovim docs
  45. 7.0 Release - LSP Mode - LSP support for Emacs
  46. Vim - Visual Studio Marketplace
  47. Awesome Emacs Keymap - Visual Studio Marketplace
  48. GitHub Atom's Code-Editor Nerds Take Over Their Universe | WIRED
  49. Vim in IntelliJ IDEA - JetBrains
  50. https://survey.stackoverflow.co/2024/technology#most-popular-technologies-editor
  51. How to Use Emacs Org-Babel Mode to Write Literate Programming ...
User Avatar
No comments yet.