One-Rule L-System

One rule — F becomes FF+FF+FFF — rewritten five times and walked at sixty degrees.

One production

sb.Append(ch == 'F' ? "FF+FF+FFF" : ch.ToString());

That is the entire grammar. A single symbol, F, and a single production replacing it with seven forwards and two turns. Anything that is not F — which is to say, the + signs the rule itself introduced — passes through unchanged.

The word grows by a factor of nine per rewrite: 9, 81, 729, 6,561, 59,049 symbols across the five generations.

Step 01

One rewrite: FF+FF+FFF. Read it as geometry — advance, advance, rotate, advance, advance, rotate, advance, advance, advance — and that shape is the whole piece in miniature.

Why sixty degrees closes it

The turn is 60°, so three turns make half a turn and six make a full one. The production contains two turns per nine symbols, and the interplay between that ratio and the forward counts is what decides whether the figure closes, spirals, or wanders.

Here it very nearly closes: the shape returns close to its starting orientation, and each rewrite adds a level of ornament to a figure that keeps roughly the same silhouette. Change the angle to 90° and the same word produces a completely different — and much less closed — object. Both alternatives are presets: Blueprint walks at 90°, Weave at 120°.

Step 02

Two rewrites, 81 symbols.

Step 03

Three, 729. The characteristic hooks are visible at two scales at once now, which is what makes it self-similar: every F in the previous stage has become a copy of the first stage.

Step 04

Four, 6,561 symbols.

Step 05

Five, 59,049 symbols, folded in order into a polyline by repeating two transformations — an advance and a sixty-degree rotation — and remembering nothing else.

The step is fixed, the figure is not

Unlike some of the L-system pieces here, this one does not refit to the frame. The step length is a preset constant:

public float Distance { get; init; } = 9f;

So each rewrite makes the figure literally nine times longer in symbol count while keeping every step the same size — and the drawing grows rather than gaining detail. It fits the frame at the preset’s iteration count because the constants were chosen to make it fit, not because anything measures it.

That is why the progression above reads as a figure being elaborated in place: at 60° the path keeps folding back on itself, so nine times the symbols does not mean nine times the extent.

Six walks

The grammar above is the whole of the piece, and every rendering here is that one word walked once. What the presets change is the walk — the angle, the depth, the frame, and the ink:

Preset	Walk	Step	Ink
Amber	60°, five rewrites, centered	9	`#E6A84B` on `#0D1524`
Blueprint	90°, five rewrites, the whole figure	6	`#1F4E8C` on `#EEEAE0`
Echo	60°, five rewrites, drawn at two scales	5	`#8FA8CE` on `#10182A`
Sliver	60°, five rewrites, starting left	9	`#6E2735` on `#E9E3D5`
Weave	120°, five rewrites, three axes only	12	`#2F4A3E` on `#F4EEDC`
Wire	60°, four rewrites, thick and spare	12	`#EAEAE4` on `#14161B`

Angle is the deepest lever. At 90° every turn is a quarter turn and every segment lies on a grid line, so Blueprint reads as a plan of rooms and corridors; at 120° every turn is a third of a circle and every segment lies on one of three axes, so Weave reads as latticework. Neither figure closes, and both come from the same word as Amber.

Depth is the second. Wire stops one rewrite early, so the same figure shows only four levels of ornament — at a larger step and a heavier stroke, it is the piece’s outline rather than its filigree.

Then framing and layering. Sliver starts the same walk at the left edge of the canvas instead of the center, so the frame crops the figure instead of fitting it. Echo draws the figure twice around the same origin — a faint pass at 1.618 times the scale beneath the main stroke — so two levels of the same self-similarity share one canvas.

The palettes are curated rather than assigned: three papers and three darks, each carrying one deliberate color, with the walk chosen to suit it.

Gallery framing

Museum presents the amber walk the way a gallery would — on a wall, behind a mat, inside a frame. The walk in the opening is the lead figure itself, with every one of Amber’s parameters: the opening is a smaller window into the same drawing, not a different one. Around it sits an ivory mat (#F0EBE0) carrying a thin bevel line in the amber ink, a dark frame, and the piece’s ink navy (#0D1524) as the gallery wall behind both, with a soft drop shadow lifting the frame off it.

The framing layer is the MuseumFrame from SkiaSharp.Extensions, and it is separate from the generative layer in the code as well as in the picture: the walk produces the artwork, the frame presents it, and neither knows anything about the other. Any preset could be framed the same way; Museum applies it to the lead figure only.

Determinism

Nothing is seeded and nothing is random. Rewriting is string substitution and the polyline is a running sum of rotated steps. The walks differ only in compile-time constants — angle, depth, step, origin, echo, palette — and Museum wraps the lead walk in the upstream MuseumFrame’s wall, mat, frame and shadow constants. Every preset renders to the same pixels on every build.

Progression 05

Variant 07