This document is broken into multiple sections. First, a general introduction and discussion of what vi is in sections 0 and 1. Section 2 is a collection of "novice" questions, questions that someone without much experience with vi might ask. These include the differences between command and insert mode, and continue ending with questions such as "How do I cut and paste?" Then, section 3 is geared toward the intermediate vi user. Starting with "How do I do a search and replace," and continuing onward from there, until it finally ends with a discussion of vi macros. Also included is a vi quick reference. This should give a canonical list of vi commands. Next, is a list of :set commands, all of which can be put into a .exrc file to customize your editing environment.

The quick reference was confirmed on a machine running SunOS with the UCB distribution of vi. Each command should work under System V and UCB versions of vi other than the one shipped with SunOS, but I have not personally confirmed this.

Unless otherwise specified this document assumes that you are in command mode.

An attempt was made to retain much of the terminology used in the original vi documentation, wherever I could remember what it was.

Also, I will often refer to regular expressions (often called regex's). Please look at the man page (man 5 regexp will show it on most Unix programs) or another reference (the O'Reilly Mastering Regular Expressions book in the bibliography, for example) for more information on what they are and what they do. They're really useful, and it won't be a waste of time. Trust me.

Yes, as long as you do not alter it in any fashion, or charge any money for it. If you plan on including it in a book, CDRom, or other such publication, please contact me first.

First, send me any errors that you may find. Also, any suggestions that you might have are also appreciated. Better yet, anything that you think is unclear. My email address is: ellidz@eridu.uchicago.edu

Also, use vi! Spread the word! I'm sorry I can't list everyone who has contributed to this faq, as many, many people have given me advice and helped out, but I fear if I were to, the list of contributers would become as long as the document itself.

[Note: I've lost my list of other people's translations, if you've translated the FAQ to another language and your translation is not listed here, please let me know.]

Marc Simon (msimon@astrolabe.frmug.org) has translated the FAQ into French. It is available at: http://tux.u-strasbg.fr/vim/vifaq.html

If you're interested in translating the FAQ into another lanugage, let me know, I'm always happy to have it be more widely available. If you let me know before you start working on it I can make sure you're not duplicating someone else's efforts.

vi is a Visual Editor (hence the name -- vi for VIsual). What is a visual editor (as opposed to a non-visual one)? Visual editors are ones that let you see the document that you are editing as you edit it. This seems pretty common in most editors today, so the idea of a non-visual editor is a little strange. Examples of non-visual editors are sed, ex, ed, and edlin (the last one being the editor shipped with DOS until relatively recently.)

vi was written by William Joy as part of the bsd distribution of Unix. It was later used by AT&T, and has been standard Unix since.

- Why does anyone use it? More importantly, why should *I* use it?

vi is default visual editor under Unix, and is therefore shipped with all recent version of Unix. (Recent being defined as post 1984 or so.) This means that whenever you run across a machine that is running a Unix of some sort, you will know that you have a powerful editor at your finger tips. Why else? vi is a powerful editor. Also, once you know vi, you can edit files really quickly, as it is extremely economical with the keystrokes. Due to its different modes for inserting and issuing commands, it is much faster than most non-mode based editors. It is also a very small editor. (The version on my machine is 200k) Also, it can do almost anything, as long as you know how to get it to do what you want.

Furthermore, as an editor it allows a lot of interaction with the Unix operating system. It allows you to use many of the powerful Unix utilities from with vi. It's possible to, from within vi, kill off a list of specific processes that you want to kill. If you haven't given yourself permision to write to the file you're editing by accident, you can change the permision without leaving vi.

vi works be having commands that work on objects. By learning only a few commands and a few objects you can learn how to do a lot of things, simply by combining the commands and the objects. Even the commands are seperated into subcategories. For example, the movement commands and the modification commands are different. If you know that d is the command to delete, and j is the command to go down a line, and you know how to combine them (dj), you can delete down one line. When you use numbers it gets even more powerful. d5j will delete 5 lines below you. Then, once you learn the character for "paragraph" (}), you already know how to delete 5 paragraphs.

- Wow! This sounds great!

Yes. There is a very good reason. It can be somewhat hard to learn, and until you do so, it will be slow and painful. Once you learn it, it will be faster, but the process of learning it is slow. I've been asked if vi was an easy editor to learn, whether it was intuitive or not. My general response to this question is: "Yes, some of us think so. But most people think that we are crazy."

Unix. That's it. However, there are many, many clones of vi that are available for different operating systems. I personally have used vi clones under: Unix, Dos, OS/2, Mac System 7. (See below for a list of specifics.)

- Okay, you've convinced me. I'm going to learn vi.

Well... That's a tricky one. There are many good books out there that cover vi; most books on Unix have at least one chapter devoted to it. There are also many books devoted specifically to vi. I don't have any preference, so your best bet might be to ask your local vi guru where they learned. Also, play around. Fire up vi with a non-important document (your dissertation is NOT a good document to learn vi with...) and play around. I can't imagine anyone learning vi without playing around with it quite a bit. Remember, if you get confused, just hit the Escape key a couple of times, and you'll be in command mode again.

I should mention at some point, and I guess here is as good a place as any, that people who think they might want to do Unix system administration, or any type of configuration of unix machines will probably also want to learn ed or ex, as some versions of Unix do not put vi in the root partition, and one might be stranded without it at some point. Ed is a good choice.

Just to list a few: STvi (STevie), elvis, vile, vim, and nvi, xvi.

elvis is available for Amiga, DOS, OS/2, Unix, VMS, Atari, Psion3a Handheld.
STevie is available for Atari ST, DOS, Unix, Mac System 7. Mac System 7 is available at any info-mac mirror in /info-mac/text (Such as ftp://ftp.hawaii.edu/info-mac/text[§])
Lemmy is available for Win95/NT at: www.accessone.com/~jai[§]
nvi is the vi that ships with BSD 4.4.
vim is available for Amiga, DOS, Mac System 7, Win 95, and Unix. Amiga, DOS, and the source are available at: ftp://ftp.fu-berlin.de/misc/editors/vim The Vim Pages are available at: http://www.math.fu-berlin.de/~guckes/vim/ Mac System 7 is available at any info-mac mirror in /info-mac/text. (See STevie)
vile is available for DOS, OS/2, Unix, VMS, Window95, WindowsNT. The source is available at: ftp://ftp.clark.net:/pub/dickey/vile[§]
xvile, a X-windows aware version of vile exists, as well.
xvi is available for DOS, Unix.
viper is available for GNU Emacs.
ftp://ftp.cs.sunysb.edu/pub/TechReports/kifer/viper.tar.Z

Mortice Kern Systems (support@mks.com), who I have absolutely no affiliation with, offers a commercial version of vi for DOS/Windows, OS/2, and WindowsNT.

There are some differences between the different vi clones. Many offer improvements, but most still allow the commands that are listed in this document, but there may be some differences. Refer to the documentation that comes with the clone for details.

These are some basic hints for the novice vi user. First, keep a command summary with you at all times. A quick reference guide/command summary is included later on. Second, get a good book that covers vi. This document is not the best way to learn it (at least not yet.) I'm not sure if this document should teach people to to use vi from scratch, as there are many good books on it already. However, there are hints here. As for choosing a book, the standard rules apply: look at it before buying it. See if any of it makes sense to you. Make sure that it has exercises that you can practice with. Compare it with other books -- after all, vi can be very confusing, and you want to make sure that it is the book that is confusing, and not just that you underestimated the difficulty of learning vi.

Also, seek out vilearn or vitutor, programs designed to teach you the basics of vi.

This may seem a bit silly, but there are many games on Unix systems that can help you learn to use vi. These help particularly with the basics. Although I don't know of any games that help with every vi command, I do know of a few that will help you learn to use hjkl to move the cursor around. NetHack, a rogue-like game, is particularly good for this, as it is a large game and can be entertaining for quite some time. Not to make the other games sound worse, but some other ones are: rogue, moria, omega, worm, and snake.

Often cited as one of the main problems with vi, and equally often cited as being one of its best strengths, vi differentiates between a "Command mode" and an "Insert mode." Understanding this difference is VITAL to learning vi. When one starts vi it starts in command mode. In this mode, one can move around the file, and issue commands to change certain areas of the text, cut, copy and paste sections of the text and do much more. Insert mode is where one can actually insert text. In other words, command mode is used to move around the document, and insert mode is used to type text into the document.

Commands such as: a, i, c, C, O, o and others will switch one from command mode to insert mode.

<Esc> or <ctrl-c> will take one out of insert mode and return one to command mode.

Get used to this distinction. It is one of the things that makes vi different from most other editors. It also allows one to do a lot of things without taking one's hands from the standard keyboard position.

For novices it is often nice to know what mode you are in. If you type: "echo set showmode >> $HOME/.exrc" at the Unix command line, it will make is so that each time vi is started it will default to showing the mode on the bottom right of the screen. (To understand what this is doing, see the sections on "setting up a .exrc" and the "set options.") If it does not show anything in the bottom right, it means that you are in command mode. I call a few different modes (append, open and insert) "insert mode" in this document.

- What should I do?

Try hitting <ctrl-[> instead. If your keyboard has a <Meta> key, try that. If neither of these work, try <ctrl-3>. Some DEC terminals use the F11 key as escape.

They're just there to let you know where the bottom of your file is, they are not actually in your document, and you do not need to worry about them.

- Do you have any suggestions?

First, if your terminal is set properly and you have a good connection, you should be able to use the arrow keys. However, if you think that you will be using vi a lot, then it makes sense to learn hjkl, as they are faster to type. Also, there are occasions where you may have a bad connection and the ESC sequences may get lost.
Here is a simple mnemonic to help remember this: j extends below the line, and k above the line when written by hand.

:q! will do it.

:r
For example, to insert the file /etc/motd, type: :r /etc/motd

This will insert the file at the current location in the file you are working on. If you specify a number before the r, it will insert it at that location in the file.

/ will search forward. ? will search backwards. ?? or // will repeat the last search. It is worth noting that these are pretty much standard in Unix. In addition, in vi, n will find the next occurrence. N will repeat the last search, reversing the direction. Regular Expressions may be used within searches.

/<ctrl-v><ctrl-<seq>>
<ctrl-v> will tell vi to take the next character literally, and not to take it as a command.

If your computer has the program fmt on it, all you need to do is type !}fmt from command mode (without a : before it). This will reformat the text from the current location until the end of the paragraph. If your machine does not have fmt, you need to find a similar program. (I gather there are many such programs available from the public domain, but I do not know much about them.)

Okay, this might be a bit complicated. Take from this section what you can, and reread it a few times. Also, experiment.

"<letter>yy will copy one line of text into register <letter>. (A register is vi-lingo for a place to store data that was cut or copied.) <letter> must be between a and z.

"<letter>dd will delete one line and place it in register <letter>. You may use a number before the yy or dd to specify the number of lines. Using an uppercase <letter> will append the text into the register leaving what was there before.

"<letter>p will put the text after the cursor.

"<letter>P will put it before the cursor. If the register contains the beginning or end of a line, the line will be placed on another line as appropriate. Y may be used as a short cut for yy. In addition, y$, yH, yM, etc. are valid, as are the equivalent d commands. For quick cuts and pastes, no register need be specified. In this case, no appending is allowed, and the register will be removed if another delete command is given. (Including x).

For example, to move the previous paragraph, one would go to the top of the paragraph, type "a13dd, move to the position in which one wishes to put the paragraph, and then type "ap to put it below the current line.

Now, presumably you want to be able to cut and paste into areas that are not just the end of the line. In order to do this, use m<letter> to mark an area. This letter may be the same as a cut/copy register, they are stored in different area of memory. Then, type "<register>[y or d]`<letter>. Where <register> is the register to put the text into, <letter> is the letter used to make, and yy or dd as appropriate.

- Ahhhh!!! I just hit dG and lost my dissertation! What can I do?

u will undo the last command. U will undo changes to the current line. (Granted, a one line dissertation would not be much.) :e! will reload the current document without saving any changes. In addition, deleted text gets stored in the registers numbered from 1 to 9.

"<n>p will put the last nth deletion. You can quickly search the registers by trying one, hitting u, and trying the next. (In order to expedite this, vi uses . slightly differently than normal. Instead of repeating the last command, it will try the next register, so all you need to do is: "1p u . u ., etc. until you undo the delete you want to undo.)

- Also, I can't get rid of the colon prompt, now what?

If vi appears to have frozen, make sure that you haven't hit <ctrl-S> by mistake. In order to undo a <ctrl-s>, hit <ctrl-q>.

If there is a colon and you can't get rid of it, you've entered ex by accident. Generally this happens by hitting "Q" from command mode. Just type vi to get back into vi.

:[m],[n]w <filename> will save between lines m and n to <filename>. This line numbering method works for almost every : command. If you use :[m],[n]w >> <filename> it will append it to the file.

The commands that follow a : are commands from the ex editor. These allow a lot of flexibility and power. For example, there are many different ways to search and replace, all of with have some similarities (in fact, they are in some ways the same...)

Well, there are a few methods. The simplest is:

:s/old/new/g

But, this only does it on the current line... So:

:%s/old/new/g

In general:

:[range]s/old/new/[cgi]

Where [range] is any line range, including line numbers, $ (end of file), . (current location), % (current file), or just two numbers with a dash between them. (Or even: .,+5 to mean the next five lines).

[cgi] is either c, g, i, or nothing. c tells vi to prompt you before the changes, g to change all of the occurrences on a line. (type yes to tell vi to change it.) i tells vi to be case insensitive on the search. The g after the last slash tells it to replace more than just the first occurrence on each line.

Another method is:

:g/foobar/s/bar/baz/g This searches for foobar, and changes it to foobaz. It will leave jailbars alone, which the other method will not. Unfortunately, if jailbars appears on the same line as foobar, it will change, too.

Of course you can also use regular expression search patterns, and a few other commands in the replacement part of the text. If you use \( and \) in the pattern to escape a sequence (and use \1, \2, etc., you can do lots of nifty things.

For example:

:g/foo/s/^\([^ ]*\) \([^ ]*\)/\2 \1/

will swap the first and second words on every line containing "foo".

Special sequences allowed are:

& everything which was matched by the search
\[1-9] The contents of the 1st-9th \(\) pair

\u The next character will be made uppercase
\U The characters until \e or \E will be made uppercase

\l The next character will be made lowercase
\L The characters until \e or \E will be made lowercase
\[eE] end the selection for making upper or lowercase

Well, okay, it doesn't really need to be a /. Lots of things will work fine. (letters, numbers and a few other things won't...)

:!cmd will run the program cmd. :sh will run an interactive shell. Within this shell, you may, if you want, run vi again. This is particularly useful when you are editing makefiles and config files for programs in an attempt to get a program to compile. The advantage over :e is that you do not need to save the file, and it will be in its old place when you exit the shell. (I advise saving the file anyway...)

- Ahhh!! I was writing my dissertation, ...

Well, you should get mail about this, but you should be able to recover the file by typing vi -r where is the name of the file that you were editing at the time of the crash. vi -r will give you a list of files that can be recovered.

:set ai will make it auto-indent for you.

:set sw=# where # is a number will set the shiftwidth (tabwidth).

You can then use <<, >> to shift a line left or right. Plus, you can use <% to shift a {, ( or [ set left or right (with >%). You must be on top of the specific {, }, (, ), [ or ] of the pair to shift them.

:set sm will show the matching {, ( or [ when you type the closing one.

:set lisp will make some changes that are useful for lisp programming. () will move back and forth over s-expressions, and {} will move without stopping at atoms.

:map <lhs> <rhs> where <lhs> is up to ten characters and <rhs> is up to 100. This will make it so that whenever you type it will replace it with <rhs>. All macros should start in command mode (except those defined with map!), but may end in any mode you desire. Remember to use <ctrl-v> before any control characters that you may use.

If you are using an Ex command, such as |, it needs to be escaped while vi is scanning the line. You should map it as :map foo <ctrl-v><ctrl-v>|.

:unmap <lhs> will remove the macro. :map! <lhs> <rhs> will make <lhs> insert <rhs> into the text of the document. map! macros may have lhs's that are much longer.

If <lhs> is #n where n is 0-9, it will be mapped to the appropriate function key.

Yep, of course. This is vi, it can do anything.

:ab email ellidz@midway.uchicago.edu will make it so that whenever you type email as a specific word, it will extend it to the entire unabbreviated word.

:una email will unabbreviate it.

Here is a macro to do it. These should be put in your .exrc file. (More on .exrc files later on.) It is a pretty simple macro, it just calls ispell on the current file. Of course, to use this you need ispell on your system. To use it, just hit V with vi. (V is not used by vi, so it makes a good key.)

map V :w<enter>:!ispell % <enter>:e!<enter><enter>

The second makes it so that one does not need to hit return after it is done checking the spelling.

- How do I make a macro to do it?

These generally appear from DOS files that get converted to Unix. They're easy to get rid of.

:%s///g will do it.

The macro bit is a bit trickier. Not something that most people can guess on their own. Here it is:

map v :%s/<ctrl-v><ctrl-v><ctrl-v><ctrl-v><ctrl-v><enter>//g

Yes, that's right. 5 of them. The last one is to escape the enter. Two of the other four are to escape the other two <ctrl-v>'s. Since the macro gets read on the ex line, you need to have two <ctrl-v>'s (since you are searching for <ctrl-v> <enter> to replace it with nothing...)

In general, if you are having trouble with macro that uses the ex line, you need to escape things a lot. Sometimes it is quicker to just keep throwing <ctrl-v>'s in until it works.

Okay, okay, so I don't expect anyone to actually ask this... But, I thought it was bizarre enough to throw in anyway. (And, it actually answers a very common question...)

vi will start up in a specific mode, called "open mode" in this situation. Things work more or less the same. Deleted characters will appear on your print out as \'s. vi will act as if the size of the window is only one line. ^r will retype the current line. z redraws the window around the current line.

- But I don't have a hardcopy terminal, and it still starts in open mode!

Well, what is happening here is that vi doesn't know what type of terminal you have. It decides that in this situation the best thing to do is to assume that you have the worst terminal possible. This might not seem useful, as not very many people need open mode, but it also is the mode that needs to know the least information about your terminal.

Now, how to deal with it. It is possible to change it for the specific session, but in general, this is not useful. If you know your terminal type, you can set it from the Unix prompt (setenv TERM <termtype> under csh and it's variants, and: TERM=<termtype> ; export TERM under sh and its variants.).

Better yet would to be to edit your .profile or .cshrc to include this so it is automatically done for you when you login. (Of course, you need to either know ed or be able to set it at the unix prompt before you'll be able to edit the file...)

If you do not know your terminal type, try vt100. Most modern terminals and terminal emulators can emulate vt100. If this does not work, find someone to help you.

Unfortunately, the source code to vi is owned by AT&T. If you happen to have a source license to a version of Unix that has vi, you should have the source code. Otherwise, you're out of luck. You may want to look at the source for some vi clones, however, as most of them are publicly available.

- I see that sections are defined by SHNHH HU - What does it mean?

Man pages are written in a language called nroff/troff. Nroff is a general purpose text formatting language, similar to TeX. What does this have to do with vi and the sections? Use the UNIX more command to look at a man page (say, /usr/man/man1/vi.1 or something). You'll see parts of the page split into sections, like .SH Name. The .SH is defining a section of the man page. Notice that SH is the first two characters of the section set option.

The section and paragraph sections are defined by a listing of pairs of macros for nroff/troff. The next section will start with a period and then any of the pairs of letters that the section is defined as. Paragraphs work the same way -- except that a blank line is also considered a paragraph break.

- But when I program, I've noticed that I can use ]] and [[ to move between functions. My functions don't have .SH or anything at the beginning, what gives?
Luckily for many C programmers, an open curly brace at the beginning of a line is also defined as a section break.

vi allows for multiple files to be open at the same time. Unlike many editors, you only see one file at a time. If you start vi with multiple files on the command line they'll all be opened up. You'll start out in the first file, and you can move to the next file by typing :n. If you've made changes to the current file that you don't want to keep, you can go on by using :n!. Note that this will discard any changes that you've made. If you want to save, you need to use :w first.

- So, I've started up vi, but now I want to be able to edit another file. How do I do this?

:n will load that file into vi. You'll need to save your current file.

:e # will edit the last file that you were editing. You can use this to swap back and forth quickly between two different files. If you are editing many files, you can use :n to cycle between them.

- But I'm only wanting to edit one file at a time. I've got one open and I want to switch permenatly to another file. How do I do that?

Just use :e and it will load it up.

:r <filename> will read in a new file at the current location. It is worth noting that Unix in general deals with the output of commands as files in many respects. Because of this, you can easily read in the output of a command into the file: :r! !<command> will read in the output.

There is a FAQ posted frequently which gives a list of all the files that are online at the vi archive. It also gives a list of addresses which mirror the vi archive. The main address is ftp://alf.uib.no/pub/vi, but it is archived at many, many sites. The vi-archive faq lists all of them. Please check that faq before ftping to it, as there is almost definitely a closer and therefore faster site to you than the one in Norway.

A few mirrors are:
ftp://ftp.uwp.edu/pub/vi[§]
ftp://ftp.uu.net/pub/text-processing/vi
ftp://ftp.cc.monash.edu.au/pub/vi
ftp://ftp.s.u-tokyo.ac.jp/misc/vi-archive[§]

The site has many, many files on vi, including a few clones. It also has the UCB distribution of vi, and lots of useful macros. Check it out.

This section is for silly vi tricks, and silly macros. Actually, any interesting vi tricks and macros are acceptable, as long as they are not too lengthy. I will add any that are suggested to me that I think are reasonable.

Note: Also check out the Silly macros down below. Many macros and tricks are interchangable.
xp
This will delete the character under the cursor, and put it afterwards. In other words, it swaps the location of two characters.
ddp
Similar to xp, but swapping lines.
yyp
duplicate a line
uu
Undo and redo last change. (This will take you to the last modification to the file without changing anything.) You can also use this to compare the changes to a line. Make the changes to the line, press U to undo the changes to the current line, and then press u to toggle between the two versions.
:g/.*/m0
This will reverse the order of the lines in the current file. m0 is the ex command to move the line to line 0.
:v/./d or :g/^$/d
Removes all blank lines.
:g/^[ ]*$/d
Removes all lines that only have whitespace.
:v/./.,/./-1join
Replaces multiple blank lines with just one blank line.

Note: <ctrl-x> means hold down control, and hit x.

  Swap character and one vertically above:
    map * kxjphxkP

  Fold a line that's too long
    map g $80<ctrl-v><ctrl-v>|F r<ctrl-v><enter>

  Change case on most words
    map v ywmno<ctrl-v><esc>P:s/./\~/g<ctrl-v><enter>0"nDdd`n@n

  Put `and' around the current word
    map *` i`<ctrl-v><esc>ea'<ctrl-v><esc>

  Put 'and' around the current word
    map *' i'<ctrl-v><esc>ea'<ctrl-v><esc>

  Put "and" around the current word
    map *" i"<ctrl-v><esc>ea"<ctrl-v><esc>

  Put `and' around the current word
    map! `` <ctrl-v><esc>bi`<ctrl-v><esc>ea'

Split a line at the cursor, and put a > at the beginning of the next line. (For quoting Usenet, etc). I had some trouble with my old version of this under some versions, so I've redone it, and I think that it should work.

    map g may0O<ctrl-v><esc>P`ao<ctrl-v><esc>P:s/./ /g<ctrl-v><enter>0i><ctrl-v><esc>$mb`ay$`bP'add

  Insert one character
    map g i$<ctrl-v><esc<r

Format a paragraph without the fmt program. (To use, use J a few times, then this a few times)

    map K 072lBhr<ctrl-v><enter>

Or, a little less elegantly, but without the need to use J and K multiple times. (Glue lines together)

    map K {wma}b:'a,.j<ctrl-v><enter>
    :s/\(.........................................................\)/\1<ctrl-v><ctrl-v><ctrl-v><enter>/g<ctrl-v><enter>

Make ctrl-x work as cut, ctrl-v as paste, ctrl-p as copy. You should mark the beginning of the area as m (use mm). (ctrl-c cannot be remapped when it is defined as the interrupt character in Unix.)

    map <ctrl-v><ctrl-x> "zd`m
    map <ctrl-v><ctrl-p> "zy`m
    map <ctrl-v><ctrl-v><ctrl-v><ctrl-v> "zP`m

Save a read-only file. Careful, it changes the permissions. When done, it changes them to read/write owner, read for everyone else. Note that this might not be the same as the original permissions.

    map K :!chmod 666 %<ctrl-v><enter>:w!<ctrl-v><enter><ctrl-v><enter>
    :!chmod 644 %<ctrl-v><enter>

  vi status line (sort of...) [Note:  It's slow...]
    map <ctrl-v><up-arrow> k<ctrl-v><ctrl-g>
    map <ctrl-v><down-arrow> j<ctrl-v><ctrl-g>
    map k k<ctrl-v><ctrl-g>
    map j j<ctrl-v><ctrl-g>
    map <ctrl-v><ctrl-f> <ctrl-v><ctrl-f><ctrl-v><ctrl-g>
    map <ctrl-v><ctrl-b> <ctrl-v><ctrl-b><ctrl-v><ctrl-g>
    map H H<ctrl-v><ctrl-g>
    map M M<ctrl-v><ctrl-g>
    map L L<ctrl-v><ctrl-g>
    map G G<ctrl-v><ctrl-g>
    map <ctrl-v><ctrl-u> <ctrl-v><ctrl-u><ctrl-v><ctrl-g>
    map <ctrl-v><ctrl-d> <ctrl-v><ctrl-d><ctrl-v><ctrl-g>

  center a line
    map = 080i <ctrl-v><esc>$78hd0^D:s/  / /g<ctrl-v><enter>$p

  redefines tab so that it inserts 5 spaces instead of a tab marker
    map! <ctrl-v><ctrl-i> <space><space><space><space><space>

  switch current and last line (repeat to reverse a file)
    map v Gdd''Pj

  yank until end of line, run it in a shell and read in the result
    map v y$o<ctrl-v><esc>pI:r!<ctrl-v><esc>"add@a

  allow vi to backspace over text that was inserted in a previous insert mode
   map! <ctrl-v><ctrl-?> <ctrl-v><esc>xa
   map! <ctrl-v><ctrl-h> <ctrl-v><esc>xa

  print the document to the default printer (for BSD replace lp with lpr).
   map v 1G!Glp<ctrl-v><enter>u

  set # to toggle line numbers on and off:
   map \o# o:se nu<ctrl-v><enter>:se nonu<ctrl-v><esc>-:map \o#
   "wp<ctrl-v><enter>
   map \d# "w2dd
   map \x# "xdd@x"xpk
   map # ma3L\o#\x#\d#`a:<ctrl-v><enter>
 
  Quote the current paragraph with '>'s.
   map Z> mc{jma}kmb:'a,'bs/^ /> /<ctrl-v><enter>'c

  Allow <ctrl-z> to suspend processes within insert mode
   map! <ctrl-v><ctrl-z> <ctrl-v<esc>:stop<ctrl-v><enter>

  Make all tabs spaces
   map! <ctrl-v><ctrl-v><ctrl-v><ctrl-i> <ctrl-v><ctrl-v><ctrl-v><ctrl-v><ctrl-v><ctrl-v> <ctrl-v><ctrl-v><ctrl-v>

Replace all tabs with the proper amount of spaces for the given tabstop. Removing the last two character (4<enter>) will allow you to specify the tabstop: #t4<enter>

   map #t 1G!Gpr -t -e4<ctrl-v><enter>
   map #T !}pr -t -e4<ctrl-v><enter>}

  Insert a ruler above the current line
   map #r O<ctrl-v><esc>i....+....1....+....2....+....3....+....4....+....5....+....6....+....7....+....8<ctrl-v><esc>

This is a macro that redefines itself: (more for heuristic reasons than anything else) It inserts foo the first time it is run, and bar all subsequent times.

  map K ifoo<ctrl-v><esc>:map K ibar<ctrl-v><ctrl-v><ctrl-v><esc><ctrl-v><enter>

This makes a end notes. It will insert a [#] at the current location and put a [#] at the bottom of the document and let you type there. Hitting `a will take you back to the original location once you are done with your end note. [#] will be the number of the end note, not the literal # character. (Pretty crazy, huh?) (Glue lines together)

map K ma1GO[0]<ctrl-v><esc>G$?[[0-9]*]<ctrl-v><enter>lyt]`aa
<ctrl-v><enter><ctrl-v><esc>O<ctrl-v><esc>pI:r!echo '1 <ctrl-v>
<esc>A + p' <ctrl-v><ctrl-v>| dc<ctrl-v><ctrl-v><ctrl-v><ctrl-v>
<ctrl-v><ctrl-v><ctrl-v><enter><ctrl-v><esc>0"yD@y0i[
<ctrl-v><esc>A]<ctrl-v><esc>kkJJJmb1Gdd`bF[yf]Go<ctrl-v><esc>pA

... means that something needs to be specified before or after the command, as appropriate. This is normally a cursor movement keys (h,j,k,l,w,b, etc.) or a line number.

(Note: this is not a canonical list, just some of the more important ones.)

The abbreviations in parenthesis may be used.  Syntax:

  :set <option> <param>   (If <param> is expected) 
  Multiple options may be specified on one line.  

  :set <option>? displays the value of the <option>
 
  :set all displays the value of all the options.  

For options without a value, set no<option> turns it off.

Any commands that can be used in command input mode ( : commands), may be used in a .exrc, which will load automatically whenever you start vi. In addition, the source command (so), abbreviations (ab), and macros may be used. There may not be any blank lines in your .exrc. A " in the first column may be used to tell vi that what follows is a comment.

This .exrc file is a real one. Mine. Because of that, it doesn't set as many options as one might wish it did to get a good idea of what may be used. However, it should get the basic idea down, and it is quite straightforward.

First, note that you do not need to specify the :, it is assumed.

" Ignore case on search
set ic
" set wordwrap 9 characters from the right
set wm=9
" show matching parenthesis
set sm
" set the shell to be zsh
set sh=/nfs/kimbark/k4/ellidz/bin/zsh
" a few abbreviations for my email addresses
ab zidlle E. Larry Lidz - ellidz@midway.uchicago.edu
ab --l -Larry
" uppercase V will run ispell -x (-x tells it not to save backups) on current
" file
map V :w<ctrl-v>:!ispell -x %<ctrl-v>:e!<ctrl-v><ctrl-v>
" = will center the line...  if I can get it to work
map = 80I <ctrl-v>$78hd0:s/  / /g<ctrl-v>$p
" v will reformat the current paragraph
map v {0!}fmt<ctrl-v>
" Splits a line in two at current cursor location, puts a > at the
"beginning of the line
map g may0O<ctrl-v>P`ay$:s/./ /g<ctrl-v>0i><ctrl-v>`aPa <ctrl-v>D
" Change the case on the current word
map K ywmno<ctrl-v><ctrl-v><ctrl-v>P:s/./\~/g<ctrl-v><ctrl-v><ctrl-v>0"nDdd`n@n

I'd like to say that vi is bug free, but unfortunateely, it's not. These bugs are bugs in the original vi, not necessarily in any of the different clones.

  
  Macros for _ do not always work properly.
  #~ does not work under AIX

This glossary will be updated as people suggest terms that they do not understand. Please let me know if you have any suggestions.

  VI QUICK REFERENCE/HELP CARDS
  Specialized System Conultants, Inc.
  (206)-367-8649
  P.O. Box 55549
  Seattle, WA 98155

  UNIX Programming Tools,
  Eric Foster-Johnson
  M and T Books, 1997.
  ISBN 1-55851-482-1
  Includes a CD-ROM containing vim.
  http://www.pconline.com/~erc/unixprog.htm

  The ULTIMATE GUIDE to the VI and EX Text Editors
  Hewlett Packard Company (authors)
  The Benjamin/Cummings Publishing Company, Inc.
  ISBN 0-8053-4460-8

  A PRACTICAL GUIDE TO THE UNIX SYSTEM
  Mark G. Sobell
  Benjamin Cummings Publisher

  LEARNING THE VI EDITOR
  Linda Lamb
  O'Reilly & Associates
  ISBN 0-937175-67-6

  UNIX POWER TOOLS  (particularly for macros)
  O'Reilly & Associates

  MASTERING REGULAR EXPRESSIONS (for RegEx)
  Jeffrey Friedl
  O'Reilly & Associates, 1997
  ISBN 1-56592-257-3

  UNIX TEXT PROCESSING
  Hayden Books, 1987
  Dale Dougherty and Tim O'Reilly
  ISBN 0-8104-6291-5

  An Introduction to Display Editing with Vi' & 'EX reference Manual' in 
  UNIX programmers Manual vol. II
  Bill Joy
  Berkeley Software
  
  EL EDITOR VI. MANUAL DE REFERENCIA
  RA-MA Editorial.

  Please make suggestions as to what books are most useful for learning
  vi. I will add books to this section as people suggest them to me.

  Copyright, E. Larry Lidz, 1994, 1995, 1996, 1997, 1998.  All Rights Reserved.

[§]: link caused problem