How to Undo in Figma: Quick and Easy Methods

Ctrl+Z on Windows. Cmd+Z on Mac. That’s the entire answer to how to undo in Figma, and the shortcut reverses your most recent action in an open file without touching what a collaborator is doing at the same moment.

It behaves the same in Figma Design, FigJam, and Dev Mode, tied to whichever session you have open in the browser or the desktop app.

Figma’s engineering team documented the rule behind it in a 2019 blog post: press undo, then an equal number of redos, and the file returns to exactly the state it held before, even while other people are editing the same objects.

What Is Undo in Figma

It reverses the last change you made inside the file you currently have open. Local to your session. Not a saved copy sitting on a server somewhere.

Press it once and the last thing you touched snaps back. Press it again and Figma steps one action further into the past.

Restoring a backup is a different operation entirely. Undo leaves named versions alone, and you never have to leave the canvas to use it.

Figma is a browser-based tool built for interface design work, and undo behaves identically everywhere inside it. Blocking out a layout, testing a prototype flow, doesn’t matter which. Same keys, same result.

Most of the confusion around it comes from expecting more than it offers.

• It’s not a saved backup you can return to days later
• Nobody else in the file can see or use your undo chain
• It keeps no permanent record of every edit the file has ever received

Redo sits right next to it and reverses the reversal, for when you step back one press too far.

Undo and Redo Keyboard Shortcuts in Figma

Ctrl+Z undoes on Windows. Cmd+Z undoes on Mac.

Redo runs on Ctrl+Shift+Z, or Cmd+Shift+Z if you’re on a Mac.

Those same keys carry across Figma Design, FigJam, and Dev Mode, since all three sit inside the same shortcut layer. Desktop app or browser tab makes no difference either.

Here’s the full set.

• Undo on Windows, Ctrl+Z
• Undo on Mac, Cmd+Z
• Redo on Windows, Ctrl+Shift+Z
• Redo on Mac, Cmd+Shift+Z
• Menu route, click the Figma icon in the top-left corner, then Edit

Figma keeps a reference for every combination inside its own shortcuts panel. If you’d rather have the whole thing in one place, there’s a dedicated list of Figma keyboard shortcuts worth bookmarking.

Windows Shortcuts

Ctrl+Z undoes. Ctrl+Shift+Z redoes.

Both work inside a text box, so fixing a typo in a label doesn’t mean clicking out of it first.

Mac Shortcuts

Cmd+Z undoes. Cmd+Shift+Z redoes.

Third-party keyboard utilities sometimes swallow Cmd+Z before Figma ever sees it. Worth ruling out if the shortcut goes quiet for no obvious reason.

How Many Actions You Can Undo in Figma

Figma has never published a fixed ceiling on undo steps per session.

The stack runs last-in, first-out, and it keeps growing for as long as your session stays open. Leave a file open all afternoon and there’s a long chain sitting behind you. Open a fresh one and there’s almost nothing to step back through.

Refreshing the tab wipes that chain. So does closing the file.

Switching pages doesn’t. Jump from a component page to a wireframe page and back, and your undo history is still intact.

The things that clear it:

• Closing the file
• Refreshing the browser tab
• Logging out and back in

The things that don’t:

• Switching pages within the same file
• Opening a different panel or inspector
• Resizing the browser window

Does Undo Affect Other People in a Multiplayer File

Undo only reverses your own actions. A collaborator’s edits sit completely outside your chain, even when the two of you are working on the same frame.

In a busy file that can still feel wrong. You press Cmd+Z, something on screen shifts, and it isn’t what you expected, because someone else moved a layer at that exact second.

Figma’s own capacity limits explain why the overlap happens so often. A single file allows up to 200 people editing at once, and 500 total participants once viewers are counted (Figma Help Center, 2025).

Your chain never reaches into anyone else’s work regardless of how crowded the file gets. What stays yours alone:

• Your own moves, edits, and deletions
• Text you typed in this session
• Layers you created or restyled
• Component changes you made yourself

Everyone else’s cursors keep moving independently of your stack, which is the whole point of a multiplayer canvas.

Undo vs Version History in Figma

Undo reverses one action inside your current session. Version history restores the whole file to a saved point in time. Confusing the two wastes real time when a file actually needs recovering.

Undo disappears the moment you close the tab. Figma’s autosave, meanwhile, keeps building version history snapshots in the background whether you ask for them or not.

On a free Starter plan that snapshot window reaches back 30 days. Professional, Education, and Organization plans keep the full history for as long as the file exists (Figma Help Center, 2025).

Worth checking the gap between free and paid Figma plans before assuming a month-old version is still sitting there waiting for you.

When Undo Is Enough

Small, immediate stuff. A typo you just made. An accidental resize or drag. A color change you want to flip back and forth against the last one.

Fast, no menus, nothing loading in a sidebar.

When Version History Is the Better Fix

Come back the next morning and undo is already gone, because the chain reset when the tab closed. Version history is what actually gets you to yesterday’s layout.

What it does well:

• Survives closed tabs and browser restarts
• Lets you name and label meaningful checkpoints
• Shows who changed what, and when

Where it costs you:

• Free plans only reach back 30 days
• Restoring an old version can overwrite recent work if you’re careless about it
• Slower than one keypress for small fixes

Undo in FigJam and Dev Mode

Leaving a design file doesn’t change the shortcut.

FigJam runs the same Ctrl+Z or Cmd+Z pattern against its own per-session stack. Dev Mode sits closer to a read-only view, so there’s rarely much to reverse there in the first place.

Desktop app and browser behave the same, so bouncing between them mid-project changes nothing.

Moving between Design and Dev Mode doesn’t merge the stacks or reset them. Each one tracks its own history.

FigJam

Sticky notes, connectors, shapes on a board, all of it undoes the way a rectangle does on a design canvas.

• Same keyboard shortcut on both platforms
• Same per-session, last-in-first-out stack

Dev Mode

Dev Mode is read-only by design, built for inspecting specs rather than editing layers, so undo mostly sits idle while you’re in there.

Annotations and measurements you add inside it still respond to Ctrl+Z or Cmd+Z when you need to back one out.

A closer look at how the mode is laid out lives in this Dev Mode guide, useful if handoff work is still new territory for you.

Switching out of Dev Mode and back into Design leaves both stacks alone.

Figma Undo Shortcut Compared to Photoshop, Sketch, and Adobe XD

Ctrl/Cmd+Z is close to universal across design tools. What sits behind the shortcut varies a lot more than the shortcut itself.

Photoshop keeps a dedicated History panel with named states you can click through instead of a linear chain. By default it lists 20 history states, and that number goes up to 1,000 in Preferences for anyone working a long, complex session (Adobe Help Center, 2025).

Figma has nothing equivalent. No visual list of past states, only the chain, one press at a time. I’ve never particularly missed the panel, though I know plenty of people who came from Photoshop and still do.

Sketch uses the same Cmd+Z pattern, but it’s Mac-only, which rules it out for a lot of teams.

Adobe XD is worth mentioning mostly to correct an assumption. Adobe confirmed back in 2023 that XD was no longer sold as a standalone app, and it’s stayed in maintenance mode since, with no new feature work (Adobe, 2023).

Once you’re switching between tools regularly, the keys stop mattering. What matters is whether you get a visual map of your steps back or a chain you feel your way through blind.

How to Undo an Action in Figma

The keyboard shortcut handles most of it. The Edit menu covers the times your hand is already on the mouse, and both pull from the same chain, so mixing them mid-session causes no conflict.

1. Press Ctrl+Z (Windows) or Cmd+Z (Mac) to reverse the last action
2. Check the canvas or Layers Panel to confirm the change actually reverted
3. Keep pressing the shortcut to step back through earlier actions, one at a time
4. If the shortcut doesn’t respond, click the Figma icon in the top-left corner, hover Edit, then select Undo
5. Press Ctrl+Shift+Z or Cmd+Shift+Z to redo if you stepped back too far

Inside a text box the shortcut still works, reversing typed characters without forcing you to click outside the label first.

You don’t need a selection. Undo always targets your last action, not whatever happens to be highlighted on the canvas at the time.

Undoing Auto Layout and Component Changes in Figma

Structural edits don’t always reverse as cleanly as a move or a resize.

Applying auto layout with Shift+A counts as one action, so one Ctrl+Z or Cmd+Z takes it off. Adjust padding, spacing, or direction afterward and every one of those queues up separately.

Which stacks up quickly:

• Add auto layout, one step
• Change spacing mode, another step
• Adjust padding, another step
• Switch direction, another step

Backing fully out of a configured frame can take five or six presses.

If auto layout is still new to your workflow, a walkthrough on using auto layout in Figma covers the properties worth learning first.

Component instances play by different rules, and this is where undo actually lets people down.

Detaching an instance uses Option+Command+B on Mac or Control+Alt+B on Windows, and the same command sits in the right-click menu on the instance itself, both on the canvas and in the Layers Panel (Figma Help Center).

Detach it and Figma converts the instance into a regular frame. Layers and properties stay exactly as they were. The link to the main component is gone for good.

Undo reverses that the moment it happens, same as any other single step.

Let a few edits pile on top, though, and the chain won’t reach far enough back. Figma has no built-in way to reattach a detached instance to its original component after that point. The practical fix is deleting the detached copy, dragging in a fresh instance, and reapplying customizations by hand. A handful of community plugins try to automate the relinking, but nothing native does it in one step.

Salesforce’s own design team found thousands of detached Lightning Design System instances during an internal audit of their Figma library, which is a pretty common outcome when a component feels too rigid for a fast deadline (Salesforce).

A broader look at how components work in Figma covers overrides, the usual alternative to detaching for small tweaks.

Teams on the Organization plan can track detach frequency through Design System Analytics. Handy for spotting the one component that keeps getting broken apart because it doesn’t match how people actually use it.

Figma rolled out Slots into open beta on March 5, 2026, built specifically so designers can customize an instance without detaching it at all (Figma, 2026). Fewer detaches, fewer moments where undo can’t reach back far enough to fix the damage.

When Undo Does Not Work in Figma

Undo fails in a handful of predictable situations, and none of them mean the feature is broken.

Nielsen Norman Group files undo and redo under its user control and freedom heuristic, one of ten usability principles established in 1994 and still used to evaluate software today (Nielsen Norman Group, 1994).

Which is part of why a greyed-out undo feels so disruptive. It isn’t a minor feature. It’s one of the things people expect from any editor without thinking about it.

The usual causes:

• Nothing to undo yet in a fresh session
• A tab refresh or file close wiped the stack
• Keyboard layout mismatched in Figma’s own settings

Empty Undo Stack

Greyed out at the very start of a session isn’t a glitch. There’s nothing in the stack yet, because you haven’t made a change for undo to reverse.

Your first edit activates it, and it stays active until something clears the chain.

Browser and Tab Resets

Same reset triggers as before. Close the file or refresh the tab and you’re starting a clean chain.

The desktop app follows the identical pattern. Quit and relaunch, and whatever you could have undone a minute earlier is already gone.

None of that affects version history, since autosave keeps building its own snapshots regardless of what happens to your undo chain.

Keyboard layout is the cause nobody suspects. Figma’s default shortcuts are built around a US QWERTY layout, and other layouts silently break Ctrl+Z or Cmd+Z along with several other commands (Figma Help Center).

The fix lives in Figma’s shortcuts panel under a dedicated Layout tab. Check it before deciding something is actually broken.

FAQ on How To Undo In Figma

Does Undo Work in Figma’s Mobile App?

The mobile app doesn’t support editing design files, so keyboard undo doesn’t apply.

FigJam is the exception. Its iPad app uses touch gestures, a two-finger tap to undo and three fingers to redo. No Android app yet.

Does Chrome or Edge Cause Undo Shortcut Conflicts Like Safari?

Rarely, in my experience.

Safari is the more common culprit. Figma’s support team has confirmed reports of Cmd+Z failing specifically in Safari, and clearing the browser’s site data is the standard fix.

What Should You Check First When Undo in Figma Stops Working?

Start with the boring possibility. The stack is empty because you haven’t changed anything in this session yet. If that isn’t it, keyboard layout is the next most likely cause, and a browser-specific conflict comes after that.

Working in that order saves time, since each check costs more than the one before it.

• Confirm the stack isn’t simply empty
• Check the keyboard layout setting
• Rule out a Safari-specific conflict

When none of those explain it, version history is the fallback, and you’re trading single-action precision for a coarser point-in-time restore.

Building components that rarely need detaching cuts down on all of this before it starts, and Figma’s component best practices are worth reading before undo turns into your daily safety net.