Bézier curves

The formula

A Bézier curve of degree n is a weighted blend of n+1 control points P0, P1, ..., Pn, with the weights coming from the Bernstein basis polynomials:

B(t) = Σ (i=0..n)  C(n,i) · t^i · (1-t)^(n-i) · P_i,     0 ≤ t ≤ 1

Reading: at parameter t, the point on the curve is a weighted average of all the control points. C(n,i) is the binomial coefficient "n choose i". The parameter t sweeps from 0 (start) to 1 (end).

The individual weights are the Bernstein basis polynomials:

b_{i,n}(t) = C(n,i) · t^i · (1-t)^(n-i)

Reading: each control point gets a bump-shaped influence that peaks somewhere in the middle and fades to zero at the ends.

The three degrees you actually see in tools:

Linear     B(t) = (1-t)·P0 + t·P1
Quadratic  B(t) = (1-t)²·P0 + 2(1-t)t·P1 + t²·P2
Cubic      B(t) = (1-t)³·P0 + 3(1-t)²t·P1 + 3(1-t)t²·P2 + t³·P3

Reading: the linear one is just a straight interpolation. The cubic — four points, third-degree — is the workhorse behind every CAD sketch, PostScript/PDF font glyph, and SVG path.

Velocity (the first derivative) is itself a Bézier curve one degree lower, built from the differences between adjacent points:

B'(t) = n · Σ (i=0..n-1)  b_{i,n-1}(t) · (P_{i+1} - P_i)

Reading: the direction the curve is heading is a blend of the "legs" of the control polygon. At the very start, B'(0) = n·(P1 - P0); at the end, B'(1) = n·(Pn - P_{n-1}). That is why the curve leaves P0 aimed straight at P1.

The weights always sum to one — the partition-of-unity property:

Σ (i=0..n)  b_{i,n}(t) = 1   for every t in [0,1]

Reading: because the weights are non-negative and add to 1, every point on the curve is a true weighted average of the control points. That single fact is where the convex-hull guarantee comes from.

Where you meet it

The CAD sketch tool. Every spline you drag in SolidWorks, CATIA, Fusion, or Onshape is a Bézier (or its cousin the B-spline / NURBS). The little square handles hanging off the curve are P1 and P2. When a design-review board argues about whether a fillet blends "cleanly," they are arguing about whether two adjacent Béziers share a tangent — G1 continuity — or share curvature too — G2.
G-code smoothing on the shop floor. A CAM post-processor turns a designed contour into thousands of tiny line segments, then a controller's look-ahead smooths the corners. Many controllers fit Bézier or NURBS segments so the tool doesn't decelerate at every faceted joint. Chatter and gouging at a corner often trace back to control points that pulled the path outside the intended stock.
Fonts and vector art on the bench display. TrueType glyph outlines are built from quadratic Béziers; PostScript, PDF, and SVG use cubics. When a rendered label on a test-stand HMI looks slightly wrong at small sizes, the outline math is Bézier evaluation plus hinting.
Motion profiles and easing. The acceleration ramp on a servo axis, or the "ease-in-ease-out" of an animated gauge, is frequently a 1-D cubic Bézier mapping time to position. Tune the two middle points and you reshape the jerk profile without rewriting the controller.

How it works

Think of a Bézier as a rubber band pinned at two ends (P0 and Pn) with magnets (P1 ... P_{n-1}) pulling it into shape. A few behaviors follow directly, and they are the reason engineers trust the primitive:

Endpoints are exact. B(0) = P0 and B(1) = Pn. The curve interpolates its first and last control point. The interior points are influences, not points on the curve — a common beginner surprise.
It stays in the convex hull. Because the weights are non-negative and sum to one, the whole curve lives inside the smallest convex polygon around the control points. If your control points fit inside the stock, the toolpath fits inside the stock. This gives you a cheap, conservative bounding box for collision and clearance checks.
Endpoint tangents are the polygon legs. The curve leaves P0 pointing at P1 and arrives at Pn coming from P_{n-1}. To butt two Béziers together smoothly, put the shared point and its two neighbors on one straight line.
Affine-invariant. Rotate, scale, or shear the control points and you get the same transform applied to the curve. You never re-evaluate the curve to move it — you move four points. That is why CAD kernels are fast.
Variation-diminishing. A straight line can't cross a Bézier more times than it crosses the control polygon. The curve is smoother than its handles, never wigglier. No spurious oscillation.

The gotchas:

Don't evaluate the polynomial the naive way. Expanding t^i (1-t)^(n-i) and summing loses precision fast at high degree. Use de Casteljau's algorithm — repeated linear interpolation ("lerp") between adjacent points, level by level, until one point remains. It is numerically stable and it hands you the subdivision point for free, which is how tools split a curve at a click. (Verified: for control points (0,0),(1,3),(3,3),(4,0) at t=0.5, de Casteljau and the direct formula both give exactly (2.0, 2.25).)
High degree is a trap. A single degree-10 Bézier is stiff and globally coupled — nudge one control point and the whole curve moves, and the math gets ill-conditioned. Real tools chain many cubic segments (a "spline") instead of raising the degree. Cubic is the sweet spot: enough freedom for an S-curve and an inflection, cheap to evaluate.
A plain Bézier cannot draw a true circle. No polynomial arc is an exact circular arc. A quarter circle is only approximated by a cubic (the classic control-point offset of about 0.5523 times the radius, good to a few parts in ten thousand). For exact conics you need a rational Bézier, where weights w_i are attached to the points and the curve becomes a ratio of two Bernstein sums — that generalization is the "NURBS" every serious CAD kernel is built on.
Continuity is not the same as smoothness you can see. Two segments can meet with matching tangents (G1) and still show a visible crease under reflected light because the curvature jumps (G2 fails). Class-A automotive surfacing lives and dies on G2.

History

The polynomials came first, decades before anyone drew a car with them. In 1912 the Russian mathematician Sergei Bernstein introduced the basis functions that now carry his name — not for design at all, but as a clean constructive proof of the Weierstrass approximation theorem, showing you can approximate any continuous function on an interval as closely as you like with these bump-shaped polynomials ^[1]^[2].

The application to shape came from two French car companies working in parallel and in secret. At Citroën, the mathematician Paul de Casteljau developed his recursive evaluation algorithm around 1959 and was the first to use these curves for computer-aided body design — but Citroën treated it as proprietary and his work went largely unpublished until the 1980s ^[1]^[3]. Meanwhile at Renault, Pierre Bézier (1910–1999), a mechanical and electrical engineer who had joined the company in 1933 and spent decades in tooling and production engineering, arrived at the same family of curves independently. Bézier published and patented, so the curves took his name ^[3]^[4].

Bézier's system, UNISURF, went live at Renault in 1968, running on IBM graphics terminals so designers could shape body panels on a screen instead of carving physical templates ^[4]. The irony is durable: the engineer got the credit and the mathematician got the algorithm, and today every tool uses both — Bézier's curves, evaluated by de Casteljau's method, on a basis Bernstein published before either man was doing this work.

Related tools

/tools/moment-of-inertia-shapes
/tools/section-modulus-rect
/tools/beam-deflection

Sources

Written by HE in our own words from the cited sources — engineering judgment included, your stamp still required. All entries →