# Quadratic vs Cubic Bezier vs Arc: Picking the Right Path Curve

> The difference between quadraticTo, cubicTo, and arcTo on Path, and when each one is the right primitive for the curve you're actually trying to draw.

**Date:** 2026-10-09T00:00:00.000Z
**Tags:** Canvas, Path, Math

## What a Bezier curve actually is

A **Bezier curve** is a smooth curve between a start point and an end
point. It's shaped by one or more
control points (A point that pulls a Bezier curve toward it without the curve ever touching it, except at the very start and end.),
placed off the curve itself, not on it.

* **Quadratic Bezier**: 3 points total, start, one control point, end.
  This is what `quadraticTo` draws.
* **Cubic Bezier**: 4 points total, start, two control points, end.
  This is what `cubicTo` draws.

The extra control point in a cubic curve is the whole difference: one
more independent pull on the shape. The next sections show exactly what
that pull does, and why it's easy to assume a control point sits on the
curve when it never does.

## The intuition

`Path.quadraticTo(x1, y1, x2, y2)` and `cubicTo(x1, y1, x2, y2, x3, y3)`
both take coordinates that look like points on the curve. They aren't.

* A control point is never a point the curve passes through, it's a point
  the curve bends *toward*. The curve touches only its start and end.
* Moving a control point closer to the straight line between start and
  end barely changes the curve; moving it far away bends the curve hard,
  but the curve still never reaches it.
* `arcTo` looks like a third member of the same family, same `Path`
  method shape, same "give it some coordinates" call signature. It isn't:
  there's no control point pulling anything, it's circular geometry
  (radius, start angle, sweep angle), a completely different kind of math
  wearing the same API shape.

- [Screen Coordinate Systems Aren't Cartesian](/screen-coordinate-system) — Why arcTo's startAngleDegrees/sweepAngleDegrees sweep clockwise on screen instead of counterclockwise, the same y-down convention behind every cos/sin call in the arc section below.

- [Polar to Cartesian: What cos and sin Are Actually Computing](/polar-to-cartesian-point) — The cos/sin circular geometry arcTo is built on, as opposed to the control-point interpolation quadraticTo and cubicTo use instead.

## Quadratic: one control point bends a line

```kotlin
val path = Path()
path.moveTo(20f, 80f)

// ❌ control point sitting almost on the straight line → barely a curve
path.quadraticTo(
    x1 = 140f,
    y1 = 70f,
    x2 = 260f,
    y2 = 80f,
)

// ✅ control point pulled far from the line → strong bulge, same endpoints
path.quadraticTo(
    x1 = 140f,
    y1 = 20f,
    x2 = 260f,
    y2 = 80f,
)
```

Both calls start at `(20, 80)` and end at `(260, 80)`, same two endpoints
every time. The only thing that changed is where the control point
sits, and that's also the only thing that changed the shape.

`quadraticTo(x1, y1, x2, y2)` draws a quadratic Bezier by sweeping a
progress value `t` (The curve's progress parameter, not a pixel coordinate. t=0 is the start point, t=1 is the end point, and every value between sweeps out the curve.)
from 0 to 1: at every step along that sweep, it linearly interpolates
from the start point toward the control point, and separately from the
control point toward the end point, then interpolates *between those
two results* again. That's one nested pass of
lerp (Short for linear interpolation: blending two values by a fraction t between them, where t=0 gives the first value and t=1 gives the second.)-the-lerp.
The control point never
appears on the final curve, it only steers which direction the blend
leans.

Drag the control point below and watch both ends stay pinned while the
curve reshapes around wherever it goes:

*\[Interactive demo: BezierControlPointDemo — view this post in a browser for the live version.]*

## Chaining quadratic curves: a single wave

A one-up-one-down wave, a single sine-like cycle, isn't a `Path` primitive,
but it doesn't need to be. It's just two `quadraticTo` calls back to back,
one pulling up to a peak, one pulling down to a trough, sharing the
midpoint between them as a hinge where the curve returns to the midline.

The trap is reusing the same assumption the earlier section warned about:
treating the control point's height as the peak's height.

```kotlin
// ❌ control point set to the desired peak height (amplitude 40 above
// the midline) → the curve only reaches half that, amplitude 20
val path = Path()
path.moveTo(20f, 130f) // midline
path.quadraticTo(
    x1 = 80f,
    y1 = 90f,
    x2 = 140f,
    y2 = 130f,
)
```

```kotlin
// ✅ control points pulled to 2x the desired amplitude → the curve
// actually peaks at amplitude 40, on both halves of the wave
val path = Path()
path.moveTo(20f, 130f) // midline
path.quadraticTo(
    x1 = 80f,
    y1 = 50f,
    x2 = 140f,
    y2 = 130f,
)
path.quadraticTo(
    x1 = 200f,
    y1 = 210f, // 2x the amplitude, below the midline this time
    x2 = 260f,
    y2 = 130f,
)
```

The reason is the same nested lerp from the intuition section, just
evaluated at a specific point: at `t = 0.5`, a quadratic Bezier sits at
`0.25 × start + 0.5 × control + 0.25 × end`. With the start and end both
pinned to the midline, that collapses to `(midline + control) / 2`, the
plain midpoint between the midline and the control point. Solve that for
"control lands at twice the amplitude" and the 2x isn't a magic constant,
it falls straight out of the weights in the interpolation.

Drag either control point below and watch the actual peak (the small red
dot) move only half as far as the handle:

*\[Interactive demo: SineWaveDemo — view this post in a browser for the live version.]*

The same hinge-and-repeat idea extends past one cycle: chain more
`quadraticTo` pairs, alternating which side of the midline each control
point pulls toward, and the same two-call pattern tiles into a longer
wave.

## Cubic: a second control point adds an S-curve

```kotlin
val path = Path()
path.moveTo(20f, 80f)

// ❌ both control points on the same side → a single bulge, same shape
// a quadratic curve could already make with one point
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 20f,
    x3 = 260f,
    y3 = 80f,
)

// ✅ control points on opposite sides → an S-curve a quadratic curve
// can never produce, no matter where its one point goes
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 140f,
    x3 = 260f,
    y3 = 80f,
)
```

`cubicTo(x1, y1, x2, y2, x3, y3)` runs the same nested-interpolation
idea one level deeper: three lerps instead of one, blending through two
control points instead of one. That extra control point is the entire
difference between quadratic and cubic, it's not a second knob for the
same bulge, it's a second, independent direction the curve can lean in,
which is exactly what makes the S-curve possible and makes it
impossible for any single-control-point quadratic curve to match.

Drag either control point below and watch both ends stay pinned while the
curve reshapes around wherever the dragged point goes:

*\[Interactive demo: BezierControlPointDemo — view this post in a browser for the live version.]*

> **The fundamental**
>
> Both are **Bezier curves**: a point at parameter `t` is computed by
> recursively linearly interpolating between control points, a technique
> called **De Casteljau's algorithm**. A quadratic curve (3 points: start,
> one control point, end) runs one level of nested lerp; a cubic curve (4
> points) runs two. The degree is always "point count minus one," and the
> control points are weights in that interpolation, never stops along the
> curve itself.

## Elsewhere: same fundamental, different framework

* **SVG path data**: the `Q` command (`Q x1,y1 x,y`) is a quadratic
  Bezier, `C` (`C x1,y1 x2,y2 x,y`) is cubic, identical math, just
  written as a string instead of method calls.
* **CSS `cubic-bezier()`**: every `transition-timing-function` and
  `animation-timing-function` curve (including the named `ease`,
  `ease-in-out`, etc.) is a cubic Bezier over time instead of space, two
  control points, same nested-interpolation mechanism, just animating a
  progress value instead of a pixel position.
* **PostScript / PDF**: the `curveto` operator takes exactly the same six
  numbers as `cubicTo`, two control points and an endpoint. SVG's `C`
  command was modeled directly on it.
* **The pen tool, in basically every vector editor**: Illustrator,
  Photoshop's vector paths, Figma, Penpot, Sketch, Affinity Designer,
  Inkscape. Dragging a curve handle out of an anchor point *is* placing
  a cubic control point by hand, the direction and length of the handle
  is the direction and distance from the anchor to the invisible
  control point steering the curve. It's not an Adobe-specific
  convention, every one of these tools is dragging the exact same two
  control points this post has been dragging the whole time, just with
  a mouse instead of a slider. Holding Alt/Option while dragging a
  handle breaks it loose from its twin, moving one control point
  independently, the same asymmetric move that produces this post's
  S-curve.

## From design to code: don't eyeball it

The pen tool section above already said it: dragging a handle in Figma or
Penpot *is* placing a cubic control point by hand. That means a path a
designer draws isn't a reference to approximate, it's the actual control
point data, already computed. Treat it that way.

**Don't eyeball the curve.** Looking at a design mock and guessing where
the control points "probably" are produces a curve that looks close in
isolation and drifts the moment the designer nudges a handle, because your
guess and their exact numbers were never the same curve to begin with.
Pull the real coordinates instead of estimating them:

* **Figma**: select the path, right-click, *Copy/Paste as* → *Copy as
  SVG*. The `d` attribute is your control points, verbatim.
* **Penpot**: select the shape, *Export* → SVG. Same `d` attribute.

Either way you get standard SVG path commands, and they map onto
`cubicTo`/`quadraticTo` argument-for-argument, in the same order:

```
SVG:    C x1,y1 x2,y2 x,y
Kotlin: cubicTo(x1, y1, x2, y2, x, y)

SVG:    Q x1,y1 x,y
Kotlin: quadraticTo(x1, y1, x, y)
```

Here's the exact S-curve from the cubic section above, as an export would
actually hand it to you:

```
M20,80 C80,20 200,140 260,80
```

```kotlin
val path = Path()
path.moveTo(20f, 80f)
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 140f,
    x3 = 260f,
    y3 = 80f,
)
```

That's not a conversion, it's a transcription. Same six numbers, same
order, no judgment call in between.

**One trap to check for first.** SVG allows a lowercase `c`/`q`, the same
command but relative to the current point instead of absolute. Compose's
`cubicTo`/`quadraticTo` only accept absolute coordinates, so a relative
command needs the current point added to every pair before it's usable
(`x1Abs = currentX + x1Rel`, and so on). Transcribe a relative command
as-is and the control point lands near the wrong anchor entirely, with no
error to tell you why the curve looks off.

## Edge cases

**`arcTo` isn't a Bezier curve at all.** `arcTo(rect, startAngleDegrees,
sweepAngleDegrees, forceMoveTo)` is defined by a bounding box and a
start/sweep angle, true circular geometry, computed with `cos`/`sin`,
not interpolation between points. There's no control point to misplace,
which is also why it can do something no Bezier curve can: trace a
*perfect* circular arc. Reach for `arcTo` specifically when you need an
exact circle or ring (a progress indicator, a dial), and reach for
`quadraticTo`/`cubicTo` when you want an organic bend that doesn't need
to be geometrically perfect.

```kotlin
val path = Path()
path.arcTo(
    rect = Rect(center = Offset(140f, 130f), radius = 80f),
    startAngleDegrees = 0f,
    sweepAngleDegrees = 270f,
    forceMoveTo = false,
)
```

Drag the sliders below. However far you push radius, start, or sweep,
the result is always a perfect arc, because there's no control point
pulling anything out of shape:

*\[Interactive demo: ArcToDemo — view this post in a browser for the live version.]*

**You can't draw a perfect circle with a single cubic Bezier, ever.** No
placement of two control points makes a cubic curve trace a true
circular arc. The two kinds of math only coincide exactly at the four
cardinal points.

Every vector tool that looks like it's drawing circles out of Bezier
curves (SVG, Illustrator, Figma, Skia itself) is faking it the same way:

* Stitch four cubic curves together, one per quadrant.
* Place each control point `radius × 0.5523` from its nearest anchor,
  the constant that best matches a cubic's tangent and curvature to a
  circle's.
* Render enough of those at a small enough radius and the error
  disappears visually. It's still there, just below the pixel.

**Crossed cubic control points produce a self-intersecting loop**, not
just an S-curve pushed further. Drag the two control points in the demo
above to opposite corners and far enough past each other and the curve
crosses itself, a real path, not a rendering bug, because nothing in the
interpolation math prevents the two nested lerps from looping back over
each other.

## When to reach for a Bezier curve

Any time a curve needs to bend in an organic, hand-tuned direction
instead of a precise circular one, `quadraticTo`/`cubicTo` is the tool.
A few places that pattern shows up in practice:

**Custom drawing and shapes**

* Smoothing a rough polyline (touch samples, stock-chart data, a
  signature pad) into a visually smooth stroke, without sampling
  hundreds of points. This is the trick behind building a wavy circular
  loading ring: sample points around the circle, then connect them with
  `quadraticTo` instead of `lineTo`.
* Blob buttons, wave underlines, or any loading indicator whose edge
  needs to wobble instead of staying circular.
* Custom corner shapes a plain `RoundedCornerShape` can't express,
  since it only knows circular corners.

**Animation and motion**

* Easing curves: the same cubic math from the Elsewhere section above,
  just mapping progress to progress instead of pixel to pixel.
* Morphing one icon or shape into another by interpolating each shape's
  control points over time.

**Illustration and vector art**

* Anything hand-drawn in a pen tool (Illustrator, Figma) and exported
  as `Path` data arrives as a string of `cubicTo` calls already.
  Recognizing the pattern is recognizing what the tool already
  generated for you.

## Mental model to actually use

**Control points are weights in an interpolation, not waypoints on a
curve.** Pick a Bezier (`quadraticTo`/`cubicTo`) when you want a bend
that only has to look organically smooth; pick `arcTo` when the geometry
has to actually be a circle.


---

Canonical page: https://recomposed.blog/quadratic-cubic-bezier-and-arc