What keyboard controls undo: a complete guide for all apps

Master the core undo shortcut across Windows and macOS, plus editor variations, redo behavior, and quick customization tips. Shortcuts Lib guides faster, safer editing for tech users and keyboard enthusiasts.

Shortcuts Lib Team

February 8, 2026·5 min read

Keyboard Shortcuts Windows Shortcuts Undo Redo Mac Shortcuts

Undo Shortcuts - Shortcuts Lib — Photo by Alexander Sinn on Unsplash

Quick AnswerFact

Undo is driven by standard shortcuts: Windows uses Ctrl+Z and macOS uses Cmd+Z. In most apps, Cmd+Shift+Z or Ctrl+Y can redo. Some editors offer multiple undo levels or an undo history panel. Behavior varies by app and environment, so verify in your current workspace.

What Undo Means Across Apps

Undo is a safety net that lets you reverse recent actions. In modern software, undo works as a stack of edits you can step back through, with a companion redo stack for reapplying undone actions. According to Shortcuts Lib, the core pattern is consistent across platforms, but the breadth of what can be undone and how far back you can go depends on the app, the document type, and the editing mode. This section introduces the concept and sets expectations for practical keyboard use.

PLAINTEXT

# Simple Python Undo Stack (illustrative)
class Editor:
    def __init__(self):
        self.history = []
        self.future = []
    def type(self, ch):
        self.history.append(ch)
        self.future.clear()
    def undo(self):
        if not self.history:
            return None
        self.future.append(self.history.pop())
        return self.history[-1] if self.history else ""
    def redo(self):
        if not self.future:
            return None
        self.history.append(self.future.pop())
        return self.history[-1]

# Demonstration
e = Editor()
for c in "abc":
    e.type(c)
print('after typing:', ''.join(e.history))  # abc
e.undo()
print('after undo:', ''.join(e.history))     # ab
e.redo()
print('after redo:', ''.join(e.history))     # abc

Python

# A minimal undo manager in Python (for educational purposes)
class UndoManager:
    def __init__(self):
        self.stack = []
        self.redo_stack = []
    def apply(self, action):
        self.stack.append(action)
        self.redo_stack.clear()
    def undo(self):
        if self.stack:
            self.redo_stack.append(self.stack.pop())
            return self.peek()
        return None
    def redo(self):
        if self.redo_stack:
            action = self.redo_stack.pop()
            self.stack.append(action)
            return self.peek()
        return None
    def peek(self):
        return self.stack[-1] if self.stack else None

The first snippet shows a simple text buffer with undo/redo using two stacks.
The second demonstrates a generic UndoManager you can adapt to commands or edits.

Common variations:

Some editors implement non-linear undo histories (branching) or time-travel debugging; however, most daily users rely on linear undo with a fixed history depth.

type

Steps

Estimated time: 15-25 minutes

1
Identify your target app and OS
Determine where you will practice undo (text editor, word processor, IDE, or browser). Note the OS and the standard shortcut set for that environment.
Tip: Start with a simple document to avoid accidental data loss.
2
Test the basic undo and redo
In a fresh document, perform a sequence of edits, then use the Undo shortcut to step back and the Redo shortcut to reapply. Observe how many steps you can reverse.
Tip: Count the number of steps you can undo to gauge history depth.
3
Experiment across contexts
Repeat in different apps and document types to see how undo depth and redo behavior change.
Tip: Some apps use the same shortcut for undo and redo, others require a separate mapping.
4
Check alternative mappings
Try the Windows and macOS variants and note any deviations from the standard model.
Tip: App-specific settings can override global shortcuts.
5
Consider customization
Where possible, customize undo/redo shortcuts to fit your workflow.
Tip: In editors like VS Code, keybindings can be adjusted per context.
6
Validate accessibility
Ensure keyboard-focused undo works with screen readers and keyboard navigation.
Tip: Accessible shortcuts help users with mobility differences.

Pro Tip: Use the Undo History (if available) to step through a longer sequence of actions beyond the last single edit.

Warning: Undo can behave differently in browsers, cloud editors, and desktop apps; verify behavior before relying on a single shortcut.

Note: Not all terminal editors support GUI-style undo; learn each tool’s editing model (vim, nano, emacs) separately.

Prerequisites

Required

Windows or macOS desktop with standard keyboard modifiers (Ctrl/Cmd, Alt/Option, Shift)
Required
A text editor or IDE with undo/redo support (e.g., VS Code, Sublime Text, IntelliJ)↗
Required
Basic familiarity with keyboard shortcuts and OS-level modifier keys
Required

Optional

Optional: access to a terminal or shell for comparing command-line history workflows
Optional

Keyboard Shortcuts

Action	Shortcut
Undo last actionDefault in most editors and many applications	`Ctrl`+`Z`
Redo last undone actionCommon redo mappings vary by app	`Ctrl`+`Y or Ctrl`+`⇧`+`Z`
Undo/Redo in a browser editor (text input)Works in many web apps like Google Docs, email editors	`Ctrl`+`Z / Ctrl`+`⇧`+`Z`
Open undo history (where available)Some apps offer an explicit history panel for multi-step undo	`Ctrl`+`H / menu path`

Questions & Answers

What are the default undo shortcuts on Windows and macOS?

On Windows, the default is Ctrl+Z; on macOS, Cmd+Z. Redo typically uses Ctrl+Y or Ctrl+Shift+Z on Windows and Cmd+Shift+Z on macOS. These conventions hold across many apps, but some programs provide alternative mappings.

Can undo history be non-linear or per-document?

Some advanced editors support non-linear or branched undo histories, but most daily editors provide a linear undo stack per document. The availability and depth depend on the application and document type.

Is undo customizable across apps?

Many editors let you remap undo and redo keys via settings or keybindings. Always verify in a dedicated keyboard shortcuts panel to avoid conflicting mappings.

How does terminal editing handle undo?

Terminal editors differ: Vim uses 'u' to undo and 'Ctrl+R' to redo; Emacs uses a different undo command. Shell history (not document undo) can be navigated with history shortcuts.

What should I test first when learning undo shortcuts?

Start with a simple document, perform several edits, and test Undo and Redo repeatedly to understand depth and timing. Then test in other apps to see variation.

Are there accessibility considerations for undo shortcuts?

Ensure shortcuts are reachable via keyboard alone and don’t conflict with screen readers or other assistive technology. Consider customizing bindings for easier navigation.