Skip to content
BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

286 Commits
images
images
 
 
CONTRIBUTING.md
CONTRIBUTING.md
 
 
Natural-phenomena.md
Natural-phenomena.md
 
 
README.md
README.md
 
 

Repository files navigation

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.


Table of contents
Growth algorithms [#]

Math and physics topics [#]

Natural phenomena

See Natural-phenomena.md

Lab experiments [#]

Useful code patterns and techniques [#]

▸ Books, publications, and talks
▸ Software

Growth algorithms

Image

Dielectric breakdown model (DBM)

Note

Related to Diffusion-limited aggregation (DLA) and Laplace equation.

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

  1. Seed growth with an initial charged point or shape, and hold a distant boundary* at zero potential (fully "discharged").
  2. 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.
  3. 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.
  4. 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.
  5. 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

Image

Diffusion-limited aggregation (DLA)

Note

Related to Dielectric breakdown model (DBM) and Laplace equation.

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:

  1. Add initial point(s) or shapes to seed growth.
  2. Add a number of walker particles.
  3. In each tick of the simulation, do the following:
    1. Move each walker a small amount in a random direction.
    2. 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:

Image

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:

  1. 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).
  2. In each tick of the simulation, for each node:
    1. Move node towards it's connected neighbor nodes (attraction).
    2. If node gets too close to any nearby nodes (connected or not), move it away from them (repulsion).
    3. 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.
  3. 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).
  4. 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:

Image

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

  1. Seed growth with a single occupied cell (or shape).
  2. Track the list of all empty cells touching the cluster - its "perimeter."
  3. 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.
  4. Update the perimeter list: remove the cell just filled, and add any new empty cells it exposed.
  5. 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:

Image

Particle Life

Note

Related to Primordial Particle System and agent-based modelling.

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

  1. Randomly place a number* of particles, assigning each one of k* types (colors).
  2. 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.
  3. In each tick of the simulation, for each particle:
    1. Find nearby particles within a maximum interaction radius*.
    2. 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.
    3. Add the summed forces to the particle's velocity, apply friction/damping*, then move it.
  4. 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:

Image

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

  1. 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.
  2. Add a set of points, each representing an autonomous agent.
  3. Each agent leaves a trail of decaying pheromones behind by adding a number* to the cells it passes through.
  4. Each agent senses the total phermone strength of cells in front of it defined by a distance* and a field of view angle*.
  5. An agent will gradually adjust its direction* to steer towards the cell(s) with the most pheromones.
  6. 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:

Image

Primordial Particle System

Note

Related to Particle Life and agent-based modelling.

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

  1. 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).
  2. In each time step, visit every particle once, in random order, and for each one:
    1. Count its neighbors within radius $r$*, splitting them into those on its left ($L$) and those on its right ($R$).
    2. Turn it by $\Delta\phi$ using the motion law above, with a fixed angle $\alpha$* and a crowding-proportional angle $\beta$*.
    3. Move it forward by a constant velocity $v$*.
  3. 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.
  4. 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:

Image

Reaction-diffusion

Note

Related to convolution kernel and Laplace equation.

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): Karl Sims - reaction-diffusion equation

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:

Image

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:

  1. Associate each auxin source with the single closest vein segment within a pre-defined attraction distance.
  2. 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).
  3. Remove any auxin sources that have vein segments within a pre-defined kill distance around it.

Closed venation:

  1. 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.
  2. 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).
  3. Remove any auxin sources that have been reached by all of their associated vein segments.

Auxin flux canalization:

  1. Give each vein segment a uniform default thickness to start with.
  2. 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:

Image

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

  1. Define an axiom* - the initial string (often just "F" or a single symbol).
  2. Define production rules* - for example, "F → FF" (each forward step becomes two forward steps).
  3. Define a number of iterations*.
  4. For each iteration, replace every symbol in the string according to its production rule, simultaneously.
  5. 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)
  6. 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.		 Image

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:

Image

Spinodal decomposition

Note

Related to reaction-diffusion.

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

  1. Fill a grid with random noise* representing the initial, unstable composition of the mixture.
  2. 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).
  3. Update every cell by combining these two effects, scaled by a diffusion rate* and a phase-separation strength*.
  4. 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

Image

Archimedean solids

Note

Related to polyhedra and Platonic 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 Image
Cuboctahedron 8 triangles
6 squares		 24 12 Image
Truncated cube 8 triangles
6 octagons		 36 24 Image
Truncated octahedron 6 squares
8 hexagons		 36 24 Image
Rhombicuboctahedron 8 triangles
18 squares		 48 24 Image
Truncated cuboctahedron 12 squres
8 hexagons
6 octagons		 72 48 Image
Snub cube 32 triangles
6 squares		 60 24 Image
Icosidodecahedron 20 triangles
12 pentagons		 60 30 Image
Truncated dodecahedron 20 triangles
12 decagons		 90 60 Image
Truncated icosahedron 12 pentagons
20 hexagons		 90 60 Image
Rhombicosidodecahedron 20 triangles
30 squares
12 pentagons		 120 60 Image
Truncated icosidodecahedron 30 squares
20 hexagons
12 decagons		 180 120 Image
Snub dodecahedron 80 triangles
12 pentagons		 150 60 Image

Articles:

Videos:

Image

Cellular automata (CA)

Note

Related to convolution kernel.

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.
  • 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 - automaton in which cell states depend on their neighborhood in the last two generations. In other words, the state at time t depends on the state at both t - 1 and t - 2.
  • Stochastic - automaton with a transition rule that incorporates a probability distribution or, in other words, some degree of randomness. Also known as probabilistic (PCA) or random cellular automata.
  • Totalistic - automaton in which the state of each cell is based on the sum of the values of its neighbor cells in the previous iteration. If it also depends on its own state in the previous iteration then the automaton can be called outer totalistic or semitotalistic.

Wolfram's classification:

Stephan Wolfram defined four classes that can be used to describe any cellular automaton or other simple computational model based on their observed behaviors. These definitions are qualitative in nature, with some room for intepretation, but are nonetheless considered the most effective classification scheme that currently exists for cellular automata.

  • Class 1: Uniformity  -  nearly all initial patterns evolve quickly into a stable, homogeneous state. Any randomness in the initial pattern disappears.
  • Class 2: Repetition  -  nearly all initial patterns evolve quickly into stable or oscillating structures. Some of the randomness in the initial pattern may filter out, but some remains. Local changes to the initial pattern tend to remain local.
  • Class 3: Random  -  nearly all initial patterns evolve in a pseudo-random or chaotic manner. Any stable structures that appear are quickly destroyed by the surrounding noise. Local changes to the initial pattern tend to spread indefinitely.
  • Class 4: Complexity  -  nearly all initial patterns evolve into structures that interact in complex and interesting ways, with the formation of local structures that are able to survive for long periods of time.

Well-known rules and rule families:

Articles, books, and other writings:

Code projects:

Creative projects:

Notable software:

Image

Conway operators

Note

Related to polyhedra, Platonic solids, and Archimedean solids.

Conway polyhedron notation, invented by mathematician John Horton Conway and later extended by George W. Hart, is a compact system for describing complex polyhedra as a short chain of operators applied to a simple seed shape. Operators are single lowercase letters applied right-to-left, so taC means "start with a cube (C), apply ambo (a), then truncate (t)" - the same recipe that produces a truncated cuboctahedron. This turns a huge space of polyhedra into a small, composable vocabulary, which is why it's a popular basis for procedural polyhedron tools.

Seeds: Starting shapes are abbreviated with a single capital letter: T (tetrahedron), C (cube), O (octahedron), D (dodecahedron), I (icosahedron), Pn (n-gonal prism), An (n-gonal antiprism), Yn (n-gonal pyramid).

Core operators:

  • d (dual) - swaps every face for a vertex and vice versa (e.g. dC = octahedron).
  • a (ambo) - adds a vertex at the midpoint of every edge and connects them, producing the "rectified" Archimedean forms (e.g. aC = cuboctahedron).
  • t (truncate) - slices off each vertex, turning it into a small new face.
  • k (kis) - raises a pyramid on every face by adding a vertex at its center.
  • j (join) - connects the centers of adjacent faces, replacing them with quadrilaterals.
  • e (expand) - pushes each face outward along its normal and fills the resulting gaps with new faces.
  • s (snub) - like expand, but with a twist added, producing a chiral form with extra triangular faces (e.g. sC = snub cube).
  • g (gyro) - the dual of snub; introduces a chiral twist without adding triangles.
  • b (bevel) - combines truncation and ambo.
  • o (ortho) - subdivides each face into quadrilaterals around its center.
  • m (meta) - combines kis and join.

George Hart later added r (reflect, mirrors a chiral form) and p (propellor), and modern implementations support dozens more (chamfer, needle, zip, loft, whirl, and others).

Articles:

Notable tools:

  • Polyhedronisme by Anselm Levskaya - interactive web app for building polyhedra with Conway operators (see Polyhedra for more)
  • Antiprism's conway by Adrian Rossiter and Roger Kaufman - command-line Conway notation processor, adapted from Hart's original implementation

Convolution kernel

Note

Related to cellular automata, reaction-diffusion, noise, and image processing.

A convolution kernel is a small matrix of numbers that defines a weighted neighborhood operation. When applied to a grid (like an image, scalar field, or cellular grid), the kernel is placed over each location, its values are multiplied by the overlapping grid values, the products are summed, and the result is written to the center cell. This operation is the foundation for countless techniques across image processing, simulations, and signal analysis.

The kernel acts as a filter that emphasizes or suppresses patterns in the data. A kernel of all ones computes the sum of a neighborhood. A kernel with larger values in the center and smaller values at the edges acts as a blur (weighted average). Kernels with opposing signs can detect edges. Different kernels solve different problems, but they all follow the same convolution process: slide, multiply, sum, repeat.

Core concepts:

  • Kernel (filter) - the small matrix applied to each location. Kernels are typically square (3×3, 5×5) but can be any shape or size.
  • Neighborhood - the set of grid values that overlap with the kernel at a given position.
  • Convolution - the process of sliding the kernel across the grid, computing weighted sums, and producing an output grid.
  • Boundary handling - strategies for dealing with edges where the kernel extends beyond the grid: zero-padding (pad with 0s), reflection, wrapping, or shrinking the output.
  • Stride - the step size when sliding the kernel (1 means every position, 2 means every other position, etc.).
  • Normalization - dividing the kernel result by the sum of the kernel values to preserve the magnitude of the output (especially important for averaging kernels).

Applications across domains:

  • Image processing - blur, sharpen, edge detection, emboss, dilation/erosion (mathematical morphology), and many other filters.
  • Reaction-diffusion systems - convolution kernels approximate the Laplacian operator, which governs how substances diffuse and interact across a spatial grid.
  • Cellular automata - rules based on the sum or pattern of a neighborhood are implicitly convolving with a kernel.
  • Fluid simulation - pressure solvers and advection schemes use convolution to distribute quantities across neighboring cells.
  • Noise generation - blurring or interpolating noise through convolution creates coherent multi-scale patterns (basis for Perlin noise smoothing).
  • Morphological operations - erosion and dilation kernels reshape binary regions (used in image segmentation and shape analysis).
  • Smoothing and filtering - low-pass filters smooth noisy data; high-pass filters enhance detail and edges.

Articles:

Videos:

Code projects and libraries:

  • scikit-image (Python) - filters, morphology, edge detection
  • OpenCV (C++, Python, JavaScript) - extensive kernel-based filtering and image processing
  • PIL/Pillow (Python) - image filters with custom kernels
  • GIMP - manual convolution filter tool for artistic exploration
  • Three.js postprocessing (JavaScript) - GPU-based convolution for real-time effects
  • Shader-based convolution - fragment shaders implement kernel operations efficiently on GPU
Image

Cymatics

Note

Related to Chladni plate

Study of the visible effects of sound and vibration on physical media. Typically involves the vibration of a plate or membrane onto which fine powder or fluids have been placed, which subsequently arrange themselves into highly symmetrical, complex patterns based on the intensity of displacement of various regions of the vibrating plate. Areas that are moving a lot will "kick" material away from them while areas that are moving very little allow material to settle and accumulate. These areas of relatively little vibration are caused by destructive interference of waves as they propagate across the plate/membrane and become out of phase with one another, creating "dead zones" where these waves cancel each other out.

Articles:

Creative projects:

Image

Delaunay triangulation and Voronoi diagrams

Note

Related to tiling / tessellation.

Delaunay triangulation is a way of connecting a set of points to form a network of non-overlapping triangles. One of the key properties of Delaunay triangulations is that the circumcircles associated with each triangle contains no other points than their three triangle vertices. When extended into 3D, Delaunay triangulation is useful for creating meshes.

Voronoi diagrams are the dual of Delaunay triangulations. This means that once a Delaunay triangulation has been computed for a set of points, a Voronoi diagram can be drawn without any additional data - just draw lines connecting the centers of the circumcircles!

Voronoi diagrams are very useful for efficiently and organically partitioning (splitting up) both 2D and 3D space. They are especially good for accurately modelling the way soft bodies (like biological cells) get smushed together in constrained environments, like embryonic cells undergoing mitosis.

Voronoi diagrams are often used (perhaps overused) in digital fabrication applications, especially 3D printing, for their characteristic aesthetic style and their ability to reduce material usage while preserving overall form. Given their popularity among amateur 3D printing enthusiasts, this effect is probably best used sparingly in serious applications.

Articles:

Image

Fibonacci sequence

Note

Related to Golden ratio.

Sequence of numbers in which each number is the sum of it's two preceding numbers. Binet's formula shows that the ratio of two consecutive numbers tends towards the golden ratio as the sequence progresses. Fibonacci numbers appear unexpectedly often in biology, having been observed in branching of trees, the arrangement of leaves on a stem, the fruit sprouts of a pineapple, the flowering of an artichoke, an uncurling fern and the arrangement of a pine cone's bracts.

Formula:

$$F_{0}=0,\quad F_{1}=1,$$

$$F_{n}=F_{n-1}+F_{n-2},$$

Sequence begins with:

$$(0), 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \ldots$$

Articles:

Image

Fourier series

Series of sinusoidal wave functions that get added together to generate a different, more complex function. In the context of morphogenesis (form generation), any line drawing can be "deconstructed" into a series of arc segments which can in turn be represented by a series of circles whose radii and rotation speeds correspond to the radii and lengths of the arc segments.

Fourier series and Fourier transforms are deeply mathematical topics with applications and research far beyond the scope of this resource list. They are extremely useful in the field of digital signal processing for noise reduction, compression, audio analysis, and so much more. A very well-known algorithm known as the fast Fourier transform (FFT) enables extraction of waveforms from music for the purposes of audio visualization.

Articles:

Videos:

Image

Fractals

Infinitely complex patterns generated via recursion that are self-similar across all scales. Thought to be found in abundance in nature, though "true" (infinite) fractals are not possible because nature uses physical matter, which has particular structures at the microscopic and smaller scales (molecules, atoms, elementary particles, etc).

Fractal features can be observed in nature in tree branching structures, leaf veins, terrain, surface textures, coastlines, rivers, succulents, snowflakes, rivers, lightning bolts, nautilus shells (both form and pattern), and so much more.

Key terms:

  • Fractal dimension - ratio providing a statistical index of complexity comparing how detail in a fractal changes with scale.
  • Self-similarity - when something is exactly or approximately similar to a part of itself.

Notable fractals:

Articles:

Notable software:

Image

Geodesic

Image credit: Vikash Mittal - Geometric phase and its applications: topological phases, quantum walks and non-inertial quantum systems (FIGURE 2).

The shortest path between two points on a curved surface - a generalization of the concept of a "straight line" to curved geometry. On a flat plane a geodesic is just a straight line; on the surface of a sphere, geodesics are arcs of great circles; on more complex curved surfaces they can bend and twist while still remaining locally "as straight as possible" at every point.

Related terms:

  • Great circle - the specific case of a geodesic on the surface of a sphere, formed by a plane passing through the sphere's center.
  • Geodesic curvature - measure of how far a curve on a surface deviates from being a geodesic.
  • Geodesic dome - structure whose triangulated struts approximate geodesic arcs across a sphere.

Articles:

Image

Geodesic dome

Note

Related to geodesics, Platonic solids, and polyhedra.

Spherical shell structure of triangular struts whose vertices all lie on a circumscribed sphere. It's typically derived from a Platonic solid with triangular faces (usually an icosahedron) by subdividing each face some number of times (the dome's "frequency") and projecting the new vertices onto the sphere - higher frequencies mean more, smaller struts and a closer approximation of a sphere.

Named for the geodesic - the shortest path between two points on a curved surface - since its edges approximate great-circle arcs. The shell distributes structural stress evenly, giving it a high strength-to-weight ratio. Popularized (though not invented) by Buckminster Fuller, whose name was later borrowed for the similarly-shaped carbon molecules called buckminsterfullerenes.

Key terms:

  • Geodesic - generalization of a straight line to curved surfaces; the shortest path between two points on the surface.
  • Geodesic polyhedron - convex polyhedron made of triangles, usually derived from subdividing a Platonic or other simple polyhedron and projecting the vertices onto a sphere.
  • Frequency - the number of times each face of the base polyhedron is subdivided before projection onto the sphere; written as nV (e.g. 3V), where a higher number means smaller, more numerous struts.
  • Strut - a single structural member (edge) connecting two vertices of the dome.
  • Chord factor - ratio used to calculate the length of a given strut relative to the radius of the sphere.

Articles:

Notable software:

  • Domerama calculators - strut-length and cover-pattern calculators for domes of various frequencies

Notable real-world geodesic domes:

  • Climatron at the Missouri Botanical Garden in St. Louis, MO, USA. Diameter = 42m (138ft).
  • La Géode at the City of Science and Industry in Paris, France. Diameter = 36m (118ft).
  • Long Beach Cruise Terminal (formerly The Spruce Goose Dome) in Long Beach, CA, USA. Diameter = 122m (400ft).
  • Matrimandir in Bommayapalayam, India. The building structure is a geodesic dome covered in golden discs. Diameter = 36m (118ft).
  • Montreal Biosphere in Montreal, Québec, Canada. Designed by Buckminster Fuller himself in 1967. Diameter = 76m (249ft) .
  • Science World building in Vancouver, Canada.
  • Spaceship Earth in the EPCOT theme park at Walt Disney World in Orlando, FL, USA. Diameter = 50m (165ft).
  • The Eden Project in Cornwall, England. Features multiple domes merged together into large, multi-area buildings.
  • The Desert Dome at the Henry Doorly Zoo and Aquarium in Omaha, NE, USA. Diameter = 70m (230 ft).
Image

Golden angle

Note

Related to the golden ratio and phyllotaxis.

Radial version of the golden ratio. It is the smaller of the two angles created by sectioning the circumference of a circle according to the golden ratio; that is, into two arcs such that the ratio of the length of the smaller arc to the length of the larger arc is the same as the ratio of the length of the larger arc to the full circumference of the circle.

In degrees the angle is approximately 137.5077640500 ..., or just 137.5 for brevity.

Articles:

Creative projects:

Image

Golden ratio

Note

Related to the Fibonacci sequence.

Also expressed as the Greek letter phi (φ), this irrational number pops up when the ratio of two numbers is the same as the ratio of their sum to the largest of the two numbers. It has been observed in many fields of the natural sciences at every scale and is has become associated with aesthetic beauty, giving it a nearly mythic reputation for some.

Expressed algebraicly $\varphi = \frac{1 + \sqrt{5}}{2} = 1.6180339887\ldots$
Expressed as line segments Image

Articles:

Image

Implicit surface

A surface defined by an equation in the form of Image. The surface itself is defined by the set of zeros of such a function. Implicit surfaces are infinitely scalable, and are much more smooth / "blobby" than surfaces defined explicitly by vertices and faces. However, they are more difficult and computationally expensive to render, requiring an algorithm like raymarching or marching cubes in order to represent the surface on a 2D screen.

Examples of implicit surface equations:

Plane $x+2y-3z+1=0$
Sphere $x^{2}+y^{2}+z^{2}-4=0$
Torus $(x^{2}+y^{2}+z^{2}+R^{2}-a^{2})^{2}-4R^{2}(x^{2}+y^{2})=0$
Surface of genus 2 $2y(y^{2}-3x^{2})(1-z^{2})+(x^{2}+y^{2})^{2}-(9z^{2}-1)(1-z^{2})=0$
Surface of revolution $x^{2}+y^{2}-(\ln(z+3.2))^{2}-0.02=0$

Articles:

Notable software:

Image

Inverse and forward kinematics

Equations used to calaculate the positions of a series of rigidly-linked segments (called the kinematic chain) based on the location of the end effector, usually located at the tip of the last segment. Useful for robotic systems like drawing machines, robot arms, and more.

Inverse kinematics calculate the angles of each linked segment given the desired location of the end effector. Will give you the angles of each segment, which can in turn be converted into motor positions for a robot.

Forward kinematics calculate the location of the end effector given the angles and lengths of each linked segment.

Articles:

Videos:

Laplace equation

Image

Note

Related to DLA, DBM, Saffman–Taylor instability, reaction-diffusion, minimal surface, fluid simulation, and Laplace transform.

The Laplace equation, $\nabla^2 \varphi = 0$, says that a field's value at any point equals the average of its immediate surroundings - no interior point can be a local bump or dip. It shows up constantly in physics because it's simply the steady-state form of diffusion, heat flow, and potential fields: whenever something free to spread out (heat, concentration, charge, pressure) has finished settling, its value obeys this equation. Solutions are called harmonic functions.

That abstractness is exactly why it matters for morphogenesis: several branching growth patterns already covered elsewhere in this list are, mathematically, the same equation wearing different clothes - a family of processes collectively known as Laplacian growth.

Laplacian growth - from equation to organic form:

Each of these solves the Laplace equation in the region around a growing cluster, then advances the cluster's boundary fastest wherever the resulting field's gradient is steepest:

  • Diffusion-limited aggregation (DLA) - random walkers stick where they first touch the cluster. In the continuum limit, the probability of a walker arriving at any boundary point is proportional to the gradient of the harmonic concentration field around the cluster - DLA is the stochastic, particle-based way of sampling a Laplacian growth process.
  • Dielectric breakdown model (DBM) - solves the Laplace equation directly for an electric potential field around the growing discharge, then grows each boundary point in proportion to the local field gradient raised to a tunable power - the same idea as DLA, made explicit and continuous.
  • Saffman–Taylor instability (viscous fingering) - inside a Hele-Shaw cell, the fluid pressure field obeys the Laplace equation (via Darcy's law), and the identical "grow fastest where the gradient is steepest" feedback produces the same branching, finger-like interface.

This is why DLA clusters, electrical discharge patterns, and viscous fingers all look so similar despite arising from unrelated physics - they're all boundaries growing into a harmonic field, differing only in their noise and boundary conditions.

Key terms:

  • Laplacian operator ($\nabla^2$ or $\Delta$) - the divergence of the gradient; measures how much a point's value differs from the average of its immediate surroundings.
  • Harmonic function - any solution to the Laplace equation; has no local maxima or minima except at the domain's boundary (the "mean value property").
  • Poisson equation - the Laplace equation with a source term ($\nabla^2 \varphi = f$); used whenever the field being solved has "generators" (charge, heat sources, image gradients) rather than being purely diffusive.
  • Boundary conditions - since the Laplace equation alone has infinitely many solutions, a specific field is picked out by fixing its values (Dirichlet) or its gradient (Neumann) on the domain's boundary - the growing cluster's surface, in Laplacian growth models.
  • Laplacian growth - the general term for a growth process where the interface advances in proportion to the gradient of a harmonic field solved in the region ahead of it.
  • Laplacian smoothing (mesh relaxation) - the discrete, iterative graphics technique of averaging each mesh vertex with its neighbors; converges toward a discrete solution of the Laplace equation.

Articles:

Videos:

  • Harmonic Functions from Khan Academy - short, visual introduction to the Laplacian and harmonic functions

Code projects:

Laplace transform

Note

Related to Laplace equation

Mathematical transform that converts a function of time into a function of complex frequency, turning differential equations into algebraic ones that are often easier to solve. It is widely used in engineering, physics, and control theory to analyze dynamic systems and their stability, resonance, and response.

The Laplace transform maps a time-domain function $f(t)$ to a frequency-domain function $F(s)$. In this form, differentiation becomes multiplication and convolution becomes multiplication, making many system problems easier to analyze. Its inverse recovers the time-domain solution for applications such as growth dynamics, signal propagation, and feedback-driven behavior.

Definition:

$$F(s) = \mathcal{L}{f(t)} = \int_0^{\infty} e^{-st} f(t) , dt$$

Where $s = \sigma + i\omega$ is a complex frequency variable, $t$ is time, and the integral converges for sufficiently large $\sigma$.

Key properties:

Property Formula Description
Linearity $\mathcal{L}{af(t) + bg(t)} = a\mathcal{L}{f(t)} + b\mathcal{L}{g(t)}$ Sum transforms equal sum of transforms
Differentiation rule $\mathcal{L}{f'(t)} = sF(s) - f(0)$ Converts derivatives to algebraic operations
Integration rule $\mathcal{L}{\int_0^t f(\tau),d\tau} = \frac{F(s)}{s}$ Converts integrals to division by $s$
Convolution theorem $\mathcal{L}{f(t) * g(t)} = F(s)G(s)$ Converts convolution to multiplication
Final value theorem $\lim_{t \to \infty} f(t) = \lim_{s \to 0} sF(s)$ Determines steady-state behavior
Initial value theorem $f(0^+) = \lim_{s \to \infty} sF(s)$ Determines initial conditions
Frequency shifting $\mathcal{L}{e^{at}f(t)} = F(s-a)$ Scaling exponential shifts frequency
Time shifting $\mathcal{L}{f(t-a)u(t-a)} = e^{-as}F(s)$ Delay in time domain multiplies by $e^{-as}$

Key terms:

  • Region of convergence (ROC) - the set of complex $s$ values for which the Laplace integral converges
  • Pole - a value of $s$ where $F(s)$ becomes infinite; poles determine system stability and response characteristics
  • Zero - a value of $s$ where $F(s)$ equals zero
  • Transfer function - the Laplace transform of a system's impulse response; describes how a system responds to inputs
  • Inverse Laplace transform - converting from frequency domain back to time domain; often done via partial fraction decomposition
  • Partial fraction decomposition - breaking a complex rational function into simpler fractions to facilitate inverse transformation

Articles:

Lissajous curves

Also known as Bowditch curves, these figures plot the trajectories of a point as it follows the path of two simultaneous sinusoidal motions.

Can be created using various physical systems including oscilloscopes, harmonographs, and more.

Equations:

$$x = a \sin t,\quad y = b \sin(nt + \varphi)$$

$$0 \leq \varphi \leq \frac{\pi}{2}, \quad n \geq 1$$

Articles:

Videos:

Image

Mass-spring system

Note

Related to soft-body physics, cloth simulation, Verlet physics, and physics engines.

A mass-spring system is a general mathematical model for deformable bodies: a graph of point masses connected by springs that obey Hooke's law (restoring force proportional to displacement from a rest length). It's one of the oldest and most widely reused abstractions in computational physics, showing up not just in computer graphics but in structural engineering (truss analysis), molecular dynamics (bond modeling), and biomechanics (tissue and muscle models). Its appeal is that a small number of local rules - distance constraints and simple forces - can produce believable global deformation without solving a full continuum mechanics problem.

In graphics and simulation, mass-spring systems are the conceptual backbone of cloth simulation, rope/hair simulation, and soft-body deformation, and are typically stepped forward with Verlet integration for stability. Real-time applications commonly layer three kinds of springs to control different deformation modes: structural springs (resist stretching), shear springs (resist skewing), and bend springs (resist folding).

Algorithm at a glance:

* indicates a potential simulation parameter

  1. Represent the body as a graph of point masses, each with position, velocity, and mass*.
  2. Connect masses with springs, each with a rest length and stiffness*.
  3. For each spring, compute the restoring force: F = stiffness × (current_distance - rest_length).
  4. Add a damping force proportional to relative velocity*: F_damping = damping × relative_velocity.
  5. Sum spring, damping, and external forces (gravity, wind, etc) on each mass.
  6. Integrate mass positions forward, commonly with Verlet integration.
  7. Detect and resolve collisions with rigid bodies and self-collisions.
  8. Repeat until the system settles or the simulation ends.

Key terms:

  • Hooke's law - the restoring force in a spring is proportional to its displacement from rest length, scaled by a stiffness constant.
  • Rest length - the preferred distance between two connected masses; springs pull toward this distance.
  • Stiffness (spring constant) - how strongly a spring resists stretching; higher values resist deformation more.
  • Damping - dissipative force proportional to velocity; prevents infinite oscillation and lets systems settle.
  • Structural constraints - springs between nearest neighbors; define topology and resist stretching.
  • Shear constraints - diagonal springs between diagonal neighbors; resist skewing.
  • Bend constraints - springs between masses separated by one neighbor; resist folding/creasing.

Articles:

Code projects:

Videos:

Image

Medial axis

The medial axis is sort of like the "skeleton" of a shape. It consists of a set of lines and curves upon which every point is equidistant between at least one closest point on the shape's boundary. In 2D this skeleton can also be thought of as a set of lines/curves whose points are the centers of circles that are tangent to at least two points on the shape's boundary.

Has applications in computer vision, pose estimation, 2D/3D character rigging, architecture, BIM (escape route optimization), and more.

Related terms:

  • Medial-axis transform - medial axis together with the associated radius function of the maximally inscribed discs. Can be used to reconstruct a shape.
  • Topological Skeleton
  • Straight skeleton - similar to medial, except always is made up of straight line segments whereas medial axis may contain curves.
  • Scale Axis Transform - generalization of medial axis transform

Articles:

Notable Tools:

  • Skeleton-Tracing, a code library for computing topological skeletons as a set of polylines from binary images. Provides implementations in C, C++, Java, JavaScript, Python, Go, C#/Unity, Swift, Rust, Julia, Processing, and OpenFrameworks.

Image

Minimal surface

Note

Related to Laplace equation.

A minimal surface is a surface that locally minimizes area, which means it settles into the smallest possible shape for a given boundary while keeping its mean curvature equal to zero. Minimal surfaces show up in architecture, material design, geometry, and optimization, and they are useful whenever you want a smooth surface or membrane that uses as little area as possible.

A soap film stretched across a wire frame is the classic physical example: the film naturally relaxes into a shape that balances tension everywhere. Frei Otto's soap-bubble experiments were important for showing how these forms emerge in the real world.

Equations:

Equation Explanation
$H = (k_1 + k_2) / 2 = 0$

Where: $H$ = mean curvature (the average curvature of a surface); $k_1$ and $k_2$ = principal curvatures (the two main curvatures at a point).		 The minimal surface condition says the average of the principal curvatures is zero.
$\nabla \cdot \left(\frac{\nabla u}{\sqrt{1 + \lvert\nabla u\rvert^2}}\right) = 0$

Where: $u(x, y)$ = surface height; $\nabla u$ = gradient of the surface; $\nabla \cdot$ = divergence (how much a field spreads out or converges).		 The minimal surface equation is the graph form of a minimal surface.
$A[u] = \iint \sqrt{1 + u_x^2 + u_y^2},dx,dy$

Where: $A[u]$ = area functional (the formula that computes total area); $u_x$ and $u_y$ = partial derivatives of the surface height.		 The area functional gives the total surface area.

Key terms:

  • Area functional - the integral that gives the total area of a surface
  • Mean curvature - the average of the two principal curvatures at a point on a surface
  • Minimal surface equation - the differential equation whose graph solutions are minimal surfaces
  • Minimal surface condition - the equation $H = 0$ that defines a minimal surface
  • Plateau's problem - finding the least-area surface spanning a given boundary
  • Principal curvatures - the two main curvatures of a surface at a point, measured in perpendicular directions

Examples:

Term Equation
Catenoid $r = a \cosh\left(\frac{z}{a}\right)$
Helicoid $x = u \cos v, \quad y = u \sin v, \quad z = a v$
Gyroid $\sin x \cos y + \sin y \cos z + \sin z \cos x = 0$

Articles:

Notable software:

  • Surface Evolver by Ken Brakke - interactive software for minimizing surface energies and constraints
  • Kangaroo Physics - Grasshopper plugin for physics-based form-finding and constraint solving, extensively used for minimal surface and structural exploration
  • PufferFish - Grasshopper plugin with mathematical surface components for minimal surface visualization and manipulation
  • Houdini Vellum - constraint-based cloth and hair solver useful for simulating membrane and fabric-like minimal surface behavior
  • MinimalSurface addon - Blender addon specifically designed for finding and generating minimal surfaces with prescribed boundary conditions
  • Mathematica Implicit Surface Visualization - tools for rendering and analyzing implicit surface equations including minimal surfaces

Notable creative work:

Notable real-world buildings:

Natural phenomena:

  • Soap bubbles and soap films - the classic physical analog for minimal surfaces
  • Butterfly wings (Papilio palinurus) - gyroid structure in wing scale ridges creates structural color via photonic crystal effects
  • Weevil exoskeleton (Lamprocyphus augustus) - Schwarz-D (diamond-type TPMS) surface with photonic properties
  • Sea urchin skeleton (echinoderm stereom) - diamond-type minimal surface formed from single-crystal magnesian calcite; guided by cytoskeletal templating
  • Endoplasmic reticulum - bicontinuous membrane network with negative Gaussian curvature and minimal surface-like topology
  • Mitochondrial cristae - morphology accurately predicted by minimal surface models; structure adapts based on cell energy state
  • Block copolymers (e.g., PS-b-PEO) - self-assemble into gyroid phase with bicontinuous nanochannels
  • Bicontinuous lipid cubic phases (monoolein/water) - form gyroid, diamond, or primitive TPMS depending on hydration level; used in drug delivery and protein crystallization
Image

Packing problems

Class of optimization problems that involve determining efficient ways to arrange (pack) objects into containers. Packing problems can be tackled using discrete mathematical methods, physics systems (as seen in Nervous System's Kinematics series), and even genetic algorithms and machine learning.

Has major applications in digital fabrication, manufacturing, and shipping logistics where material and space usage is directly related to costs. In 2D, packing/nesting problem solutions are useful for minimizing waste material in sheet goods like plywood and sheet steel, even for hobbyists. In 3D these solutions are useful for fitting as many objects as possible into 3D printer build envelopes (see article from Sculpteo).

Related terms:

Articles:

Notable tools:

Videos:

Image

Percolation theory

Mathematical framework that studies the behavior of connected clusters in random networks. At its core, percolation explores the threshold at which a system transitions from isolated fragments to a connected network spanning the entire space - a critical phenomenon with applications in material science, epidemiology, network analysis, and growth simulation.

The classical model places sites or bonds randomly on a grid, each with some occupation probability $p$. As $p$ increases, small disconnected clusters begin to merge and grow. At a critical threshold $p_c$ (the percolation threshold), a “giant component” suddenly emerges that connects from one side of the system to the opposite side. Above the threshold, clusters merge rapidly; below it, they remain fragmented. This sharp transition is a classic example of a phase transition in physics.

Key concepts:

  • Percolation threshold ($p_c$) - the occupation probability at which a spanning cluster first appears. The value depends on the lattice type: for square lattices $p_c \approx 0.593$ (bond) or $0.589$ (site), for triangular lattices $p_c \approx 0.5$ (bond), etc.
  • Cluster - a connected group of occupied sites or bonds.
  • Giant component - the largest, system-spanning cluster that emerges above the threshold.
  • Lattice types - square, triangular, hexagonal, random graphs, and others; each has different percolation thresholds and scaling behavior.
  • Major models:
    • Bond (Bernoulli) percolation - bonds (edges) between fixed sites are randomly occupied; relates to fluid flow through porous media.
    • Site percolation - individual sites (nodes) are randomly occupied; relates to disease spread or forest fire models.
    • Mixed percolation - combines site and bond percolation in one model, requiring both the sites and the bonds connecting them to be open for a cluster to form.
    • Bootstrap percolation - starting from a random set of occupied sites, empty sites are iteratively "infected" once they have at least $k$ occupied neighbors, repeating until no more sites change; models cascading activation like infection spread or social contagion.
    • Inhomogeneous percolation - the occupation probability $p$ varies from site to site (or bond to bond) instead of being uniform, e.g. to model spatially-varying material properties.
    • Long-range percolation - bonds can connect any two sites, not just nearest neighbors, with connection probability typically decaying with distance (often as a power law); can percolate via rare long "jumps" even below the classical threshold.
    • Directed percolation (oriented percolation) - bonds/sites can only be traversed along a preferred direction (e.g. "downward" through time); models epidemic spreading and non-equilibrium phase transitions.
    • Continuum percolation - occupation is defined over continuous space rather than a discrete lattice, e.g. overlapping disks or spheres; models material conductivity and wireless network coverage.
      • Germ-grain model - general stochastic-geometry framework of "germs" (points) dressed with "grains" (shapes) that may be correlated with one another or their surroundings.
      • Boolean model (Poisson Boolean model) - the germ-grain model's independent special case: germs scattered via a Poisson process, each dressed with an independent random grain; percolation occurs when grains overlap into a spanning cluster.
      • Disk model (Gilbert disk model) - special case of the Boolean model where every grain is a disk of fixed or random radius; used for random geometric graphs and wireless/sensor network connectivity.
      • Random-connection model - generalizes the Boolean/disk model into a random graph: any two points connect with a probability given by a distance-dependent "connection function," rather than by fixed-radius grain overlap.
    • Invasion percolation - growth advances by always occupying the weakest/most accessible available site rather than a random one; models fluid displacement in porous media.
    • First-passage percolation - instead of open/closed sites or bonds, each bond is assigned a random "passage time"; studies how quickly a fluid spreads from a source along the fastest weighted paths, producing random growth shapes.
    • Random-cluster model (Fortuin–Kasteleyn model) - generalizes percolation with an extra parameter $q$ that continuously interpolates between percolation ($q=1$), the Ising model ($q=2$), and the Potts model ($q>2$).
  • Critical exponents - power-law relationships describing cluster size distribution, correlation length, and other properties near $p_c$. These exponents are universal across many percolation models.
  • Universality class - percolation models grouped by shared critical exponent values; a hallmark of statistical physics.

Percolation can model porous media (oil migration through rock), disease spread (how infections propagate through a population), forest fires (how rapidly fires spread through dense vegetation), and network robustness (how many nodes can fail before connectivity is lost). In the context of morphogenesis, percolation-based growth can generate branching patterns, fragmented structures, and networks with natural-looking interconnectivity.

Articles:

Code projects and interactive tools:

Image

Phyllotaxis

Note

Related topics include the golden ratio, the golden angle, and the Fibonacci sequence.

Refers to the arrangement (taxis) of leaves (phyllo) on a plant stem. Also can refer to seed arrangements and succulent geometry.

Types:

  • Opposite - two leaves arise from the stem at the same level on opposite sides of the stem
  • Alternate - each leaf arises at a different point (node) on the stem
  • Whorled - arrangement of leaves that radiate from a single point and surround or wrap around the stem, as seen in the thumbnail for this section.
  • Distichous - special case of either opposite or alternate leaf arrangement where the leaves on a stem are arranged in two vertical columns on opposite sides of the stem
  • Decussate - occurs when successsive pairs of leaves arranged in the opposite pattern are 90 degrees apart, as in Aizoaceae family

Articles:

Code projects:

Videos:

Image

Platonic solids

Note

Related to polyhedra and Archimedean solids.

Set of regular, convex polyhedra constructed using congruent, regular polygonal faces with the same number of faces meeting at each vertex. Euclid (and perhaps Theaetetus proved mathematically that there are only five shapes that fit this criteria (below).

Name Polygon type Faces Edges Vertices Image
Tetrahedron Triangle 4 6 4 Image
Cube Square 6 12 8 Image
Octahedron Triangle 8 12 6 Image
Dodecahedron Pentagon 12 30 20 Image
Icosahedron Triangle 20 30 12 Image

Articles:

Videos:

Image

Polyhedra

Note

Related to Platonic solids, Archimedean solids, geodesic domes, and Conway operators.

A polyhedron is a solid bounded by flat polygonal faces, straight edges, and sharp vertices - the Platonic and Archimedean solids are just the two best-known families in a much larger space of shapes. For generative artists, polyhedra are a useful design space precisely because they're so constrained: a handful of construction rules (regular faces, identical vertices, symmetric arrangements) generate a finite, well-catalogued set of "correct-looking" forms, which is why the same few solids keep reappearing as base meshes for subdivision, geodesic domes, and procedural modeling more broadly.

Key concepts:

  • Convex vs. concave - convex polyhedra bulge outward everywhere with no self-intersections; concave ones have indentations or intersecting faces.
  • Classes - groupings based on construction rules, e.g. Platonic, Archimedean, Catalan, Kepler-Poinsot, Johnson, prisms/antiprisms, and near-misses.
  • Symmetry - when a shape can be rotated or reflected and still look exactly the same.
  • Stellation and facetting - dual operations for making new polyhedra from old ones: stellation extends face planes outward; facetting cuts new faces from existing vertices.

Major classes:

  • Platonic solids - the 5 regular convex polyhedra; one type of regular polygon face, identical arrangement at every vertex.
  • Archimedean solids - 13 semi-regular convex polyhedra with two or more types of regular polygon faces meeting identically at every vertex.
  • Catalan solids - the 13 duals of the Archimedean solids; face-transitive rather than vertex-transitive, so their faces aren't regular polygons but their vertex figures are.
  • Kepler-Poinsot solids - the 4 regular star polyhedra (small/great stellated dodecahedron, great dodecahedron, great icosahedron); self-intersecting stellations or facettings of the dodecahedron and icosahedron.
  • Johnson solids - the 92 remaining convex solids with regular polygon faces that aren't vertex-transitive (i.e. everything left once Platonic, Archimedean, prisms, and antiprisms are excluded).
  • Prisms and antiprisms - two infinite families of uniform polyhedra: two parallel n-gon faces connected by a ring of squares (prism) or triangles (antiprism).
  • Near-misses - convex solids with faces so close to regular that they read as "correct" at a glance (e.g. the soccer-ball-style truncated icosahedron variants used in geodesic-adjacent design); popular in architecture and fabrication because slightly irregular faces can simplify paneling or tiling.

Symmetry:

A shape has symmetry when it can be rotated or reflected and still look exactly the same - spin a cube 90° around an axis through two opposite faces and you can't tell it moved. The full set of ways a shape can do this is called its symmetry group, and the larger it is, the more interchangeable the shape's faces, edges, and vertices look.

Highly symmetric polyhedra fall into just three of these groups (doubled again with mirror reflections) - part of why the same few base shapes keep recurring in generative work:

  • Tetrahedral symmetry - 12 rotations (24 with reflections); the symmetry of the tetrahedron.
  • Octahedral symmetry - 24 rotations (48 with reflections); shared by the cube and octahedron since they're duals of each other.
  • Icosahedral symmetry - 60 rotations (120 with reflections); shared by the dodecahedron and icosahedron, and the reason icosahedral subdivision is the standard approach for geodesic domes.

A polyhedron's symmetry group also determines whether every vertex looks like every other vertex (isogonal, true of the Platonic and Archimedean solids), every face looks like every other face (isohedral, true of the Platonic and Catalan solids), or every edge looks like every other edge (isotoxal).

Stellation and facetting:

These are dual, opposite operations for generating new polyhedra from existing ones:

  • Stellation - extending a polyhedron's face planes outward until they intersect each other again, producing a larger, usually self-intersecting shape. The four Kepler-Poinsot solids are the only regular stellations of the dodecahedron and icosahedron, but a single seed shape (like the icosahedron) can have dozens of named stellations.
  • Facetting - creating new faces using only a polyhedron's existing vertices, without adding any new ones - effectively "cutting into" the solid rather than extending outward.

Key terms:

  • Face, edge, vertex - the three basic elements of a polyhedron.
  • Euler's formula - V - E + F = 2 for any simple convex polyhedron; a quick sanity check for procedurally generated meshes.
  • Dual polyhedron - swapping faces and vertices produces a shape's dual (cube ↔ octahedron, dodecahedron ↔ icosahedron, tetrahedron ↔ itself).
  • Uniform polyhedron - vertex-transitive with regular polygon faces; covers the Platonic and Archimedean solids, prisms, antiprisms, and their non-convex "star" counterparts.
  • Schläfli symbol - shorthand {p, q} describing a regular polyhedron by its face polygon (p-gon) and how many meet at each vertex (q); star polyhedra use fractions, e.g. {5/2, 5} for the small stellated dodecahedron.
  • Vertex figure - the cross-section shape formed by slicing off a vertex; used to classify uniform polyhedra by which polygons meet there.
  • Convex hull - the smallest convex shape enclosing a set of points; a common generative technique for deriving a convex polyhedron from a symmetric point distribution.

Articles:

Videos:

Notable tools:

  • Stella by Robert Webb - dedicated polyhedra exploration software (Great Stella, Small Stella, Stella4D) supporting stellation, facetting, augmentation, dualization, convex hulls, and printable nets
  • Antiprism by Adrian Rossiter - open-source command-line toolkit for generating, transforming, and converting polyhedra (GitHub)
  • Polyhedronisme by Anselm Levskaya - web app for building polyhedra from a seed shape using Conway polyhedron notation operators

Code projects:

  • polyhedronisme - source code for the Conway-notation polyhedron builder above
  • PolyJS (GitHub) by Matthew Arcus - generates and animates uniform polyhedra and compounds in Three.js using the Wythoff construction
  • Polyhedra (Three.js) by Lee Stemkoski - renders polyhedra using vertex/face data from George Hart's polyhedra encyclopedia
Image

Saffman-Taylor instability

Note

Related to DBM, DLA, differential growth, reaction-diffusion, fluid simulation, Hele-Shaw cells, and Laplace equation

Also known as viscous fingering, this is a fluid dynamics instability that occurs at the interface between two fluids of different viscosity when a less viscous fluid is pushed into a more viscous one - inside a narrow gap such as a Hele-Shaw cell, or through a porous medium. Rather than advancing as a flat front, the interface spontaneously breaks up into branching, finger-like intrusions.

The instability is a positive feedback loop: any small bump that forms on the interface sits in a region of lower flow resistance, so it advances faster than its surroundings, growing further ahead and widening into a finger; the same feedback then acts along the flanks of that finger, splitting its tip and producing a branching structure reminiscent of diffusion-limited aggregation and the dielectric breakdown model. Interfacial tension between the two fluids counteracts this, damping out short-wavelength wrinkles and setting a characteristic finger width - the balance between the two effects selects the fairly regular finger spacing seen in real experiments.

Key terms:

  • Viscous fingering - the common, descriptive name for the same phenomenon.
  • Mobility ratio - ratio between the two fluids' viscosities (or, in a porous medium, permeabilities); the interface is unstable only when the injected fluid is less viscous than the fluid it displaces.
  • Hele-Shaw flow - the mathematical description of flow through the thin gap of a Hele-Shaw cell, from which the instability was originally derived.
  • Interfacial (surface) tension - force resisting curvature of the interface; suppresses high-frequency wrinkles and sets a preferred finger width/wavelength.
  • Tip-splitting - the process by which a growing finger becomes unstable at its own tip and divides into two smaller fingers, driving the fractal branching seen in the radial configuration.
  • Channel vs. radial geometry - the two most common experimental setups: injection along a straight channel typically produces one dominant "Saffman–Taylor finger," while injection from a central point (radial) produces repeated tip-splitting into many fingers.

DIY experiments:

Viscous fingering can be observed with everyday materials without specialized equipment. When two surfaces are slowly peeled or pulled apart with a thin viscous layer (honey, jam, corn syrup, or hand lotion) between them, the less viscous fluid (air) displaces the viscous layer, creating fingerlike flow patterns at the retreating interface. The same effect occurs in setups such as:

  • Slowly peeling apart two wet pieces of paper
  • Separating two wet glass plates or acrylic sheets
  • Pulling apart plastic wrap or film from a surface coated with a viscous substance
  • Lifting a glass plate from a table with a thin layer of honey, oil, or gel underneath

These "peeling" setups exhibit viscous fingering because the viscous fluid resists the air's advance, creating an unstable interface that spontaneously breaks into fingers. This is closely related to the lifted Hele-Shaw cell concept—in both cases, viscous resistance shapes fluid interfaces during separation or displacement, revealing the same underlying physics.

Articles:

Image

Spherical harmonics

Note

Related to Fourier series

Spherical harmonics are a set of special functions defined on the surface of a sphere that form a complete, orthonormal basis - meaning any reasonably well-behaved function over the sphere (e.g. a bumpy radius, a lighting environment, a temperature field) can be reconstructed as a weighted sum of them, in the same way a Fourier series reconstructs a periodic signal from sines and cosines. They arise naturally as the angular part of the solution to Laplace's equation in spherical coordinates, which is why they show up throughout physics wherever spherical symmetry is involved - gravitational and electric potentials, atomic orbitals, geodesy, and the cosmic microwave background.

Each spherical harmonic is indexed by a degree $l$ and an order $m$, and looks like a pattern of positive and negative lobes tiling the sphere; low-degree harmonics vary slowly across the surface (capturing broad, low-frequency features) while higher-degree harmonics oscillate more rapidly (capturing fine detail) - directly analogous to how low vs. high frequency terms behave in a Fourier series. This makes them a useful tool for morphogenesis and shape modeling: an arbitrary blob-like or organic 3D form can be approximated, generated, or smoothly deformed by manipulating just a handful of spherical harmonic coefficients instead of a dense mesh.

Key terms:

  • Degree ($l$) and order ($m$) - indices identifying each spherical harmonic; the degree controls how many nodal lines (angular frequency) a harmonic has, while the order controls their orientation around the polar axis.
  • Legendre polynomials (and associated Legendre functions) - the family of functions used to build the latitude (polar-angle) part of each spherical harmonic.
  • Real vs. complex spherical harmonics - two equivalent bases for the same functions; real harmonics are more common in graphics and engineering, complex ones in quantum mechanics.
  • Multipole expansion - representing a field (gravitational, electric, etc.) as a sum of spherical harmonics weighted by coefficients, ordered from coarse (monopole/dipole) to fine detail.
  • Precomputed radiance transfer (PRT) - computer graphics technique that stores lighting/shading information as a small set of spherical harmonic coefficients for fast, approximate real-time rendering.
  • SPHARM (spherical harmonic shape description) - representing an arbitrary closed 3D surface, such as an organic blob or biological structure, as a set of spherical harmonic coefficients; used for shape analysis, comparison, and generative modeling.

Articles:

Code projects and tools:

Image

Strange attractors

Trajectories of deterministic dynamical systems that exhibit chaotic behavior while remaining confined within a bounded region of space. Unlike ordinary attractors (fixed points or periodic cycles), strange attractors have a fractal structure with infinite detail and display sensitive dependence on initial conditions - tiny differences in starting state lead to wildly divergent outcomes. Despite their deterministic rules, the long-term behavior appears random or turbulent.

Strange attractors emerge in nonlinear systems where feedback loops create complex dynamics. They are "strange" because they combine order (the system never leaves a bounded region) with chaos (unpredictable behavior). They are "attractors" because trajectories from nearby initial conditions are pulled toward them over time. Their fractal dimension is typically non-integer, a hallmark of their geometric complexity.

Strange attractors have been observed in fluid dynamics (turbulence), weather systems (weather chaos), population dynamics, electronic circuits, and more. In generative art and morphogenesis, they are often used to create organic-looking, intricate patterns and forms that would be difficult or impossible to design by hand. The self-similar, fractal-like structures they produce can simulate natural phenomena like cloud formations, terrain, and biological branching patterns.

Key terms:

  • Attractor - a set of states (points in phase space) toward which a dynamical system evolves, regardless of initial conditions. Non-strange attractors include fixed points and periodic orbits.
  • Phase space - an abstract mathematical space where each point represents a possible state of the system; trajectories trace the system's evolution through this space.
  • Chaos / Chaotic behavior - deterministic evolution that is sensitive to initial conditions; small perturbations grow exponentially, making long-term prediction impossible even though the system is not random.
  • Sensitive dependence on initial conditions - the hallmark of chaos; trajectories starting arbitrarily close together diverge exponentially fast. Related to the concept of the Lyapunov exponent.
  • Fractal structure - strange attractors typically have infinite detail at all scales, with a non-integer (fractal) dimension.
  • Basin of attraction - the set of initial conditions from which trajectories are drawn to a particular attractor.
  • Bifurcation - a qualitative change in system behavior as a parameter varies; can lead to onset of chaos or transition between different types of attractors.

Notable attractors:

Articles:

Image

Superellipse

Also known as the Lamé curve, this equation describes a closed curve that can generate shapes that look like pinched or inflated ellipses. At the extremes of the parameter space the shapes can range from an outline of a plus (+) symbol to a nearly rectangular shape with rounded corners.

Equations:

General form $\left|\frac{x}{a}\right|^{n} + \left|\frac{y}{b}\right|^{n} = 1$
Parametric $x(t)=\pm a\cos^{\frac{2}{n}}t,\quad y(t)=\pm b\sin^{\frac{2}{n}}t,\quad 0\leq t\leq\frac{\pi}{2}$

Articles:

Videos:

Image

Superformula

Generalized version of the superellipse formula proposed by Johan Giellis around 2000, capable of far more variety than the original superellipse. Unfortunately, Johan has patented use of the formula (via his company Genicap) in both the US and the EU, which means you should avoid using it for any kind of commercial work, or work that could be commercialized in some way later.

The superformula can be used to generate both 2D and 3D forms. To create 2D forms, use the general form equation to obtain polar coordinates that can be converted into Cartesian coordinates for drawing on a screen. To create 3D forms, compute the polar coordinates for two 2D supershapes, then "mix" them together using the 3D equations below.

Equations:

General form $r(\varphi) = \left(\left|\frac{\cos(m_1\varphi/4)}{a}\right|^{n_2} + \left|\frac{\sin(m_2\varphi/4)}{b}\right|^{n_3}\right)^{-1/n_1}$
3D equations $x=r_1(\theta)\cos\theta\cdot r_2(\varphi)\cos\varphi,\quad y=r_1(\theta)\sin\theta\cdot r_2(\varphi)\cos\varphi,\quad z=r_2(\varphi)\sin\varphi$

Where r is a radius and φ (phi) is an angle.

Where φ (latitude) varies between −π/2 and π/2 and θ (longitude) between −π and π.

Articles:

Code projects:

Videos:

Image

Tiling / tessellation

Note

Related to polyhedra, Wave Function Collapse (WFC), and Delaunay triangulation and Voronoi diagrams.

A tiling (or tessellation) is a covering of a plane, or other surface, by one or more shapes ("tiles") with no gaps and no overlaps. Like polyhedra, tilings are a design space defined by a small set of construction rules, which makes them a reliable source of "correct-looking" repeating patterns for generative art, procedural texture generation, and physical fabrication (laser-cut panels, tiled floors, quilting).

Key concepts:

  • Periodic vs. aperiodic - periodic tilings repeat via simple translation, so a single finite patch can tile the whole plane; aperiodic tilings (like Penrose tilings) never repeat via translation alone, no matter how far you zoom out.
  • Regular and semi-regular tilings - the 2D analog of Platonic and Archimedean solids: 3 regular tilings (one type of regular polygon) and 8 semi-regular tilings (2+ types), each with an identical arrangement of polygons at every vertex.
  • Symmetry (wallpaper groups) - every repeating 2D pattern falls into one of exactly 17 wallpaper groups, based on which combination of translations, rotations, reflections, and glide reflections leave the pattern looking unchanged.
  • Substitution tilings - built by repeatedly subdividing each tile into smaller copies of the same prototile set according to a fixed rule; many aperiodic tilings, including Penrose's, can be generated this way.

Notable named tilings:

  • Penrose tiling - the best-known aperiodic tiling, built from just two prototiles (kite & dart, or two rhombi) related by the golden ratio.
  • Wang tiles - square tiles with colored edges that must match their neighbors, with no rotation allowed in the original formalism; widely used in computer graphics for generating large, non-repetitive textures, height fields, and point distributions from a small tile set.
  • Truchet tiles - simple square tiles (split diagonally, or decorated with quarter-circle arcs) that, placed in random orientations, produce intricate maze-like or flowing patterns; a long-running favorite in generative art, first described by Sébastien Truchet in 1704.
  • The Hat and Spectre - the first known aperiodic monotiles ("einsteins"), discovered in 2023 by David Smith, Craig Kaplan, Joseph Myers, and Chaim Goodman-Strauss. Each forces aperiodicity using a single tile shape and no matching rules, resolving a problem that had been open since the 1960s.
  • Isohedral (Escher-style) tilings - tilings where every tile is equivalent to every other tile under the pattern's symmetries; the class M.C. Escher's interlocking animal and figure tessellations belong to.

Key terms:

  • Prototile - one of the shape(s) allowed in a tiling; a monotile is a tiling that uses just one.
  • Edge-to-edge - a tiling where tiles only ever share a full edge with a neighbor, never a partial one.
  • Vertex configuration - the cyclic sequence of polygon types meeting at a vertex, e.g. 3.6.3.6 for a triangle-hexagon-triangle-hexagon arrangement.
  • Matching rules - markings or notches added to prototiles that forbid periodic arrangements; used by some, but not all, aperiodic tilings to enforce non-repetition.

Articles:

Videos:

Notable tools:

  • Tactile.js by Craig Kaplan - JavaScript library for representing, manipulating, and drawing Escher-style isohedral tilings (C++ version)
  • Pattern Collider by Aatish Bhatia - interactive web tool for exploring quasiperiodic tilings, including Penrose and the Hat/Spectre monotiles
  • Penrose by Carnegie Mellon University - web-based tool that creates images from text notation. (Github repo)

Code projects:

  • Penrose.js - pure JavaScript library for generating Penrose tilings, rendered to canvas or bitmap
  • Pattern Collider - source code for the interactive tool above

Image

Travelling salesman problem (TSP)

Asks the question "Given a list of cities and the distances between each pair of cities, what is the shortest possible route that visits each city and returns to the origin city?" This classic problem is computer science classrooms to teach algorithm design and optimization techniques.

Useful for creating single-line drawings for use with pen plotters, laser cutters, CNC machines, and more.

Articles:

Notable software:

Image

Verlet physics

Note

Related to physics engines and particle systems.

Image credit: Matthew Fisher - Cloth

Family of numerical integration methods for simulating motion that skip storing velocity explicitly, instead deriving it implicitly from a particle's current and previous position. Named after French physicist Loup Verlet, who used it for molecular dynamics simulations in the 1960s, though the technique dates back further.

At each step, a particle's next position is calculated from its current position, its previous position, and the acceleration currently acting on it:

newPosition = 2 * currentPosition - previousPosition + acceleration * timeStep^2

Because positions - not velocities - are what's being directly manipulated, distance constraints (like the fixed-length "sticks" connecting particles in a rope, cloth, or soft body) can be enforced by simply nudging connected particles toward or away from each other until the constraint is satisfied, without separately tracking or adjusting velocity. This makes Verlet integration especially popular for simulating chains, cloth, ragdolls, and other constraint-based systems in games, creative coding, and animation - and it forms the conceptual basis for the more general Position Based Dynamics approach used in many modern physics engines.

Key terms:

  • Implicit velocity - since a particle's velocity is never stored directly, it can be recovered as the difference between its current and previous position.
  • Distance constraint - a rule (often visualized as a "stick") requiring two particles to stay a certain distance apart; satisfied directly by moving positions rather than applying forces.
  • Position Based Dynamics (PBD) - generalization of Verlet-style constraint solving into a broader framework for simulating cloth, rigid bodies, fluids, and more.
  • Numerical stability - Verlet integration is more stable than simple Euler integration over long simulations, since it approximately conserves energy.

Articles:

Videos:

  • ToxicLibs Verlet Physics video series by Daniel Shiffman (The Coding Train) - covers particles, springs, connected systems, and attraction behaviors in Processing with toxiclibs.js

Notable tools:

  • Vellum - Houdini's unified solver for cloth, hair, grains, and softbodies, built on an extended Position Based Dynamics approach
  • ChaosCloth - Unreal Engine's built-in cloth solver, also based on Position Based Dynamics
  • Obi (Unity asset) by Virtual Method - rope, cloth, softbody, and fluid simulation using an XPBD (Extended Position Based Dynamics) solver

Code projects:

  • toxiclibs VerletPhysics (Processing/Java addon) by Karsten Schmidt
  • toxiclibsjs (JavaScript/p5.js port of toxiclibs, including its VerletPhysics2D/3D package) by Kyle Phillips (hapticdata)
  • ofxMSAPhysics (openFrameworks addon, C++) by Memo Akten - particle/constraint physics library explicitly modeled on the same approach described in Jakobsen's article above
  • Rope and Cloth Simulation (p5.js) by Aryaman - tearable rope/cloth demo with wind and collisions

Lab experiments

Image

Belousov–Zhabotinsky (BZ) reaction

Oscillating chemical reaction that can produce complex, regularly-spaced shapes that intersect (combining or cancelling) in predictable ways. The actual chemical reaction is very complex and is thought to involve around 18 distinct steps; the original discoverers struggled to get their work published because of their difficulties in explaining the underlying mechanisms of this reaction!

It may be possible to simulate this reaction, at least superficially, using either reaction-diffusion systems or cellular automata (see the Hodgepodge Machine specifically).

Basic petri dish setup:

  1. Gather reactants: malonic acid, potassium bromate, sulfuric acid, and an indicator dye (typically ferroin, which shifts between blue and red).
  2. Mix the reactants in specific proportions (see Nigel Baldwin's videos below for exact ratios).
  3. Pour the mixed solution into a shallow petri dish or watch glass.
  4. Leave undisturbed to allow the reaction to begin.
  5. Within minutes, concentric rings or spiral waves of color will form and propagate across the dish.
  6. Observe the patterns oscillating between blue and red states as the chemical reaction continues.
  7. The reaction typically persists for 30 minutes to several hours depending on conditions and reagent concentrations.

For detailed preparation procedures and exact chemical ratios, consult the video references below - particularly Nigel Baldwin's two-part preparation series.

Articles:

Code projects:

Videos:

Image

Chladni plate

Apparatus consisting of a suspended metal plate covered in a light dusting of fine sand or powder, then vibrated by either a bow or a voice coil (speaker). Beautiful, consistent nodal patterns known as Chladni figures emerge based on the specific resonance characteristics of the plate and the frequency of vibration inducued in it. Different sizes, shapes, and thicknesses of plates create different patterns, as do different frequencies, vibration methods, and audio samples.

Examples of Chladni figures: Image

Articles:

DIY projects:

Products:

Due to its popularity as a demonstration aid in science classrooms, good-quaity Chladni plate's are available from multiple dealers including:

Videos:

Image

Hele-Shaw cell

Note

Related to Saffman-Taylor instability.

Apparatus for demonstrating and studying a pheonmenon known as viscous fingering (a.k.a. Saffman-Taylor instability), which is defined as "the formation of patterns in a morphologically unstable interface between two fluids in a porous medium" [1]. It occurs when a less viscous fluid is injected into a more viscous fluid, displacing it in a series of blobby, fractal-like fingers resembling (perhaps related to) the patterns formed by diffusion-limited aggregation or differential growth.

Setup:

The Hele-Shaw cell typically consists of two plates, usually glass or plexiglass, separated by a very narrow gap (typically 0.5 to 2 mm). The small gap constrains fluid flow to approximately 2D motion, allowing viscous fingering patterns to emerge clearly.

Procedure:

  1. Seal the edges of the two plates together, leaving injection points open.
  2. Fill the cell with a viscous fluid such as glycerin or silicone oil.
  3. Inject a less viscous fluid (such as colored water or dyed oil) through a hole in one of the plates or between the plates from the side.
  4. As pressure builds from the injection, the less viscous fluid displaces the glycerin, but the viscous resistance creates an unstable interface.
  5. Complex, branching finger-like patterns form and propagate across the gap between the fluids.
  6. For better visualization, illuminate the cell from underneath, shining light through toward the viewer. The contrast between fluids makes the fingering patterns clearly visible.

Lifted Hele-Shaw cells:

A variant called a "lifted" or "tilted" Hele-Shaw cell involves rotating or lifting the cell at an angle during the experiment. This introduces gravitational and buoyancy effects that modify the viscous fingering patterns, creating asymmetrical or spiral-like flow patterns instead of the symmetric branching seen in vertical cells. This technique reveals how gravity influences fluid dynamics and pattern formation.

Articles:

Videos:

Images:

Image

Schlieren imaging

Technique for visualizing density variations in transparent media, usually air. Essentially exaggerates the effects of refraction in different densities of air caused by heat (hot air expands, cool air contracts) or pressure (like ultrasonic transducers). Effect can be observed using just a few low-cost components:

  1. Concave mirror with a long focal length (3-4ft or more) - spherical mirrors work best, but parabolic mirrors can work
  2. Point light source - the brightest, smallest light source you can find/make. Lasers don't work well, but a simple LED with a pinhole cover or a strand of fiber optic will work. Doesn't need to be very bright.
  3. Razor blade or color filter
  4. Camera

Diagram of typical setup:

Image

Articles:

DIY projects:

Videos:


Useful code patterns and techniques

Image

Agent-based modelling

Methods for simulating the actions and interactions of autonomous entities and the complex emergent behavior they exhibit collectively. Used for simulating and analyzing collective social and biological phenomena like flocking animals (e.g. birds or fish), colony behaviors (e.g. ants and termites), crowd movement, and more.

This topic has a lot in common with the related topic of multi-agent systems, but with a different intent. Agent-based models tend to seek explanatory insight into the collective behavior of agents (often real-world organisms or systems), whereas multi-agent systems tend to be more focused on solving practical or engineering problems through optimization of the design of agents.

Insights from this topic can be directly applicable in large-scale kinetic art or LED installations, swarm robotics research, architecture, and city planning.

Characteristics of agent-based models relevant to biological modelling [1]:

  1. Modular structure: The behavior of an agent-based model is defined by the rules of its agents. Existing agent rules can be modified or new agents can be added without having to modify the entire model.
  2. Emergent properties: Through the use of the individual agents that interact locally with rules of behavior, agent-based models result in a synergy that leads to a higher level whole with much more intricate behavior than those of each individual agent.
  3. Abstraction: Either by excluding non-essential details or when details are not available, agent-based models can be constructed in the absence of complete knowledge of the system under study. This allows the model to be as simple and verifiable as possible.
  4. Stochasticity: Biological systems exhibit behavior that appears to be random. The probability of a particular behavior can be determined for a system as a whole and then be translated into rules for the individual agents.

Notables systems:

Articles:

Image

Boids

Note

Related to agent-based modelling.

Well-known type of agent-based system that realistically simulates the complex flocking behaviors of birds and fish using simple rules. Each "boid" is an autonomous agent that is only aware of its immediate neighbor boids, all following the same three rules:

  1. Separation (collision avoidance): steer to avoid crowding local flockmates
  2. Alignment (velocity matching): steer towards the average heading of local flockmates
    • Note: remember that a vector is a combination of a speed and a direction (heading)!
  3. Cohesion (flock centering): steer to move towards the average position (center of mass) of local flockmates

And here is what those rules look like when applied to a set of agents (boids):

Separation Alignment Cohesion
Image Image Image

Additional rules can be implemented to simulate specific behaviors like obstacle avoidance, predator-prey interactions, bait balls, and more.

Articles:

Code projects:

Videos:

Image

Constructive solid geometry (CSG)

Technique for 3D solid modeling that allows for the creation of complex surfaces by using Boolean operators to combine simpler objects (usually primitives like cubes, spheres, cylinders, etc). Most CAD and 3D modeling applications (like Blender, Fusion, Rhino, and more) include CSG operations, sometimes even through parametric or procedural interfaces.

Operations:

Name Descriptionn Illustration
Union Merger of two objects into one Image
Difference Subtraction of one object from another Image
Intersection Portion common to both objects Image

Articles:

Code projects:

Image

Cloth simulation

Note

Related to verlet physics, particle systems, and physics engines.

Image credit: Isabel Zhang - Project 4: Cloth Simulator

Real-time simulation of cloth dynamics - how fabric bends, stretches, folds, and interacts with collisions and external forces like wind and gravity. Most cloth solvers model cloth as a mesh of particles connected by distance constraints (springs), typically using Verlet integration or Position Based Dynamics for stability and speed. The mesh deforms and settles as constraint-based solvers iteratively push connected particles toward their rest distances, while collisions are handled by detecting and pushing cloth away from obstacles.

Cloth simulation is essential for character animation, VFX, and any scenario requiring realistic fabric behavior without pre-baked animation. It scales from interactive real-time performance in games to high-quality offline rendering in film and animation.

Algorithm at a glance:

* indicates a potential simulation parameter

  1. Create a mesh of particles (one per vertex), each with mass*, position, and velocity.
  2. Connect neighboring particles with distance constraints (structural, shear, and optionally bend constraints*) representing fabric stiffness.
  3. Each frame, apply forces* (gravity, wind, damping) to all particles.
  4. Update particle positions using Verlet integration or similar.
  5. Repeatedly satisfy constraints: for each constraint, if the distance between two particles deviates from the rest length, nudge them toward the target distance.
  6. Optionally, check each constraint against a breaking threshold* (e.g., how much it can stretch before tearing); if exceeded, remove the constraint to simulate ripping or tearing.
  7. Detect collisions with rigid bodies and other geometry, and reposition particles to prevent penetration.
  8. Repeat until the cloth settles or the simulation ends.

Key terms:

  • Structural constraint - distance constraint along the fabric's grid edges, prevents stretching.
  • Shear constraint - diagonal distance constraint, prevents skewing and distortion.
  • Bend constraint - constraint between particles separated by one edge, prevents unrealistic folding.
  • Damping - friction-like force that slows particle motion over time, helps cloth settle faster.
  • Self-collision - cloth colliding with itself; necessary for realistic folding and wrapping.
  • Constraint breaking / tearing - removal of constraints when they exceed a strain threshold*, allowing cloth to rip and tear when stretched too far; can also be triggered by collision impact.

Articles:

Videos:

Notable tools:

  • Obi Cloth (Unity asset) by Virtual Method - high-quality cloth simulation with character clothing, two-way rigidbody interaction, and aerodynamics
  • Vellum (Houdini solver) by SideFX - unified cloth/hair/grain solver using Position Based Dynamics

Code projects:

  • Cloth Simulation (p5.js) by Aryaman - interactive tearable cloth demo with wind and collisions
Image

Collision detection

Computational methods for determining when two or more shapes are intersecting either statically (right now) or predictively (in the future). In technical terms, a posterior and a priori respectively. Detecting and reacting to collisions is extremely important in videos games and physical simulations, and takes quite a lot of brains and computational muscle to do effectively in real-time, especially in large-scale systems.

Building your own collision detection code is a fun and educational exercise, but is so complex and difficult to achieve in practice that it is generally a good idea to use an establisihed physics library or VFX/modelling application for performance. See the Physics engine and Tools sections for options.

Relevant topics:

Articles:

Books:

Image

Dithering

Note

Related to convolution kernel.

In an image using a limited color palette, dithering can provide an illusion of a continuous gradient, or a field of color not in the palette. Using colors that are close to the target color, the technique applies a granular pattern of varying sizes and spacing of solid, single-color dots or lines. The human eye then interpolates between the colors at a larger scale.

Some techniques (like halftones) predate modern digital technologies because of their usefulness in traditional printmaking and engraving processes. There are even relevant techniques in the fields of painting and drawing; see stippling and pointillism! In digital imaging, modern palettes are usually comprehensive enough to reach a satisfactory visual fidelity for general purposes, but limits are still often reached in professional contexts.

Dithering is useful for realizing grayscale images with various digital fabrication equipment like laser cutters, pen plotters, CNC routers/mills, and more.

Types of dithering:

  • Random
  • Patterned
  • Ordered
    • Halftone ⭐
    • Bayer matrix
    • Blue noise matrix
  • Error-diffusion
    • Floyd-Steinberg ⭐
    • Minimized average error
    • Stucki
    • Burkes
    • Sierra
    • Two-row Sierra
    • Filter Lite
    • Atkinson
    • Gradient-based error-diffusion

Articles:

Code projects:

Image

Flow field

Note

Related to fluid simulation.

Also known as a vector field, this technique involves assigning a unique vector to each point in a 2D or 3D space describing the direction and magnitude of varying forces. Flow fields are often used together with particle systems to model complex, dynamic movement caused by wind, fluid flow, electromagnetism, and more.

Vector fields are often populated using data generated with noise or image data. Curiously, flow fields have also been used in pathfinding.

Articles:

Code projects:

  • ofxVectorField (openFrameworks add-on) by Jeremy Rotzstain (mantissa)

Videos:

Image

Fluid simulation

Note

Related to convolution kernels, Laplace equation, and Saffman–Taylor instability.

Simulates the highly complex and dynamic nature of flows in fluid volumes using computationally-efficient implementations of the Navier-Stokes equations. Can be thought of as a 2D or 3D flow field that is constantly changing based on the velocity, viscocity, and density of the fluid at each point in space and its surrounding area. This flow field is made visible through the use of digital "dyes" (usually particles) that get distributed, diffused, sheared, and blended through the system by the flow forces.

To appear realistic it is necessary for these simulations to have high fidelity, which introduces significant computational challenges, especially if one wants to run the simulation in real-time. Luckily, there are several great code packages available, and many VFX, CAD, and game development tools like Blender, Houdini, Unity and Unreal include robust fluid simulation functionality built in or available through plugins.

Fluid simulation has many practical and visual applications across a variety of disciplines. Its used in the analysis of aerodynamic properties of objects, vehicles, and buildings, in weather simulation and prediction, engine and combustion analysis, industrial systems design and analysis (plumbing, HVAC, public utilities, etc), visual effects for TV, movies, and games, and more.

Related terms:

  • FLIP (FLuid Simulation Using Implicit Particles) method
  • PIC (Particle in Cell) method
  • Reynolds number (Re) - dimensionless quantity used to predict fluid flow patterns. Laminar (smooth) flow occurs at low Re, while turbulent flow occurs at high Re.
  • Navier-Stokes equations on Wikipedia
  • Lattice Boltzmann methods (LBM) on Wikipedia
  • Rheology - branch of physics which deals with the deformation and flow of materials, both solids and liquids

Articles and papers:

Books:

Code projects:

Notable tools:

Videos:

Image

Kernel-based image processing

Note

Related to convolution kernel.

Image credit: Hrithik Patel - Kernels and Their Usage in Convolutional Neural Networks (CNN).

Applying convolution kernels to images for filtering and feature extraction. Each pixel's new value is computed as a weighted sum of its neighborhood, determined by the kernel matrix. This is one of the most practical and widely-used techniques in digital image processing.

Common image processing effects:

Effect Purpose Kernel Example
Edge detection (Sobel) Detect boundaries between regions 
-1  0  1
-2  0  2
-1  0  1
 Image
Sharpen Enhance edges and details 
0 -1  0
-1 5 -1
0 -1  0
 Image
Box blur Simple averaging blur 
(1/9) ×
1 1 1
1 1 1
1 1 1
 Image
Gaussian blur Smooth blur, weighted toward center 
(1/16) ×
1  2  1
2  4  2
1  2  1
 Image
Unsharp mask Enhance sharpness and clarity 
0 -1  0
-1 5 -1
0 -1  0
 Image
Emboss 3D relief effect 
-2 -1  0
-1  1  1
 0  1  2
 N/A

Key implementation considerations:

  • Boundary handling - what happens at image edges (zero-padding, reflection, wrapping, shrinking)
  • Kernel normalization - dividing by kernel sum to preserve image brightness
  • Separable kernels - 2D kernels that can be decomposed into two 1D operations for faster computation
  • GPU acceleration - fragment shaders and compute shaders can apply kernels in parallel across many pixels
  • Fixed-point math - integer-only math for embedded systems or performance-critical code

Articles:

Notable tools and libraries:

  • OpenCV (C++, Python, JavaScript) - comprehensive image processing with custom kernels
  • scikit-image (Python) - filters, morphology, edge detection
  • PIL/Pillow (Python) - ImageFilter module with predefined and custom kernels
  • GIMP - manual convolution filter tool (Filters > Generic > Convolution Matrix)
  • Three.js postprocessing (JavaScript) - GPU-based kernel effects
  • ImageMagick - command-line tool with -morphology and -convolve operations
Image

Lloyd's relaxation

Note

Related to voronoi diagrams.

As explained by Jason Davies, Lloyd’s relaxation algorithm (named after Stuart P. Lloyd) generates a centroidal Voronoi tessellation, which is where the seed point for each Voronoi region is also its centroid.

The algorithm computes the Voronoi diagram for a set of points, moves each point towards the centroid of its Voronoi region, and repeats.

Important concepts:

  • Convergence - every point that is being "relaxed" is moving towards the center point of a Voronoi cell, but due to computational limits in numerical precision it may not ever perfectly reach it. Therefore it is a good idea to use some sort of preset distance threshold value that causes points to stop moving once they are close enough to their target point.

Articles:

Code projects:

Image

Marching squares

Method of generating contours for a 2D scalar field (a grid of individual numerical values), like turning elevation data into a banded topographical map. The scalar values get associated with vertices of the 2D grid, then lines are drawn across each cell in different ways based on the values of their four corner vertices.

There is only a finite number of lines possible, so they can be precomputed into a lookup table and referenced quickly later for faster performance. These lines can also be linearly interpolated to smoothly transition from cell to cell, resulting in very realistic blobby / fluid structures.

Key terms:

  • Isoline - contour line tracing a single data level, or isovalue.
  • Isoband - filled area between isolines.

Illustration of algorithm:

Image

Articles:

Code projects:

Videos:

Image

Marching cubes

3D version of marching squares. Whereas marching squares uses lines and cells to trace the contours of a 2D scalar field, marching cubes uses polygons and voxels to trace the contours of a 3D scalar field, resulting in a mesh. Marching cubes can be thought of as a mesh conversion algorithm that produces meshes based on 3D scalar fields.

Originally developed by William Lorensen and Harvey Cline of General Electric in 1987 (see original paper in Articles section) for use in the medical imaging (MRI/CT) field, this algorithm has become widely used in many areas of computer graphics.

Dual marching cubes:

A variant called dual marching cubes (PDF) reverses the role of vertices and cells: instead of placing vertices on cube edges, it places vertices at voxel centers and connects them based on neighboring voxel values. This approach can reduce polygon count, better handle ambiguous cases at isovalue boundaries, and eliminate certain artifacts that appear in standard marching cubes. Dual marching cubes is particularly useful when a cleaner, more regular mesh is desired.

Algorithm [link]:

The algorithm proceeds through the scalar field, taking eight neighbor locations at a time (thus forming an imaginary cube), then determining the polygon(s) needed to represent the part of the isosurface that passes through this cube. The individual polygons are then fused into the desired surface.

  1. Choose a threshold (called an isovalue) to determine which level of values are considered inside or outside the mesh, thus setting where the mesh boundary is created.
  2. Pre-compute an array of all 256 (2^8) possible polygon configurations within a cube, where each entry is a set of IDs associated with edges of the cube (see Figure B below).
    • Note that of these 256 configurations, only 15 are unique due to repetition and symmetry (see Figure A below).
  3. For each set of 8 scalar values (forming a cube), compute an 8-bit integer where each bit corresponds to a unique scalar value (corner of the cube).
    • If the scalar value is higher than the isovalue (i.e. inside of mesh), set bit to 1
    • If lower, set bit to 0
  4. Generate polygons for each set of scalar values by drawing lines between the edges referenced in the polygon lookup table from step 2.
    • To do this, parse the 8 bits from step 3 into an integer, then use that integer as an index in the lookup table.
    • For example 00101001 = 41. Therefore the list of edges to draw lines between can be found in lookupTable[41].
  5. Each vertex of the generated polygons is placed on the appropriate position along the cube's edge by linearly interpolating the two scalar values that are connected by that edge.
  6. Calculate normals - TODO: how?
  7. Perform boolean union with all polygon fragments to form a mesh
(Figure A) diagram of 15 possible polygon configurations based on vertex bit values (Figure B) diagram of edge and vertex numbering
Image Image

Key terms:

  • Isosurface - surface that represents points of a constant value within a volume of space

Articles:

Videos:

Image

Metaballs

Note

Related to implicit surfaces, marching squares (2D) and marching cubes (3D).

Often confused with marching cubes, this is more of a mathematical concept that describes a way to define the values in 2D or 3D scalar fields based on distance to one or more points in space. They are a type of implicit surface that define blobby shapes as pure mathematical formulas rather than explicit polygons and vertices.

They can be visualized using the marching squares (2D) or marching cubes (3D) rendering algorithms. Can be used for naive fluid simulations by applying physics to the metaball center points as if they were particles. They can also be helpful in modelling soft bodies by adding elastic constraints between the center points.

A typical function chosen for metaballs is:

$$f(x,y,z) = \frac{1}{(x-x_0)^2 + (y-y_0)^2 + (z-z_0)^2}$$

Where $(x_0, y_0, z_0)$ is the center of the metaball.

Articles:

Videos:

Image

Noise

Note

Related to convolution kernel.

In the context of computer graphics, refers to pseudo-random functions useful for creating natural-looking textures and patterns. Often used to procedurally generate organic surface textures (bark, waves, rocks, etc) and to organically distribute objects across surfaces (like grass or barnacles).

Useful for adding fine details and smooth asymmetry to otherwise pristine objects - use it in displacement maps for subtle natural features.

Also helpful for creating looping animations because reproducable results can be achieved when using the same function inputs. Just iterate through a series of cyclical values (perhaps even based on frame count) and you'll end up with smoothly transitioning noise that can be mixed in with geometry, colors, and transformations that continuously loop.

The noise() function in many creative coding frameworks usually makes use of Perlin noise.

  • Curl noise - produces swirling, rotational motion patterns useful for simulating vortices, flowing fluids, and turbulent effects without the computational cost of a full physics simulation (see Curl-Noise for Procedural Fluid Flow (PDF) by Robert Bridson et al.)
  • Gradient noise - created by interpolation of a lattice of pseudorandom gradients
    • Perlin noise ⭐ - extremely influential type of gradient noise developed by Ken Perlin in 1983
  • Simplex noise - method for constructing an n-dimensional noise function comparable to Perlin noise
  • Simuation noise - function that creates a divergence-free field
  • Value noise - created by interpolation of a lattice of pseudorandom values; differs from gradient noise
  • Wavelet noise - alternative to Perlin noise which reduces problems of aliasing and detail loss
  • Worley noise - noise function introduced by Steven Worley in 1996

Articles:

  • Noise chapter in The Book of Shaders by Patricio Gonzalez Vivo & Jen Lowe

Videos:

Notable implementations:

Code projects:

Image

Particle system

Collection of independent objects (often points, shapes, images/sprites/textures, or meshes) called particles that are manipulated using dynamic forces and constraints to simulate a wide variety of natural phenomenon like fire, smoke/fog/clouds, fluids, bubbles, and so much more. Often combined with clever visual effects like transparency, blending, and light emission to create the appearance of a coherent but ever-changing entity.

Particle systems are most useful when they can handle large quantities of particles, which means that performance and smart memory management is very important. Like collision detection, building your own particle system can be fun and educational, but if you need to achieve something complex at a large scale and/or with high framerates then it's definitely a good idea to leverage dedicated libraries and tools. Many physics engines come with well-made particle systems out of necessity so be sure to consider them even if you don't need all the fun physics functionality.

Articles:

Notable software:

Image

Physics engine

Note

Related topics include collision detection and particle systems.

Simulates the movements and reactions of objects using real-world concepts like mass, velocity, constraints, and forces (like drag, gravity, and friction). Makes use of extremely optimized algorithms for collision detection, physics calculations, geometry management, and more.

Articles:

Notable open-source libraries:

Commercial libraries:

  • PhysX by Nvidia. Integrated into both Unity and Unreal. Technically open-source now, but oriented more towards commercial/industry applications.
  • Havok

If you're looking to do physical-based simulations, also take a look at game development and VFX environments like Unity, Unreal, and Houdini for their built-in physics engines.

Image

Polygon clipping

Effectively a Boolean intersection operation that "clips" (removes) parts of one polygon that are outside of another polygon. This can be useful when working with geospatial datasets and vector graphics (like SVGs), which in turn make this useful for plotter artists.

Algorithms:

Code projects:

Image

Ray tracing

Rendering technique used to create photorealistic images of 3D scenes by tracing the path of individual light rays. Rather than simulate all light rays' journeys from every light source to the camera, only the light rays that actually reach the camera are simulated.

For each pixel of the screen, a ray is cast into the scene until it hits an object. Based on the scene's lighting and the material properties of the hit object, a color value is calculated for the corresponding screen pixel. Using the angle of the specific triangle that was hit along with material properties like surface roughness, refraction, diffusion, one can also determine what direction that light ray must have come from, tracing that path and incorporating it's color information into the pixel color calculation.

The number of "bounces" examined can increase the photorealism of the resulting image, at the cost of computational resources / time.

This process is extremely computationally expensive, so it has historically only been used in pre-rendered applications like movies, animations, and still images. However, recent advancements in graphics card technology (like NVIDIA's RTX series) are beginning to make this technique available in real-time applications.

Image

Articles:

Code projects:

Image

Recursion

Note

Related to recursion.

Method of solving a problem where the solution depends on solutions to smaller instances of the same problem (as opposed to iteration). In programming terms, recursion is when a function calls itself during execution. Recursion is fundamentally connected to the concept of fractals.

Example: computing factorial

function factorialize(n) {
  if(n < 0) {
    return -1;
  } else if(n == 0) {
    return 1;
  } else {
    return n * factorialize(n - 1);
  }
}

Articles:

Shaders

Shaders are programs that are run on the GPU when processing a certain unit of rendering, usually vertices or pixels/fragments; they allow rendering programmers to manipulate their rendering output in any way they see fit.

While shaders, as the name implies, were originally conceived to allow different kinds of lighting/shading calculations, today they're used for a variety of things from lighting calculation through stylized rendering to 2D compositing or post-processing, and even complex geometry manipulations and particle effects.

Types of shaders:

Key concepts:

  • FBO (framebuffer object)
  • GPGPU (general-purpose computing on GPUs) - the concept of using the GPU to perform computation
  • Ping pong - technique in which the output texture of one shader is fed to another shader as an input, sometimes cycling back and forth multiple times. The final texture gets sent to the display, then the shaders are swapped so that the most recent output becomes the input to the next iteration.
  • Render to texture (RTT) - instead of rendering a scene to the screen, in this technique it is rendered to an "offscreen" texture that can be reused later.
  • Shading language
  • Textures
  • Uniform - a type qualifier indicating a read-only variable passed to a shader from the CPU side of the program. These values will not change within a draw call, and are available to every shader that declares it.
  • Varying - a type qualifier indicating a variable that can change within the vertex shader, then passed to the fragment shader as a read-only value.

Languages:

Articles:

Code tools:

Videos:

Signed distance function (SDFs)

Note

Related to implicit surfaces.

A function that returns the distance between a point in space to a mathematically/algorithmically defined surface (called an implicit surface). This allows algorithms like raymarching and marching cubes to efficiently render complex 3D surfaces in 2D.

SDFs are increasingly commonly used in computer art, where defining an SDF that describes a large 3D scene entirely in a single pixel shader allows the code to be ran entirely on the GPU.

Articles:

Notable open-source libraries:

Videos:

Image

Soft-body physics

Note

Related to mass-spring systems, cloth simulation, Verlet physics, and physics engines.

Image credit: CoppeliaSim docs - Physics engine differences

Soft-body physics is the applied, real-time counterpart to mass-spring systems: simulating volumetric objects - rubber, flesh, jelly, foam, organs - that deform under force and recover their shape rather than staying rigid. Unlike cloth simulation, which models thin 2D sheets, soft-body solvers operate on 3D volumes (tetrahedral meshes, voxel grids, or particle clouds) and must resist compression as well as stretching, giving deformable objects a sense of internal volume and squishiness.

Several families of techniques compete for this problem, each trading accuracy for speed differently:

  • Mass-spring - the volumetric extension of mass-spring systems: tetrahedral or lattice structures of point masses connected by springs. Fast and simple, but prone to visible artifacts (bulging, asymmetric stretching) since spring networks don't perfectly capture rotational/volumetric behavior.
  • Finite Element Method (FEM) - discretizes the body into tetrahedral elements and solves continuum-mechanics stress/strain equations directly, giving physically accurate results at higher computational cost. Common in engineering, biomechanics, and high-end VFX.
  • Shape matching - a meshless technique that computes a "goal" rigid/deformed shape for a cluster of particles each frame and pulls particles toward it; cheap, stable, and popular in games.
  • Position Based Dynamics (PBD) / XPBD - treats constraints (distance, volume, bending) as positional corrections solved iteratively rather than forces, which is unconditionally stable and easy to combine with cloth, rigid bodies, and fluids in one solver. XPBD adds proper stiffness independent of iteration count and time step.

Key terms:

  • Tetrahedral mesh - the volumetric equivalent of a triangle mesh; most FEM and volumetric mass-spring solvers discretize a soft body into tetrahedra.
  • Volume constraint - a constraint that resists compression/expansion of a tetrahedron or cell, preventing unrealistic "deflating" under stress.
  • Stress and strain - core FEM quantities describing internal forces and deformation, related through a material's stiffness (its constitutive model).
  • Shape matching - fitting a rigid or affine transform to a rest-shape point cluster each frame, then pulling particles toward the transformed goal positions.
  • Corotational formulation - a technique used in FEM/mass-spring elasticity models to separate rotation from strain, avoiding ghost forces when elements rotate.

Articles:

Videos:

Notable tools and libraries:

  • PositionBasedDynamics (C++) by Jan Bender - open-source PBD/XPBD library covering cloth, soft bodies, fluids, and rigid bodies
  • SOFA - open-source framework for real-time multi-physics simulation, widely used in biomedical soft-tissue and soft-robotics research
  • PhysX 5 by NVIDIA - GPU-accelerated FEM-based soft body simulation, open-sourced from the former NVIDIA Flex library
  • Unity
    • Obi Softbody by Virtual Method - particle-based soft body simulation
  • Unreal
  • TouchDesigner
    • Flex - GPU particle solver (Nvidia Flex) for particle-based soft materials and fluids
  • Processing
    • toxiclibs - Verlet-based particle/spring physics library commonly used for soft-body and cloth-like simulations
  • p5.js
  • Three.js
  • React Three Fiber
    • use-ammojs - Ammo.js/Bullet physics hooks with soft body
  • Houdini
    • Vellum - unified PBD solver for cloth, hair, grains, and soft bodies
  • Blender
    • Soft Body- built-in mass-spring-based soft body physics

Code projects:

Image

Spatial index

Data structure (most commonly a binary tree) that enables fast and efficient storage, manipulation, and querying of large amounts of spatial data (points in space). Commonly used by particle systems.

Common types:

Related topics:

Articles:

  • Spatial index section on Wikipedia article for Spatial database

Videos:

Image

Vectors

Vectors (specifically Euclidean or geometric vectors) are simple data structures that store spatial information representing discrete points, displacement, or forces. Understanding how to work with vectors is one of the most critical skills to learn when working with physically-based simulations and digital morphogenesis.

Vectors can be manipulated using familiar algebraic operations like addition, subtraction, multiplication, and division, which makes them extremely useful when simulating physically-based systems with objects (or agents) in motion. We can have one vector that represents a point in space and another that represents a force (like gravity or wind), then apply that force to the point by adding the two vectors together.

The term "vector" has slightly different meanings and uses in mathematics, physics, machine learning, biology, and more. In the context of digital morphogenesis, you'll most often encounter vectors as they are used in physics, representing discrete physical properties like position, displacement, velocity, direction, and more.

Properties:

  • Magnitude / length ($|\mathbf{v}|$) = the "size" of a vector obtained by taking the square root of the sum of the square of each of the vector's components (an abstraction of the Pythagorean Formula). Mathematically, $|\mathbf{v}| = \sqrt{v_x^2 + v_y^2 + v_z^2 + \ldots}$.
  • Heading / direction / angle = the direction in which a vector is pointing. Applicable when using vectors to represent forces, but not so much when representing discrete points in space.

Key concepts:

  • Unit vector = any vector with a magnitude (length) of exactly 1.
  • Normalization = operation whereby a vector is divided by its own magnitude, resulting in a unit vector with the same heading (direction) as the original vector.

Algebraic operations:

Operation Using two vectors Using a vector and a scalar
Addition $\mathbf{v}_1 + \mathbf{v}_2 = \{v_{1x} + v_{2x}, v_{1y} + v_{2y}, \ldots\}$ $\mathbf{v} + 10 = \{v_x + 10, v_y + 10, \ldots\}$
Subtraction $\mathbf{v}_1 - \mathbf{v}_2 = \{v_{1x} - v_{2x}, v_{1y} - v_{2y}, \ldots\}$ $\mathbf{v} - 10 = \{v_x - 10, v_y - 10, \ldots\}$
Multiplication $\mathbf{v}_1 \times \mathbf{v}_2 = \{v_{1x} \times v_{2x}, v_{1y} \times v_{2y}, \ldots\}$ $\mathbf{v} \times 10 = \{v_x \times 10, v_y \times 10, \ldots\}$
Division $\mathbf{v}_1 / \mathbf{v}_2 = \{v_{1x} / v_{2x}, v_{1y} / v_{2y}, \ldots\}$ $\mathbf{v} / 10 = \{v_x / 10, v_y / 10, \ldots\}$
Dot product $\mathbf{v}_1 \cdot \mathbf{v}_2 = (v_{1x} \times v_{2x}) + (v_{1y} \times v_{2y}) + \ldots$
(produces a single number)		 Not applicable.
Cross product $\mathbf{v}_1 \times \mathbf{v}_2 = \|\mathbf{v}_1\| \|\mathbf{v}_2\| \sin(\theta) \mathbf{n}$

Where: $\theta$ = angle between $\mathbf{v}_1$ and $\mathbf{v}_2$; $\mathbf{n}$ = unit normal vector. Produces a vector.		 Not applicable.

Articles:

Videos:

Notable implementations:

Image

VDBs

Note

Related or similar to spatial indices and fluid simulations

Image credit: Said Al Attrach - VDB: A Deep Dive

Grid-based data structure designed for storing and manipulating sparse 3D volumetric data - grids of voxels (3D pixels). Unlike a naive 3D array where every voxel consumes memory regardless of content, VDBs use a B-tree-like hierarchical structure that only stores voxels containing meaningful data, making them extremely memory-efficient for large, sparse volumes. Named for their characteristics (Volumetric, Dynamic, and B-tree-like), they approximate an "infinite" index space with fast O(1) random access, cache-coherent traversal, and support for dynamic topology changes.

VDBs are the industry standard in VFX and animation for representing volumetric data like smoke, fire, liquids, and distance fields. OpenVDB, an Academy Award-winning open-source library originally developed by DreamWorks Animation, has become the de facto standard format for volumetric data interchange in professional VFX pipelines.

How they work at a glance:

The VDB hierarchy typically has four levels: a root node (hash table), intermediate nodes, and leaf nodes (storing fixed blocks of voxels, usually 8×8×8). When accessing or inserting data, the tree is traversed from root to leaf, skipping branches that contain no data. This structure avoids allocating memory for empty space while maintaining fast random access patterns typical of dense grids.

Articles:

Notable tools and libraries:

  • ⭐ OpenVDB (C++, Python bindings) by Academy Software Foundation
    • GitHub repo - open-source, cross-platform library maintained by the VFX industry
    • Official docs - API reference and guides
    • Includes tools for data I/O, visualization (vdb_view), filtering, and mesh generation
  • Blender
  • EmberGen - real-time volumetric fluid simulator using VDB-compatible formats for export
  • Houdini
  • Three.js
    • mjurczyk/openvdb - adds .vdb format support with a VDBLoader as well as a FogVolume class for working with the data

Code projects:

  • fluid-engine-OpenVDB (C++) - fluid simulation engine adapting algorithms from fluid-engine-dev to leverage OpenVDB's sparse structure for memory-efficient 3D grid-based physics
  • Liquid3D (C++) - IISPH (Implicit Incompressible SPH) fluid simulation that uses OpenVDB to mesh fluid particles for Blender import
  • OpenVDB_Visualizer (C++) - volume rendering application using OpenGL and Qt5 to visualize and explore VDB files
Image

Wave Function Collapse (WFC)

Note

Related to Tiling / tessellation.

Method of procedurally generating textures and tilemaps that are similar to a single source image using ideas from quantum mechanics. Originally developed by Maxim Gumin, WFC learns local patterns and constraints from a source image, then iteratively generates new content by "collapsing" possibilities while respecting learned rules. The name references quantum superposition (many possible states simultaneously) and measurement (collapsing to a single outcome).

The algorithm works in two main steps: first, extract patterns by scanning the source image and recording which local arrangements of pixels (or tiles) occur; second, generate output by starting with all possibilities everywhere, then repeatedly choosing a location with minimum entropy (fewest valid options) and randomly collapsing it to one valid choice, then propagating constraints to neighbors to ensure the result remains compatible.

The key insight is that local compatibility - enforcing that neighboring regions respect learned patterns - naturally produces globally coherent, recognizable results even though the algorithm makes only local decisions. This approach produces remarkably human-like outputs and has become popular for game level design, texture synthesis, and procedural content generation.

Algorithm outline:

* indicates a potential simulation parameter

  1. Scan the source image to extract all $N \times N$* local patterns (e.g., all 3×3 neighborhoods of pixels or tiles).
  2. Initialize the output grid with all patterns marked as possible at every location.
  3. In each iteration:
    1. Find the location with minimum entropy (fewest valid patterns remaining).
    2. If no location remains, generation is complete.
    3. If a location has zero valid patterns (contradiction), backtrack or restart.
    4. Randomly select one valid pattern from that location and collapse it (remove all other patterns).
    5. Propagate constraints: for each neighbor, remove any patterns that would be incompatible with the collapsed pattern (based on learned adjacencies).
  4. Repeat until the entire grid is determined.

Key terms:

  • Pattern extraction - scanning the source image to find all valid local neighborhoods.
  • Entropy - in this context, the number of valid choices remaining at a location; minimum entropy heuristic prioritizes constrained areas.
  • Wave - the superposition of all possible patterns at each location before collapse.
  • Collapse - randomly choosing one pattern and removing all alternatives.
  • Constraint propagation - updating neighbors to eliminate patterns incompatible with a collapsed choice; ensures global coherence.
  • Contradiction / backtracking - if all patterns are eliminated at some location, the algorithm has failed and must restart or undo recent decisions.
  • Tile-based vs. pixel-based - the algorithm works on discrete units (tiles for maps, pixels for images) and can be adapted to 2D or 3D.

Articles:

Code projects:

  • ofxWFC3D (openFrameworks add-on) by Nuño de la Serna
  • ndwfc (JavaScript, Node.js) by Lingdong Huang.

Videos:

Image

Weighted Voronoi stippling

Note

Related to Delaunay triangulation and Voronoi diagrams, dithering, and Lloyd's relaxation.

Image credit: Windell Oskay (Evil Mad Scientist Laboratories) - StippleGen: Weighted Voronoi stippling and TSP paths in Processing.

Weighted variant of Lloyd's relaxation that uses the darkness (or density) of an underlying image to bias where points settle, producing a stippled illustration made of dots whose size and/or spacing follows the image's tone - more and/or larger dots in darker regions, fewer/smaller dots in lighter ones. Because points are still spread evenly within their local Voronoi region even as they respect image density, the result reads as a convincingly hand-drawn stipple illustration rather than a mechanical dither pattern.

Frequently paired with TSP path-finding to connect the stippled points into a single continuous line, making it a popular technique for pen plotter art.

Algorithm at a glance:

  1. Scatter an initial set of points across the image, with more points landing in darker regions (e.g. via rejection sampling against pixel brightness).
  2. Compute the Voronoi diagram for the current points.
  3. For each Voronoi cell, compute its centroid using the underlying image as a density function - darker pixels pull the centroid more strongly - rather than treating every pixel in the cell equally, as in standard Lloyd's relaxation.
  4. Move each point to its cell's weighted centroid.
  5. Repeat for some number of iterations*, or until points stop moving significantly.
  6. Render each final point as a dot, optionally sized or oriented based on local density.

* indicates a potential simulation parameter

Key terms:

  • Density function - the underlying image data used to weight where points are pulled during relaxation; typically derived from pixel brightness/darkness.
  • Weighted centroid - center of mass of a Voronoi cell computed using the density function, as opposed to the plain geometric centroid used in standard Lloyd's relaxation.

Articles:

Videos:

Notable software:

  • StippleGen by Evil Mad Scientist Laboratories - Processing-based tool that generates weighted Voronoi stipple drawings, including TSP path art.
  • Voronoi Stippling Art Generator by Joe Shenouda - browser-based tool for turning any photo into a stipple drawing

Creative projects:

Code projects:


Books, publications, and talks

Books

Publications

Talks

TODO: Add link


 Entagma's Patreon series

Software

Tools

Application Description Cost
Houdini Industry-level procedural VFX application with graphical node-based workflow. Excellent for creating high-quality renderings and animations based on generative algorithms. Allows for scripting with Python and VEX (proprietary language).
  • Apprentice - free for non-commercial users with watermarked renders
  • Indie - $269/yr for no watermarks for commercial <$100k annual profit
  • Thousands for commercial users, with complex pricing model
Rhino NURBS-based CAD program popular with architects and industrial designers. Strong ecosystem of advanced computational design plugins built by highly skilled community. Less focus on rendering, animation, and interactivity; more for form-finding with fabrication in mind. Allows for scripting with Python, RhinoScript, and more.

List of useful Rhino plugins

  • Grasshopper - extremely popular graphical node-based algorithm editor tightly integrated with Rhino’s 3D modeling tools. Highly recommended for digital morphogenesis work. Was a third-party plugin for many years, but is now a part of Rhino 6+.
  • Lunchbox - very powerful collection of utilities for generative geometry, math, data manipulation, and even machine learning.
  • Kangaroo - live physics engine for interactive simulation, form-finding, optimization and constraint solving.
  • Rhino 6 for Win - $995
  • Rhino 5 for Mac - $695
  • $195 for students (both platforms)
Unity Full-featured game engine with tools for interactivity, physics, lighting, level/character design, and more. Allows for scripting with C#.

Direct competitor of Unreal, with a reputation for being more focused on "user friendliness" and less on hyper-realism, though the gap is shrinking rapidly.

Notable features

  • Personal - free for hobbyists
  • Plus - $35/mo or ~$25/mo for prepaid year
  • Pro - $125/mo
Unreal Full-featured game engine with very similar feature set to Unity (it's direct competitor).

Has reputation for being more focused on hyper-realism, and thus is used more by high-end games studios. [?]		 Free with royalty on commercial products
Structure Synth Application for generating surprising and complex fractal 3D structures using a design grammar. Free
TouchDesigner Visual node-based environment for real-time interactive multimedia content useful for performances, installations, and fixed media works. Has roots in Houdini 4 and is considered a spin-off optimized for real-time performance work (hence the company name, Derivative).
  • Free for non-commercial projects
  • Educational - $300 for schools, educators, schools only
  • Commercial - $600
  • Pro - $2200
Cinema 4D Four versions ranging from $995-$3695

Languages and frameworks

About

Resources on the topic of digital morphogenesis (creating form with code). Includes links to major articles, code repos, creative projects, books, software, and more.

Topics

computational-geometrygrowth-algorithmsmorphogenesispattern-formationprocedural-generationresearchsimulation

Resources

Readme

Contributing

Contributing
Activity

Stars

2.3k stars

Watchers

93 watching

Forks

123 forks
Report repository

Contributors