Evolutionary Logic

Primary technical source: van den Dorpel's interview with Julian F. Miller, inventor of Cartesian Genetic Programming (CGP). See also Spike #70 interview with Tina Rivers Ryan.

The algorithm: Cartesian Genetic Programming

The specific algorithm powering Mutant Garden (and informing Death Imitates Language) is Cartesian Genetic Programming, developed by Julian F. Miller and Peter Thomson at Napier University in the late 1990s for industrial circuit board optimisation. Van den Dorpel encountered it in 2019 and implemented his own version in TypeScript.

CGP represents a computational programme as a two-dimensional grid of nodes — small functions (add, subtract, multiply, etc.). A chromosome is a string of genes encoding which nodes connect to which. Key properties:

Safe mutation: the graph structure guarantees that no mutation can produce an infinite loop. This solved van den Dorpel's central technical problem: most mutations of raw computer code cause crashes (the halting problem). The graph encodes only what can safely terminate.
Non-coding genes: the decoding process ignores some genes entirely — they contribute nothing to the current computation. But they persist, mutate, and after several generations may activate and produce new structures. This is latent potential: a genetic archive of dormant possibilities that evolution can draw on.
Multiple outputs: a single chromosome can solve more than one problem simultaneously — each output is a different solution emerging from the same generative structure.

CGP belongs to a lineage: Friedberg (1958, random program mutation), Koza (1992, tree-based GP), and CGP (1997) as a graph-based alternative, developed alongside Push and Grammatical Evolution.

The halting problem as the condition of creative mutation

Van den Dorpel's original ambition was to mutate computer code rather than just data — to let the programme itself evolve, not just its outputs. The obstacle: "most mutations of computer code cause infinite loops, stack overflows, rainbow spinners, blue screens of death, and core dumps." This is the halting problem — provably undecidable.

CGP's graph topology is the engineered solution. By constraining mutation to a grid of safe computational operations, the system can mutate freely without risk of non-termination. The creative freedom (unlimited mutation) is enabled by a structural limit (the graph).

This echoes the stop-condition problem in recursion: unchecked self-reference destroys itself. The solution in both cases is an internal architectural limit — not an external prohibition but a structural feature that keeps the process alive by preventing it from consuming itself.

The over-specialization paradox (3004)

Note 3004 (Strategies, 2010/2011) frames the evolutionary logic at its deepest structural level with two lines:

"The more highly adapted an organism becomes, the less adaptable it is to any new change"
"Over time, beautiful things tend to thrive, and ugly things tend to get discarded"

The first is the over-specialization paradox: high fitness in the current environment is also high fragility to environmental change. The specialist is perfectly tuned to its niche — and therefore most vulnerable when the niche disappears. This is the evolutionary argument for Stained Unravel's equilibrium/reconfiguration structure: the cellular automaton is deliberately destabilized when it reaches equilibrium, before it becomes too specialized to adapt. Senescence is not a failure but a structural safeguard against over-adaptation (→ Senescenence).

The second states the fitness function in its simplest aesthetic form: beauty = survival. What persists over time is what is beautiful; what is discarded is what is ugly. The "tend to" and "over time" qualifications are important — this is a stochastic claim, not a guarantee — but the directionality is asserted. This is the theoretical basis for the fitness function in Death Imitates Language: the artist's aesthetic judgment is not arbitrary but aligned with a real selection pressure that, given enough time and iterations, produces something.

Fitness functions: the mechanics of selection

Without a fitness function, evolutionary systems produce variation without direction — "always different, always the same." The fitness function gives selection a criterion: it defines what "better" means for a given generation. Van den Dorpel has formalised different theories of "better" across different works:

Work	Fitness function
Death Imitates Language (2016)	Manual — the artist decides which specimens live and die
Hybrid Vigor (2017)	Crowdsourced — the public decides
Nested Exchange (2017)	The "hipster algorithm" — maximise difference from all others in the population
Mutant Garden (2019–)	Complexity of construction (render time) vs. complexity of experience (file size after compression)

The progression is a systematic externalisation of taste into code. Each version encodes a different theory of value: subjective (manual), collective (crowdsourced), structural-relational (difference), formal (complexity ratio). The fitness function is formalised taste — the criterion that process-legibility identifies as what thirty years of practice accumulates and what AI cannot replicate.

Death Imitates Language. Manual fitness: the artist selects which organisms live and die — the earliest and most subjective criterion in the series.

Hybrid Vigor .bio. The criterion externalised — public, crowdsourced selection replaces the artist's hand.

R. Electrotype. The "hipster algorithm": fitness defined relationally, as maximal difference from every other specimen in the population.

Triddle. The formal criterion: construction complexity (render time) weighed against experience complexity (compressed file size) — taste specified structurally rather than by hand.

Non-coding genes: latent potential as archive

The non-coding gene is philosophically the most significant feature of CGP. Genes that currently contribute nothing to the computation persist in the chromosome, accumulate mutations, and can suddenly become active — producing new structures from what was dormant.

This is a biological archive of unused possibilities. The organism doesn't express them now, but they are not lost — they are carried forward, transformed, and available for future activation. Applied to an artwork: the generative system contains more possibilities than it currently expresses. The visible output is a surface on top of a much larger latent space.

This connects to mediation and the archive: the archive carries what is not currently active but shapes what can emerge. The non-coding gene is an archival structure within the algorithm itself — the past encoded into a form that can become the future.

Death as selection pressure

In Death Imitates Language, the artist decides which organisms live and die. The death of an organism is not failure but selection pressure — it clears space for fitter configurations and drives the system toward complexity. This is precisely the reframing in senescenence: death as system feature, not system failure.

The cellular automaton and the genetic algorithm share this logic. Both are systems in which death is generative: the cell that dies according to the automaton's rules, the organism that is culled by the fitness function, are both participating in the system's motion toward greater complexity.

The artist's role in both is the same: not to prevent death but to set the conditions under which death is productive. "Permitted" rather than "composed."

Life as 3.5 billion years of R&D

Julian Miller's closing formulation: "Life is a 3.5 billion year old technology."

Biological life is not the opposite of computation — it is its oldest instance. Evolution is R&D at geological timescale: mutation as random variation, natural selection as fitness function, reproduction as inheritance. What CGP compresses into rendering cycles is a recapitulation of the same logic that produced all living things.

This reframes the biological jargon question that van den Dorpel raises in the interview. The terms (mutation, crossover, breeding, fitness) are not metaphors imported from biology — they are the literal operations, abstracted. The question is not whether the algorithm is "alive" but whether life is, at some level, algorithmic. Miller's answer: studying evolutionary algorithms produces "a huge amount of respect and wonder at all living things." The bottom-up approach deepens, rather than demystifies, the question of what life is.

For the practice, this means: Mutant Garden is not a simulation of evolution. It is evolution, running at a different substrate and timescale, with a different fitness function. The organisms it breeds are not metaphors for life — they are an instance of the same process.

Algorithmic archaeology

CGP is the excavation case: an algorithm developed for industrial circuit-board optimisation in the 1990s, carrying the engineering problems it was built to solve and the specific choices Miller and Thomson made in the graph representation, redeployed for art in 2019 in a context its creators did not anticipate. Van den Dorpel on the scale of legacy code (Spike #70): "you can see remnants of Windows 3.1; it's still there." Code accumulates; "code isn't law, but rather destiny."

This is one half of a wider method. The full account — the two senses (excavation and forensic reconstruction), the pre-computer precursors (Anni Albers, Emma Kunz, Charlotte Posenenske, Vera Molnár, Manfred Mohr, Tauba Auerbach), the Albers invisible-algorithm case, the female/weaving lineage argument, and the timeline running from the loom to the LLM — now lives on its own page: Algorithmic Archaeology. CGP is that page's 1997 node.