Modes and Navigation

Now that Vim is installed and configured, it's time to understand its core concept in depth: modes. Once you understand modes and learn how to move around a file efficiently, everything else in Vim clicks into place.

Understanding Vim's Modes

Remember from the introduction: Vim has different "modes" for different tasks. Here's a complete reference:

Normal Mode — Your Home Base

Normal mode is the default mode — it's where you start when you open Vim, and where you return to between tasks. In Normal mode, every key is a command:

• h j k l move your cursor (left, down, up, right)
• dd deletes an entire line
• yy copies ("yanks") a line
• p pastes what you've copied or deleted
• u undoes your last action

You'll spend most of your time here. Think of Normal mode as the "steering wheel" — you're navigating and controlling the editor.

Insert Mode — For Typing Text

Insert mode is where you actually type text, just like in any regular editor. There are several ways to enter Insert mode, and each one positions your cursor differently:

You'll know you're in Insert mode because you'll see -- INSERT -- at the bottom of the screen. Press Escape (or Ctrl-[, which does the same thing) to return to Normal mode.

Visual Mode — For Selecting Text

Visual mode lets you highlight (select) text, then do something with the selection. It comes in three flavors:

Once you've selected text, press a command key to act on it:

• d — delete the selected text
• y — copy ("yank") the selected text
• > — indent the selected text to the right
• < — unindent the selected text to the left
• ~ — toggle uppercase/lowercase

Press Escape to cancel the selection and return to Normal mode.

Command-Line Mode — For Vim Commands

Press : (colon) from Normal mode to enter Command-line mode. A cursor appears at the bottom of the screen where you type commands:

:w              " Save the file
:q              " Quit Vim
:wq             " Save and quit
:e filename     " Open a different file
:!ls            " Run a terminal command (ls lists files in a directory)
:%s/old/new/g   " Find and replace all occurrences in the entire file

Press Enter to run the command, or Escape to cancel and go back to Normal mode.

Basic Movement — h, j, k, l

In Normal mode, you use these four keys instead of arrow keys to move your cursor:

     k          (up)
     ↑
h ←     → l     (left / right)
     ↓
     j          (down)

Why these keys instead of arrow keys? When the original vi editor was created in 1976, the computer keyboard had arrows printed on these exact keys. But the real benefit is ergonomic: these keys are on the "home row" (the middle row where your fingers naturally rest), so your hands never need to move away from the typing position.

# Practice: open any file and move around
vim ~/.vimrc
# Press j to move down one line
# Press k to move up one line
# Press h to move left one character
# Press l to move right one character

Moving by Words (Much Faster!)

Moving one character at a time with h and l is slow. Instead, you can jump by whole words:

What's the difference between w and W? Lowercase w treats punctuation as word boundaries — in the text hello-world, pressing w would stop at hello, then -, then world (three "words"). Uppercase W only uses spaces as separators — hello-world is treated as one single "WORD" and W jumps over the whole thing.

Try it yourself: Open any file and press w repeatedly to watch your cursor jump word by word. Then try b to go backward. You'll immediately see how much faster this is than pressing l over and over.

Moving Within a Line

These commands let you jump to specific positions on the current line:

Here's a practical example. Imagine your cursor is at the start of this line:

" Say this is your line: const result = calculateTotal(items);
 
0        " Cursor jumps to 'c' (very start of the line)
$        " Cursor jumps to ';' (very end)
f(       " Cursor jumps to the '(' character
;        " If there's another '(', cursor jumps to it
^        " Cursor jumps to 'c' (first non-space character)

Moving Through the Entire File

These commands let you jump around the whole file quickly — essential for large files:

gg       " Jump to the very first line
G        " Jump to the very last line
42G      " Jump to line 42
50%      " Jump to 50% through the file (the middle)

Using Counts (Multiplying Any Motion)

Here's a powerful trick: you can put a number before almost any movement command to repeat it that many times:

5j       " Move down 5 lines (instead of pressing j five times)
3w       " Move forward 3 words
10l      " Move right 10 characters
2}       " Move forward past 2 blank lines (2 paragraphs)

The formula is: number + motion = repeated motion. This works with almost every movement command and is one of the things that makes Vim so fast.

Paragraph and Sentence Movement

These commands jump by larger chunks of text — useful for scrolling through code and documents:

In code files, { and } are especially handy because functions and blocks are usually separated by blank lines. Pressing } hops from one block to the next.

Searching for Text

Searching is one of the fastest ways to navigate. It lets you jump directly to any word in the file:

/function    " Search forward for the text "function"
n            " Jump to the next occurrence
N            " Jump back to the previous occurrence
*            " Instantly search for whatever word your cursor is on

Marks (Bookmarks in Your File)

You can set marks — like bookmarks — at positions in your file and jump back to them later:

ma           " Set a mark named 'a' at your current cursor position
'a           " Jump back to the LINE where mark 'a' is located
`a           " Jump back to the EXACT position (line and column) of mark 'a'

Think of marks like sticking a Post-it note on a specific line. You can move away, do other things, and then flip right back to that exact spot.

You can use any lowercase letter for marks (ma, mb, mc, ... mz), giving you up to 26 bookmarks.

Some special marks that Vim creates automatically:

The Jump List (Browser-Like Back/Forward)

As you navigate around — searching, jumping to marks, going to specific lines — Vim remembers everywhere you've been, like a browser's history. You can go back and forward through this history:

This is extremely useful! You can jump to a function definition with /functionName, read it, then press Ctrl-o to go right back to where you were before.

Summary

Here's what you've learned:

• Vim has four main modes: Normal (commands), Insert (typing), Visual (selecting), Command-line (: commands)
• Normal mode is the default — every key is a command, not text
• Enter Insert mode with i, a, o (and others) and leave with Escape
• hjkl replace arrow keys: left, down, up, right (keeping your hands on the home row)
• Word motions: w (next word), b (back a word), e (end of word)
• Line motions: 0 (start of line), $ (end of line), f{char} (find character)
• File motions: gg (top of file), G (bottom), Ctrl-d/Ctrl-u (scroll half-page)
• Searching: /pattern (search forward), n/N (next/previous match), * (search word under cursor)
• Put a number before any motion to repeat it: 5j = move down 5 lines
• Marks (ma to set, 'a to jump back) let you bookmark positions
• Jump list (Ctrl-o back, Ctrl-i forward) works like browser history for your cursor

In the next tutorial, you'll learn to combine these movements with editing commands — this is where Vim's real power shines.

# Open your vimrc (which should have plenty of content to navigate)
vim ~/.vimrc
 
# 1. Jump to top and bottom
# Press gg — cursor jumps to line 1 (the very top)
# Press G — cursor jumps to the last line (the very bottom)
 
# 2. Go to specific lines
# Type 10G — cursor jumps to line 10
# Type 5G — cursor jumps to line 5
 
# 3. Search for text
# Type /set and press Enter — cursor jumps to the first "set"
# Press n — jumps to the next "set"
# Press n again — keeps going to the next one
# Press N — jumps BACK to the previous "set"
 
# 4. Move by words
# Press w — cursor jumps to the start of the next word
# Press w again — keeps jumping word by word
# Press b — cursor jumps back to the previous word
# Press e — cursor jumps to the end of the current word
 
# 5. Find a character on the line
# Press f" — cursor jumps to the next " on this line
# Press ; — jumps to the next " after that
# Press , — jumps back to the previous "
 
# 6. Set and use a mark
# Press ma — sets a bookmark called 'a' at your current position
# Move around the file (try gg, G, /word, etc.)
# Press 'a — cursor jumps right back to where you set the mark!
 
# 7. Jump history
# Navigate around the file (search, gg, G, etc.)
# Press Ctrl-o — cursor jumps back to where you were before
# Press Ctrl-o again — goes back another step
# Press Ctrl-i — jumps forward again
 
# When done, press :q to quit (or :q! if you accidentally edited something)