Bezier curves in computer graphics represent smooth controllable paths used in vector drawing, fonts, UI motion, animation paths, rendering, and shape design. Instead of storing every pixel or every point along a curve, a graphics system stores a small set of control points, then evaluates or approximates the smooth path when it needs to draw, animate, or edit the shape.

Common graphics use	How Bezier curves are used
Vector paths	Icons, illustrations, SVG paths, masks, clipping paths, and strokes
Fonts	Smooth glyph outlines that scale cleanly across resolutions
UI motion	Easing curves and curved movement paths
Animation	Camera rails, object paths, rig controls, and trajectory editing
Rendering	Sampling, flattening, tessellation, stroking, filling, and hit testing
Mesh workflows	Boundary curves, profile curves, guide curves, patches, and tessellated surfaces

Bezier Curves in Computer Graphics

The main reason Bezier curves are useful in graphics is that they separate the editable shape from the rendered result. Artists and designers can move handles to change the visible curve, while engineers get a compact mathematical representation that can be sampled, split, transformed, and exported reliably. The full interactive Bezier curves tutorial explains the control-point geometry and formulas in more depth; this page focuses on where those curves show up in graphics work.

In vector graphics, Bezier curves define the curved parts of paths. SVG, illustration tools, icon systems, and drawing programs often represent a shape as a sequence of straight lines plus quadratic or cubic Bezier segments. Each segment has endpoints on the visible path and one or two off-curve handles that control how the path bends between them. That makes a logo, icon, or outline editable without reducing it to a dense list of sampled points.

Fonts use the same idea at a larger scale. Glyph outlines are usually made from curve segments, so the renderer can scale text smoothly from small UI labels to large display type. The exact curve format depends on the font technology, but the practical goal is the same: preserve smooth contours with a small number of points and render them at whatever resolution the screen or printer needs.

Animation systems use Bezier curves for both paths and timing. A character, camera, particle, or UI element can follow a curved trajectory through space, while a separate easing curve controls how quickly progress changes over time. That distinction matters because a beautiful path can still feel wrong if the motion along it accelerates or slows abruptly. Bezier handles give animators direct control over the departure and arrival directions, which is why cubic handles are common in motion editors.

Bezier curves also appear in shape design, modeling, and mesh workflows. A curve can define a boundary, profile, trim path, stroke centerline, or guide curve that later becomes tessellated geometry. Bezier patches and related spline surfaces extend the same control-point idea from curves to surfaces, where a grid of handles shapes a smooth surface that can eventually be converted into triangles for rendering.

Why Control Points Work Well for Graphics

Control points are useful because they are compact, predictable, and editor-friendly. Moving an endpoint changes where the segment starts or ends. Moving an interior handle changes tangent direction and bend strength without forcing the curve to pass through that handle. That indirect control is valuable in design tools because it lets a user shape a smooth curve with a few stable gestures instead of editing many individual samples.

For engineers, the same representation is convenient because it behaves well under common graphics operations. A Bezier curve can be transformed with the same matrix as its control points, split into smaller curves with subdivision, bounded by its control polygon, and evaluated at any parameter value from $0$ to $1$. Those properties make Bezier segments practical for rendering pipelines, hit testing, export formats, and procedural shape generation.

Quadratic and cubic curves are the two most common cases. Quadratic curves have one interior control point and are simpler to store and evaluate. Cubic curves have two handles, which gives separate control over how the curve leaves the start point and how it arrives at the end point. For the equations behind those cases, see the quadratic Bezier curve formula and cubic Bezier curve formula spokes.

Rendering Bezier Curves

Rendering a Bezier curve usually means approximating it with something the graphics pipeline can draw efficiently. Most rasterizers and GPUs draw lines and triangles more directly than abstract polynomial curves, so a curve is often converted into short line segments, a stroked outline, or tessellated geometry before it reaches the final image.

The simplest rendering choice is uniform sampling: evaluate the curve at many evenly spaced values of $t$ and connect those points with straight segments. This is easy to implement, but equal parameter steps do not always produce equal visual detail. A gentle part of the curve may receive too many segments, while a tight bend may receive too few.

Adaptive tessellation improves that by adding detail where the curve bends more. The renderer estimates whether a curve segment is flat enough to approximate with a line; if not, it subdivides the curve and tests the smaller pieces. This approach spends geometry where it changes the image most, which is important for zoomable vector graphics, fonts, and high-resolution rendering.

Subdivision is closely related to De Casteljau’s algorithm. Splitting a Bezier segment creates two smaller Bezier segments that exactly reproduce the original curve when placed together. That is useful because the renderer can keep subdividing until each piece is simple enough to draw accurately.

Approximation tradeoffs are unavoidable. More segments make the curve look smoother but cost more memory, CPU time, GPU work, and antialiasing complexity. Fewer segments are faster but can create visible corners, inaccurate strokes, or unstable hit testing. Good rendering code chooses a tolerance based on screen-space error, zoom level, stroke width, and the quality requirements of the application.

How These Uses Fit Together

Across the graphics uses listed at the start, the same tradeoff keeps appearing: Bezier curves are easy to edit as control points, but they usually need to be evaluated or approximated before a renderer, physics system, or mesh pipeline can consume them. That is why computer graphics workflows often pair curve design tools with sampling, tessellation, and subdivision code.