Which keyboard shortcut reverses the last action? An Undo Guide

Discover the exact undo shortcuts across Windows and macOS, understand multi-level undo, redo nuances, and best practices with practical examples from Shortcuts Lib.

Shortcuts Lib Team

February 8, 2026·5 min read

Keyboard Shortcuts Windows Shortcuts Undo Mac Shortcuts

Undo Quick Reference - Shortcuts Lib — Photo by Ömer Yılmaz via Pexels

Quick AnswerFact

The universal shortcut to reverse the last action is Undo. On Windows, press Ctrl+Z; on macOS, press Cmd+Z. Some apps offer alternate redo toggles (e.g., Ctrl+Y or Ctrl+Shift+Z on Windows, Cmd+Shift+Z on macOS). This article explains how undo works across platforms with clear examples and caveats for common apps.

Which keyboard shortcut reverse the last action? Understanding Undo across platforms

When you work with text, code, or media, reversing a mistake is essential. The question which keyboard shortcut reverse the last action points to the standard Undo command, implemented in most apps as a single-keyboard sequence. Across Windows and macOS, the universal Undo signal is Ctrl+Z on Windows and Cmd+Z on macOS. This consistency helps reduce cognitive load when you switch between tools. However, some apps introduce variations for redo or multi-level undo, and web-based editors can remap these shortcuts depending on focus and mode. In this section, we map the basics, note exceptions, and set expectations for how undo behaves in common environments. The goal is to empower you to undo confidently, not just in editors but in browsers and productivity suites, by leveraging a consistent pattern across your daily workflow. This alignment is a core part of Shortcuts Lib’s approach to practical shortcut guidance.

JSON

{
  "Windows": "Ctrl+Z",
  "macOS": "Cmd+Z",
  "Linux": "Ctrl+Z"
}

Why it matters: Undo reduces mistakes, enables experimentation, and speeds up editing.

OS compatibility and app variations: Undo in action

Undo behavior varies slightly by operating system and the app you're using. While the core signal remains Ctrl+Z (Windows) or Cmd+Z (macOS), some editors offer multi-level undo, advanced redo, or history branching that can alter how far back you can go. In web apps, the focus state and keyboard event handling may change how Undo is captured. To help you reason about these differences, consider a small reference map that correlates OS-level expectations with common app behavior. The goal is to help you predict when Undo will work and when a peculiar app-specific override might kick in.

Python

def undo_shortcut(app, os_name):
    mapping = {
        "Windows": {"undo": "Ctrl+Z", "redo": "Ctrl+Y"},
        "macOS": {"undo": "Cmd+Z", "redo": "Cmd+Shift+Z"},
        "Linux": {"undo": "Ctrl+Z", "redo": "Ctrl+Shift+Z"}
    }
    return mapping.get(os_name, {}).get("undo", "Unknown")

Building a multi-level Undo stack: concepts and a practical example

A robust undo system typically uses a stack (or history) of actions that can be popped to revert to previous states. Multi-level undo allows users to step back through several changes, while redo re-applies actions that were undone. The core idea is to separate the action history from the current state, enabling both forward and backward navigation through edits. This approach is widely used in editors, graphic software, and even simple note apps. Below is a compact implementation that demonstrates the pattern in Python and can be adapted to GUI or CLI tools.

Python

class UndoStack:
    def __init__(self):
        self._stack = []      # history of actions
        self._redo = []       # actions that were undone, available to redo

    def perform(self, action):
        self._stack.append(action)
        self._redo.clear()     # new action clears the redo history

    def undo(self):
        if not self._stack:
            return None
        action = self._stack.pop()
        self._redo.append(action)
        return action

    def redo(self):
        if not self._redo:
            return None
        action = self._redo.pop()
        self._stack.append(action)
        return action

# Example usage
u = UndoStack()
u.perform("type: hello")
u.perform("type: world")
print(u.undo())  # outputs: type: world
print(u.undo())  # outputs: type: hello
print(u.redo())  # outputs: type: hello
print(u.redo())  # outputs: type: world

Practical examples in popular editors and editors

To make these concepts concrete in real-world tooling, here are event-driven patterns you can adopt in a web-based text editor. The first snippet captures Undo initiation with the standard Windows/macOS shortcuts; the second snippet shows how to capture Redo as well. These patterns are portable to many JavaScript-based editors and can be adapted to desktop apps via Electron, NW.js, or native bindings.

JavaScript

document.addEventListener('keydown', e => {
  const isUndo = (e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'z';
  if (isUndo) {
    e.preventDefault();
    editor.undo();
  }
});

JavaScript

document.addEventListener('keydown', e => {
  const isRedo = ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key.toLowerCase() === 'z');
  if (isRedo) {
    e.preventDefault();
    editor.redo();
  }
});

Testing, safety, and best practices for undo

Testing undo functionality ensures that your application reliably reverts to previous states and that redo correctly re-applies them. Unit tests are a practical way to guard against regressions when adding new features or refactoring state management. Consider scenarios with nested actions, batch edits, and undo boundaries after save points. A simple test can verify a basic undo/redo sequence and confirm that the internal history aligns with user expectations.

Python

def test_undo_redo_chain():
    s = UndoStack()
    s.perform("add A")
    s.perform("add B")
    assert s.undo() == "add B"
    assert s.undo() == "add A"
    assert s.redo() == "add A"
    assert s.redo() == "add B"

Steps

Estimated time: 60-75 minutes

1
Identify the last action
Review the current edit and decide which change needs reversal. If you’re unsure, start with a single-step undo to avoid overshooting.
Tip: Establish a mental point of reference before undoing.
2
Invoke Undo
Use the platform shortcut: Ctrl+Z (Windows) or Cmd+Z (macOS). If the app offers redo, be prepared to switch quickly to redo if needed.
Tip: If you’re unsure, press Undo once and verify the result before undoing again.
3
Evaluate history depth
Some apps support multi-level undo. Check the visible history or rely on a specific document state to ensure you revert to the desired version.
Tip: Avoid undoing past a critical save point unless you intend to revert further back.
4
Test redo if needed
If you undo too far, try redo (Ctrl+Y / Cmd+Shift+Z). Confirm that the state reflects the expected changes.
Tip: Practice with sample edits to build confidence before working on important documents.
5
Design undo in your own tools
If you’re implementing Undo in a project, design a stable history stack with a separate redo stack and explicit save-points.
Tip: Document the undo/redo behavior for users to avoid surprises.

Pro Tip: Learn platform-specific redo shortcuts to speed up recovery after mistakes.

Warning: Be aware some apps override Undo in special modes (e.g., full-screen or collaboration modes).

Note: In cloud-based apps, undo history may reset after reload or sync events.

Prerequisites

Required

Python 3.8+↗
Required
Node.js 14+↗
Required
A modern code editor (Recommended: VS Code)↗
Required
Basic command-line knowledge
Required

Optional

Familiarity with your primary apps (word processors, editors, browsers)
Optional

Keyboard Shortcuts

Action	Shortcut
UndoGeneral undo in most apps	`Ctrl`+`Z`
RedoRedo last undone action	`Ctrl`+`Y`
Undo/Redo (alternate patterns)Alternative in some apps; varies by app	`Ctrl`+`⇧`+`Z`

Questions & Answers

What is the simplest Undo shortcut?

The simplest Undo shortcut is Ctrl+Z on Windows or Cmd+Z on macOS. This command reverses the most recent change in virtually all editor apps. If you need to reapply it, you can use the Redo shortcut.

Does Undo work in all apps?

Undo behavior varies by app. Most text and image editors support multi-level undo, but some specialized tools may implement partial undo or use a different history model. Always check the app’s help docs for exact behavior.

What is the difference between Undo and Redo?

Undo reverses the most recent action. Redo re-applies an action that was undone. In many apps, the Redo shortcut mirrors Undo but with a different key combination, and some apps offer additional history controls.

Can I implement Undo in my own software?

Yes. Implement Undo by maintaining a stack of actions and a separate redo stack. On each new action, clear the redo history and push the action onto the undo stack. Expose Undo/Redo methods to the UI.

What should I do about undo history after a save?

Some apps reset undo history after a save point. In critical workflows, save frequently and consider creating explicit checkpoints to preserve desired undo behavior.