Vim

Vim (Vi IMproved) is a text editor created by Bram Moolenaar in 1991. It took vi — a program that was already complete — and improved it. Then improved it again. Then added a plugin system. Then added a scripting language. Then the scripting language needed plugins. Then the plugins needed configuration. Then the configuration needed a plugin to manage the configuration.

Vim is what happens when you improve something that was finished.

“Bram gave us everything we asked for. The tragedy is that we asked.”
— The Caffeinated Squirrel, installing its forty-seventh plugin at 2 AM

The Improvements That Mattered

Some of Vim’s additions to vi were genuine improvements:

• Syntax highlighting — the ability to see your code in colour, which turns out to matter more than the purists admit
• Visual mode — selecting text visually, rather than counting lines and hoping
• Split windows — editing two files simultaneously, which vi could not do
• Undo tree — not just linear undo, but branching undo, so you can explore alternatives and return. This is genuinely brilliant and underappreciated.
• Registers — multiple clipboards, each with a letter, for people who have more than one thing to paste

These are the improvements that justified the “Improved” in the name. They made vi better at editing text, which is what vi is for.

The Improvements That Didn’t

And then there were the others:

• Vimscript — a scripting language designed for editor automation that reads like someone described Perl to a person who had never seen Perl and asked them to recreate it from memory in the dark
• The plugin ecosystem — a universe of extensions that turned a text editor into a platform, and turned editing text into a hobby adjacent to editing text but not actually editing text
• The .vimrc — a configuration file that began as ten lines and grew, over years, into a document longer than most of the files it was configuring the editor to edit

The plugin language is horrible. This is not an opinion. This is an observation shared by everyone who has written Vimscript, including — one suspects — Bram Moolenaar himself, who created Vim9 script as a tacit acknowledgment that the first attempt had not gone well.

“I once tried to write a Vimscript function. After forty minutes I had produced something that worked, that I could not read, and that I would never be able to modify. I pushed it to a repository and marked it ‘do not touch.’ It has been running unchanged for six years. I am afraid of it.”
— riclib, on the Vimscript experience

The .vimrc Arms Race

No one should be allowed near a terminal without Vim knowledge. This is a fact. The modal editing model, the motion grammar (d3w — delete three words; ci" — change inside quotes; gqap — reformat paragraph), the composability of commands — these are not editor features, they are a language for manipulating text, and a developer who does not speak this language is typing with mittens.

But the .vimrc is where the knowledge goes to die.

A developer learns Vim. The developer discovers plugins. The developer installs a plugin manager (Vundle, then Pathogen, then vim-plug, then Packer, then whatever came next — the plugin managers have their own lineage, their own wars, their own archaeology). The developer installs plugins for file finding, for fuzzy matching, for git integration, for status lines, for colour schemes, for bracket matching, for snippet expansion, for language servers, for debugging, for terminal integration.

The developer’s .vimrc grows. Fifty lines. A hundred. Two hundred. The developer begins organizing the .vimrc into sections with comments. The developer splits the .vimrc into multiple files. The developer creates a dotfiles repository. The developer spends a Saturday afternoon reorganizing the dotfiles repository.

The developer has not edited a file in four hours.

“The .vimrc is not a configuration file. The .vimrc is an autobiography. Show me your .vimrc and I will tell you what year you started, which plugins you regret, and exactly when you gave up trying to make Vimscript do what you wanted and switched to a shell command.”
— A Passing AI, reading dotfiles repositories at 3 AM

The De Facto Standard

For decades, Vim was the de facto terminal editor. Not because it was the best — “best” is a religious question in editor discussions and has caused more sustained conflict than most actual religions — but because it was everywhere. Every Linux server had vi, and vi was usually Vim. Every SSH session started with Vim available. Every sysadmin, every DevOps engineer, every developer who touched a remote machine typed vim and the editor appeared and the muscle memory engaged.

This ubiquity created a generation of developers whose fingers think in Vim. They press Escape in web forms. They type :w in Google Docs. They press j and k to scroll in applications that do not support j and k to scroll, and they are briefly and genuinely confused when the application does not respond. Their fingers have been trained by a modal editor, and the training is permanent, and the fingers do not know they are not in Vim.

Every modern editor — VS Code, Zed, Neovim, even Emacs — offers a Vim keybinding mode. This is not a tribute. This is an admission that Vim’s interface was right, even if everything around it grew complicated.

Bram

Bram Moolenaar maintained Vim for thirty-two years. He died on August 3, 2023. He was sixty-two.

The editor is maintained by the community now. But Vim is Bram’s. Every keystroke in Vim is a keystroke in the editor Bram built, maintained, and gave away for free for three decades. The software world has no shortage of open-source maintainers, but Bram was one of the quiet ones — the ones who do not keynote conferences or build personal brands but simply maintain the thing, year after year, because the thing needs maintaining and they are the ones who maintain it.

Measured Characteristics

Year created:                            1991
Creator:                                 Bram Moolenaar (1961–2023)
Based on:                                vi (1976)
Scripting language:                      Vimscript (horrible)
Replacement scripting language:          Vim9 script (less horrible, too late)
Average .vimrc length (beginner):        10 lines
Average .vimrc length (intermediate):    150 lines
Average .vimrc length (advanced):        400+ lines, split across 6 files
Time spent configuring vs editing:       approaching 1:1 for power users
Plugin managers that have existed:       at least 6
Developers with permanent Vim muscle memory: millions
Developers who type :w in other applications: all of them
Improvements that mattered:              syntax highlighting, visual mode, splits, undo tree
Improvements that spiralled:             everything after the plugin system
The plugin language:                     horrible (this is not controversial)

See Also

• vi — The editor Vim improved. Whether improvement was needed is the question vi practitioners ask and Vim practitioners avoid.
• Neovim — Vim’s fork that replaced Vimscript with Lua. The surgery was necessary. The patient’s feelings about Lua are mixed.
• Emacs — The other side of the holy war. Emacs users configure in Lisp. Vim users configure in Vimscript. Both groups spend more time configuring than editing. Only the Emacs users enjoy the configuration language.
• VS Code — The editor that absorbed Vim’s keybindings without absorbing its complexity. Whether this makes it better or merely easier is the wrong question to ask in a room full of Vim users.
• VT100 — The terminal Vim inherited from vi. Still 80 columns. Still 24 rows. Still sufficient.