Hubbry Logo
Editor warEditor warMain
Open search
Editor war
Community hub
Editor war
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Editor war
Editor war
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]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Editor war

View on Grokipedia
from Grokipedia
The editor war refers to the enduring rivalry and heated debates among users of the vi and 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. 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. 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. 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. This approach made vi lightweight and ubiquitous in Unix distributions, influencing successors like Vim, which added features while preserving its core modal philosophy. 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. 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. 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. At the heart of the editor war lie stark contrasts in design philosophy: vi advocates praise its steep but rewarding , speed on resource-constrained systems, and "do one thing well" Unix , while supporters highlight its modeless operation, vast customizability, and evolution into a comprehensive environment for coding, email, and more. These differences fueled early flame wars in the and continue in contemporary discussions on platforms like and [Hacker News](/page/Hacker News), symbolizing broader tensions between simplicity and power in . Despite convergence—such as Vim modes in and GUI enhancements—the rivalry endures as a for programmers, underscoring the editors' lasting influence on open-source culture.

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 , primarily within Unix and communities. This cultural phenomenon highlights passionate discussions over editor preferences, reflecting broader tensions in software tool selection and philosophy among developers and system administrators. 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. 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 at the , building on the earlier ex line editor. Similarly, emerged in 1974 as a set of macros for the TECO editor, initiated by along with collaborators including Guy L. Steele and David Moon at MIT's AI Laboratory. By the mid-1980s, the rivalry had coalesced into public "holy wars" on , formalizing the humorous yet divisive exchanges that continue to define .

Cultural Significance

The editor war, particularly the longstanding rivalry between vi and , stands as one of the inaugural "holy wars" in , characterized by intense, recurring flame wars on that exemplified the tribalism emerging in early internet and communities. These debates transcended mere technical preferences, fostering a of communal identity where allegiance to one editor over the other signaled deeper philosophical stances, such as vi's emphasis on and efficiency versus Emacs's focus on extensibility and customization. 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 , marking initiation into the hacker and reinforcing group affiliations that persisted across projects and platforms. 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. The war's symbolic weight extended to the , where , developed under the GNU Project, symbolized collaborative extensibility, contrasting with vi's roots in proprietary Unix traditions before its open-source adaptations. 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 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 and Unix communities. This enduring polarization, far beyond any objective merits of the editors, cemented the editor war as a of open-source , where tool choice became a proxy for and .

History

Origins of vi and Emacs

The vi text editor was created in 1976 by , then a graduate student at the , 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. 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 terminal and 300-baud modems, enabling efficient operation with minimal screen refreshes and keystrokes despite delays in display updates. Within Berkeley's dynamic Unix research environment, vi was bundled into the inaugural (BSD) release in 1977, facilitating its dissemination among academic users and contributing to BSD's evolution as a major Unix variant. A pivotal advancement occurred in 1981, when Berkeley licensed vi for inclusion in AT&T's , marking its transition into commercial Unix distributions and accelerating its standardization across diverse systems. Concurrently, emerged in 1976 at the MIT , where and Guy L. Steele implemented it as a suite of macros extending the TECO editor on the Incompatible System (ITS) for machines, aiming to streamline complex editing tasks in a research setting. 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. embodied the MIT AI Lab's ethos of and software sharing, which prefigured principles by encouraging communal modifications and redistribution. In 1985, Stallman launched (initially , 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. These parallel developments unfolded in the Unix-centric landscapes of Berkeley and MIT, with vi propagating through BSD distributions and aligning with advocacy, establishing both as foundational tools in early workflows. vi's modal approach contrasted with the modeless paradigm that adopted, where editing commands integrate seamlessly with text input without mode switches.

Emergence of the Rivalry

The rivalry between vi and crystallized in the mid-1980s amid the growing adoption of Unix systems in academic and commercial settings, where debates over preferences began to escalate into community-wide conflicts. The first documented flare-ups occurred on , 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. 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. 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. This push clashed directly with vi's entrenched role as the lightweight, ubiquitous default in commercial Unix distributions from vendors like and , which prioritized minimal resource use and broad compatibility over customization. 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 Systems (BBSes) and the nascent , where hobbyist and professional programmers shared experiences and frustrations. threads titled " 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. These exchanges not only amplified the rivalry across geographically dispersed communities but also embedded it in , 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. Despite sporadic attempts at , such as neutral tool integrations, the persisted unresolved, becoming firmly entrenched by 1990 as both editors influenced subsequent tools and debates in open-source ecosystems.

Core Rivalries and Debates

vi/Vim vs. Emacs: Key Arguments

The rivalry between vi/Vim and centers on fundamental differences in design philosophy and , with proponents of each editor advancing distinct 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 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 systems. Critics of 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. 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. From this perspective, vi appears archaic and rigidly limited, ill-suited for modern programming demands that require seamless integration beyond basic editing. 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. 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. Common refrains in the community underscore these tensions, such as vi loyalists dismissing as needlessly heavyweight, while Emacs enthusiasts proclaim it the tool of "real programmers" capable of handling any task through extension. These exchanges, often laced with humor, reflect enduring loyalties formed in the early days of Unix development.

Technical Comparisons

The paradigms of vi and its derivative Vim differ fundamentally from those of . Vi employs a modal system with three primary modes: for navigation and command issuance, insert mode for text entry, and command mode for executing ex-style commands like substitutions. This modal approach enhances efficiency for repetitive tasks by allowing users to stay in 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 to enter text unnecessarily. In contrast, uses a non-modal paradigm relying on key combinations, typically involving modifier keys like Ctrl or Meta (Alt), to invoke commands directly while . organizes text into buffers, which are internal representations of files or scratch areas, enabling seamless switching between multiple documents without reloading. This buffer-centric model supports a unified 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. Extensibility in Emacs is achieved primarily through Emacs Lisp (Elisp), a dialect of 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 , , 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 or folding. 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. 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. Performance benchmarks highlight vi/Vim's advantages in startup time and resource efficiency. Vim launches much faster than without optimizations like the daemon mode, due to vi's simpler architecture. 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 's extensible framework. Both editors support terminal-based operation across platforms, but offers native GUI modes via toolkits like X11 or , adding optional overhead for visual features. An empirical study of tasks found experienced 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. Standardization further distinguishes the editors: vi is defined in the POSIX.1 standard, ensuring a minimal, portable implementation across systems with required features like basic modes and commands. , developed as part of the Project, serves as a for /Linux environments, where it is the default extensible editor in distributions like those from the .

Cultural Impact

Humor and Memes

The editor war has inspired a rich tradition of humor, originating in the wars of 1980s groups where users exchanged satirical jabs about their preferred editors' philosophies and capabilities. 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 "EMACS: Eight Megabytes And Constantly Swapping," highlighting its extensibility at the expense of efficiency. These early jests frequently appeared in signatures and posts, framing vi users as dogmatic minimalists and users as expansive innovators. As evolved, the memes transitioned from to 1990s email chains and early forum discussions, where jokes like "Emacs is a great operating system, but it lacks a decent " emphasized 's vast feature set. In the , such humor proliferated in tech articles and online communities, including parodies in open-source ; for instance, Eric S. Raymond's "" references 's development as a model of collaborative "bazaar-style" , implicitly contrasting it with more rigid tools like vi. "battles" depicting vi and as warring entities also emerged in forum posts and email signatures, symbolizing the modal versus modeless debate through whimsical illustrations. Notable cultural artifacts include the GNU Project's "Emacs vs. Vi" filk song, a humorous set to the tune of "Ghost Riders in the Sky" that chronicles the rivalry's absurdities. 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 and , adapting classic tropes to contemporary contexts like , but retain the core tribal banter. This humor has played a key role in diffusing the editor war beyond technical circles, transforming a niche debate into enduring folklore that invites newcomers to engage playfully with traditions. By reducing technical to shareable wit, these memes ensure the rivalry remains a lighthearted staple of programming culture.

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 enthusiasts, foster specialized conversations on configurations and extensions, but broader platforms like frequently close threads comparing the two editors as primarily opinion-based, aiming to prevent derailments that could overshadow technical queries. This moderation reflects a community consensus that the rivalry, while culturally ingrained, should not impede problem-solving. Similarly, meta discussions on emphasize resolving edit conflicts arising from ideological preferences in code examples, underscoring the war's potential to escalate into unproductive conflicts. At conferences like and , 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. These gatherings, dating back to the 1980s when the rivalry emerged in 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. Anecdotes from such events illustrate how the debate persists as a 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 systems positions it as an informal prerequisite for sysadmin roles, fostering gatekeeping where proficiency signals competence. Conversely, it creates rituals among veterans, with the ongoing reinforcing shared 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 . Efforts to resolve the war include neutral defaults in 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 . This choice counters gatekeeping by prioritizing accessibility, allowing newcomers to contribute without immediate immersion in the rivalry; similar shifts in and Gentoo toward nano as the system default emphasize simplicity and low learning barriers to broaden participation. These configurations represent a pragmatic pushback, fostering inclusive dynamics while acknowledging the war's enduring influence.

Modern Developments

Evolutions and Forks

Vim, developed by , was first publicly released in 1991 as an improved version of the vi editor, initially ported from the Stevie editor for the platform and later adapted for Unix systems. Over the following decades, Vim evolved through numerous releases, with significant enhancements including the addition of in version 5.0 in 1998, which allowed for color-coded display of code elements to aid readability and error detection. 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). In 2014, Neovim emerged as a of Vim, aimed at refactoring the for better and extensibility to attract a new generation of developers. Neovim introduced a modern plugin architecture that supports asynchronous operations, enabling non-blocking plugin execution, and integrated as a primary for configuration and extensions, reducing reliance on Vimscript. This 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. Subsequent releases, such as version 0.10 in September 2024, further enhanced Lua APIs, tree-sitter integration, and performance optimizations. On the Emacs side, GNU Emacs continued its iterative development, with version 28.1 released in April 2022 introducing native compilation of code as a default feature on supported platforms, significantly boosting startup times and runtime performance through using libgccjit. Version 29.1, released in July 2023, integrated Eglot as the built-in client, providing native IDE-like features without external packages and further bridging gaps with vi-style editors through improved customization options. To bridge the modal editing gap for vi users, distributions like —launched in October 2014 as a community-driven configuration—integrated Evil mode, an extensible vi emulation layer that replicates vi's states and keybindings within Emacs' ecosystem. Evil mode, developed as a package for seamless vi-like interaction, has allowed to incorporate vi workflows without abandoning its -centric customization model. These evolutions have influenced adoption patterns, with Vim remaining preinstalled on most systems for its lightweight footprint and compatibility, serving as the default editor in environments like distributions. 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%. In the 2020s, both lineages integrated the (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. 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 traditions. , 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. Similarly, Atom, launched in 2014 and discontinued in 2022, drew from 's extensibility model by enabling users to build custom packages in , fostering a hackable ecosystem that echoed the Lisp-based customization central to . This rivalry has left a lasting cultural legacy in , influencing debates around IDE customization and reinforcing open-source norms of extensibility and . For instance, IDEs like 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. Within the Emacs ecosystem, packages like Magit—a porcelain interface—demonstrate the war's promotion of deep customization, where users 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 , as developers increasingly prioritize integrated features over modal editing purity. Modern IDEs like , 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 automate routine tasks, shifting focus from editor choice to productivity enhancements. However, the core divide persists in terminal workflows, where Vim's ubiquity on servers maintains its edge. Looking ahead, the editor war's influence endures in niche domains: vi derivatives remain favored in and embedded systems for their lightweight footprint and server compatibility, with Vim used by approximately 24% of developers as of 2025. Conversely, supports practices like through Org-mode's Babel, enabling seamless integration of code, documentation, and execution in a single file, appealing to researchers and complex project maintainers.

References

  1. https://slate.com/technology/2014/05/oldest-software-rivalry-emacs-and-vi-two-text-editors-used-by-programmers.html
  2. https://www.theregister.com/2003/09/11/bill_joys_greatest_gift/
  3. https://www.linfo.org/vi/history.html
  4. https://www.gnu.org/software/emacs/manual/html_node/efaq/Origin-of-the-term-Emacs.html
  5. https://www.gnu.org/software/emacs/emacs-paper.html
  6. https://www.gnu.org/software/emacs/
  7. http://catb.org/jargon/html/H/holy-wars.html
  8. http://catb.org/jargon/html/V/vi.html
  9. https://ex-vi.sourceforge.net/
  10. https://www.linux.com/news/emacs-vs-vi-endless-geek-holy-war/
  11. http://www.catb.org/jargon/html/V/vi.html
  12. https://www.cyberciti.biz/tips/the-vi-editor-story.html
  13. http://www.catb.org/esr/writings/taoup/html/ch02s01.html
  14. https://www.tuhs.org/Mirror/Hauben/unix-Part_II.html
  15. https://www.softwarepreservation.org/projects/emacs/
  16. https://www.gnu.org/gnu/rms-lisp.en.html
  17. https://joabj.com/Writing/Tech/0112-NewsForge-Linux-vi_EMACS.html
  18. https://dl.acm.org/doi/10.1145/800045.801603
  19. https://www.catb.org/esr/writings/taoup/html/ch14s02.html
  20. https://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html
  21. https://www.gnu.org/software/emacs/manual/html_node/emacs/
  22. https://vimhelp.org/usr_41.txt.html
  23. https://stackoverflow.com/questions/1430164/differences-between-emacs-and-vim
  24. https://mjambon.github.io/vim-vs-emacs/
  25. https://stackoverflow.blog/2020/11/09/modern-ide-vs-vim-emacs/
  26. https://blog.sourcerer.io/vim-emacs-and-their-forever-war-does-it-even-matter-any-more-697b1322d510
  27. https://www.gnu.org/music/emacsvsvi.html
  28. https://stackoverflow.com/questions/3714279/what-modern-editors-compete-with-emacs-vi
  29. https://meta.stackoverflow.com/questions/387182/how-to-handle-edit-wars
  30. https://archive.fosdem.org/2020/schedule/event/emacsthoughts/
  31. https://datacenteroverlords.com/2022/12/12/learn-vi-as-a-network-or-sysadmin-today/
  32. https://survey.stackoverflow.co/2025/technology
  33. https://help.ubuntu.com/community/Nano
  34. https://flameeyes.blog/2009/10/07/more-explanations-why-nano-is-gentoo-s-default-editor/
  35. https://www.moolenaar.net/vimstory.pdf
  36. https://neovim.io/doc/user/news.html
  37. https://neovim.io/doc/user/lua.html
  38. https://github.com/neovim/neovim
  39. https://neovim.io/doc/user/whats_new.html
  40. https://www.gnu.org/software/emacs/manual/html_node/elisp/Native-Compilation.html
  41. https://www.gnu.org/software/emacs/news/NEWS.29.1
  42. https://www.spacemacs.org/
  43. https://www.vim.org/download.php
  44. https://survey.stackoverflow.co/2023#technology-text-editors-and-ides
  45. https://survey.stackoverflow.co/2024/technology#most-popular-technologies-editor
  46. https://neovim.io/doc/user/lsp.html
  47. https://emacs-lsp.github.io/lsp-mode/blog/2020/7.0-release/
  48. https://marketplace.visualstudio.com/items?itemName=vscodevim.vim
  49. https://marketplace.visualstudio.com/items?itemName=tuttieee.emacs-mcx
  50. https://www.wired.com/2015/06/github-atoms-code-editor-nerds-take-universe/
  51. https://www.jetbrains.com/help/idea/using-product-as-the-vim-editor.html
  52. https://news.ycombinator.com/item?id=44723876
  53. https://orgmode.org/worg/org-contrib/babel/how-to-use-Org-Babel-for-R.html
Add your contribution
Related Hubs
User Avatar
No comments yet.