A CSS cubic Bezier maker turns four control coordinates into a standards-compatible cubic-bezier() timing function that you can inspect, preview, and copy as CSS.

Use the CSS Cubic Bezier Generator when you need to design or validate an easing curve rather than guess at its behavior. Every cubic Bézier easing starts at progress point zero, zero and ends at one, one. The four editable numbers describe the two intermediate control points, and the result appears as an exact transition-timing-function declaration. All calculation happens in your browser, so curve, CSS, and interaction data are not uploaded, stored, or sent to an animation service.

css cubic bezier maker
CSS Cubic Bezier Maker: Check Timing Before Copying

What Each Control Coordinate Controls

The first control point uses x1 and y1, while the second uses x2 and y2. The x coordinates describe positions along input time, and the y coordinates describe output progress. This distinction matters because the parameter that draws the curve is not always the same thing as elapsed transition time.

CSS requires x1 and x2 to remain between zero and one. The generator constrains those inputs to that valid range and independently validates them before producing output. The y coordinates are more flexible: the tool accepts finite values from -10 through 10, including values below zero or above one. Those values can create anticipation or overshoot, although extreme motion needs careful testing.

The five keyword buttons load standardized control points from CSS Easing Functions Level 1. The W3C CSS Easing Functions Level 1 specification defines the syntax, validity rule, and keyword mappings used by the generator.

CSS keyword Control points Timing character
linear 0, 0, 1, 1 No acceleration or deceleration
ease 0.25, 0.1, 0.25, 1 Gentle acceleration and deceleration
ease-in 0.42, 0, 1, 1 Slow start followed by acceleration
ease-out 0, 0, 0.58, 1 Quick start followed by deceleration
ease-in-out 0.42, 0, 0.58, 1 Acceleration and deceleration around the midpoint

Choosing a keyword does not leave a hidden keyword in the output. The visible declaration always contains all four numeric control points, making it possible to record, compare, and modify the curve. Calculations retain full JavaScript numeric precision, while serialized numbers are rounded to three decimal places.

Create and Review a Curve

  1. Choose one of the five standard easing presets, or enter x1, y1, x2, and y2 for the two intermediate control points.
  2. Review the graph and the five input-to-output samples at input progress values of zero, 0.25, 0.5, 0.75, and one.
  3. Select Run preview and watch the circle travel between its two horizontal positions. Repeat the preview to compare the forward and reverse motion.
  4. Copy the complete transition-timing-function declaration, including its semicolon, and test it with the actual animated property, distance, and duration.

Understand What the Samples Measure

The graph shows the parametric Bézier curve from the fixed start to the fixed end. The sample table answers a question the control-point diagram alone cannot: how far has the animated value progressed when a particular fraction of the transition time has passed?

For each requested input progress, the solver first finds the curve parameter that produces that x coordinate and then evaluates y. It uses bounded Newton iterations and finishes with bisection when necessary. That is why a sample labeled as 50 percent input progress does not necessarily equal the curve's y value at a parameter of 0.5. The MDN cubic-bezier() reference provides additional browser-oriented syntax and behavior information.

The chart keeps a stable zero-to-one frame so ordinary curves remain easy to compare. A deliberately extreme y coordinate can extend beyond that visible square, but the chart does not imply that the result was clamped. Inspect both the numeric samples and the moving preview when anticipation or overshoot matters.

Run preview uses a 900-millisecond transform transition and the exact generated easing string. It demonstrates timing rather than production performance under every workload. A real component can feel different when its distance, duration, property, rendering cost, input device, or surrounding motion changes.

Apply the Timing Function in CSS

The generated output follows this declaration form:

transition-timing-function: cubic-bezier(x1, y1, x2, y2);

Copy the complete version containing your selected values rather than substituting the placeholders manually. Apply that declaration to the element you are animating, then set the animated property and duration separately. For example, a transition of transform needs a transition-property declaration for transform, a chosen transition-duration, and the generated transition-timing-function declaration.

Part of the animation What the generator provides What remains your responsibility
Timing function A complete transition-timing-function declaration Apply it to the intended element
Animated property Not selected by the generator Choose the property, such as transform or opacity
Duration and delay Not generated Set values appropriate for the interface
Iteration count and keyframes Not generated Configure them separately when needed
Other timing formats Outside the tool's scope Create linear() stop lists, steps() functions, or spring physics separately
Full transition shorthand Not generated Combine the declaration with the other transition properties in CSS

Test the Result in the Final Interface

A valid curve is not automatically accessible, performant, or appropriate for every interaction. The 900-millisecond preview provides a consistent comparison, but the final judgment belongs in the real component. Test the declaration with the intended travel distance, duration, animated property, surrounding motion, and input method.

Large overshoots can make a moving element appear to reverse, leave its container, or reveal content that was expected to remain clipped. Inspect those cases directly instead of assuming that the stable chart frame limits the actual output. Keep important state changes understandable without motion, avoid rapid oscillation, and check focus and pointer behavior while an element is transitioning.

Also respect reduced-motion preferences where animation is not essential. The generator does not decide whether an interaction should animate, how long it should last, or whether motion is necessary. Those choices depend on the purpose and accessibility requirements of the final interface.

Copying requests clipboard permission and writes the complete declaration when access is allowed. If browser policy denies clipboard access, the declaration remains visible and selectable, and the tool does not report a successful copy. This fallback makes it possible to verify and transfer the exact output manually.

For a reliable final check, compare the graph with the progress samples, run the preview in both directions, copy the visible declaration, and then inspect the real transition. Recording the four control coordinates alongside the tested property and duration makes the easing choice easier to compare or reproduce later.

For a deeper look, see When to Generate a CSS Triangle Instead of Coding Manually.

For a deeper look, see HTML and CSS Color Names Chart: Exact sRGB Mappings.