Marks and Jump Lists

Introduction

Marks allow you to remember positions in files and jump between them instantly. Jump lists track your movements for easy navigation history.

Marks Overview

Mark Types

Lowercase (a-z)
Uppercase (A-Z)
Numbered (0-9)

Local marks — valid within one file

ma              " Set mark 'a' at cursor
'a              " Jump to line of mark 'a'
`a              " Jump to position of mark 'a'

Persists while buffer is loaded
Erased if line is deleted
Restored with undo/redo
Each buffer has its own set

File marks — valid between files

mA              " Set mark 'A' at cursor
'A              " Jump to mark 'A' (opens file if needed)
`A              " Jump to exact position

Includes filename
Persists in ShaDa file
Can jump across files
Only 26 global marks available

Automatic marks — from ShaDa file

'0              " Position when last exiting Vim
'1              " Position when exiting before that

Set automatically by Vim
‘0 = last exit position
‘1-‘9 = previous exit positions
Cannot be set manually

Marks ‘a-‘z are like bookmarks within a file. Marks ‘A-‘Z are like bookmarks that work across files.

Setting Marks

Basic Mark Commands

Set a mark

m{a-zA-Z}       " Set mark at cursor position

Examples:

ma              " Set local mark 'a'
mA              " Set global mark 'A'
mt              " Set mark 't' (for "top")
mb              " Set mark 'b' (for "bottom")

Set mark from Ex command

:mark {a-zA-Z}  " Set mark at current line
:k{a-zA-Z}      " Short form

Examples:

:42mark a       " Set mark 'a' at line 42
:100ka          " Set mark 'a' at line 100

Use mnemonic letters for marks:

mt for “top” of a section
mb for “bottom”
mc for “code” you’re working on
md for “definition”

Special Mark Commands

m'              " Set previous context mark
m`              " Same as m'
m[              " Set start of last change/yank
m]              " Set end of last change/yank
m<              " Set start of last visual selection
m>              " Set end of last visual selection

Jumping to Marks

Jump Commands

Line Jump
Exact Jump
Without Jumplist

'{mark}         " Jump to first non-blank in line

Examples:

'a              " Go to line of mark 'a', first non-blank
'A              " Go to mark 'A' (may switch files)
''              " Go back to previous position

`{mark}         " Jump to exact position (line and column)

Examples:

`a              " Go to exact position of mark 'a'
`A              " Go to exact position of mark 'A'
``              " Go back to previous exact position

g'{mark}        " Jump without adding to jumplist
g`{mark}        " Exact jump without adding to jumplist

Difference Between ' and `

' (single quote) jumps to the line (first non-blank character)
` (backtick) jumps to the exact position (line and column)

Example:

" Set mark at column 20
ma

" Jump to line, column 1 (or first non-blank)
'a

" Jump to exact position, column 20
`a

Special Marks

Vim maintains several special marks automatically:

Change Marks
Visual Marks
Position Marks

'[              " Start of last change/yank
']              " End of last change/yank
`[              " Exact start position
`]              " Exact end position
'.              " Position of last change
`^              " Position of last insert

Example:

yap             " Yank a paragraph
`]              " Jump to end of what was yanked

'<              " Start of last visual selection
'>              " End of last visual selection
gv              " Reselect last visual selection

Example:

viw             " Select word
<Esc>           " Exit visual mode
gv              " Reselect the word

''              " Position before last jump
``              " Exact position before last jump
'"              " Position when last exiting buffer
`"              " Exact position when last exiting

Listing and Deleting Marks

List Marks

All Marks
Specific Marks

:marks          " List all marks

Example output:

mark line  col file/text
a      5    0  first function
b     42   10  second function
A     10    0  ~/project/main.lua

:marks abc      " List marks a, b, c
:marks aA       " List marks a and A

Delete Marks

Delete specific marks

:delmarks a         " Delete mark a
:delm a             " Short form
:delmarks abc       " Delete marks a, b, c
:delmarks a-d       " Delete marks a through d

Delete all local marks

:delmarks!          " Delete all lowercase marks (a-z)

This also clears the changelist.

Jump Lists

Understanding Jump Lists

Vim maintains a list of positions where you’ve “jumped” to:

jump line  col file/text
  3     1    0 first line
  2    70    5 middle section  
  1   154   23 function definition
>

The > indicates your current position.

Jump Commands

Navigation
List Jumps

:jumps          " List jump positions
:clearjumps     " Clear jump list for current window

CTRL-I and <Tab> are normally the same. In GUI or modern terminals, they can be mapped separately.

What Creates a Jump?

Commands that add to the jump list:

Jump Commands

' and ` — Jump to mark
G — Go to line
/ and ? — Search
n and N — Next/previous search
% — Jump to matching bracket
( and ) — Sentence movement
{ and } — Paragraph movement
[[ and ]] — Section movement
:tag — Jump to tag
CTRL-] — Jump to definition
Starting to edit a new file

Commands that do not create jumps:

h, j, k, l — Basic movement
w, b, e — Word movement
0, $, ^ — Line movement

Use g; and g, to navigate the change list instead of the jump list!

Change Lists

Vim remembers positions where you made changes:

g;              " Go to older change position
g,              " Go to newer change position
:changes        " List change positions

Example output:

change line  col text
    3     9    8 modified line 1
    2    11   57 modified line 2  
    1    14   54 modified line 3
>

Change List Details

Maximum 100 entries per buffer
Same limit as jump list
Changes close together are merged (within ‘textwidth’ distance)
Only actual changes count (not just cursor movement)
Persists across undo/redo

Practical Uses

Mark Usage Patterns

Code Navigation

" Mark important locations
mf              " Mark function definition
mc              " Mark caller
mt              " Mark test

" Jump between them
'f              " Go to function
'c              " Go to caller
't              " Go to test

File Bookmarks

" In main.lua
mM              " Mark Main file

" In config.lua
mC              " Mark Config file

" In utils.lua
mU              " Mark Utils file

" Jump between files
'M              " Go to main.lua
'C              " Go to config.lua
'U              " Go to utils.lua

Quick Return

" Before exploring
mm              " Mark current position

" Explore code...
/some_function<CR>
gd              " Go to definition
CTRL-O          " Go back

" Return to mark
'm              " Jump back to mark m

Combining with Operators

Marks work with operators:

" Delete from here to mark a
d'a

" Yank from mark a to mark b  
y'a'b

" Change from here to mark t
c't

" Format from mark s to mark e
='s'e

Visual Selection with Marks

" Select from mark a to mark b
v'a'b

" Select from here to mark end
v'e

" Linewise select to mark
V'a

Advanced Techniques

Restore Position After Operation

" Save position
ma

" Do operations
:%s/old/new/g

" Restore position
'a

Navigate Large Files

" Mark sections
gg              " Top of file
mt              " Mark top

50%             " Middle
mm              " Mark middle

G               " Bottom
mb              " Mark bottom

" Quick navigation
't              " Go to top
'm              " Go to middle
'b              " Go to bottom

Mark Multiple Locations for Reference

" While reading code
ma              " Mark interesting function
" Keep reading...
mb              " Mark another function
" Keep reading...
mc              " Mark another

" Review marked locations
'a              " Check first
'b              " Check second
'c              " Check third

Jump Patterns

Exploring Code

" Jump to definition
gd

" Look around
/related_function<CR>

" Go back through history
CTRL-O
CTRL-O

" Go forward
CTRL-I

Browsing Changes

" Make some changes in different locations
" ...

" Review changes
g;              " Go to previous change
g;              " And the one before
g,              " Go back forward

Search and Return

" Current position is remembered
/search_term<CR>

" Explore results
n
n
n

" Return to where you started
''              " Jump back

Configuration

Vimscript
Lua

" Jump options
set jumpoptions=stack       " Use stack-based jumplist

" ShaDa settings (save marks)
set shada='100,<50,s10,h
"         |    |   |   |
"         |    |   |   +-- no hlsearch on startup
"         |    |   +------ max 10KB per register
"         |    +---------- max 50 lines per register  
"         +--------------- remember marks for 100 files

" Show marks in sign column (with plugin)
" Plugin: vim-signature or similar

" Convenient mark mappings
nnoremap <Leader>m :marks<CR>
nnoremap <Leader>j :jumps<CR>
nnoremap <Leader>c :changes<CR>

-- Jump options
vim.opt.jumpoptions = 'stack'

-- ShaDa settings
vim.opt.shada = "'100,<50,s10,h"

-- Convenient mark mappings
vim.keymap.set('n', '<Leader>m', ':marks<CR>')
vim.keymap.set('n', '<Leader>j', ':jumps<CR>')
vim.keymap.set('n', '<Leader>c', ':changes<CR>')

-- Auto-restore cursor position
vim.api.nvim_create_autocmd('BufReadPost', {
  pattern = '*',
  callback = function()
    local mark = vim.api.nvim_buf_get_mark(0, '"')
    local lcount = vim.api.nvim_buf_line_count(0)
    if mark[1] > 0 and mark[1] <= lcount then
      vim.api.nvim_win_set_cursor(0, mark)
    end
  end,
})

Tips and Tricks

Remember last position: Add to your config to restore cursor position:

vim.api.nvim_create_autocmd('BufReadPost', {
  callback = function()
    local mark = vim.api.nvim_buf_get_mark(0, '"')
    if mark[1] > 0 and mark[1] <= vim.api.nvim_buf_line_count(0) then
      vim.api.nvim_win_set_cursor(0, mark)
    end
  end,
})

Mark Best Practices

Use lowercase for local navigation (within file)
Use uppercase for file bookmarks (between files)
Use mnemonic letters:
- mt = top, mb = bottom
- mf = function, mc = class
- md = definition, mr = reference
Don’t overuse marks — jump list and change list often suffice
Clear old marks with :delmarks periodically

Jump List Workflow

Use search (/) to explore code
Jump to definitions with gd or CTRL-]
Return with CTRL-O (not '' unless you want to add to jumplist)
Use :jumps when lost in navigation
Clear jumplist with :clearjumps when starting new task

Getting Started

User Guide

Configuration

Features

Plugin Development

Marks and Jump Lists

Introduction

Marks Overview

Mark Types

Setting Marks

Basic Mark Commands

Special Mark Commands

Jumping to Marks

Jump Commands

Special Marks

Listing and Deleting Marks

List Marks

Delete Marks

Jump Lists

Understanding Jump Lists

Jump Commands

What Creates a Jump?

Change Lists

Change List Navigation

Practical Uses

Mark Usage Patterns

Combining with Operators

Visual Selection with Marks

Advanced Techniques

Restore Position After Operation

Navigate Large Files

Mark Multiple Locations for Reference

Jump Patterns

Exploring Code

Browsing Changes

Search and Return

Configuration

Tips and Tricks

Build docs developers (and LLMs) love

Getting Started

User Guide

Configuration

Features

Plugin Development

​Introduction

​Marks Overview

​Mark Types

​Setting Marks

​Basic Mark Commands

​Special Mark Commands

​Jumping to Marks

​Jump Commands

​Special Marks

​Listing and Deleting Marks

​List Marks

​Delete Marks

​Jump Lists

​Understanding Jump Lists

​Jump Commands

​What Creates a Jump?

​Change Lists

​Change List Navigation

​Practical Uses

​Mark Usage Patterns

​Combining with Operators

​Visual Selection with Marks

​Advanced Techniques

​Restore Position After Operation

​Navigate Large Files

​Mark Multiple Locations for Reference

​Jump Patterns

​Exploring Code

​Browsing Changes

​Search and Return

​Configuration

​Tips and Tricks

Build docs developers (and LLMs) love

Introduction

Marks Overview

Mark Types

Setting Marks

Basic Mark Commands

Special Mark Commands

Jumping to Marks

Jump Commands

Special Marks

Listing and Deleting Marks

List Marks

Delete Marks

Jump Lists

Understanding Jump Lists

Jump Commands

What Creates a Jump?

Change Lists

Change List Navigation

Practical Uses

Mark Usage Patterns

Combining with Operators

Visual Selection with Marks

Advanced Techniques

Restore Position After Operation

Navigate Large Files

Mark Multiple Locations for Reference

Jump Patterns

Exploring Code

Browsing Changes

Search and Return

Configuration

Tips and Tricks