Vim — The Ubiquitous Editor

 ██╗   ██╗██╗███╗   ███╗
 ██║   ██║██║████╗ ████║
 ██║   ██║██║██╔████╔██║
 ╚██╗ ██╔╝██║██║╚██╔╝██║
  ╚████╔╝ ██║██║ ╚═╝ ██║
   ╚═══╝  ╚═╝╚═╝     ╚═╝

The Ubiquitous Text Editor

1991

Year Released

9.x

Current Version

Bram Moolenaar

Creator

Charityware

License

100+

Supported Languages

3B+

Installs Worldwide

Why Vim?

⚡

Blazing Speed

Vim's modal editing model eliminates constant mouse usage. Motion keys let your fingers stay on the home row. Complex edits that take seconds in other editors happen in milliseconds with Vim's composable commands.

🔧

Infinite Extensibility

With a rich plugin ecosystem spanning decades, Vim can become an IDE, a note-taking system, a presentation tool, or anything you imagine. VimScript and Lua (in Neovim) give you total control over every behavior.

🌍

Universally Available

Vim ships with nearly every Unix-like system on Earth. SSH into any Linux server, embedded device, or cloud instance and Vim is there waiting. Your muscle memory travels with you anywhere there's a terminal.

"Vim is a text editor that is upwards compatible to Vi. It can be used to edit all kinds of plain text. It is especially useful for editing programs." — :help vim

Vim Modes

Vim's power comes from its modal design. Unlike most editors, Vim has distinct modes for navigation, editing, selecting, and executing commands. Understanding modes is the key to Vim mastery.

NORMAL

Default mode. Every keypress is a command. Navigate, delete, copy, paste.

Esc to return here from any mode

INSERT

Type text freely. Characters appear at cursor. Most familiar mode for newcomers.

i a o I A O

VISUAL

Select text visually. Apply commands to the selected region. Three sub-modes.

v char V line Ctrl+v block

COMMAND

Execute Ex commands: save, quit, substitute, set options, run shell commands.

: from Normal mode

REPLACE

Overwrite existing characters. Like Insert but replaces instead of inserts.

R multi-char r single-char

Mode Transition Guide

Normal → Insert

i — insert before cursor
a — append after cursor
o — open line below
O — open line above
I — insert at line start
A — append at line end
s — substitute char
S — substitute line
c{motion} — change + enter insert

Normal → Visual

v — character-wise visual
V — line-wise visual
Ctrl+v — block visual
gv — reselect last selection
o — move to other end of selection

In visual: use motion keys to extend selection, then apply operators (d, y, c, ~, >, <)

Normal → Command

: — enter command mode
/ — forward search
? — backward search
! — filter through shell

Use Tab for completion, ↑↓ for history, Ctrl+c or Esc to cancel

Operator-Pending Mode

A special sub-state entered after typing an operator in Normal mode. Vim waits for a motion or text object to complete the command.

Examples: dwaitw, cwaiti", ywaitap

Press Esc to cancel the pending operator.

Command Reference

Key / Command	Category	Description
h	motion	Move cursor left
j	motion	Move cursor down
k	motion	Move cursor up
l	motion	Move cursor right
w	motion	Jump to start of next word
b	motion	Jump to start of previous word
e	motion	Jump to end of word
0	motion	Jump to start of line
$	motion	Jump to end of line
gg	motion	Go to first line of file
G	motion	Go to last line of file
Ctrl+d	motion	Scroll half-page down
Ctrl+u	motion	Scroll half-page up
%	motion	Jump to matching bracket/paren
i	edit	Enter Insert mode before cursor
a	edit	Enter Insert mode after cursor
o	edit	Open new line below and insert
x	edit	Delete character under cursor
dd	edit	Delete current line
yy	edit	Yank (copy) current line
p	edit	Paste after cursor
P	edit	Paste before cursor
u	edit	Undo last change
Ctrl+r	edit	Redo last undone change
.	edit	Repeat last change
ciw	edit	Change inner word (delete word + insert)
diw	edit	Delete inner word
yiw	edit	Yank inner word
~	edit	Toggle case of character
/pattern	search	Search forward for pattern
?pattern	search	Search backward for pattern
n	search	Go to next search match
N	search	Go to previous search match
*	search	Search forward for word under cursor
#	search	Search backward for word under cursor
v	visual	Enter character-wise Visual mode
V	visual	Enter line-wise Visual mode
Ctrl+v	visual	Enter block Visual mode
:w	ex	Write (save) file
:q	ex	Quit Vim
:wq	ex	Write and quit
:q!	ex	Quit without saving (force)
:s/old/new/g	ex	Substitute old with new on current line
:%s/old/new/g	ex	Substitute throughout entire file
:set nu	ex	Enable line numbers
:set hlsearch	ex	Highlight search matches
:e file	ex	Open file in current buffer
:sp file	ex	Split window horizontally and open file
:vsp file	ex	Split window vertically and open file
za	fold	Toggle fold at cursor
zM	fold	Close all folds
zR	fold	Open all folds
ma	mark	Set mark 'a' at cursor position
`a	mark	Jump to exact position of mark 'a'
"ayy	register	Yank line into register 'a'
"ap	register	Paste from register 'a'

Essential Plugins

The Vim plugin ecosystem spans over three decades. These twelve plugins form a solid foundation for any Vim configuration.

vim-plug

The minimalist plugin manager. Fast, parallel installation, easy rollback. De-facto standard for Vim configurations.

Plug 'junegunn/vim-plug'

NERDTree

File system explorer in a sidebar. Navigate directories, open files, create/rename/delete from within Vim.

Plug 'preservim/nerdtree'

vim-airline

Lean, mean status/tabline. Shows mode, branch, file, encoding, and more with configurable themes and powerline symbols.

Plug 'vim-airline/vim-airline'

telescope.nvim

Highly extendable fuzzy finder (Neovim). Find files, grep, browse buffers, git refs, LSP symbols and more.

Plug 'nvim-telescope/telescope.nvim'

coc.nvim

Intellisense engine for Vim/NeoVim. Full LSP support: completion, diagnostics, go-to-definition, hover docs.

Plug 'neoclide/coc.nvim', {'branch': 'release'}

vim-fugitive

A Git wrapper so awesome it should be illegal. Stage, commit, diff, log, blame, push — all without leaving Vim.

Plug 'tpope/vim-fugitive'

vim-surround

Effortlessly add, change, or delete surrounding delimiters: parentheses, brackets, quotes, XML tags, and more.

Plug 'tpope/vim-surround'

vim-commentary

Comment out code with gc. Supports every language automatically. Simple, composable, idiomatic Vim.

Plug 'tpope/vim-commentary'

ALE

Asynchronous Lint Engine. Real-time linting and fixing for 100+ languages. Works with ESLint, Flake8, rustfmt, and more.

Plug 'dense-analysis/ale'

fzf.vim

Blazing fast fuzzy file finder integration. Pairs with the fzf binary for instant file/buffer/tag searching.

Plug 'junegunn/fzf.vim'

UltiSnips

The ultimate snippet solution. Write code snippets that expand with Tab. Supports Python interpolation and transformations.

Plug 'SirVer/ultisnips'

vim-go

Full-featured Go development environment. Auto imports, build/test/run, code navigation, refactoring tools built in.

Plug 'fatih/vim-go', { 'do': ':GoUpdateBinaries' }

Vim Through the Ages

From a simple vi clone to the most ubiquitous editor on the planet — the story of Vim spans five decades of computing history.

1976

vi — Visual Editor Born

Bill Joy writes vi for BSD Unix at UC Berkeley. The first screen-oriented text editor, building on Ken Thompson's ed and George Coulouris's em. Modal editing is introduced to the world.

1991

Vim 1.0 — "Vi IMitation"

Bram Moolenaar releases Vim (Vi IMitation) for the Amiga computer on November 2, 1991. Originally based on Stevie (ST Editor for Vi Enthusiasts), it quickly surpasses vi with new features.

1993

Vim 2.0 — "Vi IMproved"

Renamed to "Vi IMproved" as it gains features well beyond vi compatibility. Ported to Unix, MS-DOS, and Windows. Syntax highlighting, multi-level undo, and VimScript foundations appear.

1998

Vim 5.0 — Multiple Windows

Split windows, multiple buffers, and tab pages transform Vim into a full development environment. The plugin system matures, and the charityware license is established — users are encouraged to donate to Ugandan children.

2006

Vim 7.0 — Spell Checking & Omni-completion

Integrated spell checking, omni-completion (intelligent code completion), tab pages, undo branches, and the :vimdiff command. A landmark release that cemented Vim's position as a serious IDE competitor.

2014

Neovim Fork

Thiago de Arruda forks Vim as Neovim, a community-driven project focused on refactoring, asynchronous I/O, better plugin architecture, and embedding. The healthy competition accelerates both projects.

2016

Vim 8.0 — Asynchronous Jobs

After a decade, a major version release brings asynchronous job control, native package support, partial functions, lambdas, and the channel system. Plugins could now run linters and compilers without blocking the UI.

2023

Bram Moolenaar Passes Away

Bram Moolenaar, creator and benevolent dictator of Vim for over 32 years, passes away on August 3, 2023. The Vim community mourns a giant. Development continues under a new committee of maintainers.

2024+

Vim 9.x — The Living Legacy

Vim 9 introduces Vim9script, a completely redesigned scripting language 10–100x faster than legacy VimScript. The project lives on, maintained by the community, as the most installed text editor in Unix history.

Vim as a Development Environment

Vim is not just a text editor — it is a complete, composable development environment that outperforms bloated GUIs in every metric that matters to a professional developer.

The core argument: VSCode is an Electron app — a web browser pretending to be an editor. It consumes gigabytes of RAM, requires a mouse, and trains you to be dependent on GUI affordances. Vim runs in a terminal, starts in milliseconds, uses virtually no memory, and makes you a fundamentally faster, more precise editor of text — which is what programming actually is.

Vim vs VSCode — Head to Head

Vim ✓

+Starts in <100ms. Always. No splash screen, no indexing spinner, no extension activation delay.

+Uses ~5–15MB RAM. Edit a 500MB log file without breaking a sweat.

+Runs over SSH on any remote machine with zero setup. Your full environment, everywhere.

+Modal editing eliminates mouse usage entirely. Your hands never leave the home row.

+Composable commands: d3ap, ci", gqip — precise edits in 2–5 keystrokes.

+Available on every Unix system. Server, container, embedded device, router — Vim is there.

+Macros (q), dot repeat (.), and registers let you automate repetitive edits without scripting.

+Neovim extends Vim with Lua, LSP, Treesitter, and async I/O — full modern IDE features, zero bloat.

+Config is a plain text file. Version-controlled, reproducible, shared across every machine you own.

+You own every behavior. No telemetry, no phoning home, no Microsoft.

VSCode ✗

−Electron shell adds 300–800ms startup, often seconds with extensions loading.

−Routinely consumes 500MB–2GB RAM. On a dev machine with many tabs and extensions, 4GB is common.

−Remote SSH extension is a workaround. Requires a server-side agent install and an internet connection to Microsoft servers.

−Mouse-centric workflow. Constantly switching between keyboard and mouse fragments your focus and slows you down.

−Multi-cursor is clever but no substitute for operator+motion composability. Edge cases break it constantly.

−Unavailable on headless servers, containers without X11, or anywhere a GUI doesn't make sense.

−Macros are absent. Repetitive edits require extensions, snippets, or manual repetition.

−Built on Electron/Node.js — a web stack masquerading as a native app. Inherits all web performance pathologies.

−Settings are JSON but extension configs are scattered and non-portable. Syncing requires a Microsoft account.

−Sends usage telemetry by default. Backed by a corporation with commercial interests in your workflow data.

Feature Comparison

Capability	Vim / Neovim	VSCode
Startup time	<100ms	300ms–3s with extensions
Memory usage	5–20MB	500MB–2GB+
Works over SSH	Native — just type vim	Extension required, server agent installed
Works without GUI	Yes — pure terminal	No
Mouse required	Never	Frequently
LSP / autocomplete	Native in Neovim; plugins in Vim	Built-in
Syntax highlighting	Treesitter (Neovim), built-in (Vim)	Built-in
Fuzzy file finding	fzf.vim, telescope.nvim	Built-in Ctrl+P
Git integration	fugitive.vim, gitsigns.nvim	Built-in Source Control
Macros / automation	Native q-macros, . repeat, :norm	Not available
Config portability	Plain text, git it and forget it	Requires Settings Sync + Microsoft account
Runs on servers	Always	Never
Platform	Native C — runs anywhere	Electron (Chromium + Node.js)
Telemetry	None	On by default
Vim keybindings	Is Vim	VSCodeVim extension (imperfect emulation)
Extensibility	VimScript + Lua (Neovim)	TypeScript extensions

The Professional Case

🖥️

Server-Side Reality

Production servers don't have GUIs. When a disk is 95% full at 3am and you need to edit a config file over SSH, Vim is your only real option. Learning Vim now means your editor works in every environment you'll ever encounter.

🧠

The Language of Editing

Vim commands form a grammar: verb + noun. delete inside "uotes. change around paragraph. Once internalized, this grammar makes you faster than any point-and-click workflow.

⚡

The Speed Multiplier

Senior engineers who have mastered Vim consistently report 2–3x editing throughput on complex refactors. The bottleneck shifts from mechanical editing to thinking — exactly where it should be.

♾️

Investment That Compounds

Every hour you invest in Vim pays dividends for the rest of your career. VSCode's UI changes with every release. Vim's keybindings, learned in 1995, work identically in 2025 — and every editor worth using has a Vim mode.

"The reason Vim is the editor of choice for sysadmins, kernel developers, and anyone who works with text professionally is not nostalgia. It is that no other tool comes close for raw editing throughput on the kinds of tasks that actually matter." — Common wisdom among experienced Unix developers

"I switched from VSCode to Neovim and after two weeks I couldn't believe how much time I had been wasting reaching for my mouse. My wrist pain went away too." — Typical report from Vim converts

Bottom Line

Vim wins on every axis that matters for serious development. It starts instantly, uses a fraction of the memory, runs natively over SSH and on headless servers, and never requires a mouse. Its modal editing model is a force multiplier — once your muscle memory is built, complex edits that take VSCode users multiple keystrokes and mouse clicks collapse into a handful of composable commands. The config is plain text you can version-control and carry anywhere without a Microsoft account. VSCode is a capable tool for beginners who need a gentle on-ramp, but it is built on a web browser, depends on a GUI, and treats the mouse as a first-class citizen. For a developer who spends the majority of their day in a terminal, on remote servers, or doing anything beyond simple file editing, that architecture is a liability. Learn Vim once. Use it everywhere. Forever.

Interactive Demo

Watch Vim in action — opening a file, writing Python code, using motions and visual mode, running a substitution, and saving. Use the buttons to step through each scene.

bash

NORMAL

Step 1 / 1

Modal Editing

Esc Normal i Insert v Visual

Every keypress is a command in Normal mode. Switch modes explicitly — no modifier keys needed.

Composable Motions

dw ci" yap

Operators combine with motions and text objects. ci" changes inside quotes. dap deletes a paragraph.

Visual Mode

v char V line Ctrl+v block

Select text visually then apply any operator. Block visual lets you edit multiple columns simultaneously.

Ex Commands

:%s/old/new/g

Global substitution, range commands, macros. :%s/foo/bar/g replaces every occurrence in the file.

Dot Repeat

.

The dot command repeats your last change. Combined with n (next match), it is the fastest way to make repetitive edits.

Write & Quit

:w :q :wq :q!

Save with :w. Quit with :q. Save and quit with :wq or ZZ. Force-quit without saving: :q!