There is a sentence in animation tooling that sounds like marketing but is actually the whole technical argument:
Lottie records motion. A simulated format describes it.
Once you see the difference, you cannot unsee it. Let me show it with numbers and code rather than adjectives.
What a Lottie file actually contains
Export a 2-second loop from After Effects through Bodymovin and you get a JSON document full of sampled values. For every animated property, at some interval, there is a keyframe with a value:
{
"i": { "x": [0.667], "y": [1] },
"o": { "x": [0.333], "y": [0] },
"t": 24,
"s": [100, 100, 100]
}
The exporter does not know that your bounce came from a spring. It knows what the spring looked like for two seconds, and it writes that down. The player interpolates between the samples and paints the result.
This is why Lottie files can be tiny (dotLottie compresses beautifully) and why they cannot react. A recorded performance has no inputs.
What happens when the design changes
The killer is not file size. It is iteration.
You ship the loader. A week later someone changes the button from 48px to 56px. In Lottie the animation is baked at the old size; you reopen After Effects, re-export, re-run Bodymovin, re-test. There is no "the button is 56px now" property. There is only a new recording.
Same with timing. Marketing wants the spring snappier. That is a new export, not a slider.
The measured comparison
The Exode team published a benchmark comparing the same scene — 100 rounded squares animating position, rotation, scale, opacity and fill over a 2-second eased loop — authored identically in Lottie and in .exode, rendered frame by frame in headless Chrome with the GPU flushed each frame.
| Runtime | File | Per frame (avg) | Runtime download (gzip) |
|---|---|---|---|
| lottie-web (canvas) | 141 KB .json
|
0.70 ms | 76 KB |
| dotlottie-web (WASM) | 3.1 KB .lottie
|
0.40 ms | WASM player |
| Exode (current) | 157 KB .exode
|
0.70 ms | ~740 KB |
Read that honestly, because a lot of comparison posts would not show you this table.
Lottie wins file size, decisively. dotLottie at 3.1 KB for that scene is excellent engineering. dotLottie wins frame time at 0.40 ms. Exode ties lottie-web on speed and loses badly on download size today. The team's published plan targets a ≤76 KB lazy-loaded base runtime and a compact .lexode export, but targets are not shipped code, and you should treat them as such.
So why would anyone use the format that is currently bigger? Because the scene above is the easy case — a linear loop with no interaction. It is the case where recording wins.
The case where recording cannot compete
Now make the scene interactive:
- the squares follow the pointer with spring physics
- clicking one selects it, and the others reflow
- the reflow must be interruptible mid-flight
- reduced-motion users get an instant reposition
- the list comes from an API and the count changes
A recorded format has no answer for any of those. You can bake five variants and crossfade, but pointer-following, interruption and data-driven counts are not states you can pre-render. You end up writing the interaction in JavaScript and using the animation file as decoration.
A simulated format stores the rules:
{
"id": "card-1",
"physics": { "type": "dynamic", "mass": 1, "friction": 0.2, "restitution": 0.6 },
"constraints": [{ "type": "followPath", "pathId": "reflow-track" }]
}
and the runtime integrates it every frame. The file does not need to know how many pixels the card travels, because the travel is computed from the same spring the designer tuned. Change the viewport, change the count, interrupt halfway — the motion stays correct because it was never recorded.
That is the trade: more runtime, less file, and behaviour that survives contact with real input.
Where Lottie is still the right call
I use Lottie constantly and I am not going to pretend otherwise.
- Onboarding illustrations and empty states. Nothing responds, nothing changes. A 40 KB dotLottie is perfect.
- Marketing pages. Autoplay loops, hero illustrations, no state.
- After Effects pipelines. If your motion designer lives in AE, forcing them into a different tool is a cost with no return for a non-interactive asset.
- Native app splash screens. Playback-only by definition.
- Anything where the runtime budget is measured in kilobytes. This is a real constraint on low-end Android.
The mistake is not using Lottie. The mistake is using Lottie for a component that needs to think.
The migration question
If you have a Lottie loader and you are happy, keep it. I would not migrate a decorative loop.
If you have a Lottie "interactive" prototype held together by segment scrubbing and event listeners, that is the signal. Count the glue code. In my experience it is usually 150–400 lines of JavaScript whose only job is to translate application state into a frame range. That code is the thing a state machine replaces.
A rule of thumb
Ask one question: does the animation need to know something the designer did not know at export time?
If no — Lottie, every time. Smaller, faster, ubiquitous.
If yes — the count, the pointer, the error, the viewport — you need a format that stores rules. That is the category Exode is in, alongside Rive and code-driven approaches like GSAP.
UX Baba writes about interaction design and front-end craft. Exode is one option in this category; the benchmark above is published in full, including the columns where it loses, at exodeui.com.
Top comments (0)