Vim handles text history differently from almost every other modern text editor. While tools like VS Code or Sublime Text utilize a linear undo stack—where moving backward and then making a change deletes any "future" states—Vim employs a powerful structure known as the Undo Tree. This architecture ensures that no edit is ever truly lost, even if you undo several steps and then begin typing anew.

Understanding the mechanics of the Vim undo and redo system is essential for any developer looking to move past basic text entry into high-efficiency buffer management.

Fundamental Commands for Daily Editing

In standard editors, undo and redo are often the first shortcuts users learn. In Vim, these actions are performed in Normal Mode and offer granular control over how changes are reverted.

Basic Undo and Redo

The most frequent operations involve moving backward and forward along the current editing path.

  • u: This command undoes the last change. You can prepend it with a count, such as 3u, to undo the last three distinct editing operations.
  • Ctrl + r: This is the redo command. It reverses the last undo. Like its counterpart, it supports counts (e.g., 2<Ctrl-r> to redo two steps).
  • :undo and :redo: These are the command-line mode equivalents. While less common for quick edits, they are useful when you want to jump to a specific change number.

The Special Case of Capital U

Vim includes a unique command that often confuses beginners: the capital U.

  • U: This command undoes all latest changes made on one specific line. It reverts the line to the state it was in when you most recently moved the cursor onto it.

Crucially, U itself is considered a change in the undo history. This means that if you use U and then realize you preferred the edited version, you can press u to "undo the undoing of the line." This circular logic is a departure from the linear u command and serves as a precursor to understanding Vim's complex history management.

Navigating the Non-Linear Undo Tree

To truly master Vim, one must visualize history as a tree with branches rather than a straight line. In a linear system, if you undo five changes and type one new character, those five changes are gone forever. In Vim, those five changes are simply moved to a different branch.

Understanding Branching

Imagine you have a file with the word "Start."

  1. You change it to "Start - Alpha." (Change 1)
  2. You change it to "Start - Alpha - Beta." (Change 2)
  3. You press u twice, returning to "Start."
  4. You type "Start - Gamma." (Change 3)

In a traditional editor, "Alpha" and "Beta" are now deleted from history. In Vim, they still exist. Change 1 and 2 form one branch, while Change 3 starts a new branch from the root.

Moving Through Time with g- and g+

Because the undo history can branch, u and Ctrl + r only move you up and down the active branch. To reach other branches, you need chronologically-aware commands.

  • g-: Moves to an older state of the text, regardless of which branch that state belongs to. It effectively travels back in time.
  • g+: Moves to a newer state of the text, traversing forward through time across different branches.

When you find yourself in a situation where you "undid too much" and then typed something, and now Ctrl + r won't take you back to your original work, g- is the key to recovery.

Precision Time Travel and State Jumping

Vim provides several methods to jump to specific points in history without mashing the u key repeatedly. This is particularly useful in long editing sessions.

Using the Earlier and Later Commands

The :earlier and :later commands allow for extremely precise navigation based on time, change counts, or file saves.

  • :earlier 5m: Reverts the buffer to the state it was in 5 minutes ago.
  • :earlier 30s: Jumps back 30 seconds.
  • :earlier 1h: Jumps back one hour.
  • :earlier 1f: This is a powerful variant. The f stands for "file save." This command reverts the buffer to the state it was in at the time of the last :w (write). Using :earlier 2f would go back to the state two saves ago.

Conversely, :later moves forward using the same units (s for seconds, m for minutes, h for hours, d for days).

Identifying States with Undo List

If you are unsure where to jump, you can inspect the "leaves" of the undo tree.

  • :undolist: This command displays a table of all terminal points in your undo branches. The output includes:
    • number: The change number (useful for the :undo {n} command).
    • changes: How many changes are in that branch.
    • time: When the change was made.

Once you identify the change number from this list, you can jump directly to it using:

  • :undo 12: This instantly sets the buffer to the state following change 12.

Configuring Persistent Undo for Long-Term Recovery

By default, Vim’s undo history lives only in memory. When you close a buffer or exit the editor, that history is purged. For professional workflows, enabling Persistent Undo is a game-changer. It allows you to undo changes made yesterday or even last month.

Enabling Persistent Undo in .vimrc

To enable this feature, you must tell Vim to save undo information to a file on disk. In our testing, it is best practice to centralize these files in a single directory to avoid cluttering your project folders with hidden .un~ files.

Add the following to your .vimrc or init.lua: