Based in Kyiv

©2026

Why We Stopped Using Ease-In-Out and Started Writing Our Own Bezier Curves

A glowing wire bent into a smooth S curve in the dark

Most interface motion looks the same because most developers use the same four default curves. We spent three weeks building a small library of custom easing functions for a studio in Chiado, and it changed how we think about every transition since.

Ana from Mono Studio sent us a reference video with a note: “can the menu feel like this.” The clip was a cupboard door in a Japanese furniture ad, closing with a tiny overshoot before settling. Nothing in our design system did that. Every transition we shipped used ease-in-out, the default nobody questions, and it suddenly looked flat next to a sixty-year-old piece of joinery.

The problem with default easing

ease-in-out is a single curve, roughly cubic-bezier(0.42, 0, 0.58, 1), baked into every browser since 2009. It is symmetrical, polite and slightly dull. Thousands of interfaces use it for everything from a dropdown opening to a toast notification sliding in, which means thousands of interfaces move the same way regardless of what they’re actually depicting.

What the curve is hiding

A bezier easing function is really a velocity graph disguised as a shape. The two control points describe acceleration and deceleration over time, nothing more. Once we started reading curves that way instead of as abstract shapes in a dev tools panel, it became obvious why so many animations feel mechanical: they accelerate and decelerate at exactly the same rate, every single time.

A clear acrylic French curve ruler on dark paper
Draftsmen bent their curves by hand long before CSS had cubic-bezier().

Building a curve from reference footage

For the cupboard door, we opened the reference clip in After Effects, stepped through it frame by frame, and plotted the x-position of the door edge against time. Twenty-two frames at 24fps. The motion overshot its resting point by about six pixels around frame 16, then eased back over the remaining six frames.

That overshoot does the work. A standard ease curve never goes past its destination; it approaches asymptotically. To get a real overshoot in CSS you need values outside the 0 to 1 range on the y-axis, something like cubic-bezier(0.34, 1.56, 0.64, 1), which pushes the curve above 100% before it settles back.

Measuring instead of guessing

We used to eyeball these numbers. Now we keep a short checklist before writing any custom curve for a client project:

  • Find or shoot reference footage, even a phone video of a real object is enough
  • Identify the point of maximum velocity and roughly where it falls in the timeline
  • Note whether the motion overshoots, and by how much relative to total distance
  • Sketch the curve in a tool like cubic-bezier.com before touching code
  • Test at the actual pixel distance the production element will travel, not a placeholder

Translating keyframes into cubic-bezier

CSS cubic-bezier only takes four numbers: x1, y1, x2, y2. The x values must stay between 0 and 1 because they represent time, which can’t run backwards. The y values can go outside that range, which is exactly how you get bounce and overshoot. Once we understood that constraint, writing curves stopped being guesswork and started being closer to solving an equation with known boundaries.

For Mono’s menu, we landed on cubic-bezier(0.17, 0.89, 0.32, 1.28) for the opening animation and a gentler cubic-bezier(0.55, 0, 0.1, 1) for closing, since the reference footage showed the door opening with more energy than it closed with. Two different curves for two directions of the same motion, which is something a single default easing can never express.

Where it falls apart in the browser

Bezier timing functions only control a single property’s rate of change over a fixed duration. They say nothing about physics, mass or interruption. If a user clicks the menu again mid-animation, a pure CSS transition either snaps or queues awkwardly, because bezier curves don’t know how to resume from an arbitrary velocity. That’s the point where we switch to a spring-based library in JavaScript, usually Framer Motion’s spring type or a small custom RAF loop, because springs are defined by stiffness and damping rather than a fixed timeline, so they can be interrupted and still look continuous.

A small library of named curves

By the end of the project we had six curves instead of one default, each named for what it’s supposed to feel like rather than for its numbers:

Naming them mattered more than we expected. “Overshoot-soft” and “snap-hard” get used correctly by other developers on the team without them needing to understand bezier math. It’s the same reasoning behind naming design tokens instead of hardcoding hex values; the abstraction only works if the name carries meaning.

“A curve is a decision, not a default. If you can’t explain why an animation uses the timing it uses, you probably copied it from somewhere else.” Tiago Reis, motion designer, during our review call

What changed on the next project

Three months later, working on a booking flow for a hotel group in Cascais, we reused the same process instead of reusing the same curves. The reference this time was a hotel key card tapping against a reader, a short, firm motion with almost no overshoot at all. The resulting curve, cubic-bezier(0.25, 0.1, 0.25, 1), is barely different from a standard ease numerically, but it was chosen rather than assumed, and that’s the actual shift in how we work now.

None of this makes animations objectively better by some universal standard. A library with eighteen named easing curves and no clear logic behind them is worse than one honest default used consistently. The goal isn’t more curves. It’s being able to say, specifically, why this transition moves the way it does.

Leave a Reply

Your email address will not be published. Required fields are marked *

Recent posts