A 50% CSS cubic-bezier sample is the curve’s y-value after finding the parameter whose x-value is 0.5, so it is not necessarily the y-value obtained by setting t = 0.5.
When you generate a CSS cubic-bezier easing, CSS does not use the curve parameter t as elapsed time. It maps elapsed time to the x-axis, solves for the matching parameter, and then uses the y-axis to determine animated progress. The 50% sample therefore answers a practical question: “How far has the animated value progressed halfway through the duration?”

Why the 50% row can differ
A CSS cubic Bézier curve starts at the fixed point (0,0) and ends at (1,1). The editable controls (x1, y1) and (x2, y2) shape the path between those endpoints. The x coordinates describe where control points occur in input time, while the y coordinates describe the resulting output progress.
The parametric x coordinate is calculated as x(t) = 3(1−t)²t x1 + 3(1−t)t²x2 + t³. The y coordinate uses the same weights with y1 and y2. Setting t to 0.5 selects the midpoint of the curve’s parameter sweep, but that does not automatically mean the midpoint of elapsed animation time.
For a 50% input-progress sample, the browser first finds a parameter for which x(t) equals 0.5. It then evaluates y at that parameter. Only when x(0.5) also equals 0.5 is the half-time parameter identical to 0.5.
| Concept | What it represents |
|---|---|
| Input progress | The fraction of elapsed duration represented by the curve’s x coordinate. |
| Curve parameter t | The internal position used to sweep from the start of the curve to its end. |
| 50% sample row | The output y-value found after solving for the parameter whose x coordinate is 0.5. |
| Curve value at t = 0.5 | The y-value evaluated directly at the parameter midpoint, which may correspond to a different amount of elapsed time. |
The condition for matching the two values
The half-time output and the direct value at t = 0.5 use the same sampling point when x(0.5) equals 0.5. With the fixed CSS endpoints, that condition occurs when x1 + x2 equals 1. The linear and ease-in-out presets have this relationship; many other curves do not.
Even when the required parameters differ, their y-values can occasionally coincide because of the particular shape of the curve. Matching output numbers therefore do not prove that the generator evaluated t = 0.5. The sample table remains the reliable view of output at a specified input progress.
Read the sample table correctly
The CSS Cubic Bezier Generator displays five input-to-output samples for input progress values of 0, 0.25, 0.5, 0.75, and 1. For every row, the solver first finds the curve parameter that produces the requested x coordinate and then evaluates y. The 0.5 row is therefore the actual output halfway through the input interval.
This calculation uses bounded Newton iterations and switches to bisection when necessary. That distinction prevents the common error of treating the curve parameter as elapsed time even when the x controls make those values different. The MDN cubic-bezier() reference documents the same input-progress behavior for CSS easing functions.
The graph helps reveal the curve’s shape, while the table answers the question the diagram alone cannot: how much progress has occurred at a particular fraction of time? Calculations retain full JavaScript numeric precision, and coordinates are rounded to three decimal places only when the CSS declaration is serialized. A minute difference after pasting a rounded declaration can therefore be a serialization detail, separate from the main difference between input progress and t.
Generate and verify the curve
- Choose the starting point. Select a standard easing preset or enter x1, y1, x2, and y2. The x controls must remain between 0 and 1 because CSS defines values outside that closed range as invalid. The tool accepts finite y controls from −10 through 10, constrains the x inputs, and independently validates the constraints before producing output.
- Inspect the graph and numeric samples. Review the curve’s direction, anticipation, and overshoot. At the 0.50 sample, read the output value associated with 50% elapsed input progress; do not substitute a value read directly at t = 0.5. The surrounding 0.25 and 0.75 rows also show how unevenly the curve allocates output progress.
- Run the motion preview. The preview moves a circle between two horizontal positions with a 900-millisecond transform transition using the exact generated easing. Repeated clicks compare forward and reverse motion. This reveals timing character, but it does not reproduce every production condition.
- Copy the complete declaration. The Copy action requests clipboard permission and writes the full transition-timing-function declaration, including its semicolon. If browser policy denies clipboard access, the declaration remains visible and selectable, and the status does not falsely report success.
- Test the final interface. Apply the declaration to the real animated property, travel distance, and duration. The generator creates only the timing function, so you still need to choose the property, duration, delay, and any iteration settings. It does not create a complete transition shorthand, keyframes, spring physics, linear() stops, or steps() timing.
Compare the standard easing presets
The preset buttons use the standardized control points defined by W3C CSS Easing Functions Level 1. These mappings provide a useful baseline for seeing how x and y controls affect the half-time row.
| CSS keyword | cubic-bezier() equivalent |
|---|---|
| linear | cubic-bezier(0, 0, 1, 1) |
| ease | cubic-bezier(0.25, 0.1, 0.25, 1) |
| ease-in | cubic-bezier(0.42, 0, 1, 1) |
| ease-out | cubic-bezier(0, 0, 0.58, 1) |
| ease-in-out | cubic-bezier(0.42, 0, 0.58, 1) |
Choosing a keyword does not make the visible output the keyword itself. The declaration always exposes all four control numbers, making the timing explicit and easy to compare or modify. In the linear preset, input progress and t are the same, so its 50% sample is also the value at t = 0.5.
Interpret the graph and extreme curves
The square chart plots the parametric curve from the fixed start to the fixed end. It is a shape view, not a direct clock: a geometric midpoint on the curve does not necessarily mark half of the elapsed duration. Use the numeric samples when the question concerns progress at a particular input time.
Standard curves remain inside the chart’s stable zero-to-one frame. A deliberately extreme y control can extend the plotted path outside that square, but the numeric samples and moving preview still use the actual computed easing. They are not silently clipped merely because the chart frame stays fixed.
Valid y coordinates may fall below zero or rise above one. Negative output can create anticipation, while output above one can create overshoot. Large overshoots can make controls appear to reverse, leave their container, or reveal content that was expected to remain clipped, so inspect the motion rather than assuming the chart has clamped it.
Test the timing in its real interface
The preview demonstrates timing, not performance under every workload. A real component can feel different when the property, distance, duration, rendering cost, input device, or surrounding motion changes. Test the declaration in the final layout, including repeated forward and reverse interactions.
A technically valid curve is not automatically accessible, performant, or appropriate. Keep important state changes understandable without motion, respect reduced-motion preferences when animation is not essential, avoid rapid oscillation, and check focus and pointer behavior while an element is transitioning.
For the original question, use the 0.50 sample row as the output at 50% elapsed time. Treat t = 0.5 only as the midpoint of the curve parameter unless the x coordinates make that the same point. All generator calculations run in the browser, and curve, CSS, and interaction data are not uploaded, stored, or sent to an animation service.
For a deeper look, see When to Generate a CSS Toggle Switch Instead of Manual CSS.
For a deeper look, see What Should I Compare Before I Generate a CSS Triangle?.