How to Animate in Figma: Create Dynamic Prototypes

Figma has one built-in way to animate, and it isn’t a plugin or a second app. Smart Animate compares two frames, works out what changed, and interpolates position, size, rotation, opacity and fill between them without manual keyframing.

You set it up in the Prototype tab, the same panel where Instant and Dissolve sit as the other two transition options Figma gives you on any plan.

There’s also Figma Motion now, a separate timeline based tool that went to public beta on June 24, 2026. Smart Animate still ships as the default way to interpolate between frames on every plan, so it’s the one most people touch first.

What Is Smart Animate in Figma

Two frames go in. Figma looks at both, finds the layers they share, and fills the gap between them. Position, size, rotation, opacity and fill color all tween on their own, and you never set a keyframe.

A prototype connection can be set to Instant, Dissolve or Smart Animate. Instant jumps. Dissolve fades one frame into the next. Only Smart Animate bothers to look at what actually changed and move the individual pieces accordingly.

The option lives in the Prototype tab, part of the broader workflow for prototyping in Figma, in the Animation dropdown right beside Instant and Dissolve.

A static mockup shows what a screen looks like. Smart Animate shows what it feels like to move between two of them.

A few numbers worth knowing before you start clicking around.

• A new connection defaults to Instant, not Smart Animate
• The default trigger is On Click
• The default duration is 300 milliseconds
• The feature arrived in 2019, announced in Figma’s own blog post “Announcing Smart Animate and Advanced Transitions”
• Figma Motion, a separate timeline based animation tool, opened to open beta for every plan on June 24, 2026, at Figma’s Config event

Liferay’s design team started testing Smart Animate the week it shipped in 2019. They found it covered most of their prototyping needs without switching over to Principle for every single interaction.

The appeal is pretty plain. No manual keyframing, since Figma fills the gap between two states by itself. Everything stays in the same file as the static design, so there’s no trip to another app and no re-export when a button moves. One click and Presentation mode plays the whole thing back.

The costs are just as plain:

• Only five properties are supported, nothing at the shader or particle level
• Layer names decide everything, and one typo drops the transition back to a plain dissolve
• There’s no native export of the finished transition as a video or a GIF

How Smart Animate Matches Layers Between Frames

Matching is the entire mechanism. Get it wrong and the transition quietly reverts to a plain dissolve, with no warning and no error.

What has to line up:

• Layer names must be identical across both frames, case included
• Layer hierarchy has to match, so an object nested two levels deep in frame one sits two levels deep in frame two as well
• Parent frames need matching names too, although the name of the top level frame itself doesn’t matter
• Text layers are the exception here, matched by text style rather than by name when Figma auto named them from the content itself

Nested component instances complicate this fastest. It helps to be comfortable with how to use components in Figma before stacking animation on top of them, since a swapped instance reads as a brand new object unless the outer names still match.

Which Properties Smart Animate Can Animate

Position, size, rotation, opacity, fill. Figma’s own documentation caps Smart Animate at five properties and that’s the whole list.

• Position moves the x and y coordinates from the start frame to wherever they land in the destination
• Size scales width and height up or down between the two frames
• Rotation animates orientation around a single anchor, whether you rotate one layer or a whole group at once
• Opacity only works if you set a layer to 0 percent instead of hiding it, and then Smart Animate treats the fade as a real transition
• Fill handles solid colors, gradients and image fills between frames

Fill covers more ground than people expect. If you already know how to make a gradient in Figma, animating between two of them takes no extra setup at all.

Drop shadow and inner shadow sit outside this list, and so does shape to shape morphing. Introduce either one and Figma falls back to a plain dissolve instead of a tween.

Setting Up a Smart Animate Transition

The setup is short enough to do from memory after the second time.

1. Duplicate the starting frame so both share the same layer names automatically
2. Change whatever needs to move, resize, rotate, fade or recolor in the new frame
3. Open the Prototype tab and drag the connection node from the first frame to the second
4. Set the trigger, usually On Click for a first pass
5. Switch the Animation dropdown from Instant to Smart Animate
6. Adjust easing and duration, or leave the 300 millisecond default in place for now
7. Repeat the connection for every additional frame in the flow
8. Press Present and click through the flow to confirm it moves the way you expected

Step one matters more than it looks. Duplicating the frame is what keeps every layer name identical between the two states, and it’s a faster habit than building a fresh frame in Figma from a blank canvas each time.

That handoff moment, watching connected frames animate inside Presentation view, is what teams point to when explaining why they bother with any of this. YETI’s design director, Andrew Matthews, has credited Figma’s prototyping tools with making that moment feel real, since developers can see how a design should come together instead of guessing from static screens.

Choosing the Right Trigger for an Interaction

Every Smart Animate connection needs a trigger before it needs anything else.

The trigger decides what starts the motion, turning static screens into genuine interactive elements the moment someone clicks, drags or hovers. Figma’s developer documentation lists 12 separate trigger types in total, though you’ll live inside about four of them.

On Click, On Drag and While Hovering

• On Click is the standard choice for buttons and links, deliberate and expected
• While Hovering and Mouse Enter both cover feedback states, but they behave differently once the cursor leaves
• On Drag was built for carousels, sliders and swipe gestures, where the user’s own motion drives the transition

On Hover and On Press snap back once the trigger ends, according to Figma’s developer documentation. Mouse Enter, Mouse Leave, Mouse Up and Mouse Down commit to the new frame permanently, which is the difference that catches people out.

After Delay and Key or Gamepad Press

After Delay runs on a timer instead of a person’s input, counted in milliseconds from the moment the frame appears.

Key or gamepad press works the same way, except it waits for a specific input device rather than a clock:

• Keyboard
• Xbox One controller
• PS4 controller
• Nintendo Switch Pro controller

Almost nobody reaches for the gamepad option. It exists for anyone prototyping a game or a television interface meant to be navigated with a remote. Teams at companies like Spotify and Netflix build exactly these kinds of production minded prototypes in Figma before a single trigger fires in real code.

Controlling Easing and Duration

Easing decides whether a transition feels alive or robotic. It’s the setting people skip and then wonder why the prototype feels cheap.

Figma’s developer documentation names 13 curves across its bezier and spring presets, more than most people ever touch in a single project.

Preset Easing Curves

Five of the thirteen cover almost everything a typical flow actually needs.

Custom Bezier Curves and Duration Values

Past the presets, Custom Bezier gives you four control points, x1, y1, x2 and y2, which is how you match a curve your design system already defines in code.

Custom Spring swaps that for mass, stiffness, damping and initial velocity, so the motion reacts like a physical object rather than following a fixed timeline.

Duration is set in milliseconds and defaults to 300. Figma’s own team recommends stretching it out while you’re still building, purely so you can see what’s happening frame by frame, then pulling it back before anyone else sees the file.

Longer is not automatically better. A transition that takes 800 milliseconds to move a button feels sluggish no matter how nice the curve is underneath it.

Animating Components, Variants and Auto Layout

Components add something Smart Animate wasn’t originally built around, which is state.

Variants give that state a name. Interactive Components give it a trigger of its own.

Variant Properties as Animation States

Turn a component into a set of variants, say Default, Hover and Pressed, and each variant becomes its own frame inside the same matching system Smart Animate already relies on. Nothing new to learn, really.

• Connect one variant to another with On Click and the action Change To
• Hover variants usually pair with While Hovering so the state reverts on its own
• Boolean properties toggle nested layers on or off inside the same transition

None of it works without the groundwork of how to create variants in Figma done properly first, since Smart Animate only ever reacts to states that already exist.

Auto Layout’s Effect on Animated Resizing

Auto Layout and Smart Animate do not always get along.

Figma’s own support team has confirmed cases where an Auto Layout frame resets scroll position or snaps instantly instead of tweening, particularly when padding or spacing changes size between two states. Annoying to debug, because nothing about the file looks wrong.

The workaround most designers land on is isolating the resizing element in its own frame, kept separate from how auto layout in Figma governs padding and spacing for the rest of the screen.

And when the two keep fighting over the same resize, Instant is the honest fallback, at least until that specific bug gets fixed.

Animating Overlays and Modal Transitions

Overlays work differently from a regular frame connection.

Figma treats every overlay as a new frame stacked above the current screen, not as a Smart Animate destination in its own right.

They exist for a specific, recurring set of jobs. Alerts, confirmations, tooltips, on-screen keyboards, and interactive hamburger menus that slide out without leaving the current screen.

• Open Overlay shows a new frame above the current screen without navigating away from it
• Position can be centered, set to one of six edge and corner anchors, or Manual, positioned relative to whatever triggered it
• Background is either none or a single solid color layered behind the overlay content
• Close on click outside is optional, and it dismisses the overlay the moment someone taps anywhere else
• Nested overlays close in reverse order, so the most recently opened one dismisses first

Figma’s developer documentation lists 8 overlay position types in total: Center, six directional anchors, and Manual.

Background blur behind an overlay is a fairly recent addition. Figma staff confirmed it shipped as part of the company’s 32nd Little Big Updates release in 2023, after designers spent years faking the same look with a full screen frame trick.

Smart Animate does become available the moment two overlays share matching layers, through a separate action called Swap Overlay.

Why Smart Animate Is Not Working

Nine times out of ten, a broken Smart Animate transition traces back to layer names, not a bug.

That last row trips up more people than any other. Community threads going back to 2021 describe the same pattern: override a nested instance and the parent transition stops behaving, even though the layer names still match on paper.

One especially disruptive version of this showed up in desktop app build 107.0, when Interactive Components and Smart Animate briefly stopped working together at all, based on reports Figma’s own community team tracked in December 2021.

None of this means Smart Animate is unreliable. The matching system just rewards discipline, and naming layers on purpose clears up most of these problems before they start.

When Smart Animate Does Not Apply

Smart Animate is not a general purpose animation tool.

It interpolates between two states you already built. It has no concept of a value that reacts to real time input on its own.

• Completely different layouts leave it nothing to match, so when the destination frame shares no real structure with the start frame, the whole flow dissolves instead of animating
• Physics and state machines are outside its reach, since it tweens between two fixed points and never models velocity, gravity or input driven states
• Production ready output isn’t on offer at all, because nothing built with Smart Animate ships inside a real app, it only demonstrates intent inside Figma’s own prototype viewer
• Complex, many object choreography, meaning staggered and sequenced animation across a dozen elements, usually needs manual timeline control that Smart Animate was never built to offer

Motion that reacts to real time or runtime data instead of two fixed states is exactly what pushes production teams toward state machine tools generally.

CARS24, an automotive e-commerce platform, ran into that wall with their previous animation format. Motion designers there found text needed converting to vectors before it could change at runtime, and the team moved to Rive’s state machine model instead, according to Rive’s own case study published in June 2025.

Reaching for Smart Animate on any of these fronts costs time twice. Once trying to force it, and again rebuilding in whatever tool was actually built for the job.

Smart Animate vs Other Prototyping and Animation Tools

Smart Animate isn’t really competing with these tools. It sits a step earlier than all of them.

ProtoPie goes furthest on hardware. It can read a phone’s accelerometer, its proximity sensor and even its microphone, conditions no Figma prototype can touch.

Rive works the opposite direction entirely. Instead of tweening between two states someone built by hand, it runs a state machine that reacts to whatever input it receives, and it ships as the actual animation inside the live app rather than a demo of one.

None of these replace Smart Animate for the job it’s actually good at, which is showing a stakeholder how a screen should feel in the time it takes to duplicate a frame.

Exporting and Handing Off Figma Animations

Figma won’t export the motion for you, so handoff comes down to workarounds. A few of them cover almost every real scenario.

Screen Recording and Plugin Export

The simplest option needs no plugin at all.

• Screen recording means capturing Presentation view directly and trimming the clip afterward, the lowest effort route and also the least flexible
• The LottieFiles plugin converts a prototype flow into a Lottie animation, or preserves click and hover behavior when exported as an Interactive State Machine in the .lottie format
• The Jitter plugin lets you copy layers straight out of Figma, refine the timing inside Jitter, then export once the motion feels right

LottieFiles’ own Figma integration documentation, last updated on June 9, 2026, splits this into two distinct export paths: Prototype Flow for timeline style motion, and Interactive State Machine for anything that needs to keep its click and hover behavior alive.

Jitter’s own site lists export options up to 4K resolution and 120 frames per second, across .mov, .mp4, .webm, Lottie and GIF.

Dev Mode Specs for Developers

Dev Mode takes a different approach to the same handoff problem.

Rather than exporting a finished asset, it shows a developer the trigger, easing name and duration already set on a connection, alongside the usual spacing, color and typography specs. It’s the same panel covered in any broader Figma dev mode guide, since animation timing sits right next to everything else the panel exposes.

Dev Mode alone won’t generate CSS or React code for the motion itself. That deeper handoff belongs to Figma Motion, the newer timeline tool, which can copy CSS, JSON or React straight from its own panel.

Workday leaned on this kind of developer handoff in Figma to close the gap on the specs side of the process. Tammy Snow, VP of Research, Analytics & Design at Workday, has said Dev Mode lets the team hand off a design in a way that limits misalignment between what got designed and what actually gets built.

So, roughly: Smart Animate previews the motion, and a plugin or Dev Mode does the work of making it portable.

FAQ on How To Animate In Figma

Is Figma primarily an animation tool or a design tool with animation features?

Figma is a design and prototyping platform first, with animation added as a supporting feature. Smart Animate, Interactive Components and Figma Motion sit inside a broader toolset built for interface design, not a dedicated motion app like Rive or Principle.

What is the difference between Smart Animate and Morph, the PowerPoint feature?

Both interpolate matching objects between two static states automatically. PowerPoint’s Morph transition works between slides for presentations, while Smart Animate works between Figma frames inside a clickable prototype, with triggers, easing curves and duration values PowerPoint’s feature does not expose.

When was Smart Animate released and who built it?

Figma introduced Smart Animate in 2019 alongside a new Drag interaction, detailed in the company’s own blog post. Product manager Nikolas Klein led the design, built around patterns found in customer NPS survey feedback rather than a single requested use case.

Does Figma prototyping respect WCAG reduced-motion settings?

Not automatically. Figma’s prototype player has no built-in detection for the operating system’s reduced-motion preference, unlike browsers that read prefers-reduced-motion in CSS. WCAG 2.3.3 still expects motion to be pausable or avoidable, so designers need to build a calmer alternative manually.

Can you preview a prototype without entering Presentation Mode?

Yes. Figma offers inline preview, a smaller player available directly inside the design file, alongside the full Presentation view. Inline preview only supports mobile device frames, phone, watch and tablet, while Presentation view supports every device preset Figma provides.

Does Smart Animate work inside Figma Slides the same way it works in Design files?

Not entirely. Prototypes embedded inside Figma Slides reload every time the slide changes, and designers have reported softer image quality compared to viewing the same prototype directly, according to Figma Community threads acknowledged by Figma’s own support team in 2024.

What Should You Check First When Smart Animate Breaks?

A broken transition usually comes down to a layer name that no longer matches, a structural change between two frames, or a property the feature was never built to interpolate in the first place.

Work through it in this order and you’ll catch nearly every failure.

• Layer names, exact matches including case and spacing
• Layer hierarchy and grouping, matched between frames
• The property itself, checked against what Smart Animate supports

This order trades thoroughness for speed. A quick rename fixes the visible symptom fastest, but it skips the harder question of whether the two frames share the right structure, which only a full file audit answers.

That audit usually leads designers toward how to make Figma interactive beyond a single transition, since Smart Animate only reacts to states someone already built by hand.