Vim

Getting Started

Fundamental Vim concepts including modes, exiting, and opening files.

Modes

Vim operates in several modes. Understanding modes is key to using Vim effectively.

Entering Insert mode

These keys transition from Normal mode to Insert mode at various cursor positions.

Code

1
i    " Insert before cursor
2
a    " Insert after cursor
3
o    " Open new line below and enter Insert mode
4
O    " Open new line above and enter Insert mode
5
I    " Insert at beginning of line
6
A    " Insert at end of line

Press Esc at any time to return to Normal mode.
i and a are the most commonly used: i inserts before cursor, a inserts after.

Entering Visual mode

Visual mode lets you select text for operations like copy, delete, or indent.

Code

1
v      " Character-wise Visual mode
2
V      " Line-wise Visual mode
3
Ctrl-V " Block-wise Visual mode

Use V to select entire lines quickly.
Ctrl-V is powerful for column editing.

Entering Command-line mode

Command-line mode allows you to execute Ex commands, search, and filter text.

Code

1
:    " Enter Command-line mode
2
/    " Enter search forward
3
?    " Enter search backward

Press Esc or Ctrl-C to cancel and return to Normal mode.
Use Tab for command completion in Command-line mode.

Exiting

How to save files and exit Vim.

Save and quit

These commands write the buffer to disk and/or close Vim.

Code

1
:w     " Save (write) the file
2
:q     " Quit (fails if unsaved changes)
3
:wq    " Save and quit
4
:x     " Save and quit (only writes if changes exist)
5
ZZ     " Save and quit (Normal mode shortcut)

:x and ZZ only write if the buffer has been modified, preserving file timestamps.
:wq always writes, even if no changes were made.

Quit without saving

Force-quit commands discard unsaved changes. Use with caution.

Code

1
:q!    " Quit without saving (force quit)
2
ZQ     " Quit without saving (Normal mode shortcut)
3
:qa!   " Quit all windows without saving

The ! modifier forces the operation, bypassing safety checks.
:qa! is useful when you have multiple buffers/windows open.

Save all and quit

Multi-buffer save and quit commands for working with several files at once.

Code

1
:wa    " Save all modified buffers
2
:wqa   " Save all buffers and quit
3
:xa    " Save all modified buffers and quit

:wa saves all buffers but keeps Vim open.
:wqa and :xa close Vim after saving everything.

Opening Files

Different ways to open files in Vim from the command line.

Basic file opening

Open files directly from the shell with optional line or pattern positioning.

Code

1
vim file.txt          " Open a file
2
vim +42 file.txt      " Open file at line 42
3
vim +/pattern file.txt " Open file at first match of pattern

The + flag accepts any Ex command to run after opening.
Use vim + file.txt to open at the last line.

Opening multiple files

Open multiple files in different layouts directly from the command line.

Code

1
vim file1.txt file2.txt   " Open in buffers (:bn to switch)
2
vim -O file1.txt file2.txt " Open in vertical splits
3
vim -o file1.txt file2.txt " Open in horizontal splits
4
vim -p file1.txt file2.txt " Open in tabs

Use -O for side-by-side editing of related files.
Use -p for tab-based workflow.

Opening files from within Vim

Open additional files without leaving Vim using Ex commands.

Code

1
:e file.txt     " Edit a file in current window
2
:sp file.txt    " Open in horizontal split
3
:vsp file.txt   " Open in vertical split
4
:tabe file.txt  " Open in new tab

:e replaces the current buffer; use :bn to go back.
Tab-complete file paths with Tab in command mode.

Navigation

Moving efficiently through files and text in Vim.

Basic Movement

Fundamental cursor movement commands in Normal mode.

Character and line movement

The h/j/k/l keys replace arrow keys for efficient navigation without leaving the home row.

Code

1
h  " Move left
2
j  " Move down
3
k  " Move up
4
l  " Move right
5
0  " Jump to beginning of line
6
^  " Jump to first non-blank character
7
$  " Jump to end of line

Use 0 for absolute start, ^ for first non-whitespace character.
Prefix with a number for repeated movement (e.g., 5j moves down 5 lines).

Word movement

Word motions navigate by word boundaries. Lowercase variants treat punctuation as word boundaries; uppercase variants only use whitespace.

Code

1
w   " Move forward to start of next word
2
b   " Move backward to start of previous word
3
e   " Move forward to end of current/next word
4
ge  " Move backward to end of previous word
5
W   " Move forward to start of next WORD (space-delimited)
6
B   " Move backward to start of previous WORD
7
E   " Move forward to end of next WORD

Use w/b for precise navigation around punctuation.
Use W/B for faster navigation across mixed text.

Document Movement

Commands for navigating through the entire document quickly.

Jumping to document positions

Jump directly to specific lines or screen positions.

Code

1
gg     " Go to first line of document
2
G      " Go to last line of document
3
:42    " Go to line 42
4
42G    " Go to line 42 (Normal mode)
5
H      " Move to top of screen (High)
6
M      " Move to middle of screen (Middle)
7
L      " Move to bottom of screen (Low)

gg and G are essential for quick top/bottom navigation.
H/M/L position the cursor on the visible screen area.

Scrolling

Scroll the viewport while maintaining or moving the cursor.

Code

1
Ctrl-D " Scroll down half a page
2
Ctrl-U " Scroll up half a page
3
Ctrl-F " Scroll down a full page (Forward)
4
Ctrl-B " Scroll up a full page (Backward)
5
Ctrl-E " Scroll down one line
6
Ctrl-Y " Scroll up one line

Ctrl-D and Ctrl-U are the most commonly used scroll commands.
Ctrl-E and Ctrl-Y scroll without moving the cursor line.

Search Movement

Finding text and navigating by search patterns and character jumps.

Pattern searching

Search for text patterns in the file. Vim supports regular expressions in search.

Code

1
/pattern   " Search forward for pattern
2
?pattern   " Search backward for pattern
3
n          " Repeat search in same direction
4
N          " Repeat search in opposite direction
5
*          " Search forward for word under cursor
6
#          " Search backward for word under cursor

Use :set hlsearch to highlight all matches.
Press :noh to clear search highlighting.

Character-level jumps

Jump to specific characters on the current line. Extremely useful for precise horizontal navigation.

Code

1
f{char}  " Jump forward to next occurrence of {char}
2
F{char}  " Jump backward to previous occurrence of {char}
3
t{char}  " Jump forward to just before {char}
4
T{char}  " Jump backward to just after {char}
5
;        " Repeat last f/F/t/T in same direction
6
,        " Repeat last f/F/t/T in opposite direction

f and t are among the most efficient ways to move within a line.
Combine with operators like d or c (e.g., dt) to delete/change up to a character).

Marks and Jumps

Setting bookmarks and navigating the jump list.

Setting and jumping to marks

Marks let you bookmark positions in a file and jump back to them.

Code

1
ma       " Set mark 'a' at current position
2
'a       " Jump to line of mark 'a'
3
`a       " Jump to exact position of mark 'a'
4
:marks   " List all marks
5
''       " Jump to position before last jump (line)
6
``       " Jump to position before last jump (exact)

Lowercase marks (a-z) are local to a buffer; uppercase marks (A-Z) are global across files.
Use ` (backtick) for exact column position, ' (single quote) for line start.

Jump list navigation

The jump list tracks your movement history. Use Ctrl-O/Ctrl-I to go back and forth.

Code

1
Ctrl-O   " Jump to older position in jump list
2
Ctrl-I   " Jump to newer position in jump list
3
:jumps   " Show the jump list

Searches, marks, and line jumps are all recorded in the jump list.
Ctrl-O is one of the most useful navigation shortcuts in Vim.

Editing

Commands for inserting, copying, pasting, and transforming text.

Inserting Text

Various ways to enter Insert mode and begin typing.

Basic insert commands

Each command enters Insert mode at a different position relative to the cursor or line.

Code

1
i  " Insert before cursor
2
I  " Insert at beginning of line
3
a  " Append after cursor
4
A  " Append at end of line
5
o  " Open new line below
6
O  " Open new line above

A is especially useful for adding content to the end of a line.
o and O are preferred over pressing Enter manually.

Substitute and replace

These commands combine deletion with entering Insert or Replace mode.

Code

1
s  " Delete character under cursor and enter Insert mode
2
S  " Delete entire line and enter Insert mode
3
C  " Delete from cursor to end of line and enter Insert mode
4
r  " Replace single character (stays in Normal mode)
5
R  " Enter Replace mode (overwrite characters)

s is equivalent to cl (change one character).
R is useful for fixed-width editing or overwriting text in place.

Clipboard Operations

Deleting, yanking (copying), and putting (pasting) text.

Delete and yank commands

Delete commands cut text into a register. Yank commands copy without deleting.

Code

1
x     " Delete character under cursor
2
X     " Delete character before cursor
3
dd    " Delete (cut) entire line
4
D     " Delete from cursor to end of line
5
yy    " Yank (copy) entire line
6
Y     " Yank entire line (same as yy)
7
d{motion} " Delete text covered by motion (e.g., dw, d$)
8
y{motion} " Yank text covered by motion (e.g., yw, y$)

Deleted text is stored in the unnamed register and can be pasted with p.
Use d$ or D to delete from cursor to end of line.

Put (paste) and system clipboard

Put commands paste text from registers. The + and * registers access the system clipboard.

Code

1
p     " Put (paste) after cursor
2
P     " Put (paste) before cursor
3
"+y   " Yank to system clipboard
4
"+p   " Paste from system clipboard
5
"*y   " Yank to primary selection (X11)
6
"*p   " Paste from primary selection (X11)

Vim must be compiled with +clipboard for system clipboard support.
On macOS, + and * registers behave the same.

Undo and Redo

Undoing and redoing changes in Vim.

Basic undo and redo

Vim maintains an undo tree that allows undoing and redoing changes.

Code

1
u       " Undo last change
2
Ctrl-R  " Redo last undone change
3
U       " Undo all changes on current line
4
5u      " Undo last 5 changes

Vim has unlimited undo by default (limited only by memory).
U (uppercase) undoes all changes on the current line since last entering it.

Undo branches and persistence

Vim tracks undo as a tree, not just a linear stack. Use time-based undo to revert by duration.

Code

1
:undolist       " Show undo branches
2
g-              " Go to older text state
3
g+              " Go to newer text state
4
:earlier 10m    " Go to state 10 minutes ago
5
:later 5m       " Go to state 5 minutes from undo point
6
:set undofile   " Enable persistent undo across sessions

:earlier and :later accept time units like s, m, h.
Enable undofile in your vimrc for persistent undo history.

Find and Replace

Search and replace text using substitute commands.

Basic substitution

The substitute command is one of the most powerful editing tools in Vim.

Code

1
:s/old/new/          " Replace first 'old' on current line
2
:s/old/new/g         " Replace all 'old' on current line
3
:%s/old/new/g        " Replace all 'old' in entire file
4
:%s/old/new/gc       " Replace all with confirmation

The g flag means global (all occurrences on a line).
The c flag prompts for confirmation at each match.

Advanced substitution

Advanced substitution with ranges, flags, and regex word boundaries.

Code

1
:5,20s/old/new/g     " Replace in lines 5 through 20
2
:'<,'>s/old/new/g    " Replace in visual selection
3
:%s/old/new/gi       " Case-insensitive replace
4
:%s/\<word\>/new/g   " Replace whole word only
5
:%s/pattern//gn      " Count matches without replacing

Use \< and \> for word boundaries in Vim regex.
The n flag counts matches without performing replacement.

Operators and Text Objects

Combining operators with motions and text objects for powerful editing.

Operators

Operators perform actions on text defined by a motion or text object.

Common operators with motions

The operator + motion pattern is the foundation of Vim editing: {operator}{motion}.

Code

1
dw    " Delete from cursor to next word
2
d$    " Delete from cursor to end of line
3
cw    " Change word (delete and enter Insert mode)
4
c$    " Change from cursor to end of line
5
yip   " Yank inner paragraph
6
>>    " Indent current line right
7
<<    " Indent current line left
8
==    " Auto-indent current line

Double an operator to apply it to the whole line (dd, yy, cc, >>).
Operators can be prefixed with a count: 3dd deletes 3 lines.

Case and filter operators

Case operators change letter casing. The filter operator (!) pipes text through external commands.

Code

1
gUw   " Uppercase from cursor to end of word
2
guw   " Lowercase from cursor to end of word
3
g~~   " Toggle case of entire line
4
g~w   " Toggle case of word
5
gUU   " Uppercase entire line
6
guu   " Lowercase entire line
7
!}sort " Filter paragraph through external sort command

g~ toggles case, gU uppercases, gu lowercases.
The ! operator is powerful for integrating external tools.

Text Objects

Text objects define regions of text for operators to act upon.

Word, sentence, and paragraph objects

i = inner (just the content), a = around (content plus surrounding whitespace/delimiters).

Code

1
ciw   " Change inner word
2
caw   " Change a word (including surrounding space)
3
dis   " Delete inner sentence
4
dap   " Delete a paragraph (including trailing blank line)
5
yip   " Yank inner paragraph

ciw is one of the most commonly used text objects for replacing a word.
dap is useful for removing entire paragraphs cleanly.

Delimiter-based text objects

Delimiter text objects work with quotes, brackets, parentheses, and HTML/XML tags.

Code

1
ci"   " Change inside double quotes
2
ca"   " Change around double quotes (including quotes)
3
di(   " Delete inside parentheses
4
da(   " Delete around parentheses (including parens)
5
ci{   " Change inside curly braces
6
dit   " Delete inside HTML/XML tags
7
cat   " Change around tags (including the tags)
8
ci[   " Change inside square brackets

These work regardless of cursor position within the delimiters.
Equivalent pairs: ci( = ci), ci{ = ci}, ci[ = ci].

Repeating

Repeating commands and building efficient editing workflows.

Dot command and repetition

The dot command (.) is one of the most powerful features in Vim, repeating the last change.

Code

1
.     " Repeat last change
2
;     " Repeat last f/F/t/T search
3
,     " Repeat last f/F/t/T in reverse
4
3dd   " Delete 3 lines
5
5j    " Move down 5 lines
6
2yy   " Yank 2 lines
7
4>>   " Indent 4 lines

Design your edits to be repeatable with dot (e.g., use ciw over individual character edits).
Number prefixes work with almost all commands.

Effective dot command usage

Combine search (n) with dot (.) for a powerful manual find-and-replace workflow.

Code

1
/word      " Search for 'word'
2
ciwreplace " Change word to 'replace'
3
n          " Jump to next occurrence
4
.          " Repeat the change
5
n          " Jump to next
6
.          " Repeat again

This pattern gives you control over each replacement, unlike :%s.
Use n to skip an occurrence, . to replace it.

Visual Mode

Selecting and operating on text visually.

Visual Selection

Entering Visual mode and selecting text.

Visual mode types

Visual mode provides a way to select text before applying an operator.

Code

1
v      " Enter character-wise Visual mode
2
V      " Enter line-wise Visual mode
3
Ctrl-V " Enter block-wise Visual mode
4
gv     " Reselect last visual selection
5
o      " Move to other end of selection
6
O      " Move to other corner of block selection

Use o to adjust the other end of the selection without starting over.
gv is extremely useful after an operation to reselect the same area.

Extending selections

Combine entering Visual mode with text objects or motions to select specific regions.

Code

1
viw    " Select inner word
2
vip    " Select inner paragraph
3
vi"    " Select inside quotes
4
vi(    " Select inside parentheses
5
vit    " Select inside tags
6
V5j    " Select current line and 5 lines below

In Visual mode, any motion extends the selection.
Text objects in Visual mode select the entire object.

Visual Operations

Operations you can perform on visually selected text.

Common visual operations

After making a visual selection, apply an operator to act on the selected text.

Code

1
d    " Delete selection
2
x    " Delete selection (same as d)
3
y    " Yank (copy) selection
4
c    " Change selection (delete and enter Insert)
5
>    " Indent selection right
6
<    " Indent selection left
7
=    " Auto-indent selection
8
J    " Join selected lines

These operations exit Visual mode after execution.
Use gv to reselect if you need to apply another operation.

Case and formatting operations

Visual mode allows case changes, formatting, and running Ex commands on selected lines.

Code

1
~    " Toggle case of selection
2
U    " Uppercase selection
3
u    " Lowercase selection
4
gq   " Format/rewrap selected text
5
:    " Enter command mode for selection (adds '<,'>)

Pressing : in Visual mode automatically adds the range '<,'>.
gq reformats text to the textwidth setting.

Visual Block

Block-wise visual selection for column editing.

Block selection and editing

Block Visual mode enables column-oriented editing across multiple lines simultaneously.

Code

1
Ctrl-V       " Enter block visual mode
2
I{text}Esc   " Insert text before block on all lines
3
A{text}Esc   " Append text after block on all lines
4
r{char}      " Replace all characters in block with {char}
5
c{text}Esc   " Change block content on all lines
6
d            " Delete the block

After pressing I or A, text appears on the first line only; it applies to all lines after pressing Esc.
Block mode is invaluable for editing tabular data or adding prefixes.

Practical block editing example

Practical examples of using block visual mode for commenting and uncommenting code.

Code

1
" Add comment prefix to lines 5-15:
2
5G          " Go to line 5
3
Ctrl-V      " Enter block visual
4
10j         " Extend selection 10 lines down
5
I# Esc      " Insert '# ' at start of each line
6

7
" Remove first 2 characters from lines:
8
Ctrl-V      " Enter block visual
9
10j         " Select 10 lines
10
ll          " Extend 2 columns right
11
d           " Delete the block

This technique works well for adding/removing comment characters.
Use $ in block selection to extend to end of each line regardless of length.

Windows and Tabs

Managing multiple views, windows, tabs, and buffers.

Split Windows

Splitting the Vim window for side-by-side editing.

Creating and navigating splits

Splits let you view and edit multiple files or different parts of the same file.

Code

1
:sp          " Horizontal split (same file)
2
:sp file     " Horizontal split with file
3
:vsp         " Vertical split (same file)
4
:vsp file    " Vertical split with file
5
Ctrl-W s     " Horizontal split (same as :sp)
6
Ctrl-W v     " Vertical split (same as :vsp)
7
Ctrl-W w     " Cycle through windows
8
Ctrl-W h     " Move to window left
9
Ctrl-W j     " Move to window below
10
Ctrl-W k     " Move to window above
11
Ctrl-W l     " Move to window right

Ctrl-W is the window command prefix for all window operations.
Use Ctrl-W w to cycle quickly between two windows.

Resizing and closing windows

Resize and manage window layout. Prefix resize commands with a count for larger adjustments.

Code

1
Ctrl-W =     " Equalize window sizes
2
Ctrl-W _     " Maximize current window height
3
Ctrl-W |     " Maximize current window width
4
Ctrl-W +     " Increase height by 1 line
5
Ctrl-W -     " Decrease height by 1 line
6
Ctrl-W >     " Increase width by 1 column
7
Ctrl-W <     " Decrease width by 1 column
8
Ctrl-W q     " Close current window
9
:only        " Close all windows except current

Use 10 Ctrl-W + to increase height by 10 lines.
Ctrl-W = is useful after creating/closing splits to rebalance.

Tab Pages

Using tab pages for organizing multiple files.

Creating and managing tabs

Tabs in Vim are layouts that can each contain multiple windows/splits.

Code

1
:tabnew        " Open a new empty tab
2
:tabe file     " Open file in a new tab
3
:tabclose      " Close current tab
4
:tabonly       " Close all other tabs
5
:tabs          " List all tabs

Vim tabs are different from tabs in other editors. Each tab can contain multiple windows.
Use :tabe with a file path to quickly open files in new tabs.

Navigating between tabs

Navigate between tabs using Normal mode shortcuts or Ex commands.

Code

1
gt           " Go to next tab
2
gT           " Go to previous tab
3
3gt          " Go to tab 3
4
:tabfirst    " Go to first tab
5
:tablast     " Go to last tab
6
:tabmove 0   " Move current tab to first position
7
:tabmove     " Move current tab to last position

gt and gT are the fastest way to switch tabs.
Tab numbers are 1-indexed in Vim.

Buffers

Managing buffers for efficient multi-file editing.

Listing and switching buffers

Buffers represent open files in memory. You can switch between them without closing any.

Code

1
:ls          " List all buffers
2
:buffers     " List all buffers (same as :ls)
3
:bn          " Go to next buffer
4
:bp          " Go to previous buffer
5
:b name      " Switch to buffer by partial name
6
:b 3         " Switch to buffer number 3
7
:b#          " Switch to alternate (last used) buffer

:b with partial name matching allows quick buffer switching.
Ctrl-^ or :b# toggles between the current and last buffer.

Buffer management

Manage buffer lifecycle and apply commands across multiple buffers.

Code

1
:bd          " Delete (close) current buffer
2
:bd 3        " Delete buffer number 3
3
:bd file.txt " Delete buffer by name
4
:set hidden  " Allow switching buffers without saving
5
:%bd         " Delete all buffers
6
:bufdo cmd   " Execute command in all buffers

set hidden in your vimrc allows switching buffers with unsaved changes.
:bufdo is powerful for batch operations (e.g., :bufdo %s/old/new/ge).

Advanced Features

Advanced Vim features for power users.

Macros

Recording and replaying sequences of commands.

Recording and playing macros

Macros record a sequence of keystrokes and replay them. They are stored in registers (a-z).

Code

1
qa       " Start recording macro into register 'a'
2
q        " Stop recording
3
@a       " Play macro stored in register 'a'
4
@@       " Replay the last executed macro
5
5@a      " Play macro 'a' five times

The bottom of the screen shows 'recording @a' while recording.
Macros can include any Normal mode commands, motions, and operators.

Practical macro example

A practical macro that wraps each line in quotes and adds a trailing comma.

Code

1
" Convert a list of words to quoted, comma-separated:
2
" apple       ->  'apple',
3
" banana      ->  'banana',
4
" cherry      ->  'cherry',
5

6
qa            " Start recording to register a
7
I'Esc         " Insert quote at start
8
A',Esc        " Append quote and comma at end
9
j0            " Move to start of next line
10
q             " Stop recording
11
2@a           " Apply to next 2 lines

End macros with j0 to position for the next line, making them repeatable.
Use a large count (e.g., 999@a) to apply a macro to all remaining lines.

Registers

Named storage areas for text, macros, and special values.

Using named registers

Named registers (a-z) let you store multiple pieces of text independently.

Code

1
"ay      " Yank into register 'a'
2
"ap      " Paste from register 'a'
3
"Ay      " Append to register 'a' (uppercase)
4
:reg     " View all register contents
5
:reg a   " View contents of register 'a'

Uppercase register name (A-Z) appends to the register instead of overwriting.
Registers are shared between yank, delete, and macro operations.

Special registers

Special registers hold system clipboard, last search, last command, and other special values.

Code

1
"0p      " Paste last yanked text (not deleted)
2
"+y      " Yank to system clipboard
3
"+p      " Paste from system clipboard
4
"_d      " Delete to black hole register (truly delete)
5
"/       " Last search pattern register
6
":       " Last command register
7
".       " Last inserted text register
8
"%       " Current filename register

"0 always holds the last yank, even after deleting (which goes to "1-"9).
"_ is the black hole register: text deleted into it is truly gone.

Folds

Folding and unfolding sections of code or text.

Managing folds

Folds hide sections of text, making large files easier to navigate.

Code

1
zo       " Open fold under cursor
2
zO       " Open fold under cursor recursively
3
zc       " Close fold under cursor
4
zC       " Close fold under cursor recursively
5
za       " Toggle fold under cursor
6
zA       " Toggle fold under cursor recursively
7
zM       " Close all folds in document
8
zR       " Open all folds in document

za is the most convenient for toggling individual folds.
zM and zR are useful for getting an overview or seeing all content.

Creating folds

Create folds manually or configure automatic folding by indent, syntax, or other methods.

Code

1
zf{motion}    " Create a fold over motion
2
zf5j          " Create fold over next 5 lines
3
:3,10fold     " Create fold from line 3 to 10
4
zd            " Delete fold under cursor
5
zE            " Delete all folds in window
6
:set foldmethod=indent  " Fold by indentation
7
:set foldmethod=syntax  " Fold by syntax
8
:set foldmethod=manual  " Manual fold creation

Manual folds require foldmethod=manual.
For code, foldmethod=syntax or foldmethod=indent are most useful.

Spell Checking

Built-in spell checking in Vim.

Spell check commands

Vim has built-in spell checking that highlights misspelled words and offers corrections.

Code

1
:set spell       " Enable spell checking
2
:set nospell     " Disable spell checking
3
:set spelllang=en_us " Set spell language
4
]s               " Jump to next misspelled word
5
[s               " Jump to previous misspelled word
6
z=               " Show spelling suggestions
7
zg               " Add word to spell file (good word)
8
zw               " Mark word as incorrect (wrong word)
9
zug              " Undo zg (remove from spell file)

Misspelled words are highlighted based on your colorscheme.
Use ]s and [s to quickly navigate between spelling errors.

Spell checking workflow

A typical workflow for spell-checking a document using Vim.

Code

1
:set spell        " Turn on spell check
2
]s                " Go to first error
3
z=                " See suggestions, pick number
4
1z=               " Accept first suggestion directly
5
]s                " Go to next error
6
zg                " Add technical term to dictionary

1z= accepts the first suggestion without showing the menu.
Use zg liberally for technical terms and proper nouns.

Command-Line Tricks

Powerful Ex commands and external command integration.

External commands and filters

Vim integrates with the shell, letting you run commands and pipe text through filters.

Code

1
:!ls              " Run external command
2
:!python %        " Run current file with Python
3
:r !date          " Insert output of date command
4
:r !curl -s URL   " Insert content from URL
5
:.!tr a-z A-Z     " Filter current line through tr
6
Ctrl-R Ctrl-W     " Insert word under cursor in command line

% in Ex commands refers to the current filename.
:r inserts command output below the cursor.

Normal and global commands

:norm runs Normal mode commands on lines. :g (global) runs commands on matching lines.

Code

1
:norm A;          " Append semicolon to current line
2
:%norm A;         " Append semicolon to all lines
3
:g/pattern/d      " Delete all lines matching pattern
4
:v/pattern/d      " Delete all lines NOT matching pattern
5
:g/TODO/norm O    " Add blank line above every TODO
6
:.                " Repeat last Ex command

:g/pattern/command is incredibly powerful for batch line operations.
:v is the inverse of :g, matching lines that do NOT contain the pattern.

Options and Settings

Common Vim options for customizing your editing environment.

Display and search settings

Configure how Vim displays content and handles searching.

Code

1
:set number          " Show line numbers
2
:set relativenumber  " Show relative line numbers
3
:set cursorline      " Highlight current line
4
:set hlsearch        " Highlight search matches
5
:set incsearch       " Show matches while typing
6
:set ignorecase      " Case-insensitive search
7
:set smartcase       " Case-sensitive if uppercase present
8
:set nowrap          " Disable line wrapping

Combine ignorecase with smartcase for intelligent case matching.
Toggle any boolean option with :set option! (e.g., :set number!).

Indentation and tab settings

Configure how Vim handles indentation, tabs, and whitespace display.

Code

1
:set expandtab       " Use spaces instead of tabs
2
:set tabstop=4       " Display width of tab character
3
:set shiftwidth=4    " Number of spaces for auto-indent
4
:set softtabstop=4   " Spaces per Tab keypress
5
:set autoindent      " Copy indent from current line
6
:set smartindent     " Smart auto-indenting for C-like code
7
:set list            " Show invisible characters
8
:set listchars=tab:>-,trail:. " Define how to show invisibles

Always set all four tab-related options together for consistency.
Use :retab to convert existing tabs to spaces (or vice versa).

Redirection and Pipes

Piping text to and from external commands.

Filtering and piping

Vim can pipe buffer content to shell commands and read results back.

Code

1
:w !cmd          " Pipe buffer content to external command
2
:r !cmd          " Read command output into buffer
3
:%!sort          " Sort all lines in the file
4
:%!sort -u       " Sort and remove duplicates
5
:'<,'>!sort      " Sort selected lines
6
:%!python -m json.tool " Format JSON

:w !cmd writes to stdin of cmd, not to a file named !cmd.
:%!cmd replaces the entire buffer with the command output.

Clipboard and advanced piping

Use external tools for clipboard operations and advanced text processing.

Code

1
:w !pbcopy          " Copy buffer to macOS clipboard
2
:r !pbpaste         " Paste from macOS clipboard
3
:w !xclip -sel clip " Copy to clipboard on Linux
4
:w !wl-copy         " Copy to clipboard on Wayland
5
:%!column -t        " Align text into columns
6
:%!awk '{print $2}' " Extract second field of every line

Choose the clipboard command based on your operating system.
Combine with visual selection for operating on specific regions.

Vim

Getting Started

Modes

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Entering Insert mode

Entering Visual mode

Entering Command-line mode

Exiting

Accessibility

Best Practices

Common Errors

Keywords

Save and quit

Quit without saving

Save all and quit

Opening Files

Accessibility

Best Practices

Common Errors

Keywords

Basic file opening

Opening multiple files

Opening files from within Vim

Navigation

Basic Movement

Accessibility

Best Practices

Common Errors

Keywords

Character and line movement

Word movement

Document Movement

Accessibility

Best Practices

Common Errors

Keywords

Jumping to document positions

Scrolling

Search Movement

Accessibility

Best Practices

Common Errors

Keywords

Pattern searching

Character-level jumps

Marks and Jumps

Accessibility

Best Practices

Common Errors

Keywords

Setting and jumping to marks

Jump list navigation

Editing

Inserting Text

Accessibility

Best Practices

Common Errors

Keywords

Basic insert commands

Substitute and replace

Clipboard Operations

Accessibility

Best Practices

Common Errors

Keywords

Delete and yank commands

Put (paste) and system clipboard

Undo and Redo

Accessibility

Best Practices

Common Errors

Keywords

Basic undo and redo

Undo branches and persistence

Find and Replace

Accessibility