Draft

Field notes · A visual essay

The Biological Stack of a Tree

Read an organism the way you'd read a software stack — a tree at the top, a photon at the bottom, every layer computing the one above it.

Liam Zebedee · June 2026

A tree is a stack. Not a metaphor for one — an actual tower of abstractions, each layer built out of the one beneath it, the way an app sits on a runtime sits on an operating system sits on silicon. The strange part is that nobody wrote the layers down. The whole tower is generated, at runtime, out of a one-dimensional string. Here is the descent, top to bottom — and then the two axes the diagram leaves out: time, and the environment it grows into.

A tree — the whole organism

Organs & tissues — leaves, roots, bark; structural composites

Hormones — signalling molecules with specific shapes

Cells — tens of millions of them, each running a gene-regulatory network

Proteins & peptides — 1D chains folded into 3D machines

DNA & mRNA — the 1D code, and the central dogma that reads it

Fundamental particles — atoms, electrons, the photon that starts it all

IThe descent

A tree

Start at the top. This single figure rearranged how I think about form: read it left to right and you fall from a whole tree down through wood, cell organisation, the cell wall, and finally the polymer chains of cellulose and lignin — six orders of magnitude in one row. The structure is self-similar. The same fibres-in-a-matrix logic repeats at every scale. A tree isn't drawn top-down; it's one small rule, run over and over.

The anatomy of wood across scales, from whole tree to molecular chains — One organism, six orders of magnitude — tree to molecular chain

A self-assembling thing

It helped to stop picturing a cell as a machine following a blueprint, and start picturing it as a self-assembling factory — one that builds the plan as it goes. There's no separate CAD file and assembly program. The genome is closer to the weights of a neural network than to a folder of part drawings: it doesn't describe the tree so much as generate it, and the same weights produce a slightly different tree every time.

A self-assembling robotic factory, as a metaphor for the cell — A cell as a factory that assembles itself

Organs & tissues

One layer down are the organs and tissues — leaves, roots, bark — and the thing to notice is that they're not placed, they're grown into. Development is a dynamical system. A leaf doesn't unfold from a stored image; it relaxes into shape as hormones and genes push on each other. A single regulatory hand-off — miR156 giving way to miR172 — is enough to walk a plant through its transitions: juvenile, to adult, to flowering. The morphological development of one leaf is a whole choreography of meristem, expansion, and senescence.

The morphological development of a single leaf — Morphological development of a single leaf — transitions all the way down

Structural composites

Where life needs to hold a shape, it reaches for the same trick again and again: a stiff fibre laid into a soft matrix, secreted layer by layer. A tree does it with cellulose and lignin. A shell does it with a thin lip of mantle tissue that lays down mineral in bands — a simple local rule plus growth gives you the logarithmic spiral. A hair does it with keratin. The composite is always a recording of the algorithm that built it.

A generative model of seashell growth: the mantle secreting shell in layers — A shell is a generative model — the mantle laying down the spiral

Hormones

How does a body with no brain in the middle coordinate across its whole length? It broadcasts molecules with a specific shape. A hormone doesn't do anything itself — it's a signal, a key cut to fit a particular receptor. A plant pumps auxin, cell to cell, down its root; an animal runs hormones through a bloodstream and nerves. Drawn side by side, the two long-range signalling networks rhyme — and at the bottom of the diagram is the small, specific molecule that carries the message.

Hormone transport networks in an animal body and a plant root, with the auxin molecule — Long-range signalling, animal and plant — and the molecule that carries it

Cells — tens of millions of them

Now the load-bearing layer. Every cell carries the same genome — the entire source for the whole organism — but each one runs a different slice of it. Which genes get read is decided by a gene regulatory network: a dynamical circuit of proteins switching each other on and off. These circuits are doing real computation — genetic feedback loops, oscillators (a literal clock-and-wavefront, the same trick that segments your spine), repeaters, and logic. Reverse-engineering them, and then mapping the whole repertoire as a state space, is most of what modern developmental biology is.

Reverse-engineering the gene regulatory circuit of a single root — Reverse-engineering a root's regulatory circuit

Gene regulatory circuits running as oscillators — The same circuits, running as oscillators

The inferred state space of a gene regulatory network — The inferred state space — every stable form the network can fall into

Underneath the GRN, the cell is a dense mesh of other concerns: protein–protein interactions (molecular machines physically docking, like a vault protein latching onto a microtubule by raw electrostatics), an internal state the cell senses and updates, a cell wall and structure to hold its shape, and an energy budget — ATP, the universal currency, minted and spent. Stack all of that into one membrane and you have the smallest unit that's unambiguously alive.

A vault protein docking onto a microtubule by electrostatic interaction — Protein meeting protein — a vault docking onto a microtubule

It's so much machinery that the honest test of "do we understand a cell?" is: can we simulate one? The closest anyone has come is a whole-cell model of a near-minimal organism (the JCVI minimal cell) — every reaction, every molecule, in software. It runs. It is also brutally hard, which tells you how much is packed into this one layer.

Molecules, proteins, peptides

Below the cell, the parts themselves: proteins, peptides, enzymes, the hormones from two layers up. A protein is a 1D chain that folds into a 3D machine, and the fold is where the function lives. The fold isn't designed either — the chain falls into the 3D structure that minimises its energy, pure physics relaxing into a basin. Insulin is the small, beautiful case: built long as proinsulin, pinned by three disulfide bonds, then trimmed in the middle. Shape first, cut second.

Insulin in its folded 3D form — …and folded into its 3D form

How proinsulin folds and is cleaved into insulin — Folded, bonded, then cleaved — proinsulin into insulin

DNA & mRNA

One layer deeper is the code. DNA is the 1D string that everything above is generated from; mRNA is the working copy. The rule that connects code to machine is the central dogma — a one-way-ish flow of state that's worth memorising because the entire stack hangs off it:

The central dogma: DNA transcribed to mRNA, translated to protein, folded — The central dogma — DNA → mRNA → amino-acid chain → folded protein

Read it as a pipeline: DNA is transcribed into mRNA, mRNA is translated codon-by-codon into a chain of amino acids, and the chain folds. Three bases pick one amino acid — a clean 64→20 lookup table, best drawn as a wheel — and the whole thing is just a long printout of A, C, G and T that a cell reads as a single instruction: build this. (We only saw the double helix for the first time as an X-ray smudge, Photo 51.)

The genetic code drawn as a radial codon wheel — The 64→20 lookup table, as a wheel

A printout of an insulin DNA sequence from a patent — The source code, printed — an insulin gene from a patent

Photo 51, the first X-ray image of DNA — The first image of DNA's structure

Fundamental particles

The bottom of the stack is just physics. Atoms — built from protons, neutrons and electrons — bond into the small molecules everything else inherits, and the geometry of those bonds sets the rules: water's O–H at 95.84 pm, bent at 104.45°, is why water is polar, why it dissolves life, and why biology is wet at all. Go one step lower and you reach the photon — the packet of light a leaf catches in photosynthesis to pay for the entire tower above it.

The geometry of the water molecule: 95.84 pm, 104.45 degrees — The geometry that sets the rules — water (H₂O)

The discovery of neon's isotopes by mass spectrometry — Even atoms come in variants — neon's isotopes, weighed

IITwo more dimensions: time & environment

The stack above is a snapshot — a frozen cross-section. But the tower is built in time, and it's built into a place. Two axes the layer diagram leaves out.

Does a tree grow the same in space?

Here's the question that breaks the blueprint intuition: would this tree grow the same on a station in orbit? Almost certainly not — and that's the point. A leaf is not a "leaf." A leaf is a program that relaxes into leaf-like shapes in Earth-like environments. Change gravity, light, temperature, the medium, and the same code settles into a different basin. The genome doesn't store the shape; it stores a generator, and the environment is one of its inputs.

A generative landscape: an organism relaxing into a shape rather than following a design — Does an organism follow a design, or relax into a shape?

And we can finally watch the relaxation happen. Gaussian-splat reconstruction turns a cheap turntable-and-camera rig into 4D video of a plant growing in full 3D — the time axis, made measurable.

Evolution & optimisation

The generator itself has a history. The loop is almost embarrassingly simple: something random happens — a mutation — a feature arises, and selection keeps it if it pays. Run that for four billion years and you don't get noise, you get optimisation so tight it looks designed. Plot metabolic rate against body mass for everything from a microbe to a whale and ~24 orders of magnitude fall on a single straight line. Life is tuned to a power law it never agreed to — and hormones, those shape-specific signals, are some of the oldest knobs the loop has found to turn.

Metabolic rate versus body mass, a single straight line across 24 orders of magnitude — Kleiber's law — one line, microbes to whales

IIIA central tool: inference

One small protein remembers the whole tree of life.

Because the code is inherited and only edited at the margins, biology is shot through with inference: you can read history straight off the molecules. Insulin is so essential it has barely changed — line the hormone up across species and most letters are identical, differing in only a spot or two. From those few differences you can rebuild the lineage: human clusters with chimp and macaque, camel with cow and buffalo. The protein is a fossil of the phylogeny.

A phylogenetic tree rebuilt from insulin sequences — The lineage, rebuilt from one hormone

Insulin sequence alignment across species, mostly conserved — Insulin across species — change in only a spot or two

IVUnsolved

Two questions I can't yet answer, and they're really the same question wearing different clothes.

How does it compute?

The stack is generative — a 1D string unfolds into a 4D body — but how, exactly, does the regulatory network compute the next step? We can map its state space; we can name the oscillators and the logic gates. We still can't read a genome and predict the organism, the way you'd run a program and predict its output. The decompression from code to body is the missing function.

How do we simulate it?

And if we did understand the computation, could we run it? A whole-cell simulation of a minimal organism barely fits on a cluster; a whole-tree simulation is science fiction. The diagram below is the current frontier of the first question — a map of which network topologies can produce which morphogen patterns. It's a beautiful map. It is not yet a compiler.

A map of gene-regulatory network topologies and the patterns they can produce — A map of the computation — not yet a way to run it

VWhere this is going: biotech

If an organism is a stack you can read and write, the frontier is the tooling — and the most exciting tool is the robotic lab. We already write at the bottom of the stack: synthesise a gene, clone it into a plasmid, drop it into a living cell, and let the cell's own machinery build and fold the protein. That's recombinant expression — the organism as the factory — and it's how insulin is made.

The recombinant expression pipeline for making a protein in a host cell — Writing at the bottom of the stack — recombinant expression

An Opentrons liquid-handling robot deck layout — The protocol, run by a robot — an Opentrons deck

Lab robots like Opentrons turn those protocols into code, and pair them with closed-loop experiments — a robot arm and a model breeding plants, scoring each generation against the optimum and trying again. (I wrote more about programming these in DNA, genes, OpenTrons.) Run the read-write-select loop fast enough, on hardware, and you start to engineer the stack instead of just reading it.

Robotic plant breeding with an AI in the loop — The read–write–select loop, handed to a robot

A companion to Diagrams From Biology — the same borrowed figures, reorganised as a single climb down the stack and back. The diagrams come from papers, textbooks, patents and renders, credited where I could; what's mine is the order.