Two apps can use the exact same animation, the same panel sliding up the same distance in the same time, and one feels polished while the other feels cheap. The difference is almost always the easing.
Easing is how speed changes during a movement. Nothing in the physical world starts or stops instantly; a drawer accelerates when you pull it and slows as it hits the stop. When UI motion copies that behaviour, our brains read it as natural. When it moves at a constant speed, it reads as mechanical.
This is a practical guide to UI animation easing and spring physics: what each curve communicates, when to use springs, and starting values you can actually use.
Easing in plain words
An easing curve maps time to progress. On a graph, time runs along the bottom and progress up the side. A straight line is linear: constant speed. A curve that's steep at the start and flat at the end is ease-out: fast start, gentle finish.
| Easing | How it feels | Use it for |
|---|---|---|
| Ease-out (decelerate) | Arrives quickly, settles gently | Things entering the screen: modals, menus, toasts |
| Ease-in (accelerate) | Starts slow, leaves fast | Things leaving the screen and not coming back |
| Ease-in-out | Gentle start and finish | Things moving from one spot to another on screen |
| Linear | Constant, mechanical | Progress bars, spinners, colour or opacity loops |
| Spring | Physical, can overshoot slightly | Gestures, drag and release, playful feedback |
The most common mistake I see is using ease-in for entrances. The element starts slowly, so the interface feels laggy right when the user is waiting for a response. Default to ease-out for anything appearing.
Tip
If you only remember one thing: things coming in should decelerate, things going out should accelerate. That single rule fixes most UI motion.
Cubic bezier curves
In CSS, easing is usually a cubic-bezier() with four numbers that position two control handles. The keywords ease-out, ease-in and ease-in-out are presets, but they're fairly mild. Custom curves give more character:
/* A stronger ease-out for entrances */
.sheet-enter { transition: transform 300ms cubic-bezier(0.2, 0.8, 0.2, 1); }
/* An ease-in for exits */
.sheet-exit { transition: transform 200ms cubic-bezier(0.4, 0, 1, 1); }
Notice the exit is shorter than the entrance. Users care about what's arriving; they don't need to watch something leave.
Duration: the other half of easing
Easing and duration work together. As a general guide used across most design systems:
- Small changes (button states, toggles, colour): very short, around 100 to 200 milliseconds.
- Medium movement (dropdowns, toasts, cards): around 200 to 300 milliseconds.
- Large movement (full-screen sheets, page transitions): around 300 to 500 milliseconds.
Larger distances need a little more time, and larger screens slightly more than phones. But err on the short side. Motion that feels "luxurious" in a review becomes tiresome by the hundredth use.
From my work
As a motion graphic designer at Algoworks I animated UI transitions and micro-interactions in After Effects, where you can obsess over curves in the graph editor. The lesson that carried over to product work: the curve matters more than the duration, but in a real product, shorter almost always wins.
Springs: physics instead of curves
A spring animation doesn't use a fixed curve and duration. It simulates a mass on a spring, so the motion comes out of physical settings:
- Stiffness (tension): how strongly the spring pulls towards its target. Higher means faster and snappier.
- Damping (friction): how quickly the movement calms down. Lower damping means more bounce.
- Mass: how heavy the object feels. Heavier means slower to start and stop.
The relationship between stiffness and damping is often summarised as the damping ratio. Below 1, the spring overshoots and bounces. At exactly 1 (critically damped), it arrives as quickly as possible without overshooting. Above 1, it creeps in slowly.
Why springs suit modern UI
Springs handle interruption beautifully. If a user flicks a sheet and then grabs it mid-motion, a spring picks up from the current position and velocity instead of jumping or restarting. That's why gesture-driven interfaces on iOS and in libraries like Framer Motion lean on springs. Apple's SwiftUI and Framer Motion both offer simpler spring controls too, based on a perceived duration and an amount of bounce, which are easier to reason about than raw stiffness and damping.
Watch out
Bounce is seasoning, not the meal. A lot of overshoot on a banking confirmation or a medical result looks frivolous. Save visible bounce for playful moments and keep serious flows critically damped or close to it.
Starter values you can tweak
These are sensible starting points, not rules. Tune them by eye on a real device.
- Button press feedback: scale down slightly with a quick ease-out, then spring back with little or no bounce.
- Bottom sheet: spring with high stiffness and damping near critical, so it arrives fast and settles without wobble.
- Toast or snackbar: ease-out entrance around 250 milliseconds, ease-in exit a bit shorter.
- Modal: fade plus a small scale from just under full size, ease-out, around 200 to 250 milliseconds.
- Like or favourite icon: a spring with a small, visible bounce for a moment of delight.
- Drag and release: always a spring, using the gesture's velocity.
Making easing consistent across a product
Random curves on every screen make a product feel incoherent. Treat motion like colour and type: define a small set of tokens.
- Define three to four durations (for example: fast, medium, slow).
- Define three to four easing tokens (standard, enter, exit, spring).
- Document which components use which tokens.
- Add them to your design system and to code as named variables.
- Include a reduced-motion version for every token.
- Review new animations against the tokens before they ship.
My guide on setting up a design system in Figma covers tokens in general, and animation principles for web design explains the classic principles behind all of this, like slow in and slow out.
Note
In Figma prototypes, Smart Animate supports both bezier easing and spring presets, so you can test feel before handoff. Write the final values in your handoff notes so developers don't have to guess from a video.
Work with us
Need motion for your product? Our motion design studio creates UI animation, Lottie and Rive assets and product videos.
FAQ
What is the best easing for UI animation?
There isn't one best curve, but ease-out is the safest default for elements entering the screen because it responds instantly and settles gently. Use ease-in for elements leaving, ease-in-out for movement across the screen, and springs for gestures.
What's the difference between easing and spring animation?
Easing uses a fixed duration and a curve that defines how speed changes over that time. A spring simulates physics with stiffness, damping and mass, so its duration comes from the settings, and it handles interruptions and gesture velocity more naturally.
How long should a UI animation be?
Most UI animations work best somewhere between about 100 and 500 milliseconds, depending on how far things move and how big the change is. Small feedback should be very quick; large screen transitions can be a little longer. When in doubt, go shorter.
Key takeaways
- Easing controls how speed changes, and it's the biggest factor in whether motion feels natural.
- Default to ease-out for entrances, ease-in for exits and ease-in-out for movement on screen.
- Springs use stiffness, damping and mass, and suit gestures and interruptible motion.
- Keep bounce for playful moments; serious flows should settle without wobble.
- Turn your durations and curves into motion tokens so the whole product feels consistent.
What to do next
Open your product and find one animation that feels "off". Check its easing first, then its duration. Swapping one ease-in for an ease-out is often all it takes. If you'd like a designer with a motion background to define a motion system for your product, tell me about your project.