The L-System

An L-System has three components: an alphabet of symbols, an axiom (the starting string), and a set of production rules that substitute each symbol simultaneously with every application.

Consider the simplest non-trivial example. The alphabet is {A, B}, the axiom is A, and there are two rules:

Applied once: A becomes AB. Applied twice: AB becomes ABA. Applied three times: ABA becomes ABAAB. The lengths grow as Fibonacci numbers. No drawing involved, just string rewriting. The geometry comes later.

Now consider the first rule that produces visible geometry. The Koch Snowflake:

• Axiom: F--F--F
• Rule:

At depth 0, the string is F--F--F, a triangle. At depth 1, each F expands into F+F--F+F. At depth 2, each of those Fs expands again. The string grows exponentially. No pixel has been placed. The shape exists only as text.

This is the key insight Lindenmayer offered: form is latent in grammar. Before the drawing begins, the structure is complete. The interpreter merely reveals it.

The geometric interpreter for an L-System borrows from Logo's "turtle graphics", a concept developed at MIT in 1967. A turtle sits at a point in space, facing a direction. It understands two instructions: move forward a fixed distance, and rotate by a fixed angle.

To draw an L-System, the turtle reads the final string character by character. F moves it forward and draws. + and - rotate it. The square brackets implement a stack, the mechanical equivalent of a branch: push your current state, walk the branch, pop back to the fork and continue.

// The complete turtle interpreter, compacted
function drawLSystem(ctx, sentence, angle, stepLen) {
  let x = 0, y = 0, dir = -90; // start pointing up
  const stack = [];

  for (const ch of sentence) {
    if (ch === 'F') {
      const rad = (dir * Math.PI) / 180;
      const nx = x + Math.cos(rad) * stepLen;
      const ny = y + Math.sin(rad) * stepLen;
      ctx.beginPath();
      ctx.moveTo(x, y);
      ctx.lineTo(nx, ny);
      ctx.stroke();
      x = nx; y = ny;
    } else if (ch === '+') { dir += angle; }
    else if (ch === '-') { dir -= angle; }
    else if (ch === '[') { stack.push({ x, y, dir }); }
    else if (ch === ']') {
      ({ x, y, dir } = stack.pop()); // return to branch fork
    }
  }
}

This is the entirety of the interpreter. The grammar does everything else. The same loop, given different strings, produces a snowflake, a tree, or a fern, the difference lives entirely in the production rules.

What Lindenmayer formalized in 1968 was not an algorithm for making plants look like plants. It was evidence that the visual complexity of biological form is a consequence of recursive rule application, not design, not intention, not intelligence.

The generative artist who uses L-Systems occupies a strange position: author of the rules, but not the output. The grammar is written in minutes. The plant it produces is not anticipated. The surprise is structural, it belongs to the combinatorics of the substitution, not to any explicit creative decision.

That gap between rule and consequence is where generative art lives.