glossary

Text inside angle brackets names one key, usually one that doesn't type a character. When you're pressing keys, you press that key and never type the brackets or the letters between them. <Esc> is the Escape key and <CR> is Enter, so A;<Esc> is three keystrokes: A, a semicolon, then Escape. (In a mapping or a config file you do write the notation out, as in :nnoremap <Leader>w :w<CR>.)

<C-u> means hold Ctrl, tap u, let go. It counts as a single keystroke. Case doesn't matter for Ctrl plus a letter, so <C-u> and <C-U> are the same key. Neovim's help spells it CTRL-U, and you may also see it printed as ^U. On a Mac this is the Control key, not Command.

A capital letter means Shift plus that letter, and it's usually a different command from the lowercase one: a appends after the cursor, A appends at the end of the line. Keys without a capital form are written with <S-…>, as in <S-Tab> for Shift+Tab. Symbols are written as themselves, so $ is whichever key types a dollar sign on your keyboard.

<CR> is the Enter key. The name comes from carriage return, and <Enter> and <Return> mean the same thing. You'll see it at the end of anything typed on the command line or into a search, as in :w<CR> or /todo<CR>, because nothing happens until you press it. Key chips on this site draw it as ⏎.

<Esc> is the Escape key, your way back to Normal mode. It leaves Insert or Visual mode, cancels a half-typed command and closes the command line without running anything. <C-[> sends exactly the same key, and some people prefer it because it's closer to the home row.

A few more keys get names because they're invisible or easy to misread in print: <BS> is Backspace, <Tab> is Tab, <Space> is the space bar and <Del> is Delete. The arrow keys are <Up>, <Down>, <Left> and <Right>. Chips here draw them as ⌫, ⇥, ␣, Del and arrows.

Three ordinary characters that need a name inside key notation, because otherwise they'd be read as part of it. <lt> is a plain <, so <lt>Esc> types the text <Esc> instead of pressing Escape. <Bar> is the | character, which separates commands on the command line, and <Bslash> is a backslash. You'll mostly meet them in mappings and in this site's solutions.

A stand-in key for your own shortcuts. A mapping written as <Leader>w uses whatever mapleader was set to when that mapping was created, so set it first. Neovim, like Vim, falls back to a backslash when it's unset, so out of the box <Leader>w means \ then w. Many configs make it the space bar (vim.g.mapleader = ' ' in Lua). This site's page keys follow that habit: <Space>f opens the lesson finder.

Most commands are several keys typed one after another, not pressed together. gg is g, then g again. ciw is c, then i, then w. Only a modifier inside angle brackets is held down, and only for its own key: <C-w>j is Ctrl+w, let go, then a plain j.

Curly braces mark a slot you fill in yourself; the braces are never typed. f{char} means f followed by any character, such as f( or fx. d{motion} means d followed by a motion, like dw or d$. {a-z} stands for one lowercase letter, and words like {pattern} or {new} describe what goes in that spot. Hover a chip like these anywhere on the site for a reminder.

A count is a number typed in front of a command: 3j moves down three lines and 2dd deletes two. This site writes the slot as {count} (or {N}). Neovim's help writes [count], because square brackets mean optional, and leaving the number out usually means 1. Some commands read the count as a position instead: {count}G goes to that line. Counts on both halves of an edit multiply, so 3d2w deletes six words.

A double quote plus a register name, typed before a command, tells that command which register to use. "ayy yanks the line into register a, and "ap puts it back later. Neovim's help shows this optional prefix as ["x]. Where a register name is required instead, as after <C-r> in Insert mode, the slot is written {register}.

A sequence that starts with : opens the command line along the bottom of the screen. The characters after it are typed there and <CR> runs the command, so :w<CR> is three keystrokes: colon, w, Enter. Key lists such as the cheat sheet often leave off the final <CR> and just say :w, the way you'd name the command out loud.

{Visual} in front of a key means you press it while text is selected. {Visual}gc reads: select some lines (say with Vj), then press gc, Neovim's comment toggle.

Where the site shows keys that were actually pressed (your key log, the solution and the par line), each keystroke gets its own chip and special keys are drawn compactly: ⏎ is Enter, Esc is Escape, ⇥ is Tab, ⌫ is Backspace, ␣ is a space, and Ctrl combos read like Ctrl-u. Elsewhere keys appear in notation, like <C-u>. Hover any chip that uses notation to see what it means.

Where Vim starts, and where <Esc> brings you back to. Keys here are commands rather than text: x deletes a character, w jumps to the next word, dd deletes a line. Most editing time is spent here, with short trips into Insert mode to type. A drill only counts as solved once you're back in Normal mode.

The mode for typing text, where keys behave like in any other editor. You enter it with keys such as i (before the cursor), a (after it) or o (on a new line below), and leave it with <Esc>. A handful of Ctrl keys still edit while you type, like <C-w> to delete the word before the cursor.

Select first, then act. v starts a characterwise selection, V a linewise one (whole lines) and <C-v> a blockwise one (a rectangle of columns). Motions stretch the selection, and an operator such as d, y or > then works on exactly what's highlighted. Handy when you want to see the text before you change it.

Entered with R. Each character you type overwrites the one under the cursor instead of pushing it along, like the overtype mode some editors toggle with the Insert key. <BS> brings back what was there before. To swap a single character, r{char} does it without changing mode at all.

Typing :, / or ? moves you to a one-line prompt along the bottom of the window. After : you type an Ex command such as :w or :sort; after / or ? you type a search pattern. <CR> runs it, <Esc> gives up, and <Up> recalls earlier entries.

The brief state after you type an operator like d, c or y, while Vim waits to hear what to act on. d on its own changes nothing yet; a motion or text object completes it (dw, ci(), and <Esc> calls it off. Drills don't count as finished while an operator is still pending.

Neovim can run a shell, or any other program, inside a buffer with :terminal. Press i to enter Terminal mode, where your keys go straight to that program, and <C-\><C-n> to get back to Normal mode. The drills here run in a browser, so they don't cover it.

A command that acts on a stretch of text you describe right after it. The everyday ones: d deletes, c changes (deletes, then drops you into Insert mode), y yanks (copies), > and < shift indentation, gU and gu change case, and Neovim adds gc for comments. On its own an operator just waits for a motion or a text object.

Any key that moves the cursor: w, j, $, f,, }, G, even a search with /. On its own it just moves you. After an operator it marks out the text to act on, from the cursor to wherever the motion would land, so d$ deletes to the end of the line. A word motion is one that moves by words: w, b, e and ge, plus their WORD versions W, B, E and gE (Neovim's help groups all eight under word motions).

A way to name a chunk of text by what it is instead of by moving across it: iw is the word under the cursor, i" the inside of a quoted string, ap a paragraph plus the blank lines after it. They work in Visual mode or right after an operator, and the cursor can sit anywhere inside the object. An i object is the inner part; an a object also takes the surrounding space or the delimiters.

The idea that makes Vim click: an edit is a little sentence. The operator is the verb and a motion or text object is the noun, so dw reads "delete word", ci( "change inside parentheses" and yap "yank a paragraph". Every new verb works with every noun you already know, and the other way round, which is why a small vocabulary goes a long way.

Typing an operator twice makes it act on the current line: dd deletes it, yy yanks it, cc replaces it, >> indents it and gUU uppercases it. Put a count in front to cover more lines, so 3dd deletes this line and the two below it.

The three shapes a piece of text can take. Characterwise text runs from one character to another (what dw or v covers). Linewise text is whole lines (dd, dj, V). Blockwise text is a rectangle of columns (<C-v>). The shape travels with the text into its register, which is why p puts a deleted line on a new line below instead of in the middle of the current one.

For characterwise motions: whether the edit takes both ends of the stretch it covers. An inclusive motion does, so de deletes through the last letter of the word and df, takes the comma with it. An exclusive motion leaves out the end nearer the bottom of the file. Going forward, that's where the motion lands: dw stops just before the next word starts. Going backward, it's where the cursor started: db deletes back to the start of the word but keeps the character under the cursor. t is inclusive like f, yet dt, stops one short because t lands just before the comma. When an edit grabs one character too many or too few, this is usually why.

. repeats your last change: the last command that edited text, including anything you typed during that visit to Insert mode. Fix one word with cw, type the new word, press <Esc>, then move to the next one and press . to make the same fix. Motions and : commands aren't repeated (@: does that for the command line). A count, as in 3., replaces the original count.

u undoes the last change and <C-r> redoes it (in Insert mode <C-r> pastes a register instead). A whole visit to Insert mode, from i to <Esc>, normally undoes as one step. Vim keeps an undo tree rather than a single list, so even changes you undid and then typed over can still be reached with g- and g+ (in Neovim itself; the browser drills keep a simple list).

Either a stretch of keyword characters (letters, digits and _) or a stretch of punctuation and other symbols. Spaces separate words but don't belong to them, so foo.bar(x) holds six words: foo, the dot, bar, (, x and ). An empty line also counts as a word, which is why w stops on one. The lowercase motions w, b, e and ge, and the iw/aw objects, move by these. Which characters count as letters is up to the iskeyword option; the default covers letters (accented ones too), digits and _.

A run of any non-blank characters, split only by whitespace. Where foo.bar(x) is six words, it's a single WORD, and an empty line counts as one too. The capital keys W, B, E, gE, iW and aW work in WORDs, which makes them the fast choice through URLs, file paths and punctuation-heavy code.

Text that ends with ., ! or ? followed by a space, a tab or the end of the line. Closing brackets and quotes may sit between the punctuation and the space, and an empty line also ends a sentence. ( and ) jump between sentence starts, and is/as select one.

A block of lines between empty lines. } and { jump to the empty line after or before it, and ip/ap select it. One catch: for { and } a line holding only spaces is not empty, so they go right past it. (The ip and ap objects do treat such a line as a break.)

Everything up to a line break. A long line may wrap across several rows on screen but is still one line to Vim, so j hops over the wrapped part; gj and gk move by screen rows instead. Line numbers count real lines, and those are what 42G or :42 jump to.

The first character on a line that isn't a space or a tab: where the text starts after any indentation. ^ jumps there and I inserts there. 0 is different: it goes to the very first column, before the indent.

A named slot that holds text: Vim's version of a clipboard, except there are dozens of them. Every yank, delete and change writes to one, and p puts one back. Usually that's the unnamed register and you don't need to think about it; type " and a name before a command to use a different one. :reg shows what each register holds.

The ones you'll meet most:

• "" unnamed: what a plain p uses. It follows your latest delete or yank.
• "0 yank: your latest yank, which deletes leave alone.
• "1 to "9 numbered: recent deletes and changes of a line or more, newest in "1.
• "- small delete: the latest delete shorter than a line.
• "a to "z named: filled only when you ask. "A to "Z add to them instead of replacing.
• "_ black hole: text sent here is simply gone, and no other register changes.
• "+ and "* the system clipboard (not available in the browser drills).
• Read-only: ". the last inserted text, ": the last command line and "% the file name.
• "/ holds your last search (you can't yank or delete into it), and "= is the expression register.

A saved position. ma sets mark a where the cursor is; `a jumps back to that exact spot and 'a to the first non-blank of its line. Lowercase marks belong to one buffer, while capital ones like mA work across files. Vim also keeps some marks for you: `. takes you to your most recent edit, and '' returns to the line you jumped away from.

Some motions count as jumps: the long-distance ones, like G, gg, a search with / or n, %, { and }, or going to a mark. Before each jump Vim notes where you were in the jump list, so <C-o> steps back to older spots and <C-i> (often the same key as <Tab>) steps forward again, much like a browser's back and forward buttons. Small moves such as w or j don't count.

Vim also remembers where each change happened. g; steps back through those places and g, steps forward again, a quick way to return to your edit after looking around elsewhere. The latest one is also kept as the mark ., so `. jumps straight to it.

A recording of keystrokes you can play back. qa starts recording into register a, q stops, and @a replays it; @@ repeats whichever macro ran last. Because a macro is stored in an ordinary register, you can paste it with "ap, edit it as text and yank it back.

What you type after / or ? (and inside :s and :g) is a pattern, Vim's own flavour of regular expression. Most characters match themselves, but a few are special: . matches any character, * repeats the thing before it, and ^ and $ pin the match to the start or end of a line. Starting a pattern with \v ("very magic") makes it read more like the regex you may know from other languages.

An extra instruction after a second / that moves the cursor relative to the match. /foo/e lands on the last letter of foo instead of the first, /foo/e+1 one character after it, /foo/s-1 one before the start, and /foo/+1 at the start of the line below. An empty pattern reuses the previous one, so //e repeats the last search with a new offset.

What Vim actually edits: its own in-memory copy of a file's text. Your changes stay in that copy until :w writes them back to disk. Many buffers can be open at once even if you can see only one; :ls lists them, and :bn / :bp cycle through them. On this site the editor in each drill is labelled buffer too.

A pane on screen that shows part of a buffer. Splitting with :sp or <C-w>v gives you two of them, each free to show its own buffer or another stretch of the same one. Closing a window doesn't close its buffer. Nearly every window command starts with <C-w>.

A separate screen with its own arrangement of split windows. You can keep several, and gt / gT flip to the next or previous one. Unlike browser tabs they aren't one per file: a tab can hold several windows, and the same buffer can appear in more than one tab.

A command typed after :, like :w (write), :s (substitute) or :sort. The name comes from ex, the line editor that vi grew out of. Ex commands work on lines, so most of them take a range, and nearly all have short forms: :s is short for :substitute, and :t is another name for :copy.

Which lines an Ex command works on, written right after the :. :3,7d deletes lines 3 to 7. % means every line, . the current line, $ the last one, and .,+2 this line and the two after it. Press : while text is selected and Vim fills in '<,'>, the lines of the selection.

A setting that changes how Vim behaves, changed with :set. :set number turns line numbers on, :set nonumber turns them off, :set number! flips it and :set number? shows the current value. In a Lua config the same thing is vim.o.number = true. Neovim's help writes option names in single quotes, like 'ignorecase'.

A key binding of your own: when you type the left-hand side, Vim acts as if you had typed the right-hand side. :nnoremap <Leader>w :w<CR> makes <Leader>w save the file in Normal mode; in Lua that's vim.keymap.set('n', '<Leader>w', ':w<CR>'). The nore means non-recursive: the right-hand side is used as written, without expanding other mappings inside it.

Neovim's built-in manual, and a very good one. :h w explains the w key, :h i_CTRL-W covers <C-w> in Insert mode, :h notation describes the shorthand on this page and :h word gives the exact definition of a word. Inside the help, <C-]> follows a link and <C-o> comes back. (On this site, :h opens the site's own keymap help, and :h {key} searches the cheat sheet.)

One small exercise in a lesson: an editor with some text, a target to reach and a prompt naming the technique to use. It's solved when the buffer matches the target, the cursor is in the right spot (if the target marks one) and Vim is settled: back in Normal mode with nothing half-typed.

Every drill comes with several variants: different text that practises the same keys. One is picked at random for each attempt, and some movement drills also shuffle where you start and where you need to go, so you learn the technique rather than one answer.

:retry, the ↻ retry button, or r while you're outside the editor restarts the drill with a different variant. A second attempt is never a replay of the first, so it tests the skill and not your memory of the answer.

The keystroke count of the drill's reference solution, as in golf. Every key press counts, including <Esc>, <CR> and each letter typed in Insert mode. A Ctrl combo like <C-u> is one keystroke, Shift or Ctrl on its own is none, and commands for the site itself, like :hint, are free. Finishing at or under par earns a ★; going over is still a pass, with room to improve.

The pane next to the editor showing what the buffer should look like when you're done. When the cursor's final spot counts, a block in the target marks it, and the buffer outlines the same spot as soon as your text matches (straight away in movement drills, where only the cursor moves). The target toggle turns that outline off, as does :set notarget typed from page keys (after :q). The diff toggle, on by default, shows what still needs adding (green) or removing (red). Window and tab drills show the layout to reach instead.

The editor where you work on a drill. It's a Vim emulator running in the browser (CodeMirror with a Vim layer, set up to behave like Neovim's defaults), so the keys taught here do what they would in nvim. A few things only work in a real Neovim, such as the undo tree's g- and g+ or buffer commands like :ls. :q hands your keys back to the page, and i jumps back into the editor.

Some drills switch off keys that would skip the technique being taught. They're listed under the prompt as disabled, and pressing one flashes a warning instead of acting. A disabled key still works as an argument, so with h disabled fh still finds an h. Arrow keys are off in every drill by default (except on the command line), and the settings page has more challenges, such as no hjkl.

A drill you've solved without revealing its solution first. The home page counts how many you've cleared, and each module's lesson list shows a green dot per cleared drill, or a yellow one once you've also matched par. Progress is saved in your browser, and the settings page can export it.

A finish after you revealed the solution (with :solution or the button). It's recorded, but the drill only counts as cleared once you solve it again without peeking. Hints are free: :hint shows them one at a time, gentlest first, and doesn't mark the drill as assisted.

Each drill can show an example: the par keys replayed one at a time on different text, with each key shown as it goes in, so you can watch the technique before trying it on your own variant. :example shows or hides it from the keyboard.

Outside the editor, the site itself listens for Vim-style keys: j and k scroll or move through lists, / finds lessons, : opens a command line and ? lists every key. The pill in the bottom-right corner reads NAV while page keys are live and DRILL while you're typing in an editor.