Dragon Curve

Fold a strip of paper in half, always the same way, unfold every crease to a right angle.

Folding paper

Take a strip of paper. Fold it in half, right over left. Fold it in half again, the same way. Do it fourteen times — you cannot, but the arithmetic can — then unfold it so every crease opens to exactly ninety degrees, and look at the edge.

That shape is the dragon curve, and the whole piece is a transcription of the folding as geometry: each fold is a rotated copy of the curve so far.

var (bx, by) = pts[^1];
for (var i = 0; i < pts.Count; i++)
{
    var dx = pts[i].x - bx;
    var dy = pts[i].y - by;
    rotated[i] = (bx + dy, by - dx); // a quarter turn
}

The recurrence says: the curve after n+1 folds is the curve after n folds, then a copy of the curve rotated a quarter turn about its endpoint, read backwards. That reversal is the paper being turned over as it unfolds, and it is the only interesting line in the piece.

Step 01

One fold. Two segments and one corner — literally a folded strip.

Making the shape

The curve starts as one unit segment. Each fold appends a copy of the whole curve so far — rotated a quarter turn about the endpoint, then read backwards from that shared vertex, so the two halves join at exactly one point:

for (var i = rotated.Length - 2; i >= 0; i--)
    pts.Add(rotated[i]);

Every vertex sits on the integer lattice and every segment is one unit long. There is no geometry beyond that: no angles, no trigonometry, no floating point until the finished list of integer points is scaled to fit the frame.

Step 02

Three folds, eight segments. Read the turns: right, right, left, right, right, left, left. The sequence is not periodic and never becomes periodic.

It never crosses itself

Step 03

Seven folds, and the curve’s signature spiral has appeared. Two things about it are worth stating precisely.

It touches but does not cross. At any number of folds the curve is a simple path: segments meet at endpoints, and distinct segments never intersect in their interiors. This is a theorem about the fold sequence, not a lucky choice of scale — the paper it describes could not have overlapped itself.

Each fold doubles it. The curve after n+1 folds is the curve after n folds, plus a copy of itself rotated ninety degrees about its endpoint. That is why the spiral motif, once it appears, appears at every scale simultaneously.

Step 04

Ten folds. A thousand segments in a shape that is starting to look like it has an outline.

The limit

Step 05

Fourteen folds: 16,384 unit segments. Taken to infinity the curve fills a region of the plane with positive area — so the interior has dimension 2 — while the boundary of that region is fractal, with Hausdorff dimension about 1.5236.

Four copies of the dragon, rotated by 0°, 90°, 180° and 270° about a common point, tile the plane exactly: no overlap, no gap. The shape that comes out of folding paper is also a tile.

Refit at every stage

The stages above are not one drawing zoomed. Each fold changes the curve’s bounding box in shape as well as in size — it is not self-similar in its aspect ratio — so the code measures the extent and refits after every fold:

var scale = MathF.Min(scaleX, scaleY);

A fixed scale would have pushed the later stages off the canvas, and an early stage would have been a mark in the corner. The consequence is that the apparent segment length shrinks as the progression runs, which is the honest picture: fourteen folds of the same strip of paper, not fourteen strips.

The pose

Every drawing is posed thirty degrees before the fit. The dragon’s bounding box alternates tall and wide with every fold, so axis-aligned it can only ever fill one axis of a square frame. Turned thirty degrees, the two axes square up — the posed curve fills both axes of the frame at every fold count — and the long diagonal of the dragon runs corner to corner.

The pose is a rigid motion of the finished vertex list: the folding itself stays on the integer lattice, every crease still ninety degrees. Only the camera turned.

Six renderings

Rendering	Iterations	Segments	Treatment
Folio	14	16,384	flat indigo ink on warm paper
Crease	14	16,384	two inks alternate by the fold that made each segment
Strata	14	16,384	every earlier fold drawn beneath, translucent
Tile	13	8,192 × 4	four copies about one shared corner
Ember	14	16,384	a crimson-to-amber gradient swept along the curve
Drift	16	65,536	a cold blue gradient at a thinner stroke

Each rendering changes how the folded strip is drawn, not just which color it wears.

Crease colors each segment by the fold that created it. Fold n appends the segments 2^n through 2^(n+1)−1, so alternating the inks by fold alternates them between a curve and its own rotated copy — at every scale at once.

Strata draws the whole progression in a single frame: each earlier fold level beneath the final curve, translucent, so the finished line sits on top of the ghosts of everything it was folded from.

Tile draws four copies of the curve, each rotated a quarter turn further about the curve’s endpoint. That corner is shared by all four copies — the common point from the tiling argument above — so the piece renders as the tile it is.

Ember and Drift sweep curated gradients along the construction order, so hue reads the same way drawing order does: start to finish, fold after fold. Drift runs two more folds, which quadruples the segment count. At a fixed frame that puts four segments where one used to be, so the curve stops reading as a line and starts reading as a filled region with a ragged edge — the limit behaviour arriving early because the resolution ran out before the mathematics did.

The museum

One plate is not another way of drawing the curve but a way of presenting the Folio: the finished drawing, hung. The curve is rendered exactly as the lead plate draws it — at print scale, so the ink stays proportionally the same — and then a separate framing layer mounts it on a gallery wall: a deep sage room with a faint vignette, a walnut frame, a warm mat with a bevelled cut, a soft wall shadow, and a label plate bearing the first fold as its mark.

The framing layer knows nothing about dragons; it frames any rendering the piece produces, and the curve itself is never drawn differently for having been framed. That separation is the point: generation builds the strip of folded paper, presentation hangs it in a room.

Determinism

Nothing is seeded and nothing is random. The curve is a deterministic recurrence over rotated copies, the arithmetic stays on the integer lattice, and only the final fit to the frame uses floating point. The variants apply the same rules further — copies rotated about the shared corner, earlier folds layered beneath — so none of them introduces a choice that was not already in the recurrence.

Progression 05

Variant 07