The IDE Wars

The Elder Gods: Emacs and vi

In 1976, two editors emerged independently of each other. Both are still actively developed today, and their followers have faced off for decades in the so-called editor war.

vi was written by Bill Joy at UC Berkeley on an ADM-3A terminal whose cursor keys sat on the HJKL keys, which is why vi still navigates with h, j, k, l. Joy had no numeric keypad. He also had no fast connection: vi was optimized for 300-baud modems, where every transmitted character counted. The modal editor (normal mode for navigation, insert mode for typing) was not a philosophical decision. It was bandwidth economics.

Emacs was written by Richard Stallman (with Guy Steele and others) in 1976, originally as a collection of TECO macros at MIT; the free reimplementation GNU Emacs followed in 1985 as a political instrument. Emacs was more than an editor, it was a programmable environment. Emacs Lisp allowed every aspect of the editor to be customized. Stallman’s condition of exchange: whoever wrote Emacs extensions had to share them. That was the primordial form of the copyleft idea, before the GPL existed.

Emacs became a complete counter-world: reading email in Emacs, keeping a calendar in Emacs, browsing the web in Emacs, playing Tetris in Emacs. The joke was old but accurate: “Emacs is a great operating system, lacking only a decent editor.” vi adherents preferred the opposite: one tool that mastered one thing perfectly.

The war rages on in forums, Reddit threads, and conference hallways to this day, with no victor and no ceasefire.

Eclipse: The Enterprise Answer

In 2001, IBM released Eclipse as an open source IDE and handed the project to the Eclipse Foundation in 2004. The strategic background: IBM wanted to create a standard IDE for Java that was nobody’s proprietary product, and thereby open up the market.

Eclipse worked. It became the de facto standard for Java development in enterprises. The plugin system was powerful: thousands of extensions, one for every use case. Eclipse for Android development (ADT). Eclipse for C++ (CDT). Eclipse for PHP. Eclipse as the universal tool.

The growth carried the seed of failure. Eclipse became slow. Startup time grew with every installed plugin. The user interface was consistently inconsistent: perspectives, views, workspaces, editors, each with its own interaction rules. Developers learned Eclipse because they had to; they rarely loved it.

JetBrains: Intelligence as the Differentiator

In the same year as Eclipse, in fact a few months earlier (January 2001), three Russian developers whose company was based in Prague released a competing product. IntelliJ IDEA (JetBrains, 2001) was commercial, cost money, and was technically superior.

JetBrains’ core thesis: an IDE should understand the code, not just display it. IntelliJ analyzed semantically. Refactoring was precise, not textual. Autocomplete knew the context. The editor knew which methods existed on which type, which parameters a function expected, which imports were missing.

The strategy was risky: charging programmers money in a world with a free Eclipse. But developers who tried JetBrains rarely switched back. The productivity gain was tangible, not abstract.

JetBrains expanded the model: PyCharm for Python, WebStorm for JavaScript, GoLand for Go, CLion for C++. Each IDE specialized, each IDE built on the same core. The license model switched to subscriptions in 2015, controversial in the community, commercially successful.

Visual Studio Code: Microsoft’s Improbable Dominance

In 2015, Microsoft was not a company whose software developers installed voluntarily. Satya Nadella had just taken the helm, the cultural turn toward open source was underway but incomplete. Then Microsoft released Visual Studio Code.

VS Code was Electron-based, a Chromium browser running a web application. For performance purists, that was heresy. Electron apps were considered sluggish, memory-hungry, conceptually wrong. The Emacs community treated the Electron concept with contempt.

VS Code ignored the criticism and became dominant anyway. Why?

The extension ecosystem grew faster than any predecessor’s. The Language Server Protocol (LSP) (developed and published by Microsoft) decoupled language intelligence from the IDE. An LSP server for Python worked in VS Code, in Vim, in Emacs, in any editor with an LSP client. That was not product strategy, it was infrastructure thinking.

The price helped: free, open source (MIT). No subscription, no tiers. Students, hobbyists, professional developers, same version.

By 2023, according to the Stack Overflow Developer Survey, 73.7% of all developers used VS Code. Emacs: 4.7%. Vim: 22.3% (with Neovim rising separately). IntelliJ IDEA: 26.8%, but as a specialist for specific languages, not a universal tool.

Dead End: Eclipse as a Universal Platform

Legacy

The editor war has not been settled, it has shifted. Emacs and Vim are livelier than ever, driven by a generation that values control and configurability over comfort. Neovim modernizes Vim with Lua scripting and LSP integration. Helix, Zed, Fleet: new editors keep appearing, with new promises.

VS Code won the middle: the mass market, the learners, the polyglots. JetBrains holds the specialists willing to pay for semantic depth. Vim and Emacs hold the philosophers.

The real innovation was the Language Server Protocol: it decoupled language intelligence from the IDE and made the editor war a little more irrelevant. Whatever editor you choose, the intelligence comes from the same server.

📚 Sources

• vi — Wikipedia
• GNU Emacs History (GNU Project)
• Eclipse Foundation: History and Background
• IntelliJ IDEA — Wikipedia
• Visual Studio Code — Wikipedia
• Language Server Protocol Specification (Microsoft)
• Stack Overflow Developer Survey 2023 — IDEs