Redo Shortcut Key: The Complete Guide for Windows, Mac, and Every Major App in 2026

You just undid something — and immediately realized the undo was the mistake. Now you need to redo it. What's the keyboard shortcut?

If you've ever fumbled for the redo command while thinking "I know this, why can't I remember it," you're not alone. Redo is one of the most useful and most inconsistently implemented shortcuts in computing. This guide covers everything: the standard redo shortcuts on Windows and Mac, how redo works in every major application, what to do when redo doesn't work as expected, and the productivity techniques that make undo/redo a superpower.

Key Takeaways

• Windows redo shortcut: Ctrl+Y (or Ctrl+Shift+Z in many apps). Mac redo shortcut: Cmd+Shift+Z (or Cmd+Y in some apps).
• Undo (Ctrl+Z / Cmd+Z) and redo are a pair — redo reverses an undo, stepping forward through your action history.
• Redo only works after an undo — you can't redo something you never undid. New actions clear the redo stack.
• Shortcuts vary by application — browsers, Office apps, Adobe tools, and code editors each have their own conventions and quirks.
• Mastering undo/redo history (including multi-level undo) dramatically speeds up editing, designing, and coding work.

Table of Contents

1. What Is Redo?
2. The Standard Redo Shortcuts
3. Redo on Windows
4. Redo on Mac
5. Redo on Linux and ChromeOS
6. Redo in Microsoft Office (Word, Excel, PowerPoint)
7. Redo in Google Docs, Sheets, and Slides
8. Redo in Adobe Creative Apps
9. Redo in Code Editors and IDEs
10. Redo in Web Browsers
11. Redo on Mobile (iOS and Android)
12. How Undo/Redo Actually Works (Under the Hood)
13. When Redo Doesn't Work: Troubleshooting
14. Undo/Redo Productivity Techniques
15. Customizing Redo Shortcuts
16. Frequently Asked Questions

What Is Redo?

Redo reverses an undo. That's the whole concept — but it unlocks a surprisingly powerful workflow.

Here's the mental model. Every application that supports editing maintains a history of your actions — a timeline. When you type a sentence, delete a paragraph, or move an image, each action is recorded in order.

• Undo steps backward through that timeline, reversing your most recent action.
• Redo steps forward through the timeline, re-applying actions you've undone.

Think of it like walking: undo is stepping backward, redo is stepping forward again. You can only step forward (redo) into ground you've already covered and then stepped back from (undone).

The critical rule

Redo is only available immediately after an undo. The moment you perform a new action — type a character, paste something, format text — the "future" timeline is erased and the redo option disappears. This is universal across virtually all software.

Example:

1. Type "Hello" → Undo (text disappears) → Redo available (retypes "Hello")
2. Type "Hello" → Undo (text disappears) → Type "Goodbye" → Redo gone (the "Hello" future was replaced)

Undo/redo vs. version history

Don't confuse undo/redo with version history (Google Docs' "Version history," Word's "AutoRecover," etc.). Undo/redo is a short-term, in-session timeline — it typically resets when you close the document. Version history is long-term snapshots saved over time. Both are useful; they solve different problems.

Work smarter: The same principle behind undo/redo — non-destructive, reversible workflows — is central to how we build custom AI software at NexaAI Pro: every action traceable, every change reversible.

The Standard Redo Shortcuts

Here's the quick reference — the answer most people are looking for:

Why two redo shortcuts on Windows? Historical accident. Ctrl+Y was the original redo shortcut in early Windows applications (dating back to the 1980s). Ctrl+Shift+Z came later, mirroring the Mac convention — it's literally "Shift + Undo," which is intuitive: adding Shift reverses the direction. Most modern Windows apps support both, but Ctrl+Y remains the "official" Windows standard while Ctrl+Shift+Z is more common in cross-platform and creative applications.

On Mac, Cmd+Shift+Z is the standard — again, "Shift + Undo." Some Mac apps (notably Microsoft Office for Mac) also accept Cmd+Y for Windows-user familiarity.

How to remember it

• Windows: "Y" = "Yes, do it again"
• Mac: Shift reverses direction — Undo goes back, Shift+Undo goes forward
• Universal: Redo is always Undo plus something (Shift or a different key)

Redo on Windows

System-wide

Ctrl+Y works as redo in most native Windows applications: Notepad, WordPad, File Explorer (for rename operations), and the classic Windows dialog text fields.

Ctrl+Shift+Z also works in many modern Windows apps, especially:

• Web browsers (Chrome, Edge, Firefox) for text fields
• Modern Microsoft Store apps
• Cross-platform applications (VS Code, Figma, Notion)

Windows 10/11 specifics

In File Explorer, Ctrl+Z undoes file operations (rename, move, delete to Recycle Bin) and Ctrl+Y redoes them. This is genuinely useful — and genuinely dangerous. Undoing a file delete is a lifesaver; redoing it after changing your mind… less so. Note that File Explorer's undo history is limited and doesn't survive a restart.

In Windows Settings and dialog boxes, text-field undo/redo (Ctrl+Z / Ctrl+Y) generally works wherever you can type.

What about Ctrl+Shift+Z not working?

If Ctrl+Shift+Z does nothing in a Windows app, try Ctrl+Y — the app probably only implements the classic shortcut. Conversely, if Ctrl+Y does nothing (or does something unexpected — in some apps Ctrl+Y triggers a different command), try Ctrl+Shift+Z.

Redo on Mac

System-wide

Cmd+Shift+Z is the Mac standard for redo, working across virtually all native Mac applications: TextEdit, Notes, Mail, Pages, Numbers, Keynote, Finder (for rename/file operations), and everywhere else the Edit menu appears.

In fact, on Mac you can always check: open the Edit menu and look at what's listed next to "Redo" — macOS requires apps to show their shortcuts there. If redo is available, you'll see ⇧⌘Z (that's Shift+Command+Z in Mac symbol notation).

Mac shortcut symbols decoded

Mac menus use symbols instead of key names, which confuses newcomers:

So ⇧⌘Z = Shift + Command + Z = Redo.

Cmd+Y on Mac

Some cross-platform apps (particularly Microsoft Office for Mac and some Adobe apps) support Cmd+Y as redo for the benefit of Windows switchers. But Cmd+Shift+Z is the native Mac convention and works everywhere — learn that one first.

The three-finger swipe (trackpad)

On Mac trackpads, a three-finger swipe left triggers Undo and a three-finger swipe right triggers Redo in many applications. It's a delightful gesture once you build the muscle memory — try it in TextEdit or Notes.

Redo on Linux and ChromeOS

Linux

Linux desktop environments generally follow the Windows convention: Ctrl+Z for undo, Ctrl+Shift+Z (or Ctrl+Y) for redo. GNOME, KDE, and most GTK/Qt applications support both redo variants.

Terminal-based editors have their own conventions (see the code editors section below) — the GUI shortcuts don't apply in a terminal.

ChromeOS

Chromebooks use Ctrl+Z / Ctrl+Shift+Z, matching the browser convention (since ChromeOS is essentially the Chrome browser as an operating system). Ctrl+Y also works in many contexts.

Redo in Microsoft Office (Word, Excel, PowerPoint)

Office has the most sophisticated undo/redo implementation in mainstream software.

The shortcuts

• Undo: Ctrl+Z (Windows) / Cmd+Z (Mac)
• Redo/Repeat: Ctrl+Y (Windows) / Cmd+Y (Mac)
• Alternative redo: Ctrl+Shift+Z also works in newer Office versions

The Repeat quirk

Here's what confuses people: in Office, Ctrl+Y is labeled "Repeat" as well as "Redo." It does double duty:

1. After an undo: it redoes (reverses the undo)
2. Otherwise: it repeats your last action

That second behavior is incredibly powerful. Format a heading as bold+blue, then select another heading and press Ctrl+Y — it applies the same formatting. It's like a one-step macro for your most recent action. (The F4 key does the same thing.)

Multi-level undo dropdown

Click the small arrow next to the Undo button in the Quick Access Toolbar (or press Ctrl+Z repeatedly) to see a list of recent actions. You can select any point in the list to undo everything up to that point at once. The Redo button similarly offers a dropdown after undos.

Office supports 100 levels of undo by default (configurable in Word via registry/options). That's deep enough for almost any editing session.

Excel specifics

In Excel, undo/redo works for cell edits, formatting, and most operations — but not all. Running a macro, for example, clears the undo stack (a notorious gotcha). Saving used to clear undo in very old Excel versions but hasn't for decades — you can undo after saving in modern Excel.

Ctrl+Y in Excel also triggers Repeat, which is fantastic for formatting: format one cell, select others, Ctrl+Y to apply the same formatting.

PowerPoint specifics

Same shortcuts, same Repeat behavior. Particularly useful for: nudging objects into position (undo/redo to compare positions), trying different layouts, and formatting consistency across slides.

Redo in Google Docs, Sheets, and Slides

Google's web apps use the browser-friendly convention:

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z (also Ctrl+Y / Cmd+Y in most cases)

Unlimited-ish history

Google Docs maintains a very deep undo history — effectively unlimited for practical purposes within a session. But the real power is Version history (File > Version history > See version history, or Ctrl+Alt+Shift+H): it shows named, timestamped snapshots going back indefinitely, with the ability to restore any version or copy from it.

The collaboration wrinkle

In collaborative documents, undo only undoes your actions, not your collaborators'. If someone else edited while you were working, your undo timeline interleaves oddly — undoing your change might not restore the exact prior state if a collaborator changed the same region. When in doubt, check Version history.

Sheets specifics

Google Sheets' undo covers cell edits, formatting, and structural changes (insert/delete rows). Like Excel, some operations (notably Apps Script executions) clear the undo stack.

Redo in Adobe Creative Apps

Adobe apps are where redo shortcuts get… creative.

Photoshop

• Undo: Ctrl+Z / Cmd+Z — but with a twist (see below)
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z
• Step Backward/Forward: Alt+Ctrl+Z / Ctrl+Shift+Z (legacy)

The Photoshop history lesson: For decades, Photoshop's Ctrl+Z only toggled the single most recent action (undo/redo one step). Multi-step undo required Alt+Ctrl+Z (Step Backward). In 2018, Adobe finally changed Ctrl+Z to standard multi-level undo — a change celebrated by an entire generation of designers. If you're using an older Photoshop version or following old tutorials, this explains the confusion.

The History panel (Window > History) shows up to 50 states by default (configurable up to 1000) — click any state to jump directly to it, which is faster than pressing undo repeatedly. For AI-assisted image editing workflows, see our Gramhir Pro AI image generator review.

Illustrator

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z

Standard multi-level undo. The History is less prominent than in Photoshop, but Edit > Undo/Redo works as expected through many levels.

Premiere Pro

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z

Premiere's History panel (Window > History) is invaluable for editing — it lists every action, and clicking any entry jumps the project to that state. Note that some operations (like rendering or certain effects changes) may not be fully undoable.

After Effects

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z

Same pattern. After Effects also has a History panel for jumping between states.

InDesign, Lightroom, XD/Figma

• InDesign: Ctrl+Z / Ctrl+Shift+Z — standard
• Lightroom: Ctrl+Z undoes develop adjustments; the History panel (left side in Develop module) lists every adjustment for jumping
• Figma: Ctrl+Z / Ctrl+Shift+Z — plus collaborative version history

Redo in Code Editors and IDEs

Developers live in undo/redo — and editors offer the most powerful implementations.

VS Code

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z (also Ctrl+Y on Windows)

VS Code's undo is per-file and extremely deep. The Timeline view (Explorer > Timeline) shows file history including saves, which complements undo for longer-term recovery. Extensions like "Local History" add even more safety net.

Pro tip: VS Code groups rapid typing into single undo units — pressing Ctrl+Z once undoes a whole burst of typing, not one character. This is usually what you want.

JetBrains IDEs (IntelliJ, PyCharm, WebStorm)

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z

JetBrains adds Local History (right-click > Local History > Show History) — a built-in, IDE-level version control that tracks every change independently of Git. It's saved many developers from disasters that undo alone couldn't fix.

Sublime Text

• Undo: Ctrl+Z / Cmd+Z
• Redo: Ctrl+Shift+Z / Cmd+Shift+Z (also Ctrl+Y)

Vim/Neovim

Vim does undo/redo differently — and more powerfully:

• Undo: u
• Redo: Ctrl+R
• Undo branches: Vim keeps branches of undo history. If you undo, then make a new change, the "undone" future isn't destroyed — it's preserved as a branch you can navigate with :undolist and time-travel commands like :earlier and :later.

Vim's persistent undo (:set undofile) even preserves undo history across sessions — close Vim, reopen the file days later, and you can still undo.

Emacs

• Undo: Ctrl+/ or Ctrl+_ or Ctrl+X u
• Redo: There's no single "redo" — Emacs treats undo itself as undoable: pressing undo again after an undo redoes. (This confuses newcomers but is logically elegant.)

Redo in Web Browsers

In browsers, undo/redo applies to text fields (address bar, forms, text areas) — not to navigation (that's what Back/Forward are for).

• Undo in text field: Ctrl+Z / Cmd+Z
• Redo in text field: Ctrl+Shift+Z / Cmd+Shift+Z (Chrome, Edge, Firefox) or Ctrl+Y

Common scenario: You type a long comment, accidentally delete it or navigate away, and panic. If the text field still has focus (or you can get it back), Ctrl+Z often restores the text. Browser text-field undo is surprisingly resilient — but don't rely on it for important writing; use a proper editor. For finding images and content visually on the web, see our guide to image search techniques.

Note: Browser extensions like form savers (Lazarus-style) add extra protection for web form content.

Redo on Mobile (iOS and Android)

Mobile redo is less discoverable but exists:

iOS

• Shake to Undo: Shake the device → "Undo Typing" popup. Shake again after undoing → redo option appears. (Can be disabled in Settings > Accessibility > Touch.)
• Three-finger gestures: Swipe left with three fingers = Undo; swipe right with three fingers = Redo. Double-tap with three fingers opens the edit menu with Undo/Redo buttons.
• Keyboard: If using a hardware keyboard, Cmd+Z / Cmd+Shift+Z work as on Mac.

Android

• Gboard: The undo/redo buttons aren't in the default layout, but you can access them via the toolbar (tap the > or grid icon above the keyboard). Some Gboard versions support Ctrl+Z/Ctrl+Shift+Z with hardware keyboards.
• App-specific: Many Android apps (Google Docs, etc.) have undo/redo buttons in their toolbars.
• No universal gesture equivalent to iOS's three-finger swipe.

How Undo/Redo Actually Works (Under the Hood)

For the curious — and for anyone building software — here's what's happening beneath the surface.

The command pattern

Most applications implement undo/redo using the Command pattern: every user action is encapsulated as an object containing both the action and its inverse.

• Typing "A" → command stores "insert 'A' at position 5" + inverse "delete character at position 5"
• Undo executes the inverse; redo re-executes the original

The application maintains two stacks: an undo stack (actions performed) and a redo stack (actions undone). New actions push onto the undo stack and clear the redo stack — which is exactly the behavior you experience.

Memory considerations

Storing every action's inverse consumes memory. Applications manage this by:

• Limiting history depth (50, 100, 1000 levels)
• Compressing consecutive similar actions (typing bursts become one undo unit)
• Storing deltas (only what changed, not entire document states)
• Checkpointing (periodic full snapshots + deltas between them)

This is why undo history resets when you close a document — the stacks live in memory.

Why some actions can't be undone

Actions with external side effects often can't be undone: sending an email, printing, running a script that modifies files, or any operation that affects systems outside the application's control. Good applications either warn you or exclude such actions from the undo stack entirely.

Building reliable software: These same principles — command patterns, reversible operations, audit trails — are foundational to the custom AI platforms we engineer at NexaAI Pro. See our services to learn how we build them.

When Redo Doesn't Work: Troubleshooting

"Redo is grayed out"

Cause: You haven't undone anything, or you performed a new action after undoing (which cleared the redo stack). Fix: This is normal behavior, not a bug. There's nothing to redo.

"Ctrl+Y does something weird"

Cause: In some applications, Ctrl+Y is assigned to a different command (e.g., in some IDEs or specialized software). Fix: Use Ctrl+Shift+Z instead, or check the Edit menu to see what redo is bound to in that app.

"Undo/redo stopped working mid-session"

Cause: An operation cleared the history stacks (running a macro in Excel, certain plugins, or the app hit its memory limit for history). Fix: Check if the app has a separate history panel or version history feature. Save your work, and be aware that the timeline restarted.

"I undid too many times and lost work"

Cause: Pressing Ctrl+Z repeatedly without watching what was happening. Fix: Press Ctrl+Shift+Z (redo) repeatedly to step forward again — the actions aren't lost, just undone. Alternatively, check the app's history panel or version history to jump directly to the desired state.

"Redo works in one app but not another"

Cause: Different apps, different shortcuts. The app may only support Ctrl+Y or only Ctrl+Shift+Z. The app may only support Ctrl+Y or only Ctrl+Shift+Z. Fix: Try the alternative shortcut. Check the Edit menu — it always shows the correct shortcut for that application.

"My custom shortcut conflicts"

Cause: You (or an app) remapped keys, creating a conflict. Fix: Check the app's keyboard shortcut settings and resolve the conflict. On Mac, System Settings > Keyboard > Keyboard Shortcuts lets you override menu shortcuts per-app.

Undo/Redo Productivity Techniques

Knowing the shortcuts is table stakes. Here's how power users leverage undo/redo:

1. The "try it and see" method

The fastest way to learn any software: try something, and if it doesn't work, undo. This fearless experimentation is only possible when undo is reflexive. Practice until Ctrl+Z is muscle memory — it changes how you approach unfamiliar tools.

2. A/B comparison

Tweaking a design, photo edit, or paragraph? Make the change, then rapidly alternate undo/redo (Ctrl+Z / Ctrl+Shift+Z) to compare before and after. This flicker-comparison reveals differences your eyes miss in static before/after views. Designers iterate this way constantly — see our rapid prototyping guide for more on fast design iteration.

3. The safety net for bulk operations

Before running find-and-replace across a document, applying a macro, or doing a bulk rename: pause, note that you can undo, then proceed confidently. For truly irreversible operations, save a copy first — undo is a safety net, not a guarantee.

4. History panel navigation

In Photoshop, Premiere, Office (via the dropdown), and IDEs, don't press undo 30 times — open the history list and click the state you want. It's faster and you can see what each step was.

5. Combine with version history

Use undo/redo for short-term exploration ("let me try this formatting") and version history for long-term safety ("let me get back to yesterday's draft"). They're complementary, not competing.

6. Teach your team

In collaborative environments, inconsistent undo/redo knowledge causes real problems — people afraid to experiment, or worse, people who don't realize their "undo" didn't fully revert a shared document. A two-minute shortcut orientation pays for itself immediately.

Customizing Redo Shortcuts

Don't like the defaults? Most professional software lets you remap:

• VS Code: File > Preferences > Keyboard Shortcuts — search "redo"
• JetBrains IDEs: Settings > Keymap — search "redo"
• Photoshop: Edit > Keyboard Shortcuts
• Microsoft Office: File > Options > Customize Ribbon > Keyboard Shortcuts
• Mac (system-wide): System Settings > Keyboard > Keyboard Shortcuts > App Shortcuts — you can rebind any menu item, including Redo, per application
• Windows: No built-in system-wide remapping, but PowerToys Keyboard Manager or AutoHotkey can remap keys globally

A word of caution: custom shortcuts don't transfer between machines, and they confuse anyone else who uses your computer. The standard shortcuts are standard for a reason — consider whether the customization is worth the friction.

Frequently Asked Questions

What is the redo shortcut key?

On Windows, the redo shortcut is Ctrl+Y (or Ctrl+Shift+Z). On Mac, it's Cmd+Shift+Z. These reverse your most recent undo, stepping forward through your action history.

Why is redo Ctrl+Y on Windows but Ctrl+Shift+Z on Mac?

Historical convention. Ctrl+Y dates to early Windows applications; Ctrl+Shift+Z ("Shift + Undo") became popular later as a more intuitive alternative and is the Mac standard. Most modern Windows apps support both.

What's the difference between redo and repeat?

In most apps they're the same command. In Microsoft Office, Ctrl+Y does double duty: after an undo it redoes; otherwise it repeats your last action (e.g., reapplying formatting). The F4 key also triggers Repeat.

Can I redo after closing and reopening a file?

Generally no — undo/redo history lives in memory and resets when the document closes. Exceptions: Vim with persistent undo enabled, and applications with explicit version history (Google Docs, Office AutoRecover). For long-term recovery, use version history, not undo.

How many levels of undo do most apps support?

It varies: Office supports 100, Photoshop's History panel defaults to 50 (configurable to 1000), Google Docs is effectively unlimited within a session, and most text editors support hundreds. The practical limit is rarely the constraint — your memory of what you did is.

Why did my redo option disappear?

You performed a new action after undoing. Any new edit — even typing a single character — clears the redo stack permanently. This is universal behavior, not a bug.

Is there a redo gesture on touchscreens?

On iOS: three-finger swipe right (or shake after undoing). On Android: no universal gesture, but Gboard's toolbar and individual apps often provide undo/redo buttons.

Want to build software with the same attention to user experience? NexaAI Pro designs custom AI platforms where every interaction feels effortless — talk to us about your project.