Vim

Vim (“Vi IMproved”) is the most successful descendant of Bill Joy’s vi — a free, cross-platform, modal text editor created by Dutch programmer Bram Moolenaar and first released for the Amiga on November 2, 1991. What began as a hobbyist’s vi imitation grew, over three decades of continuous development, into one of the most widely used programming editors in the world: the default vi on most Linux distributions and macOS, the subject of one of open source’s largest plugin ecosystems, and the host of its own scripting language, Vim script. More than a program, Vim became the standard-bearer for modal editing itself — when developers speak of “Vim keybindings” in VS Code, JetBrains IDEs, or a web app, they are speaking Vim’s dialect of vi’s grammar.

History & Origins

An Amiga without vi

In 1988 Bram Moolenaar bought a Commodore Amiga, only to find that the editor he used at work — vi — didn’t exist for it. Among the free vi clones circulating at the time was Stevie (“ST Editor for VI Enthusiasts”), written by Tim Thompson for the Atari ST and ported to the Amiga by Tony Andrews. Moolenaar took the Stevie port as his starting point and began improving it: fixing bugs, filling in missing vi commands, and adding features vi never had, most importantly multi-level undo (vi could only undo one change).

Version 1.14 — the first public release, then standing for “Vi IMitation” — was released on November 2, 1991 and reached Amiga users via Fred Fish’s freely distributable disk #591. A Unix port followed, and with Vim 2.0 in December 1993 the name’s expansion officially changed to “Vi IMproved”: the imitation had overtaken the original.

Charityware

Vim’s license is one of the most distinctive in open source. It is free software (GPL-compatible), but it is also charityware: the license and the editor’s :help uganda documentation ask users who enjoy Vim to consider donating to help children in Uganda. Moolenaar had volunteered at the Kibaale Children’s Centre in southern Uganda in the 1990s and founded the ICCF Holland foundation to support it; Vim’s popularity funneled decades of donations to the project, and the community has continued this charitable mission — more recently through the Kuwasha organization — since his death.

Design Philosophy

Keep vi’s grammar, remove vi’s limits

Vim’s core bet was that vi’s modal command language — operators (d, c, y) composed with motions (w, $, /pattern) and counts, so that d2w deletes two words — was worth preserving exactly, while everything around that grammar could be modernized. Vim kept compatibility with vi’s commands (and for years defaulted to a compatible mode) but layered on what 1970s hardware had made impossible:

• Multi-level undo with, since Vim 7, a full undo tree of branching history
• Multiple windows and tab pages, including vertical splits
• Syntax highlighting for hundreds of file types
• Text objects — diw (delete inner word), ci" (change inside quotes) — extending vi’s grammar itself
• Visual mode for selecting text by character, line, or block
• Registers, macros (q), marks, and sessions for repeatable, resumable work
• Comprehensive built-in documentation (:help), plus the vimtutor interactive tutorial

An editor you program

The second bet, made explicit when Vim 5.0 added scripting in 1998, was that an editor should be extensible in its own language. Vim script (also called VimL) lets users and plugin authors automate anything the editor can do:

1
2
3
4
5
6
7
8

" Legacy Vim script
function! TrimTrailingWhitespace() abort
  let l:save = winsaveview()
  keeppatterns %s/\s\+$//e
  call winrestview(l:save)
endfunction

autocmd BufWritePre * call TrimTrailingWhitespace()

Vim script is dynamically typed and famously idiosyncratic, but it powered an enormous ecosystem: plugin managers, fuzzy finders, git integrations, and language tooling, distributed for decades through vim.org and later GitHub. Vim9 script, introduced with Vim 9.0 in 2022, is a redesigned dialect — compiled rather than interpreted, with def functions, type annotations, and compile-time checking — that executes much faster than legacy script (the project’s documentation cited expected speedups of roughly 10 to 100 times for compiled functions versus legacy script, achieved by compiling functions instead of re-parsing lines):

1
2
3
4
5

vim9script
def Greet(name: string): string
  return $'Hello, {name}!'
enddef
echo Greet('World')

Legacy and Vim9 script coexist; Vim 9.1 added classes and objects, and Vim 9.2 added enums, generic functions, and tuples, turning what began as macro glue into a genuine, if niche, programming language.

Evolution

Vim’s major releases trace a steady expansion from vi clone to programmable editing platform:

The Neovim fork

By the early 2010s, Vim’s aging C codebase and conservative pace frustrated some contributors. In 2014 Neovim launched as a fork with an explicit agenda: refactor the core, make plugins asynchronous and remotely scriptable, and embed Lua as a first-class configuration language. The fork proved healthy for both projects — Vim 8.0’s async jobs and channels arrived in 2016, the first major Vim release in a decade — and today Vim and Neovim advance in parallel, sharing vi’s grammar and much of Vim’s runtime while serving different tastes: Vim prioritizing stability, portability, and Vim9 script; Neovim prioritizing Lua, built-in LSP, and rapid iteration.

After Bram

Bram Moolenaar led Vim as its benevolent dictator for life for over thirty years, personally reviewing essentially every patch. His death on August 3, 2023, at age 62, was mourned across the software world and raised real questions about the project’s future. The community answer came quickly: longtime contributor Christian Brabandt and a team of maintainers took over the repository, and the releases since — Vim 9.1 in 2024, dedicated to Bram, and the feature-rich Vim 9.2 in 2026 — demonstrated that the project could outlive its founder.

Current Relevance

Vim in 2026 is simultaneously infrastructure and enthusiasm. As infrastructure, it is simply there: the vi command on most Linux systems resolves to Vim or a minimal build of it, macOS ships it in the base system, and anyone administering servers over SSH will meet it. As enthusiasm, it remains a top-tier developer editor by choice: developer surveys consistently place Vim (and increasingly Neovim) among the most-used editors, its plugin ecosystem remains active, and its editing model keeps spreading through emulation — the VS Code Vim extension alone counts millions of installs. Development is active under the post-Bram maintainer team, with Vim 9.2’s Vim9 language work, experimental Wayland support, and XDG-aware configuration showing a project still evolving rather than merely maintained.

Why It Matters

Vim settled an argument that vi started: that modal, composable, keyboard-only editing is not a relic of slow terminals but a durable local optimum that developers will voluntarily climb a steep learning curve to reach. It proved that a lone programmer’s free-time clone could become more important than the commercial original, that an editor could be a programmable platform a decade before “extensions marketplace” was a phrase, and that open source could fund humanitarian work through nothing more coercive than a :help uganda screen. Its influence is everywhere its name appears — Neovim, IdeaVim, “vim mode” — and in younger modal editors like Kakoune and Helix that treat Vim as the tradition to build on or argue with. Few pieces of software have been both a universal default and a lifelong personal craft; Vim, thirty-five years on, is still both.