Every few weeks someone asks me which motion tool they should standardise on. The honest answer is that they are not the same category of thing, so the comparison people want — "which one wins" — cannot be answered in the abstract.
So I ran the same brief through all five. Here is the brief:
A product card in a React storefront. Hover lifts it and reveals a quick-add button. Quick-add opens a quantity stepper. Changing quantity springs the price. Adding to cart plays a success state, then a toast. It must work with keyboard focus, respect
prefers-reduced-motion, and read its price from live data.
That last sentence is what separates the tools. Not the animation.
The short version
| Tool | Wins at | Stops being the right choice when |
|---|---|---|
| Figma | Static layout, design systems, team collaboration | The screen has to do something |
| Rive | Character/mascot state machines, tiny runtimes, game art | You need full-screen UI layout and DOM semantics |
| Lottie | Non-interactive playback of After Effects work, tiny files | The animation depends on input, state or data |
| GSAP | Precise imperative sequencing, scroll, complex timelines | Designers need to author and iterate on it |
| Spine | 2D skeletal animation for games | You are building a web or app interface |
| Exode | One canvas for layout + physics + logic + code export | You only need a static mockup or a 5-second sticker |
Now the part that matters — what actually happened in each.
Figma: fastest to draw, slowest to make real
The static card took twenty minutes. Variants, auto layout, tokens, all clean. Figma is still the best drawing environment in the industry and I am not going to pretend otherwise.
Then I built the interaction. Hover state, quick-add, stepper, toast — four frames and a nest of prototype arrows. It presented beautifully in the preview window. It also could not tell me what happens when the network request fails, because prototypes have no concept of a request.
The price spring needed a separate component variant per number. The quantity stepper needed a frame per quantity. By the fourth number I gave up and left a note for the developer: "make it feel like this."
That note is the handoff tax. Figma's newer motion features narrow it — you can inspect real timing and easing values now, and that is genuinely useful — but the output is still a description of motion, not motion.
Verdict: excellent for the drawing, and for design review. Not a runtime.
Rive: the best state machine for art, not for UI
Rive is the tool that made state machines normal for animators, and it earns that reputation. I rebuilt the card's hover and success animation as a Rive state machine in under an hour. The transitions were clean, the inputs sensible, and the runtime is small and proven in production games.
The problem started when the card had to be a real product card.
Rive is a stage, not a layout engine. Once I needed text to wrap, a grid to reflow at 768px, and a price to come from a fetch, I was fighting the tool. The output is a .riv binary on a <canvas> — a closed box beside your DOM, not inside it. Keyboard focus, screen readers and form libraries all stop at the canvas boundary.
For a mascot that reacts to scroll, Rive is still my first call. For a checkout card, it is the wrong shape of tool.
Verdict: superb for character and micro-interaction art. Not built for application layout.
Lottie: beautiful, tiny, and frozen
I exported an After Effects version of the card animation through Bodymovin. The .json was 180 KB; a .lottie build came in at a few KB. Playback was smooth and the file was tiny.
Then I needed the hover to follow the pointer. Lottie cannot do that. I needed the success state to fire after an API resolves. Lottie cannot do that either. You can bake variants into segments and cut between them, but every interaction becomes an if-statement in your app that scrubs a video-like timeline.
That is fine — genuinely fine — for loaders, onboarding illustrations and empty states. It is a playback format. It was never designed to be a state machine, and modern dotLottie has not changed that.
Verdict: the right tool when nothing needs to respond. Wrong tool when everything does.
GSAP: unlimited power, no design surface
GSAP is the most capable animation library in the browser and I use it regularly. In forty lines I had the spring, the stagger, the toast, and full control over interruption. ScrollTrigger and the timeline API are still unmatched for sequencing.
What GSAP does not give you is a place for a designer to work. The card lived in my editor as code. Every timing tweak was a deploy. There is no canvas, no shared file a design team can open, and no state machine — you build that yourself, which is fine if you are the one building it.
GSAP is a library. It belongs inside an application. The other tools on this list are trying to be where the application gets made. Those are different jobs, and comparing them head-to-head usually means someone is about to make an expensive organisational mistake.
Verdict: keep it. It is not a competitor to a design canvas; it is what you reach for when code is the source of truth.
Spine: the game animator's tool, and it should stay that way
Spine is the best 2D skeletal animation tool for games, full stop. Mesh deformation, IK, curve timelines, and a decade of Unity/Unreal pipeline work behind it. I rigged a simple character in an afternoon and the result was better than anything I would hand-key.
But the checkout card is not a character. Spine has no flexbox, no breakpoints, no text layout worth the name, and its runtime is aimed at game engines. Using it for product UI would be like using a forklift to butter toast.
Verdict: if you ship games, buy Spine. That is not a compromise; it is the correct answer.
Exode: what I was actually trying to do
I rebuilt the card in Exode last. Layout used flexbox constraints that mirror CSS, not artboard copies. The stepper read from a real number input. The price spring was a physics transition with stiffness and damping, tuned live on the canvas. The success state was a state machine with three states and two inputs.
The part I cared about most: the export. The card compiled to a React component with props for price and quantity, a callback for add-to-cart, and a prefers-reduced-motion fallback. Not a description of the motion — the component that runs it.
That is the design bet Exode makes. It is a motion development environment, not a drawing app with playback. The tradeoff is real: it is younger than Figma, its ecosystem is smaller, and if your team already ships Lottie illustrations perfectly well you should not move them for the sake of novelty.
So which one?
- Static screens, design systems, review: Figma.
- A mascot or icon that reacts: Rive.
- An illustration that plays: Lottie.
- Complex code-authored sequencing: GSAP.
- Game characters: Spine.
- A whole interactive screen that has to ship as code: an environment that owns layout, logic and runtime together — which is the gap Exode is built for.
The mistake is not picking the "wrong" tool. It is picking three of them and paying the integration cost forever.
I work on Exode, so treat the last section accordingly. The rest is what happened when I actually tried the others. If you want to test the workflow on your own screen, there is a free tier at exodeui.com.