Bézier Curve Point Calculator

Formula

A Bézier curve is defined by control points $P_0,P_1,\dots ,P_n$ and a parameter $t$ in the interval $[0,1]$. In Bernstein polynomial form, the curve is written as follows.

where the Bernstein basis polynomials are

In 2D, those same weights act separately on the horizontal and vertical coordinates. That means the curve point can be viewed as one weighted blend for x and another weighted blend for y, both driven by the same parameter.

This form is elegant and compact, but many implementations evaluate Bézier curves with De Casteljau’s algorithm instead. That is the method used by this calculator. It arrives at exactly the same point while relying only on repeated linear interpolation, which tends to be more intuitive geometrically and more stable numerically.

What Is a Bézier Curve?

A Bézier curve is a parametric curve defined by a sequence of control points $P_0,P_1,\dots ,P_n$. The curve starts at $P_0$ and ends at $P_n$. Intermediate control points shape the path but do not usually lie on the curve itself. That is why dragging a handle in a design tool changes the curve even when the handle is not literally on the visible path.

The parameter $t$ runs from 0 to 1. As $t$ increases, the point on the curve moves smoothly from the first control point to the last. A linear Bézier simply interpolates between two points. A quadratic curve uses three control points. A cubic curve uses four. Higher-degree curves continue the same idea with more control points and more flexibility.

Bézier curves are everywhere: in vector graphics editors, font outlines, SVG path data, animation systems, UI transitions, and game tools. One reason they are so common is that the control polygon gives a direct, manipulable way to shape smooth motion or geometry. Another reason is that the curves stay inside the convex hull of their control points, which makes their behavior predictable during design and debugging.

That predictability is part of why so many design and engineering tools still rely on Bézier segments decades after they became standard. They strike a useful balance between expressiveness and control. A small set of points can describe a very smooth path, yet the influence of each point is understandable enough that artists, interface designers, and programmers can all reason about the same curve without switching to completely different mental models.

How De Casteljau’s Algorithm Works

De Casteljau’s algorithm evaluates the curve by blending neighboring points over and over. You begin with the original control points. For a chosen value of $t$, you interpolate between each adjacent pair. That produces a shorter list of new points. Then you repeat the same step on the shorter list, and repeat again until only one point remains.

That first step finds the point between each neighboring pair at fraction $t$ of the way from left to right. The process then continues with the same structure at every level:

After enough rounds, there is only one point left: $P_0^{\left(n\right)}$. That final point is exactly $B\left(t\right)$, the Bézier curve value at parameter $t$. The method is especially appealing because each step is just ordinary linear interpolation in 2D, so it matches the way many people already think about geometry.

In practical terms, this means the calculator is not guessing or sampling coarsely. It is computing the exact curve point implied by your control polygon and your chosen parameter. For most graphics-scale coordinates, this method is accurate, stable, and easy to verify. It is also a good teaching tool because every stage can be visualized as a new, smaller control polygon nested inside the previous one.

Geometric Intuition and Use Cases

The control points form a control polygon. You can imagine the curve as being guided by this polygon rather than passing through every point. When De Casteljau’s algorithm runs, each interpolation stage creates a new polygon nested inside the previous one. Those nested polygons collapse toward the final curve point for the chosen $t$. This is why the algorithm feels so visual: it literally constructs the answer through geometry.

That intuition helps explain several practical facts. If all control points are collinear, the Bézier curve lies on that same line. If you move a middle control point, the curve bends toward it but does not necessarily cross it. If you sample many values of t, you trace the full path that a moving object or drawing command would follow. The point returned by the calculator is therefore useful not only as a standalone number, but also as a building block for plotting, collision checks, animation timing, or debugging exported vector data.

• Checking the coordinate of an object moving along a motion path at a known time fraction.
• Inspecting points on SVG or canvas curves when a rendered path looks wrong.
• Verifying a cubic timing curve or easing path in UI work.
• Sampling a font or illustration outline without writing custom code first.

Because this calculator returns one precise point, it works well beside drawing software or development tools. You can take a control polygon from a design file, paste the coordinates here, test several values of t, and compare the numerical results with what you see on screen. That process is often faster than reverse-engineering a renderer or guessing whether the problem comes from control points, parameterization, or coordinate conversion.

Example

Consider a quadratic Bézier curve with three control points. This is one of the easiest cases to compute by hand, which makes it a good check that the calculator is behaving exactly as expected.

• $P_0=(0,0)$
• $P_1=(1,2)$
• $P_2=(2,0)$

Now choose $t=0.5$. First interpolate between the original pairs of points.

Then interpolate once more between those two new points.

So the point halfway along the quadratic curve is $(1,1)$. If you paste those three control points into the calculator and set t = 0.5, you should get the same result. That makes this a handy test case whenever you want to confirm your understanding or compare the calculator to your own code.

The same pattern scales naturally. With a cubic Bézier there is one more interpolation stage. With higher-degree curves there are more stages still, but the rule never changes: keep blending neighboring points until only one point remains. That consistency is a major reason De Casteljau’s method is so attractive in both teaching and production code.

Interpreting the Results

The calculator returns a coordinate pair $(x,y)$. The meaning of that pair depends on your own coordinate system. In a graphics program it might be pixels. In a mathematical plot it might be units on a Cartesian plane. In normalized motion design work it might live in a range like $[0,1]$. The calculator does not impose units or scaling. It simply preserves the coordinate system of the control points you entered.

That also means you should interpret the result in context. If t changes over time, the point can drive an animated object. If you evaluate several values of t, you can sketch the shape of the whole curve. If the point is not where you expected, the issue may be the order of the control points, the coordinate system orientation, or a misunderstanding of how intermediate control points influence the path.

It is also worth remembering that equal steps in t do not necessarily correspond to equal travel distance along the drawn curve. A point sampled at 0.25 and another at 0.50 are evenly spaced in parameter space, but the visible arc length between them might be short or long depending on the shape of the segment. That distinction is important in animation and simulation work, where you may care about both position on the curve and the apparent speed of motion along it.

Comparison: Different Bézier Degrees

Bézier curves of different degrees all use the same core idea, but they differ in flexibility and how many control points they need. The calculator handles them uniformly: as long as you provide at least two valid points, it keeps interpolating until one answer remains.

For everyday web and graphics work, cubic Bézier curves are especially common because they offer a strong balance between expressive shape control and manageable complexity. Quadratic curves remain useful in some font and vector contexts, while higher-order curves appear more often in specialized modeling or in intermediate representations before a tool breaks them into simpler segments. This calculator treats all of them with the same evaluation rule, so the learning you do here transfers cleanly across degrees.

Limitations and Assumptions

This calculator is deliberately focused. It answers one precise question very well: given a list of 2D control points and a parameter t, where is the point on the Bézier curve? That focus makes it simple and reliable, but it also means there are some boundaries worth keeping in mind.

• 2D points only: Each control point must be a 2D coordinate in the form x,y. The page does not evaluate 3D curves or rational Bézier curves.
• Input format matters: Use one coordinate pair per line. Commas are expected between x and y, and extra descriptive text on a line will cause a parse error.
• Parameter range: The calculator accepts t only in the usual interval from 0 to 1. In theory, Bézier formulas can be extrapolated outside that range, but this tool is intentionally focused on the standard segment.
• Single-point output: The tool returns one point per calculation. It does not draw the whole curve or sample many values automatically.
• Floating-point precision: Extremely large or extremely tiny coordinates may reveal ordinary floating-point rounding limits, although De Casteljau’s method is generally stable for common graphics work.
• Point order is significant: Reordering control points usually changes the curve, often dramatically. The same set of coordinates in a different order is not the same Bézier segment.
• Segment continuity is not enforced: If you chain several curves together in your own project, matching endpoints or tangents between segments is up to you.

Within those assumptions, the calculator gives a dependable answer that is easy to compare with production graphics code, animation tools, and manual examples. If your goal is to know the exact coordinate on a Bézier curve at a particular parameter value, this page is built for that task. If you later need tangent vectors, arc-length approximation, subdivision, or multi-segment continuity, those are natural next steps, but they are separate questions from the one solved here.