Before it was a copilot demo or a keynote slide, machine-found form was a paper. In 1962 Lawrence J. Fogel published On the Organization of Intellect; Ingo Rechenberg and John Holland pushed it through the 70s; and in 1986 Richard Dawkins bolted a tiny program to The Blind Watchmaker that bred endless little “Biomorphs” from nothing but selection. Evolutionary computation was real science for two decades before it was ever useful at a drawing board. What changed that — for architects and engineers specifically — was one man deciding non-programmers deserved the same engine.

That man is David Rutten, and the tool is Galapagos. He wrote up the whole thing on his blog I Eat Bugs For Breakfast as a rough transcript of the lecture he gave at AAG10 in Vienna on 21 September 2010. Read it now, fifteen years on, and the striking thing is not how much has dated — it’s how little.

←TODAY: Galapagos has shipped inside Grasshopper since 2010; Rutten’s AAG10 Vienna lecture still reads as the clearest primer on evolutionary solvers written for people who don’t code.
→3012: Parametric optimisation goes ambient — background-continuous, like clash checks did — and the offices that learned the engine, not just the Start button, are the ones still steering it.
Fulcrum: Galapagos was honest about being slow and uncertain, and that honesty is exactly why it aged into infrastructure while louder tools aged into changelogs.

Give the man his credit

Let’s set the record straight, because the industry rarely does. Rutten built Grasshopper in 2007 — the visual programming environment that reorganised how a generation designs — and Galapagos as its native evolutionary solver. Autodesk’s Dynamo arrived in 2012, five years later, into a Revit world that Grasshopper had already taught to think in nodes and wires. None of that is an attack; it’s just chronology, and chronology matters when we’re deciding who to thank. PAZ has covered Rutten’s living legacy before, in our piece on Grasshopper’s new wave of copilots — tools that only work because his canvas was structured enough for a machine to read in the first place.

The rarer thing is his honesty. In that same series he writes that Galapagos “needs a lot of work to make it more robust,” that it’s best on “small or partial problems,” and that “to try and evolve anything complicated will almost certainly result in frustration.” People have quoted that last line as a verdict on the tool. It isn’t. It’s a designer managing expectations — telling users who always want the solver to do more exactly where the wall is, so they stop blaming the engine for physics. An author critical of his own work is a genuinely strange skill in this business. It’s also why you can trust everything else he says.

The engine, in one breath

Rutten’s mental model is a fitness landscape. Two variables — he calls them genes — become an x/y plane, and the quality of each combination becomes elevation. The solver’s whole job is finding the highest peak on a surface it cannot see. It scatters a random Generation Zero, ranks everyone by fitness, kills the worst, breeds the best so the children land somewhere in the intermediate model-space, and repeats. Twelve genes means a 12-dimensional volume no one can draw — but the five-part anatomy stays identical. That’s the beauty of it: the picture scales even when the intuition can’t.

The Tool: Galapagos — David Rutten’s evolutionary solver, shipped free inside Grasshopper for Rhino. No plugin, no licence key, no repo to clone; it has been sitting in your Params → Util panel the whole time. It turns any Grasshopper definition into an optimisation problem: wire number sliders in as Genes, wire one value out as Fitness, and let selection do the rest. Worth an architect’s afternoon because it’s the most durable piece of applied AI in our toolchain — older than most of the plugins fighting over the same job today.

Setup: Galapagos itself needs no install — but to feel the engine before you drive it, run this 15-line standalone. It’s the exact anatomy David describes, in plain Python, so you understand what the real solver is doing under the hood.

import random

def fitness(g):                     # a two-gene landscape with peaks
    x, y = g
    return abs(x * y) + 0.5 * abs((1 - x) * (1 - y))

def breed(a, b):                    # child lands in the intermediate space
    return [random.uniform(min(p, q), max(p, q)) for p, q in zip(a, b)]

pop = [[random.random(), random.random()] for _ in range(50)]   # Gen Zero
for gen in range(50):
    pop.sort(key=fitness, reverse=True)
    elite = pop[:10]                # kill off the worst performers
    pop = elite + [breed(random.choice(elite), random.choice(elite))
                   for _ in range(40)]
    print(f"gen {gen:2d}  best fitness = {fitness(pop[0]):.4f}")

First steps:

1. Save as galapagos_feel.py and run python galapagos_feel.py. Watch best fitness climb across 50 generations — that rising number is the whole idea, made visible.
2. Open Rhino 8 → Grasshopper. Drop a Galapagos component. Wire two Number Sliders into its Genome input and one measured value (a distance, an area, a panel count) into Fitness.
3. Right-click Galapagos → pick the Evolutionary solver → Start Solver. Same climb as your script, now on real geometry you can watch move.
4. Flip the fitness from maximise to minimise — say, minimise structural mass — and re-run. Same engine, opposite hill.

Where it actually earned its keep

This is not theory for us. In PAZ Academy’s own project work — the roof of Budapest’s House of Hungarian Music in Liget Budapest — Galapagos did the unglamorous optimisation nobody photographs: threading the roof’s openings between the park’s existing trees, distributing the thousands of gold origami leaves across the underside of the canopy, and helping resolve the helicoidal stairs, the structural sizing, and the acoustic geometry into something that could actually be built. Every one of those is a fitness landscape. None of them would have been as good, as fast, without David Rutten’s engine underneath. That’s the correction worth making: Galapagos wasn’t a curiosity we outgrew — it was a branch of applied AI for the building industry, arriving quietly a decade before anyone put “AI” on a construction slide.

The honest cost, stated by Rutten and confirmed by anyone who’s run it overnight: evolutionary solvers are slow. A light, shadow, or acoustic fitness can take a minute per iteration — fifty generations of fifty individuals is a two-day wait, and there’s no guarantee the machine recognises The Answer even after it finds it. A solver that admits it might fail is refreshingly employable.

Atelier: For a Swiss studio the trap is treating Galapagos as a magic “solve” button on Wettbewerb night and then cursing it at 02:00 when it hasn’t converged. Reach for it exactly where Rutten says it’s strong — small, well-posed problems: panel counts, opening ratios, a stair rise, a facade that has to hit a daylight target. This Monday, pick one live definition and add a single measurable Fitness output to it — nothing more — then run Galapagos on two genes over lunch. You’ll learn more about your own model in one hour than in a week of manual slider-nudging.

Hack: Breed two genomes by hand and watch the child land between its parents — the one move that turns a random guess into directed search. This is the crossover step, the beating heart of what David calls exploring “fresh ground.”

import random
def breed(a, b):
    return [random.uniform(min(x, y), max(x, y)) for x, y in zip(a, b)]
mom, dad = [0.2, 0.5], [0.8, 0.1]
print(breed(mom, dad))   # child sits in the intermediate model-space

Run it a dozen times. The child is never wilder than its parents — always between them — which is precisely why a population converges instead of scattering. Change min/max to a wider range and you’ve invented mutation. That’s the whole trick, and it’s genuinely worth understanding before you trust any solver, David’s or otherwise.

One last thing, from further down the road. The tools that aged worst in my line of work weren’t the ugly ones — they were the ones you couldn’t reopen after the vendor went dark. Galapagos has survived fifteen years partly because Rutten built it into an ecosystem people could read and extend, and stayed honest about its limits. When you pick a solver this quarter, ask the question that outlives every demo: in twenty-five years, can someone still open your file and see what the machine decided? Go run the script, then go thank the engine — and the man — by using it where it’s genuinely strong.

Learn-it:

• The source series (start here): David Rutten, “Evolutionary Principles applied to Problem Solving” — ieatbugsforbreakfast.com
• Revit-side counterpart: the Dynamo BIM blog — useful context for how node-based design spread after Grasshopper.
• Sober tech coverage: AEC Magazine — technology for repeatable mining of computational-design tooling.
• PAZ / personal note: the House of Hungarian Music — a built example of what an evolutionary solver does to a roof, a stair, and a soffit of gold leaves.