/wiki / learn-vim-progressively

Learn Vim Progressively — Map of Content

2026-09-02T00:00:00.000Z

Map of Content for Learn Vim Progressively — 11 concepts. Start here to navigate learn-vim-progressively.

Core Concepts

vim-basic-commands — concept
vim-buffers — concept
vim-completion — concept
vim-macros — concept
vim-modes — concept
vim-rectangular-blocks — concept
vim-repetition — concept
vim-search-navigation — concept
vim-splits — concept
vim-text-objects — concept
vim-visual-selection — concept

Mechanisms & How Things Work

Auto-generated — edit to curate. Pages that explain processes/flows.

Comparisons & Tradeoffs

(No synthesis yet — create via ingest or query —save)

Vim Basic Survival Commands

2026-04-12T00:00:00.000Z

The Problem

New Vim users are lost without familiarity of any commands. Without these five commands, you cannot open a file, save it, or do anything productive.

Core Idea

Five core Normal-mode commands are enough to survive: insert text, delete characters, save, and quit.

How It Works

Essential commands for Level 1 (Survival):

Command	Action
`i`	Enter Insert mode (type text)
`x`	Delete character under cursor
`:wq`	Save and quit (`:w` = save, `:q` = quit)
`dd`	Delete (cut) the current line
`p`	Paste the last deleted/yanked text

Recommended additions:

hjkl — cursor movement (←↓↑→), j looks like down arrow
:help <command> — show help for any command (:help for general help)

Key Properties

All five commands work in Normal mode
dd both deletes and yanks (stores in default register)
:wq fails if file is read-only — use :wq! to force
p pastes after cursor, P pastes before cursor

Edge Cases & Gotchas

x works on characters, not bytes in multi-byte encodings
dd copies to register, so p can retrieve it
:wq saves even without changes — use :x to save only if modified

Connections

Vim Modes — All commands work in Normal mode
Text Objects — Extend deletion/selection beyond single lines
Navigation — Moving efficiently within lines and files
Repetition — Repeat commands with counts

Vim Buffers

2026-04-12T00:00:00.000Z

The Problem

Editing multiple files sequentially requires efficiently loading, saving, and switching between file buffers.

Core Idea

A buffer is an in-memory copy of a file. Vim provides commands to load, save, and navigate between open buffers.

How It Works

Basic buffer commands:

Command	Action
`:e <path>`	Open (edit) a file
`:w`	Save current buffer
`:w <path>`	Save to new file
`:saveas <path>`	Save buffer as new file
`:x`	Save if modified and quit
`:q`	Quit (fails if unsaved)
`:q!`	Quit without saving
`:qa!`	Quit all, ignore changes
`:bn`	Next buffer
`:bp`	Previous buffer

Key Properties

:q! discards unsaved changes
:x only writes if buffer is modified
ZZ = :wq (write and quit)
Buffer list persists until explicitly cleared

Edge Cases & Gotchas

Unload buffer vs delete buffer are different
Hidden buffers: :bn fails with unsaved changes — use :bn! or :set hidden
:b# switches to alternate buffer

Connections

Vim Splits — Each split shows a buffer
Survival Commands — Basic save/quit
Vim Modes — Works in Normal mode
Macros — Can record buffer operations

Vim Completion

2026-04-12T00:00:00.000Z

The Problem

Retyping long identifiers or boilerplate text wastes time. Completion suggestions improve speed and reduce typos.

Core Idea

In Insert mode, Vim provides keyword completion from the current buffer and loaded files.

How It Works

Completion commands in Insert mode:

Key	Action
`<C-n>`	Next match
`<C-p>`	Previous match
`<C-x><C-l>`	Line completion
`<C-x><C-f>`	Filename completion

Workflow:

Type the start of a word
Press <C-n> or <C-p> to cycle through suggestions
Accept with right arrow or completion key
Continue typing or press <C-n> for more options

Key Properties

Completion is keyword-based from open buffers
Searches all loaded buffers, not just current
<C-n> / <C-p> cycle through matches
Works with dictionaries, thesaurus, and more via plugins

Edge Cases & Gotchas

Need at least one charactertyped before completion works
Dictionary completion via 'dictionary' option
LSP completion is separate (see LSP wiki for language-aware)

Connections

Language Server Protocol — Language-aware completion (vs basic word completion)
Vim Modes — Completion in Insert mode
Survival Commands — Insert mode basics
Repetition — Can repeat insertions

Vim Macros

2026-04-12T00:00:00.000Z

The Problem

Repetition with . is limited to the last change. Complex multi-step sequences need more powerful automation.

Core Idea

Macros record and replay sequences of Normal-mode commands using registers (a-z).

How It Works

Recording workflow:

qa — start recording to register a (shows recording @a)
Perform the sequence of commands
q — stop recording
@a — replay the macro
@@ — replay last executed macro

Example: Numbered list

Place cursor on line with 1
qaYp<C-a>q — record: yank line, paste, increment number, stop
@a — writes 2 below 1
@@ — writes 3 below 2
100@@ — creates 1 through 103

Key Properties

Registers are named a-z (26 total)
Uppercase registers append: qA appends to register a
Macros persist until overwritten
Works across files if registers are preserved

Edge Cases & Gotchas

Macros execute at Normal mode — recording in Insert mode includes literal keystrokes
<C-a> increments if cursor is on/on after a number
:reg shows all register contents

Connections

Repetition — Simpler than macros for single changes
Vim Modes — Recording works in Normal mode
Visual Selection — Can record visual selections
Block Selection — Can be combined with macros

Vim Modes

2026-04-12T00:00:00.000Z

The Problem

Standard text editors map most keystrokes directly to characters on screen. Vim is a modal editor where keystrokes have different meanings depending on the current mode. This design allows efficient keyboard-driven editing without modifier keys, but requires learning mode switching.

Core Idea

Vim uses modal editing — different keystrokes do different things depending on the current mode. The main modes are Normal (for commands), Insert (for typing), and Visual (for selection).

How It Works

Normal mode: Default mode. Keystrokes are commands (move, delete, yank, etc.). Press ESC to return here from other modes.
Insert mode: Type characters literally. Press i from Normal to enter, ESC to exit.
Visual mode: Select text for operations. Enter with v (character-wise), V (line-wise), or <C-v> (block-wise).

Key mappings:

Key	Action
`i`	Enter Insert mode before cursor
`a`	Enter Insert mode after cursor
`ESC`	Return to Normal mode

Key Properties

Vim starts in Normal mode by default
Mode switching is explicit — no hold-to-edit like Ctrl in conventional editors
Visual mode has three variants: character, line, and block
: 进入 Ex 命令行 mode (also considered a mode)

Edge Cases & Gotchas

Accidental key presses in Normal mode can cause unintended edits (e.g., i in the middle of a word inserts before it, not split it — use s or a instead)
Caps Lock matters: i is insert, I is different command
:help mode shows current mode help

Connections

Survival Commands — Five commands that work in Normal mode
Text Objects — Selection commands that require Visual mode
Visual Selection — Modes for selecting text blocks
Macros — Recording in Normal mode

Vim Rectangular Blocks

2026-04-12T00:00:00.000Z

The Problem

Editing multiple lines at the same column is common (indentation, commenting). Character/line selection can’t handle this — you need column-based selection.

Core Idea

Block-wise visual mode (<C-v>) selects rectangular columns across multiple lines. This enables simultaneous edits to many lines at once.

How It Works

Entry: <C-v> from Normal mode (or <C-q> on Windows if clipboard interferes)

Use cases:

Comment multiple lines:
1. 0 — go to first column
2. <C-v> — start block selection
3. <C-d> — move down (or jjj, %, etc.)
4. I-- [ESC] — insert comment prefix on each line
Append to all lines:
1. <C-v> select blocks
2. Move to target lines
3. $ — extend to end of lines
4. A, type text, ESC

Window commands:

<C-w><dir> — switch split (dir = h,j,k,l or arrows)
<C-w>_ — maximize horizontal split
<C-w>| — maximize vertical split
<C-w>+ / <C-w-> — resize splits

Key Properties

Block selection persists during operations
All selected lines get the same edit
Case matters: <C-v> is block, V is line, v is character
Works with :split and :vsplit for window splits

Edge Cases & Gotchas

Windows: <C-q> if <C-v> is clipboard paste
$ selects to end of longest line, not each line individually
Block selection combined with A appends at line ends

Connections

Visual Selection — Block selection is a variant
Macros — Can record block selection operations
Text Objects — Alternative selection syntax
Vim Splits — Related window functionality

Vim Repetition

2026-04-12T00:00:00.000Z

The Problem

Repeating the same operation multiple times is inefficient. Manual replication wastes time and introduces inconsistency.

Core Idea

Two repetition mechanisms: the dot command (.) repeats the last change; numeric prefixes repeat commands N times.

How It Works

Dot Command (`.`)

Repeats the last Simple change
Examples:
- 100idesu [ESC] writes “desu” 100 times
- . repeats that 100 “desu”
- 3. repeats 3 times (300 total, not 300!)
A Simple change = one command that makes one change

Numeric Prefix (`N<command>`)

Precedes any command with a count
Examples:
- 2dd — delete 2 lines
- 3p — paste 3 times
- 5 dw — delete 5 words
- 10j — move down 10 lines

Key Properties

. only repeats simple changes, not complex sequences
Numeric counts are multiplied, not added: 3. × 3 = 9 not 6
Operator + motion = repeat-able command: d2w is one command
u undo is itself undo-able

Edge Cases & Gotchas

. doesn’t repeat Ex commands (:s/...)
. after . compounds: 2. = 6 total
Search/replace needs :s///& or & to repeat

Connections

Survival Commands — dd and p are repeatable
Vim Modes — Repetition works in Normal mode
Navigation — N prefix repeats search
Macros — More complex repetition with recording

Vim Search and Navigation

2026-04-12T00:00:00.000Z

The Problem

Moving inefficiently kills productivity. Cursor-by-cursor navigation doesn’t scale for large files. Efficient editing requires efficient movement commands.

Core Idea

Vim provides granular movement commands: character, word, line, search, and screen-level navigation.

How It Works

Key	Destination
`0`	First column (column 0)
`^`	First non-blank character
`$`	End of line
`g_`	Last non-blank character
`fa`	Next `a` on line (repeat with `;`, back with `,`)
`ta`	Just before next `a`
`Fa` / `Ta`	Same, backward

Word moves:

w — start of next word
e — end of current word
b — start of previous word

WORD vs word: word = alphanumeric + underscore; WORD = whitespace-separated

gg — start of file (shortcut for 1G)
G — last line
N G — line N

Search:

/pattern — search forward, ?pattern backward
* — search word under cursor forward
# — search word under cursor backward
% — jump to matching bracket (`, { or [)

Key Properties

All movement commands can be combined with operators: d$, yG, ce
* is smart: uses word boundaries
Counts work: 3w moves 3 words; 5j moves 5 lines down
n repeats last search, N reverses

Edge Cases & Gotchas

^ visually appears above _ but is different
f is line-local — doesn’t wrap by default, use ; or search
Word boundaries differ from TEXT objects boundaries

Connections

Survival Commands — hjkl are basic movements
Repetition — Combine with counts
Vim Modes — All work in Normal mode
Visual Selection — Can use as motions

Vim Splits

2026-04-12T00:00:00.000Z

The Problem

Working with multiple files or views requires switching buffers. Split windows provide simultaneous visibility of multiple files or different parts of the same file.

Core Idea

Vim supports horizontal (:split) and vertical (:vsplit) window splits for simultaneous file viewing. Window commands enable navigation and resizing.

How It Works

Split commands:

Command	Action
`:split` or `:sp`	Horizontal split (top/bottom)
`:vsplit` or `:vsp`	Vertical split (left/right)
`:split <file>`	Split and open file
`<C-w><dir>`	Switch focus (dir = h,j,k,l or arrows)
`<C-w>_`	Maximize horizontal split
`	`
`<C-w>+`	Grow split by 1 line
`<C-w>-`	Shrink split by 1 line

Key Properties

Each split has its own buffer
Splits share registers and global settings
:hide closes current split
:only closes all other splits

Edge Cases & Gotchas

Resize mode: <C-w>= equals all split sizes
Tab-based workflow is modern alternative to splits
:help split has comprehensive documentation

Connections

Block Selection — Shares window commands
Survival Commands — Buffer commands apply in splits
Visual Selection — Works across splits
Vim Modes — All commands work in split windows

Vim Text Objects

2026-04-12T00:00:00.000Z

The Problem

Single-character/single-line operations are inefficient when editing structured text (quotes, brackets, paragraphs). Manually counting or searching to select delimited blocks is error-prone.

Core Idea

Text objects allow selecting delimited content (words, sentences, paragraphs, quoted strings, brackets) with two-character commands: <action>i<object> (inside) or <action>a<object> (around).

How It Works

Pattern: <action>a<object> and <action>i<object>

action: any operator (d delete, y yank, v select)
i: inside (content only)
a: around (including delimiters)

Common objects:

Object	Meaning
`w`	word
`W`	WORD (whitespace-separated)
`s`	sentence
`p`	paragraph
`"`	double quotes
`'`	single quotes
`)` or `b`	parentheses
`]`	brackets
`}`	braces
`t`	tags (like `<html>`)

Key Properties

ci" changes inside quotes without deleting the quotes
da" includes the quotes in the deletion
v2i) selects the inner two parentheses groups
Count prefixes work: d2i( deletes two nested groups

Edge Cases & Gotchas

Visual mode doesn’t need an action — just vi" works
Nested quotes: counts work (ci"" — inner pair in "foo"bar")
Objects are motion-compatible — y works same as d (yanks)

Connections

Vim Modes — Requires Visual or Normal mode
Survival Commands — Use operators like d, y
Visual Selection — Text objects extend selection
Repetition — Can repeat text object operations

Vim Visual Selection

2026-04-12T00:00:00.000Z

The Problem

Editing arbitrary regions requires cursor gymnastics or awkward mouse selection. Standard editors let you select text then act on it — Vim needs equivalent functionality.

Core Idea

Visual mode selects text ranges then applies operators. Three variants: character-wise, line-wise, and block-wise.

How It Works

Entry commands:

Key	Selection Type
`v`	Character-wise (highlight characters)
`V`	Line-wise (highlight entire lines)
`<C-v>`	Block-wise (rectangular column selection)

Post-selection operations:

J — join selected lines together
< — indent left
> — indent right
= — auto-indent
~ — toggle case

For block selection across lines:

<C-v> start block
Move (jjj or <C-d> or /pattern or %)
$ go to end of lines
A, type text, ESC to append to all lines

Key Properties

Selection endpoint is marked at cursor position when entered
Works with all operators: d, y, c, gU, gu, etc.
o moves cursor to opposite end of selection
gv reselects last visual selection

Edge Cases & Gotchas

Windows: may need <C-q> instead of <C-v> for block mode
Block selection with $ selects to end of longest line
Visual mode is temporary — operators exit back to Normal

Connections

Vim Modes — Visual is one of the three main modes
Macros — Record actions on visual selection
Block Selection — Special case of visual block mode
Text Objects — Alternative selection syntax

/wiki / learn-vim-progressively

Learn Vim Progressively — Map of Content

Core Concepts

Mechanisms & How Things Work

Comparisons & Tradeoffs

Suggested Reading Order

Vim Basic Survival Commands

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Buffers

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Completion

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Macros

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Modes

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Rectangular Blocks

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Repetition

The Problem

Core Idea

How It Works

Dot Command (.)

Numeric Prefix (N<command>)

Key Properties

Edge Cases & Gotchas

Connections

Vim Search and Navigation

The Problem

Core Idea

How It Works

Line-level navigation:

Word moves:

File navigation:

Search:

Key Properties

Edge Cases & Gotchas

Connections

Vim Splits

The Problem

Core Idea

How It Works

Key Properties

Edge Cases & Gotchas

Connections

Vim Text Objects

The Problem

Core Idea

How It Works

Key Properties

Dot Command (`.`)

Numeric Prefix (`N<command>`)