Algorithms, not Blueprints
Developmental algorithms and generative complexity
The scientific idea
A developing brain does not have to be specified as a complete blueprint. Instead, genes and cells can implement developmental algorithms: relatively compact rules that are applied repeatedly as cells divide, migrate, differentiate, extend processes, respond to chemical signals, and interact with their neighbors.
This creates an important distinction between describing an endpoint and describing a process that generates the endpoint. A complicated pattern might require thousands of bits, coordinates, or instructions if we tried to specify every part of it directly. Yet the same pattern may be generated by a much shorter rule that is repeated over time. In that sense, development can be generative rather than descriptive.
The demonstration begins with an abstract example—a cellular automaton—and then applies the same logic to a schematic developing neural process. The biological simulation is not intended as a literal model of axon guidance. Its purpose is to show how a small collection of local rules can generate organized structure without storing the final structure in advance.
The instructions do not have to contain a picture of the finished structure. They can specify local rules for building it.
Launch Algorithms, not Blueprints
The HTML file and this Quarto file should be kept in the same folder.
How to run the demonstration
The simulation has two parts:
- Abstract rule — a cellular automaton based on Rule 110.
- Biological growth — a schematic developmental system in which a growing process follows local chemical cues.
Both parts use the same basic controls.
- Play / Pause starts and stops the simulation.
- Step advances the simulation one developmental step at a time.
- Reset returns the current simulation to its original state.
- Slow–Fast changes the animation speed.
- Mutate one rule changes one element of the current rule set and restarts from the same initial condition.
In the biological simulation an additional control appears:
- Same rules, new embryo runs the same developmental rules again with a different sequence of small random variations.
For teaching, Step is especially useful at the beginning of each demonstration. It allows the class to see that the complex endpoint is being constructed incrementally rather than appearing all at once.
Part 1: Abstract rule
What you are seeing
The first display is a one-dimensional cellular automaton. Each horizontal row is a population of cells. A cell can be in only one of two states: active or inactive.
The simulation begins with a very simple initial condition: a single active cell.
To generate the next row, each cell examines only three cells in the row immediately above it:
- its left neighbor,
- itself,
- its right neighbor.
Three binary cells can occur in only eight possible combinations:
111, 110, 101, 100, 011, 010, 001, and 000.
Rule 110 specifies one output—0 or 1—for each of those eight local situations. That eight-entry lookup table is the entire rule used to generate every subsequent row.
No row contains instructions for the final pattern. Each row is generated only from the row before it.
Try it
Begin with Step rather than Play.
Advance five or ten rows and watch the pattern emerge from the single starting cell. Then press Play and allow the rule to continue operating.
As the display grows, look at the counters beneath the simulation.
Rule table remains fixed at eight binary decisions. The amount of information needed to state the local rule does not increase as the pattern grows.
Displayed endpoint reports a deliberately simple, literal description of what is currently on the screen: one bit for every displayed cell. That number grows rapidly because more and more cells have now been specified.
Active cells counts the number of cells in the active state.
The comparison is the point. A short rule is being reused to construct a much larger object.
The large endpoint number is a naive literal description length. It asks how much information would be required if we simply listed the state of every displayed cell.
It should not be interpreted as the Kolmogorov or algorithmic complexity of the resulting pattern. Because the pattern can be generated from a short rule plus an initial condition, it has a compact generative description. The demonstration contrasts a long literal description of the endpoint with a short description of the process that generates it.
Mutate one rule
Reset the simulation and run Rule 110 long enough to recognize its characteristic structure. Then press Mutate one rule.
Only one entry in the eight-entry lookup table changes. The initial condition remains the same.
Run the simulation again.
A very small change to the generative rule can produce a large change in the pattern that emerges after many iterations.
This illustrates an important evo-devo principle: evolution does not necessarily have to specify a new anatomical structure directly. A genetic change can alter a parameter or developmental rule, and repeated application of that altered rule can amplify the difference during development.
Part 2: Biological growth
Select 2 · Biological growth.
What you are seeing
The abstract cells are replaced by a schematic developing neural process. A growth cone begins near the left side of the field and moves through a landscape containing several chemical influences.
The simulation uses four visible rules:
- Seek A. The growing process tends to turn toward the attractant labeled A.
- Avoid B. A repellent labeled B bends nearby growth away from it.
- Branch conditionally. Branches are more likely to form when the growing process enters the region containing sufficient C, the branch-promoting cue.
- Stop locally. Growth stops when it reaches a sufficiently strong target-associated stopping cue, or when a branch exceeds its permitted lifetime.
These are intentionally simplified rules. Real neural development involves many interacting guidance molecules, receptors, transcriptional states, cell-cell interactions, mechanical constraints, and activity-dependent processes. The purpose here is to isolate the logic of generative development.
Run the normal development
Press Reset, then use Step several times.
The small dark dot at the tip is the active growth cone. The blue line behind it records the path produced by its previous local decisions.
Then press Play.
Notice that the growing process does not move along a precomputed route. At each step it responds again to the chemical environment around its current location.
As it crosses the field:
- attraction toward A helps pull growth toward the far side,
- B locally deflects the trajectory,
- the yellow C: branch zone creates conditions in which new branches can appear,
- the purple STOP region terminates growth near the target.
The final arbor is therefore an accumulated history of many local decisions.
No rule says:
Draw this particular branch from these coordinates to those coordinates.
Instead, the rules say things such as seek, avoid, branch under these conditions, and stop under these conditions. The geometry emerges when those rules are repeatedly applied in space and time.
Watch the counters
The three counters beneath the biological simulation make the same comparison in a different way.
Visible rule set remains four conceptual rules: seek, avoid, branch, and stop.
Literal geometry counts four coordinates for every line segment that has been drawn. It is a deliberately naive estimate of how much information would be needed to describe the displayed arbor segment by segment.
Branches created reports how many branch points emerged as the local branching condition was repeatedly evaluated.
Again, the important contrast is between a compact generative procedure and a much more detailed endpoint.
Change one developmental parameter
Reset the biological simulation and let it run normally. Note the approximate density of the final arbor.
Now click Mutate branching threshold and run it again.
The guidance rules have not changed. The locations of A, B, C, and the target have not changed. The important alteration is the threshold at which the branch-promoting condition is satisfied.
Lowering that threshold makes branching easier. A small change in one developmental parameter can therefore produce a visibly different endpoint after the rule has been applied many times.
This is a simple model of an important evolutionary and developmental principle:
Changing a rule or parameter can change anatomy without specifying the new anatomy directly.
Same rules, new embryo
Return to the normal branching rule and run the biological simulation once.
Then click Same rules, new embryo and run it again.
The large-scale organization should remain recognizable, but the exact positions of individual branches can differ. The simulation introduces small random variations into individual growth decisions while keeping the developmental rules and chemical landscape unchanged.
This illustrates another important feature of development. A developmental program can be reliable without being microscopically identical on every run. Robust rules and constraints can produce a recognizable organization even though individual trajectories differ in detail.
What to take away
The two simulations make the same argument at different levels.
In the cellular automaton, a small lookup table repeatedly applied to local neighborhoods generates a large global pattern.
In the biological example, a small set of local responses to chemical cues generates an organized arbor.
In neither case is the final structure stored as a detailed drawing.
Development works by running rules. Evolution can modify those rules, their thresholds, their timing, or the environments in which they operate. Large anatomical consequences can therefore emerge from relatively small changes in the developmental process.