Digital morphogenesis studies how forms, shapes, and patterns emerge in nature through computational models of biological, chemical, and physical processes, with applications in architecture, fabrication, art, engineering, biomedicine and more.
This list is a compact reference of growth algorithms, lab experiments, and related math/physics/programming topics so readers can find unexpected relationships and patterns across disciplines.
Contributions are welcome! If you have improvements, links, or missing topics to add, please open an issue or PR.
Growth algorithms
Dielectric breakdown model (DBM)
Image credit: Ellak Somfai - Dielectric breakdown model in 3 dimensions.
Generalization of DLA that models how an electrical discharge propagates through an insulating (dielectric) material, producing the branching patterns known as Lichtenberg figures - the same kind of patterns seen in lightning, fulgurites in sand, and burn marks left by high-voltage discharge.
Rather than growing a cluster from randomly-walking particles like DLA, DBM solves Laplace’s equation for the electric potential around the growing cluster at every step, then extends growth from whichever boundary site has the strongest local field.
A single exponent, η (eta), controls how sharply growth concentrates at high-field points: at η = 1 the model is statistically equivalent to DLA, higher values produce sparser and more needle-like branches, and η = 0 produces smooth, non-fractal growth.
Algorithm at a glance:
* indicates a potential simulation parameter
- Seed growth with an initial charged point or shape, and hold a distant boundary* at zero potential (fully “discharged”).
- Solve for the potential field filling the space around the cluster - either by repeatedly relaxing a grid (each free cell settles toward the average* potential of its neighbors, over some number of iterations*) until the field stabilizes, or by approximating it with a batch of random walkers* launched from the boundary and recording where each one first touches the cluster.
- For each empty cell touching the cluster (a “candidate” site), calculate its local field strength as how much its potential has dropped relative to the cluster’s fixed potential.
- Raise each candidate’s field strength to the power of the growth exponent* (η), normalize the results into probabilities, and randomly pick one (weighted by those probabilities) to add to the cluster.
- Repeat, resolving the field again after each new addition.
Key terms:
- η (eta) - exponent controlling how strongly growth favors high-field regions; DLA is the η = 1 case of DBM.
- Lichtenberg figure - branching discharge pattern that DBM was originally developed to explain.
- Rigid and elastic bond models - DBM variants used to study electrical and mechanical breakdown (fracture) networks.
Articles:
Code projects:
- Lichtenberg-Figures - DBM-based simulation of Lichtenberg figure formation, accounting for the stochastic nature of dielectric breakdown
Diffusion-limited aggregation (DLA)
Process in which particles of matter stick together (aggregate) as they chaotically move (diffuse) through a medium that provides some sort of resistive (limiting) force. As these particles clump together over time they form characteristic fractal branching structures known as Brownian trees.
Very interesting macro-structures begin to emerge at around the 1-10 million particle range in 3D, but in order to get there you’ll need to be smart about your rendering pipeline and make use of optimized code in a performant language or environment (C/C++, CUDA, GLSL shaders, Houdini, etc).
Algorithm at a glance:
- Add initial point(s) or shapes to seed growth.
- Add a number of walker particles.
- In each tick of the simulation, do the following:
- Move each walker a small amount in a random direction.
- If any walker particle is colliding with a fixed/clustered particle, convert that walker particle into a fixed/clustered particle.
Key terms:
- Walker - randomly-moving particle not attached to any other particle
- Cluster - group of multiple particles stuck together
- Brownian tree - name of characteristic branching structure that emerges
Articles:
Code projects:
Creative projects:
Notable software:
Videos:
Differential growth
Process that acts on continuous chains of nodes connected by lines using simple rules (attraction, repulsion, alignment; not unlike boids) in order to produce undulating, buckling forms that mimic or simulate meandering rivers, rippled surface textures of plants/seeds/fruits, space-filling behaviors of worms, snakes, intestines, and much more.
Algorithm at a glance:
2D:
- Begin with a set of nodes connected in a chain-like fashion to form a path (or multiple paths). Each node should have a maximum of two neighbors (one preceding, one following).
- In each tick of the simulation, for each node:
- Move node towards it’s connected neighbor nodes (attraction).
- If node gets too close to any nearby nodes (connected or not), move it away from them (repulsion).
- Move node towards the midpoint of an imaginary line between it’s preceding and following nodes (alignment). It wants to rest equidistance between them with as little deflection as possible.
- In each tick of the simulation, evaluate the distances between each pair of connected nodes. If too great, insert a new node between them (adaptive subdivision).
- At some interval, insert new nodes in the chain to over-constrain the system and induce growth. The bends and undulations that emerge are a result of the system trying to equalize the forces using the rules defined in step 2.
Articles and discussions:
Code projects:
Creative projects:
Eden growth model
Image credit: Silvio Costa Ferraria et al - Figure 1 from Pitfalls on the determination of the universality class of radial clusters
Created by Murray Eden in 1961 (paper (PDF)), this is a type of surface fractal growth process where material randomly accumulates on the boundary of clusters. Sort of like DLA but without all the empty space between branches. Thought to be a good way to model certain kinds of bacterial and lichen growth.
Algorithm at a glance:
* indicates a potential simulation parameter
- Seed growth with a single occupied cell (or shape).
- Track the list of all empty cells touching the cluster - its “perimeter.”
- Pick one perimeter cell to fill in - either uniformly at random*, or weighted by how many cluster cells it touches* - and add it to the cluster.
- Update the perimeter list: remove the cell just filled, and add any new empty cells it exposed.
- Repeat.
Key terms:
- Perimeter / boundary sites - the empty cells adjacent to the cluster; the pool of candidates for the next growth step.
- Growth-site weighting - how a perimeter cell is chosen each step; picking uniformly among all perimeter cells produces a different texture than weighting by how many cluster neighbors a cell has.
- Kardar–Parisi–Zhang (KPZ) universality class - broad category of surface-growth models that share the same statistical scaling behavior; the Eden model is a classic example used to study it.
Articles:
Code projects:
Particle Life
Image credit: detail of the example results from Particle Life Simulation by Hunar Ahmad
Family of particle systems in which every particle belongs to one of several types (usually drawn as colors), and every ordered pair of types is assigned its own attraction or repulsion strength. Those strengths are held in a small matrix that can be filled randomly and then tuned by hand, which makes the system extremely easy to explore - each new matrix is effectively a new set of “physics” to play with.
Crucially, the matrix does not have to be symmetric: green can be attracted to red while red is repelled by green. That asymmetry is what lifts the results beyond simple clumping, producing cell-like clusters with membranes, wandering “creatures” that chase and flee each other, orbiting pairs, snaking chains, and blobs that pinch off copies of themselves - all within one parameter space.
Originally explored by Jeffrey Ventrella as Clusters and later popularized under the name “Particle Life” by CodeParade in 2018, this is one of the most approachable emergent systems to implement, since the core is just a nested loop over pairs of particles.
Not to be confused with the Primordial Particle System, which uses a single kind of particle steering by neighbor counts - here the effects depend entirely on multiple types treating each other differently.
Algorithm at a glance:
* indicates a potential simulation parameter
- Randomly place a number* of particles, assigning each one of
k* types (colors).
- Build a
k × k matrix* of attraction values (commonly in the range -1 to 1), one for each ordered pair of types, where negative values mean repulsion. Random matrices are a good starting point, and the matrix need not be symmetric.
- In each tick of the simulation, for each particle:
- Find nearby particles within a maximum interaction radius*.
- For each neighbor, compute a force: strong repulsion when closer than some minimum distance* (so particles cannot collapse into a single point), and beyond that, an attraction or repulsion scaled by the matrix value for the pair of types involved. The exact shape of the falloff curve varies between implementations and has a big impact on the results.
- Add the summed forces to the particle’s velocity, apply friction/damping*, then move it.
- Wrap or bounce particles at the edges of the world*.
Key terms:
- Types (or families/colors) - the classes of particle whose interactions the matrix describes
- Attraction matrix -
k × k table of per-pair attraction and repulsion strengths
- Minimum distance - radius inside which particles always repel each other
- Maximum radius - distance beyond which particles ignore each other, usually enforced with a spatial index
- Friction - velocity damping, without which the system heats up and flies apart
Articles:
Videos:
Projects:
Physarum
Image credit: Sage Jenson (@mxsage)
Technique for modelling the observed behaviors of the slime mold physarum polycephalum using agent-based modelling. Originally described in 2010 paper by Jeff Jones, and more recently popularized by artist Sage Jensen (@mxsage), this algorithm produces highly dynamic and organic-looking webs that can seem very life-like and biological in nature.
Algorithm at a glance:
* indicates a potential simulation parameter
- Consider the simulation space as a grid, with each cell storing a number representing the combined strength of pheromones left by the agents who have passed through it.
- Pheromones in each cell diffuse at some rate* to neighboring cells as they decay (at some rate*) in each step of the simulation.
- Add a set of points, each representing an autonomous agent.
- Each agent leaves a trail of decaying pheromones behind by adding a number* to the cells it passes through.
- Each agent senses the total phermone strength of cells in front of it defined by a distance* and a field of view angle*.
- An agent will gradually adjust its direction* to steer towards the cell(s) with the most pheromones.
- Render the trails (not the agents) by mapping the pheromone strength number in each cell to a range or gradient of colors.
Articles:
Code projects:
Creative projects:
Primordial Particle System
Image credit: detail of Figure 3G from Schmickl, Stefanec & Crailsheim (2016)
Described in 2016 by Thomas Schmickl, Martin Stefanec and Karl Crailsheim of the Artificial Life Lab in Graz, Austria, a Primordial Particle System (PPS) is a minimal agent-based model in which self-propelled particles move through continuous space while steering based only on how many neighbors they can see to their left and right - a motion law even simpler than boids, with no cohesion, separation or alignment rules. It is a separate system from Particle Life, where all of the behavior comes instead from multiple particle types with per-pair attraction rules.
Despite containing no notion of cells, membranes or reproduction, the system spontaneously produces cell-like structures with a dense interior surrounded by a ring-like membrane, and those structures go through a full life cycle: they feed on the surrounding “nutrient” field of free particles, grow, divide into daughter cells and spores, and die when starved. Left running, the population of cells levels off along a sigmoidal curve much like bacteria growing in a petri dish, making this one of the most striking demonstrations of how self-structuring, self-reproducing and self-sustaining behaviors can emerge from a single line of math.
Motion law:
$$\Delta\phi = \alpha + \beta \cdot N_{t,r} \cdot \text{sign}(R_{t,r} - L_{t,r})$$
Where $L$ and $R$ are the number of neighbors within radius $r$ in the semicircles to the particle’s left and right, $N = L + R$ is the total number of neighbors, $\alpha$ is a fixed rotation, $\beta$ is a rotation proportional to local crowding, and a positive $\Delta\phi$ is a turn to the right.
Algorithm at a glance:
* indicates a potential simulation parameter
- Randomly distribute particles across the habitat with random headings, at a density* of around 0.08 particles per square unit (the paper uses a 250x250 unit space that wraps around at the edges).
- In each time step, visit every particle once, in random order, and for each one:
- Count its neighbors within radius $r$*, splitting them into those on its left ($L$) and those on its right ($R$).
- Turn it by $\Delta\phi$ using the motion law above, with a fixed angle $\alpha$* and a crowding-proportional angle $\beta$*.
- Move it forward by a constant velocity $v$*.
- Update particles asynchronously - each particle senses and moves within the same loop, so it sees the already-updated positions of the particles visited before it in that time step. Updating everything simultaneously instead will not produce the same results.
- Optionally color-code particles by local neighborhood size to make the structures legible (see below).
Reference parameter set: $\text{PPS} = \langle r = 5, \alpha = 180°, \beta = 17°, v = 0.67 \rangle$
Color coding (as used in the paper):
- Green ($N \leq 13$) - free-floating “nutrient” particles
- Brown ($13 \leq N \leq 15$) - premature spores
- Magenta (more than 15 neighbors within a much smaller radius of 1.3) - mature spores
- Blue ($15 < N \leq 35$) - the bulk of cell structures, including their membranes
- Yellow ($N > 35$) - the densest interiors of cells
Articles:
Videos:
Projects:
Reaction-diffusion
Grid-based process that generates complex and dynamic patterns based the interactions of two chemicals as they diffuse through a medium and react with one another. At every location on the grid these chemicals (usually referred to as A and B) have a chance of causing a reaction that converts chemicals of one type to another based on their relative concentrations at that location.
Throughout the simulation chemical A is added at a particular feed rate (f) and chemical B is removed at a particular kill rate (k) - adjusting these rates can result in wildly different emergent patterns.
Equation (via Karl Sims):
Key terms:
- Feed rate - rate at which chemical
A is added to system
- Kill rate - rate at which chemical
B is removed from the system
- Diffusion rate - rate at which each chemical spreads, which acts as a kind of scaler to a 3x3 Laplacian transform
- Reaction chance - probability that one
A will be converted to a B when in the presence of two Bs.
- Gray-Scott model
- Pearson’s classification
- Turing patterns
Articles:
Notable tools:
Code projects:
Creative projects:
Videos:
Space colonization
Process for iteratively growing networks of branching lines based on the distribution of growth hormone sources (called “auxin” sources) to which the lines are attracted. Originally described by Adam Runions and collaborators at the Algorithmic Botany group at the University of Calgary, this system can be used to simulate the growth of leaf venation patterns and tree-like structures, as well as many other vein-like systems like Gorgonian sea fans, circulatory systems, root systems, and more.
The original algorithm describes methods for generating both “open” (as seen in the example GIF) and “closed” venation networks, referring to whether or not secondary or tertiary veins connect together to form loops (or anastomoses).
Algorithm at a glance:
For both the open and closed variants of this algorithm, begin by placing a set of points on the canvas representing sources of either the auxin growth hormone (as in leaves) or ambient nutrients (as in trees).
Open venation:
- Associate each auxin source with the single closest vein segment within a pre-defined attraction distance.
- For each vein segment that is associated with at least one auxin source, calculate the average direction towards them as a normalized vector and generate a new vein segment that extends in that direction at a pre-defined segment length (by scaling the normalized direction vector by that length).
- Remove any auxin sources that have vein segments within a pre-defined kill distance around it.
Closed venation:
- Associate each auxin source with all of the vein segments that are both within a pre-defined attraction distance and within the source’s relative neighborhood.
- For each vein segment that is associated with at least one auxin source, calculate the average direction towards them as a normalized vector and generate a new vein segment that extends in that direction at a pre-defined segment length (by scaling the normalized direction vector by that length).
- Remove any auxin sources that have been reached by all of their associated vein segments.
Auxin flux canalization:
- Give each vein segment a uniform default thickness to start with.
- Beginning at each terminal vein segment (that is, segments with no child segments), traverse “upwards” through each parent vein segment, adding their child vein segment thickness to their own until you reach a root vein segment (a segment with no parent segment).
Key terms:
- Auxin source = a discrete location towards which vein segments are attracted. In biology, auxin is a hormone found in plants that promotes growth.
- Auxin flux canalization = process by which veins become thicker as they grow longer. The longer a vein gets, the more auxin flows through it (“flux”), causing veins to progressively thicken from their tips to their roots. “Canalization” references the process by which “canals” of water form.
- Relative neighborhood = point P is a relative neighbor of a point Q if there is no other point R closer to P and Q than they are to each other.
Articles and papers:
Creative projects:
Code projects:
Videos:
L-systems (Lindenmayer systems)
String rewriting system invented by biologist Aristid Lindenmayer in 1968 to model the growth processes of plant development and other organisms. L-systems use simple grammatical rules to iteratively expand a string of symbols, which can then be interpreted geometrically (e.g., using turtle graphics) to produce complex branching structures. Despite their simplicity, L-systems can generate remarkably naturalistic plant forms, fractals, and branching patterns.
The key insight is that local production rules (each symbol rewrites to a sequence of symbols) applied recursively across iterations can generate globally complex structures without explicitly encoding the final form. This makes L-systems particularly powerful for modeling hierarchical biological growth.
Algorithm at a glance:
* indicates a potential simulation parameter
- Define an axiom* - the initial string (often just “F” or a single symbol).
- Define production rules* - for example, “F → FF” (each forward step becomes two forward steps).
- Define a number of iterations*.
- For each iteration, replace every symbol in the string according to its production rule, simultaneously.
- Interpret the final string geometrically:
- Common symbols:
F (move forward and draw), f (move forward without drawing), + (turn left), - (turn right), [ (push position/heading to stack), ] (pop position/heading from stack)
- Render the resulting path or tree structure.
Example:
| Description |
Rendered Result |
Axiom: F
Rule: F → F[+F]F[-F]F
After iteration 1: F[+F]F[-F]F
After iteration 2:
F[+F]F[-F]F[+F[+F]F[-F]F]F[+F]F[-F]F[-F[+F]F[-F]F]F[+F]F[-F]F
When rendered with angle=25°, this produces a branching plant-like structure. |
 |
Key terms:
- Axiom - the starting string
- Production rules - symbol-to-string mappings applied each iteration
- Turtle graphics - geometric interpretation of the L-system string using position, heading, and a drawing pen
- Stochastic L-systems - rules chosen probabilistically rather than deterministically, creating variation
- Parametric L-systems - rules can use parameters and conditions for more sophisticated generation
- Context-sensitive L-systems - rules depend on neighboring symbols, allowing more complex interactions
Articles:
Videos:
Notable tools and libraries:
- Blender
- Houdini
- TouchDesigner
- Unity
- SpeedTree - commercial procedural tree generator with L-system-based generation
- Unreal Engine
Spinodal decomposition
Physical process by which a homogeneous mixture (a molten alloy, polymer blend, glass, etc.) spontaneously separates into two distinct phases when rapidly cooled (“quenched”) into an unstable region of its phase diagram. Unlike typical nucleation-based phase separation, no discrete starting sites or thermodynamic barrier are needed - tiny composition fluctuations grow everywhere in the material simultaneously.
The result is a characteristic pattern of intertwined, worm-like regions that grow and merge (“coarsen”) over time while roughly maintaining the same overall proportions of each phase - visually similar to some reaction-diffusion patterns, though it arises from a different underlying process (phase-separation thermodynamics rather than a chemical feed/kill reaction). It’s commonly modeled with the Cahn-Hilliard equation, a PDE describing how the concentration of the two phases diffuses and separates over time.
Algorithm at a glance:
* indicates a potential simulation parameter
- Fill a grid with random noise* representing the initial, unstable composition of the mixture.
- At each step, for every cell, calculate how its concentration should change based on two competing effects: diffusion (smoothing out differences with its neighbors) and phase separation (pushing its value away from the mixed middle and toward one pure phase or the other).
- Update every cell by combining these two effects, scaled by a diffusion rate* and a phase-separation strength*.
- Repeat, letting separated regions grow and merge (coarsen) over time.
Key terms:
- Cahn-Hilliard equation - the PDE most commonly used to model spinodal decomposition.
- Quench - rapid cooling of a mixture into an unstable region of its phase diagram, triggering decomposition.
- Coarsening - the slow, ongoing growth and merging of separated regions over time.
- Nucleation - the barrier-driven alternative to spinodal decomposition, where phase separation starts at discrete sites rather than everywhere at once.
Articles:
Code projects:
Math and physics topics
Archimedean solids
Set of 13 semi-regular convex polyhedra composed of regular polygons meeting in identical vertices, excluding the 5 Platonic solids (which are composed of only one type of polygon) and excluding the prisms and antiprisms.
Each shape can be constructed by starting with one of the Platonic solids and truncating it’s corners or edges in various ways.
List of Archimedean solids:
| Name |
Faces |
Edges |
Vertices |
Image |
| Truncated tetrahedron |
4 triangles
4 hexagons |
18 |
12 |
 |
| Cuboctahedron |
8 triangles
6 squares |
24 |
12 |
 |
| Truncated cube |
8 triangles
6 octagons |
36 |
24 |
 |
| Truncated octahedron |
6 squares
8 hexagons |
36 |
24 |
 |
| Rhombicuboctahedron |
8 triangles
18 squares |
48 |
24 |
 |
| Truncated cuboctahedron |
12 squres
8 hexagons
6 octagons |
72 |
48 |
 |
| Snub cube |
32 triangles
6 squares |
60 |
24 |
 |
| Icosidodecahedron |
20 triangles
12 pentagons |
60 |
30 |
 |
| Truncated dodecahedron |
20 triangles
12 decagons |
90 |
60 |
 |
| Truncated icosahedron |
12 pentagons
20 hexagons |
90 |
60 |
 |
| Rhombicosidodecahedron |
20 triangles
30 squares
12 pentagons |
120 |
60 |
 |
| Truncated icosidodecahedron |
30 squares
20 hexagons
12 decagons |
180 |
120 |
 |
| Snub dodecahedron |
80 triangles
12 pentagons |
150 |
60 |
 |
Articles:
Videos:
Cellular automata (CA)
A regular grid of cells with states that are updated each iteration in according to rules. Developed by Stanislaw Ulam and John von Neumann at the Los Alamos National Laboratory in the 1940s, this system has been used to model physical, biological, and social phenomena with remarkable variety and accuracy.
Key terms:
- Cell - a discrete location on the grid
- State - the “value” of a cell. Many CAs just have two states (on/off), but others use many.
- Neighborhood - set of cells surrounding a given cell. Most common types are Von Neumann and Moore, though others exist.
- Rule(s) - mathematical functions or if/else statement(s) that define what the next state of a cell should be based on various criteria like the states of that cell’s neighbors. Sometimes called transition rules.
- Generation - result of one iteration of the system.
Types:
- Asynchronous - automaton in which each cell is updated independantly of the others over time. Multiple update schemes have been proposed by various researchers.
- Block - automaton in which the grid of cells is divided into non-overlapping blocks, with rules being applied to entire blocks rather than individual cells. Also known as a partitioning cellular automaton.
- Continuous - automaton in which each cell has a real number value instead of an integer state.
- Continuous spatial - automaton in which the cell locations are continuous.
- Cyclic - automaton in which cells are initialized with one of a number of states in a range, then can be “consumed” when a neighboring cell has a successor state, causing the cell’s state to take on that successor state. In other words, if cells can take on a value in the range
[0,9], then a cell with value 2 can be “consumed” by a neighboring cell with value 3, causing the cell to take on the value of 3. When cells reach the state at the end of the range, they are reset to the state at the beginning of the range (wrapping around).
- Discrete - the “default” configuration for cellular automata, in which a grid of regular square cells and integer states are used.
- Elementary - 1D cellular automata with two states and 256 possible rules. Thought to be the simplest possible cellular automaton.
- Life-like - any 2D outer totalistic automaton that uses two states and a Moore neighborhood, and whose transition rule can be expressed as a function of the number of neighboring cells that are in the “alive” state. Three standard rule notations exist, and a large number of rules have been identified and researched.
- Neural - automaton whose local transition rule is represented by a neural network, typically learned by optimizing for desired large-scale forms or behaviors. Often also continuous and stochastic.
- Reversible - automaton in which past grid states can be determined using later grid states. In other words, if you know the state at time
t, you can compute the state at t - 1.
- [Second-order](https://en.
README 内容过长，已截取前 64 KB。完整内容请前往 GitHub 仓库查看。
评论