CSS requires x1 and x2 to stay in the closed range from 0 to 1 because they represent input-time positions, so a cubic-bezier() value with either x coordinate outside that range is invalid. This boundary applies to the timeline used by the easing function, not to the final position of the animated element.
That distinction explains why y1 and y2 may fall below zero or rise above one while x1 and x2 may not. The x coordinates determine when the curve is sampled; the y coordinates determine how far the animated value has progressed at that time. A y value beyond the ordinary output range can create anticipation or overshoot without extending the transition beyond its duration.
When you generate a CSS cubic-bezier curve, an x-coordinate restriction is therefore a standards-validity rule, not merely a visual guide imposed by the graph. The CSS Cubic Bezier Generator makes that distinction explicit by constraining x inputs to their valid CSS range while retaining finite y values from -10 through 10.

How CSS reads the four control values
A CSS cubic Bézier easing function has the form cubic-bezier(x1, y1, x2, y2). Its start point is fixed at (0, 0), and its end point is fixed at (1, 1). The four supplied numbers describe two intermediate control points: P1 uses x1 and y1, while P2 uses x2 and y2.
The x coordinates belong to the horizontal, input-progress axis. They indicate positions along the transition’s normalized elapsed time, which runs from zero at the start to one at the end. The y coordinates belong to the vertical, output-progress axis. They indicate the corresponding animated-value progress and may describe movement outside the usual zero-to-one output range.
When CSS evaluates the easing, it receives an input progress based on elapsed time. At the midpoint of a transition, for example, the input progress is 0.5. The engine finds the appropriate point on the curve and uses its y value as the output progress. It does not simply treat the curve’s internal parameter as elapsed time.
The CSS Easing Functions Level 1 specification defines both the cubic-bezier() syntax and the rule that each x control coordinate must be between zero and one.
Why the input range cannot extend beyond 0 and 1
A transition’s input timeline starts at zero and ends at one. The intermediate x control points must remain inside that same normalized domain so the easing can map advancing input time to a clear output value. CSS does not interpret an x value of 1.2 as an instruction to sample the curve 20 percent beyond the transition’s end; the resulting function is simply invalid.
The restriction also preserves the forward ordering of the time axis. With valid x coordinates, the curve can represent a single easing relationship between elapsed progress and output progress. Extending a control point beyond the domain would introduce a timing shape that CSS does not permit for this syntax, even if the shape might look reasonable when drawn on an unrestricted graph.
Its interface constrains x inputs to the valid CSS range, and the underlying calculation independently validates those constraints before producing a declaration. This prevents a visually plausible curve from being copied into CSS as an invalid timing function.
The y axis follows a different rule. A negative y coordinate can create anticipation, such as movement slightly backward before the main transition begins. A y coordinate above one can create overshoot beyond the destination. These are output-progress effects, so they do not extend the input timeline or make the cubic-bezier() declaration invalid.
| Coordinate | What it controls | CSS rule or generator limit | Effect outside the ordinary 0-to-1 range |
|---|---|---|---|
| x1 and x2 | Positions along normalized input time | CSS requires the closed range 0 through 1 | The complete cubic-bezier() value is invalid |
| y1 and y2 | Output progress of the animated value | No CSS 0-to-1 restriction; this generator accepts finite values from -10 through 10 | Values below zero can anticipate, and values above one can overshoot |
How the standard easing keywords map to control points
The five continuous easing presets offered by the generator use the standardized control points defined for linear, ease, ease-in, ease-out, and ease-in-out. Their x coordinates all satisfy the same input-time rule.
| CSS keyword | Equivalent cubic-bezier() control points |
|---|---|
| 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 cause the visible output to remain a hidden keyword. The generator exposes the equivalent four-number cubic-bezier() declaration, making the timing explicit for comparison, documentation, and later adjustment. MDN’s cubic-bezier() reference provides additional browser-oriented examples of the same behavior.
Generate and inspect a valid curve
- Choose a preset or enter the four coordinates. Open the CSS Cubic Bezier Generator, select one of the five standard easing presets, or enter x1, y1, x2, and y2 directly. Keep each x input within zero and one. You can use a negative or greater-than-one y value within the supported finite range of -10 through 10 when you specifically want anticipation or overshoot.
- Review the graph, samples, and motion together. Inspect the parametric curve, the five numeric samples, and the Run preview. The samples correspond to input progress values of zero, 0.25, 0.5, 0.75, and one. Check the moving element for acceleration, slowdown, reversal, or overshoot rather than judging the shape from the graph alone.
- Copy the complete declaration and test it in context. Copy the visible transition-timing-function declaration, including its semicolon, and apply it to the real animated property, travel distance, and duration. If clipboard access is denied by browser policy, the declaration remains visible and selectable for manual copying.
The result updates immediately as a graph, an exact transition-timing-function declaration, five input-to-output samples, and a moving preview. Calculations retain full JavaScript numeric precision; numbers are rounded to three decimal places only when the declaration is serialized. All calculation takes place in the browser, and no curve, CSS, or interaction data is uploaded or sent to an animation service.
Read the graph and samples correctly
The numeric table answers a question the control-point diagram alone cannot: how far has the animated value progressed when a particular fraction of the duration has elapsed? For each sample input, the solver first finds the curve parameter that produces the requested x coordinate and then evaluates y at that parameter.
Consequently, the row at 50 percent input is not automatically the curve’s y value when its internal parameter is also 0.5. The two values coincide only for particular control-point combinations. Treating the curve parameter as elapsed time can produce a convincing but incorrect explanation of what the animation will do.
The chart also uses a stable zero-to-one square so ordinary timing curves remain easy to compare. A deliberately extreme y value can make the parametric curve extend outside that visible square. That does not mean the output has been clipped: the sample table and moving preview still use the actual computed easing. A deeper inspection of the samples before shipping helps confirm both the timing and the amount of overshoot.
Apply the timing function in the real interface
The generated output is a timing function, not a complete transition. It does not create the animated property, duration, delay, iteration count, keyframes, spring physics, linear() stop list, or steps() timing. Use the copied transition-timing-function declaration alongside the other transition settings required by the interface.
The Run preview demonstrates timing with a circle moving between two horizontal positions over a 900-millisecond transform transition. It is useful for comparing forward and reverse motion, but it does not reproduce every production condition. The same easing can feel different when the animated property, travel distance, duration, rendering cost, input device, or surrounding motion changes.
Test the declaration in the final interface rather than treating the preview as proof of performance or usability. For nonessential animation, respect reduced-motion preferences and ensure that important state changes remain understandable without motion. Overshooting values also need visual checks for clipping, focus behavior, pointer interaction, and content that was expected to remain hidden.
Valid syntax does not guarantee desirable motion
A curve can satisfy the CSS validity rules and still create confusing behavior. A large overshoot may make a control appear to reverse, move outside its container, or reveal content that the surrounding layout expected to conceal. Rapid oscillation can also make a transition harder to follow.
The x-coordinate requirement guarantees that the timing function belongs to the valid CSS input domain; it does not guarantee that the motion is accessible, performant, or appropriate. Keep state changes legible, avoid excessive overshoot, and judge the curve on the real property and duration. This keeps the original cubic-bezier() syntax intact while making the practical result easier to verify.
Related reading: Why Is a CSS Toggle Switch Built From a Checkbox?.