[Note: The commands for multiple windows and buffers are explained in a different file, see vim_win.html]

1. Introduction
2. Notation
3. Starting Vim
   1. Command line
   2. Workbench (Amiga only)
   3. Vim window (Amiga only)
   4. Initialization
   5. Suspending
   6. The viminfo file
4. Modes
   1. Introduction
   2. Switching from mode to mode
   3. Insert and Replace mode
      1. special keys
      2. special special keys
      3. 'textwidth' option
      4. 'expandtab' option
      5. Replace mode
      6. Insert mode completion
   4. Command_line mode
      1. Command line editing
      2. Command line completion
      3. Ex command lines
      4. Ex command line ranges
      5. Ex special characters
   5. The window contents
   6. Abbreviations
   7. Digraphs
   8. Using the mouse
   9. On-line help
5. Editing files
   1. Introduction
   2. Editing a file
   3. The argument list
   4. Writing and quitting
   5. Using the QuickFix mode
   6. Editing binary files
   7. Automatic commands
6. Cursor motions
   1. Left-right motions
   2. Up-down motions
   3. Word motions
   4. Text object motions
   5. Text object selection
   6. Pattern searches
   7. Various motions
7. Scrolling
8. Tags and special searches
   1. Tags
   2. Identifier searches
9. Inserting text
10. Deleting text
11. Changing text
    1. Delete and insert
    2. Simple changes
    3. Complex changes
    4. Formatting text
    5. Formatting C programs
12. Copying and moving text
13. Visual mode
14. Various commands
15. Repeating commands
    1. Single repeats
    2. Multiple repeats
    3. Complex repeats
16. Undo and redo
17. Key mapping
18. Recovery after a crash
    1. The swap file
    2. Recovery
19. Options
    1. Setting options
    2. Automatically setting options
    3. Saving settings
    4. Options summary
20. Terminal information
    1. Startup
    2. Terminal options
    3. Window size
    4. Slow and fast terminals
21. Differences from Vi and Ex
    1. Missing commands
    2. Missing options
    3. Limits

The motion commands can be used after other commands, called operators, to have the command operate on the text that was moved over. That is the text between the cursor position before and after the motion. If the motion includes a count and the operator also had a count, the two counts are multiplied. For example: "2d3w" deletes six words.

The operator either affects whole lines, or the characters between the start and end position. Generally, motions that move between lines affect lines (are linewise), and motions that move within a line affect characters. However, there are some exceptions.

A character motion is either inclusive or exclusive. When inclusive, the start and end position of the motion are included in the operation. When exclusive, the last character towards the end of the buffer is not included. Linewise motions always include the start and end position.

Which motions are linewise, inclusive or exclusive is mentioned below. There are however, two general exceptions:

1. If the motion is exclusive and the end of the motion is in column 1, the end of the motion is moved to the end of the previous line and the motion becomes inclusive. Example: "}" ends at the first line after a paragraph, but "V}" will not include that line.
2. If the motion is exclusive, the end of the motion is in column 1 and the start of the motion was at or before the first non-blank in the line, the motion becomes linewise. Example: If a paragraph begins with some blanks and you do "d}" while standing on the first non-blank, all the lines of the paragraph are deleted, including the blanks. If you do a put now, the deleted lines will be inserted below the cursor position.

Instead of first giving the operator and then a motion you can use Visual mode: mark the start of the text with "v", move the cursor to the end of the text that is to be affected and then hit the operator. The text between the start and the cursor position is highlighted, so you can see what text will be operated upon. This allows much more freedom, but requires more key strokes and has limited redo functionality. See the chapter on Visual_mode.

If you want to know where you are in the file use the "CTRL-G" command or the "g_CTRL-G" If you set the 'ruler' option, the cursor position is continuously shown in the status line (which slows down Vim a little).

NOTE: Experienced users prefer the hjkl keys because they are always right under their fingers. Beginners often prefer the arrow keys, because they do not know what the hjkl keys do. The mnemonic value of hjkl is clear from looking at the keyboard. Think of j as an arrow pointing downwards.

6.1 Left-right motions

h or

<Left> or

CTRL-H or

<BS>

[count] characters to the left (exclusive). Note: If you prefer <BS> to delete a character, use the mapping:

:map CTRL-V<BS> X
(to enter "CTRL-V<BS>" type the CTRL-V key, followed by the <BS> key) See :fixdel if the <BS> key does not do what you want.

l or

<Right> or

<Space>

[count] characters to the right (exclusive).

0

To the first character of the line (exclusive). When moving up or down, stay in same screen column (if possible).

<Home>

To the first character of the line (exclusive). When moving up or down, stay in same text column (if possible). Works like "1|", which differs from "0" when the line starts with a <Tab>. {not in Vi}

^

To the first non-blank character of the line (exclusive).

$ or <End>

To the end of line and [count - 1] lines downward (inclusive).

g0 or g<Home>

When lines wrap ('wrap on): To the first character of the screen line (exclusive). Differs from "0" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the leftmost character of the current line that is on the screen. Differs from "0" when the first character of the line is not on the screen. {not in Vi}

g^

When lines wrap ('wrap' on): To the first non-blank character of the screen line (exclusive). Differs from "^" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the leftmost non-blank character of the current line that is on the screen. Differs from "^" when the first non-blank character of the line is not on the screen. {not in Vi}

g$ or g<End>

When lines wrap ('wrap' on): To the last character of the screen line and [count - 1] screen lines downward (inclusive). Differs from "$" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the righmost character of the current line that is visible on the screen. Differs from "$" when the last character of the line is not on the screen or when a count is used. {not in Vi}

|

To screen column [count] in the current line (exclusive).

f{char}

To [count]'th occurrence of {char} to the right. The cursor is placed on {char} (inclusive).

F{char}

To the [count]'th occurrence of {char} to the left. The cursor is placed on {char} (inclusive).

t{char}

Till before [count]'th occurrence of {char} to the right. The cursor is placed on the character left of {char} (inclusive).

T{char}

Till after [count]'th occurrence of {char} to the left. The cursor is placed on the character right of {char} (inclusive).

;

Repeat latest f, t, F or T [count] times.

,

Repeat latest f, t, F or T in opposite direction [count] times.

k or

<Up> or

CTRL-P

[count] lines upward (linewise).

j or

<Down> or

CTRL-J or

<NL> or

CTRL-N

[count] lines downward (linewise).

gk or

g<Up>

[count] display lines upward (exclusive). Differs from 'k' when lines wrap. {not in Vi}

gj or

g<Down>

[count] display lines downward (exclusive). Differs from 'j' when lines wrap. {not in Vi}

- <minus>

[count] lines upward, on the first non-blank character (linewise).

+ or

CTRL-M or

<CR>

[count] lines downward, on the first non-blank character (linewise).

_ <underscore>

[count] - 1 lines downward, on the first non-blank character (linewise).

<C-End> or

G

Goto line [count], default last line, on the first non-blank character (linewise). If 'startofline' not set, keep the same column.

<C-Home> or

gg

Goto line [count], default first line, on the first non-blank character (linewise). If 'startofline' not set, keep the same column.

:[range]

Set the cursor on the (last) specified line number (cannot be used with an operator).

{count}%

Go to {count} percentage in the file, on the first non-blank in the line (linewise). To compute the new line number this formula is used: {count} * number-of-lines / 100. See also 'startofline' option. {not in Vi}

<S-Right> or

w

[count] words forward (exclusive).

W

[count] WORDS forward (exclusive).

e

Forward to the end of word [count] (inclusive).

E

Forward to the end of WORD [count] (inclusive).

<S-Left> or

b

[count] words backward (exclusive).

B

[count] WORDS backward (exclusive).

ge

Backward to the end of word [count] (inclusive).

gE

Backward to the end of WORD [count] (inclusive).

Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is on a non-blank. This is because "cw" is interpreted as change-word, and a word does not include the following white space. {Vi: "cw" when on a blank followed by other blanks changes only the first blank; this is probably a bug, because "dw" deletes all the blanks}

Another special case: When using the "w" motion in combination with an operator and the last word moved over is at the end of a line, the end of that word becomes the end of the operated text, not the first word in the next line.

The original Vi implementation of "e" is buggy. For example, the "e" command will stop on the first character of a line if the previous line was empty. But when you use "2e" this does not happen. In Vim "ee" and "2e" are the same, which is more logical. However, this causes a small incompatibility between Vi and Vim.

6.4 Text object motions

(

[count] sentences backward (exclusive).

)

[count] sentences forward (exclusive).

{

[count] paragraphs backward (exclusive).

}

[count] paragraphs forward (exclusive).

]]

[count] sections forward or to the next '{' in the first column. When used after an operator, then the '}' in the first column. (linewise).

][

[count] sections forward or to the next '}' in the first column (linewise).

[[

[count] sections backward or to the previous '{' in the first column (linewise).

[]

[count] sections backward or to the previous '}' in the first column (linewise).

A sentence is defined as ending at a '.', '!' or '?' followed by either the end of a line, or by a space. {Vi: two spaces} Any number of closing ')', ']', '"' and ''' characters my appear after the '.', '!' or '?' before the spaces or end of line. A paragraph and section boundary is also a sentence boundary.

A paragraph begins after each empty line, and also at each of a set of paragraph macros, specified by the pairs of characters in the 'paragraphs' option. The default is "IPLPPPQPP LIpplpipbp", which corresponds to the macros ".IP", ".LP", etc. (these are nroff macros, the dot must be in the first column). A section boundary is also a paragraph boundary. Note that this does not include a '{' or '}' in the first column.

A section begins after a form-feed in the first column and at each of a set of section macros, specified by the pairs of characters in the 'sections' option. The default is "SHNHH HUnhsh".

The "]" and "[" commands stop at the '{' or <}" in the first column. This is useful to find the start or end of a function in a C program. Note that the first character of the command determines the search direction and the second character the type of brace found.

6.5 Text object selection

a

select [count] words (see word). {not in Vi}

A

select [count] WORDS (see WORD). {not in Vi}

s

select [count] sentences (see sentence). {not in Vi}

p

select [count] paragraphs (see paragraph). {not in Vi}

S

select [count] blocks, from "[count] [(" to the matching ')' (see [(). {not in Vi}

P

select [count] blocks, from "[count] [{" to the matching '}' (see [{). {not in Vi}

When used after an operator:

For non-block objects:

The operator applies to the object and the white space after the object. If there is no white space after the object or when the cursor was in the white space before the object, the white space before the object is included.

For a block object:

The operator applies to the block excluding the surrounding braces. If the cursor was on one of the braces (or on the indent before '{' or '}) they are included.

When start and end of the Visual area are the same (just after typing "v"):

One object is selected, the same as for using an operator.

When start and end of the Visual area are not the same:

For non-block objects the area is extended by one object or the white space up to the next object. The direction in which this happens depends on which side of the Visual area the cursor is. For the block objects the block is extended one level outwards.

Note the difference between using a movement command and an object. The movement command operates from here (cursor position) to where the movement takes us. When using an object the whole object is operated upon, no matter where on the object the cursor is. For example, compare "dw" and "da": "dw" deletes from the cursor position to the start of the next word, "da" deletes the word under the cursor and the space after or before it.

6.6 Pattern searches

/{pattern}[/]<CR>

Search forward for the [count]'th occurrence of {pattern} (exclusive).

/{pattern}/{offset}<CR>

Search forward for the [count]'th occurrence of {pattern} and go {offset} lines up or down (see below). (linewise).

/<CR>

Search forward for the [count]'th latest used pattern with latest used {offset}.

//{offset}<CR>

Search forward for the [count]'th latest used pattern with new {offset}. If {offset} is empty no offset is used.

?{pattern}[?]<CR>

Search backward for the [count]'th previous occurrence of {pattern} (exclusive).

?{pattern}?{offset}<CR>

Search backward for the [count]'th previous occurrence of {pattern} and go {offset} lines up or down (see below) (linewise).

?<CR>

Search backward for the [count]'th latest used pattern with latest used {offset}.

??{offset}<CR>

Search backward for the [count]'th latest used pattern with new {offset}. If {offset} is empty no offset is used.

n

Repeat the latest "/" or "?" [count] times. {Vi: no count}

N

Repeat the latest "/" or "?" [count] times in opposite direction. {Vi: no count}

*

Search forward for the [count]'th occurrence of the keyword after or under the cursor (exclusive). Only whole keywords are search for, like with the command "/\<keyword\>". If there is no keyword after or under the cursor, any non-blank word is used to search for. {not in Vi}

#

Same as "*", but search backward. The English pound sign (character 163) also works. {not in Vi}

g*

Like "*", but don't put "\<" and "\>" around the word. This makes the search also find matches that are not a whole word. {not in Vi}

g#

Like "#", but don't put "\<" and "\>" around the word. This makes the search also find matches that are not a whole word. {not in Vi}

gd

Goto local Declaration. When the cursor is on a local variable, this command will jump to its declaration. First a search is made for the end of the previous function, just like "[]". If it is not found the search stops in line 1. From this position a search is made for the keyword under the cursor, like with "*", but lines that look like a comment are ignored (see 'comments' option). Note that this is not guaranteed to work, Vim does not really check the syntax, it only searches for a match with the keyword. If included files also need to be searched use the commands listed in include_search. {not in Vi}

gD

Goto global Declaration. When the cursor is on a global variable that is defined in the file, this command will jump to its declaration. This works just like "gd", except that the search for the keyword always starts in line 1. {not in Vi}

CTRL-C

Interrupt current (search) command.

These commands search for the specified pattern. With "/" and "?" an additional offset may be given. There are two types of offsets: line offsets and character offsets. {the character offsets are not in Vi}

The offset gives the cursor position relative to the found match:

[num]	[num] lines downwards, in column 1
+[num]	[num] lines downwards, in column 1
-[num]	[num] lines upwards, in column 1
e[+num]	[num] characters to the right of the end of the match
e[-num]	[num] characters to the left of the end of the match
s[+num]	[num] characters to the right of the start of the match
s[-num]	[num] characters to the left of the start of the match
b[+num]	[num] characters to the right of the start (begin) of the match
b[-num]	[num] characters to the left of the start (begin) of the match

If a '-' or '+' is given but [num] is omitted, a count of one will be used. When including an offset with 'e', the search becomes inclusive (the character the cursor lands on is included in operations).

Examples:

pattern	cursor position
/test/+1	one line below "test", in column 1
/test/e	on the last t of "test"
/test/s+2	on the 's' of "test"
/test/b-3	three characters before "test"

If one of these commands is used after an operator, the characters between the cursor position before and after the search is affected. However, if a line offset is given, the whole lines between the two cursor positions are affected.

A very special offset is ';' followed by another search command. For example: