Open the sketch. A small machine in the corner is already at work — the Gosper glider gun, firing a fresh glider off the edge every thirty generations. Nobody told it to; it obeys the rule, everywhere, forever. That gun is why we lead the ACTION desk with Conway’s Game of Life and not with something prettier: it is the only emergence demo where nothing is hidden.

Here is the whole specification. A dead cell with exactly three live neighbours is born; a live cell with two or three survives; everything else goes empty next tick. That is B3/S23 — birth-then-survival, do not transpose it. Nine birth flags, nine survival flags, eighteen bits, and those eighteen bits are the entire design space of a system that is Turing-complete. Read it twice; it will not get longer.

Martin Gardner put this in front of the world in Scientific American‘s “Mathematical Games” in October 1970; Conway had worked it out on pen and paper around 1968. The lineage runs back to 1940s Los Alamos, where Stanisław Ulam suggested the discrete lattice that let John von Neumann build a self-replicating machine — 29 states, some 200,000 cells. Conway’s move was compression: two states, eight neighbours, a rule you hold in your head. In November 1970 Bill Gosper’s MIT team won Conway’s $50 bet by building that gun and proving a pattern could grow without bound. The popularisation is half the achievement; credit all of them.

←TODAY: the sketch runs in your browser now, and the whole thing downloads as one self-contained page that works offline. →3012: the settlements that stayed cheap to heat were the ones drawn as occupancy, not as image. Fulcrum: a local rule applied everywhere with no plan still produces a global form somebody has to pay to warm.

Now touch it. Press read as plan: live cells become rooms and only their exposed edges are drawn, so the magenta that remains is envelope. Watch party-wall share collapse as the gun sprays loose cells across the field. Switch the seed to still lifes and watch the same number climb: same rule, opposite form. Change the rule to Seeds (B2/S) — a world with no survival flag at all — and nothing ever holds still. Draw your own cells with the pointer, press space to pause, s to step one generation.

PAZ ported the sketch’s engine to Python on 2 September 2026 and reproduced the canon: the glider translating one cell diagonally every four generations, the block sitting still, the blinker at period 2, the R-pentomino going constant after generation 1103 at 116 live cells — matching the published figure. (The six escaping gliders are the literature’s count, not ours.) Our own number is the pair that matters: a solid 10×10 block scores a 90% party-wall share; the same 100 cells scattered so none touch score 0%. Same population, same rule, opposite envelope.

Atelier: that readout is the same ratio SIA 380/1 makes you account for — thermal envelope against the floor area it wraps — computed in two lines on a diagram you can draw in ten seconds. The habit worth breaking is arguing massing on the image and defending it on area only after the energy consultant reports back. Monday move: sketch three massing options as filled cells, read the party-wall share for each, and bring that number to the massing review instead of to the post-rationalisation. It will not replace the calculation; it will change which option arrives at it.

Be honest about where this breaks. Life’s rule is uniform, memoryless and synchronous — a city is none of those: land is priced, owners differ, decisions are sticky. The real instrument is Keith Clarke’s SLEUTH, a self-modifying cellular automaton built at UC Santa Barbara to forecast urban growth; it needs slope, exclusion and transport layers before it predicts anything. Our grid is its crude ancestor: a thinking toy, not a planning tool.

Hack: read the party-wall share straight off the live cells. Count each room’s east and south neighbour; every hit is one shared edge that carries no steady-state heat loss. Shared over total edges is your compactness number.

def party_wall_share(cells):        # cells: set of (x, y) live rooms
    shared = sum((x+1, y) in cells for x, y in cells) \
           + sum((x, y+1) in cells for x, y in cells)
    edges  = 2 * len(cells)         # each room offers one E and one S edge
    return shared / edges           # 1.0 = party-walled, 0.0 = scattered

Then press view / remix the code — the panel prints the functions actually running, pulled live, not a copy. Break the rule, watch what the cheat costs, and if you want the on-ramp to code that behaves this way, Daniel Shiffman’s The Nature of Code is the canonical one. Go abuse the grid until it teaches you something.