A CSS cubic bezier generator converts four control coordinates into a standards-compatible CSS cubic-bezier() timing function, then lets you inspect its progress and motion before copying the exact declaration.
Every cubic Bézier timing curve begins at the fixed point zero, zero and ends at one, one. The four editable values describe two intermediate control points: x1 and x2 position them along the input-time axis, while y1 and y2 control the resulting output progress. This model makes it possible to create different acceleration, deceleration, anticipation, and overshoot patterns without changing the animation's duration.

A four-number timing model
The CSS Cubic Bezier Generator accepts either one of the five standard CSS easing presets or four numeric coordinates. Its result updates immediately as a graph, a complete transition-timing-function declaration, five input-to-output samples, and a moving preview. It is designed for the specific task of creating and checking a cubic-bezier() timing function.
The generator does not produce an entire transition rule. You still need to select the animated property, distance, duration, delay, and any other relevant behavior in your own CSS. That separation keeps the generated timing declaration easy to compare and audit while leaving implementation decisions in the context where the animation runs.
All calculation happens in the browser. Curve, CSS, and interaction data are not uploaded, stored, or sent to an animation service, so you can use the tool to experiment with non-sensitive values without adding a remote processing step.
Choose valid control coordinates
The W3C CSS Easing Functions Level 1 defines the syntax, x-coordinate validity rule, and keyword mappings used by the generator. Because x1 and x2 represent input-time positions, each must stay within the inclusive range of zero to one. The interface constrains those inputs, and the underlying calculation independently validates the constraints before producing output.
| Value | Meaning | Accepted range | Effect on timing |
|---|---|---|---|
| x1 and x2 | Positions along the input-time axis | Zero to one, inclusive | Determine how elapsed progress maps to the curve parameter |
| y1 and y2 | Intermediate output-progress positions | Finite values from -10 through 10 | Can shape acceleration, deceleration, anticipation, or overshoot |
| Start and end | Fixed curve endpoints | Zero, zero and one, one | Ensure the timing function begins and ends at the expected progress values |
The y coordinates are not restricted to the zero-to-one range. A negative value can create anticipation by moving below the starting progress, while a value above one can create overshoot. Large excursions can make motion reverse, leave a container, or reveal content that was expected to remain clipped. The generator preserves these values rather than clamping the computed animation to a zero-to-one range.
The preset buttons provide standardized starting points based on the CSS keyword mappings:
| CSS keyword preset | Standard control coordinates |
|---|---|
| linear | 0, 0, 1, 1 |
| ease | 0.25, 0.1, 0.25, 1 |
| ease-in | 0.42, 0, 1, 1 |
| ease-out | 0, 0, 0.58, 1 |
| ease-in-out | 0.42, 0, 0.58, 1 |
Choosing a keyword does not make the keyword itself the visible result. The declaration always exposes all four control numbers, giving you an explicit value that can be recorded, compared, and modified without hidden defaults. The calculation retains full JavaScript numeric precision, while numbers are rounded to three decimal places only when the declaration is serialized.
Audit the graph, samples, and preview
Read the parametric graph correctly
The graph plots the parametric curve from the fixed start to the fixed end, while the square chart keeps a stable zero-to-one frame for comparing ordinary timing curves. An intentionally extreme y value can therefore extend outside the visible square. That does not mean the samples or preview have clipped the value: the sample table and moving preview continue to use the actual computed easing.
Use the graph to understand the shape of the curve, not to infer every intermediate output value. It is especially useful for spotting abrupt changes, pronounced anticipation, or overshoot that may need adjustment.
Check progress at real input positions
The five samples correspond to input progress values of zero, 0.25, 0.5, 0.75, and one. They answer a question the control-point diagram alone cannot: how far has the animated value progressed when a particular fraction of elapsed time has passed?
CSS timing uses elapsed input progress on the x axis, which does not always equal the curve parameter. To calculate each sample, the solver finds the parameter whose x coordinate matches the requested input and then evaluates the corresponding y coordinate. It uses bounded Newton iterations and switches to bisection when necessary. As a result, the displayed value at 50 percent input may differ from evaluating the curve directly at a parameter of 0.5.
This distinction helps when comparing curves numerically. The MDN cubic-bezier() reference provides additional browser-oriented syntax and behavior examples, while the generator's sample table gives you a direct way to inspect the selected curve at meaningful input positions.
Watch the motion before shipping it
The Run preview toggles a circle between two horizontal positions with a 900-millisecond transform transition using the exact generated easing string. Running it repeatedly lets you compare forward and reverse motion, making sudden reversals and strong overshoot easier to notice.
The preview demonstrates timing rather than production performance under every workload. The same declaration can feel different when the animated distance, duration, property, rendering cost, input device, or surrounding motion changes. Treat the preview as an early check, not a substitute for testing in the final interface.
Generate a CSS cubic bezier
- Open the CSS Cubic Bezier Generator and choose a standard preset, or enter x1, y1, x2, and y2 yourself. Keep both x values between zero and one, and use finite y values from -10 through 10.
- Review the graph for the overall curve shape. Look for unexpected loops, strong anticipation, or overshoot that extends beyond the ordinary zero-to-one progress range.
- Inspect the five numeric samples at input progress values of 0, 0.25, 0.5, 0.75, and 1. Read each value as output progress at that point in elapsed time, not as a direct curve-parameter reading.
- Run the motion preview several times. Compare the forward and reverse passes, and adjust the y coordinates if the timing feels abrupt, confusing, or unsuitable for the intended interface.
- Copy the complete CSS declaration, including its semicolon. If clipboard access is denied, select the still-visible declaration manually rather than assuming the copy succeeded.
- Paste the timing function into the real transition and test it with the intended property, travel distance, and duration. Check reduced-motion behavior and make sure important state changes remain understandable without animation.
Place the timing function in real CSS
The generated output is a standalone transition-timing-function declaration. For example, the standardized ease controls can be placed in a rule as follows: transition-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1);
The declaration controls how progress changes over the transition, but it does not decide what moves or for how long. Set the animated property, duration, and delay separately in your stylesheet. If the element uses a transition shorthand elsewhere, verify that the final computed rule still applies the generated timing function.
Test the declaration with the real content and interaction. A short movement across a small distance may make an aggressive curve feel abrupt, while a larger movement may expose overshoot or reversal. Also test the direction in which users can trigger the transition. A curve that feels balanced forward can produce a different impression when the element returns to its starting position.
Do not judge the curve from the 900-millisecond preview alone. The preview has a fixed motion distance and duration, so its result can differ from a menu, modal, carousel, drag interaction, or page transition. Adjust the surrounding CSS and retest the complete experience rather than changing the easing values to compensate for an unrelated layout problem.
Production checks and tool boundaries
A standards-compatible curve is valid CSS, but validity alone does not make a motion accessible, performant, or appropriate. Avoid rapid oscillation and make sure focus, pointer behavior, and state changes remain understandable while an element is transitioning. If animation is not essential, respect reduced-motion preferences in the final implementation.
Overshoot deserves particular attention. A value outside the normal progress range can move an element beyond its final position, expose content, or appear to reverse unexpectedly. Inspect the moving preview and numeric samples instead of assuming that a curve shown inside the chart has been clamped.
Copy CSS asks for clipboard permission and writes the complete declaration. If browser policy blocks access, the declaration remains visible and selectable, and the tool's status does not claim that the copy succeeded.
The generator intentionally focuses on one cubic-bezier() timing function. It does not generate keyframes, spring physics, linear() stop lists, steps() functions, duration, delay, iteration count, or a complete transition shorthand. Keeping those responsibilities separate makes the output predictable and lets you review the timing function before adding it to production CSS.
If you're weighing options, When Should I Generate a CSS Triangle? covers this in detail.
If you're weighing options, CSS Cubic Bezier Maker: Check Timing Before Copying covers this in detail.