abhinavbwj/algorithmic-patterns
L-systems, cellular automata, agent-based modeling, swarm intelligence, reaction-diffusion, growth algorithms, packing algorithms, and nature-inspired computation for AEC design
npx skills add https://github.com/Abhinavbwj/Claude-skills-for-Computational-Designers --skill algorithmic-patternsFor three and a half billion years, evolution has solved the optimization problems architects and engineers face daily: distributing material efficiently, creating structures that resist loads with minimal mass, organizing circulation for millions of agents, regulating temperature without mechanical systems, and generating complex forms from simple rules. Nature-inspired computation translates these solutions into programmable algorithms that transform AEC practice.
The fundamental insight is that complexity does not require complex instructions. A fern frond with thousands of precisely placed leaflets emerges from a recursive rule fitting in a single line of code. A termite mound maintaining two-degree temperature stability is built by agents following three local rules. An oak tree optimally distributing material to resist wind has no central controller -- it grows according to Wolff's law, depositing material where stress is highest.
Emergence produces macro-scale patterns from micro-scale interactions without centralized control. In AEC, this challenges conventional top-down design, replacing it with local rules and boundary conditions that self-organize into coherent spatial configurations.
Key properties of emergent systems:
The computational thesis underlying all algorithmic patterns is that irreducible complexity can emerge from reducible rules. Stephen Wolfram demonstrated this with elementary cellular automata: Rule 110, defined by 8 binary transitions, is Turing-complete. A one-dimensional grid of cells with two states and nearest-neighbor rules can compute anything computable. For AEC: a branching structure with thousands of unique members can be specified by 3-4 L-system rules; a facade with apparent randomness generated by a 2-state CA; an optimal circulation network by 10,000 agents following 3 flocking rules.
| Aspect | Top-Down (Traditional) | Bottom-Up (Algorithmic) |
|--------|----------------------|------------------------|
| Control | Centralized | Distributed |
| Specification | Global geometry | Local rules |
| Adaptability | Low (manual redesign) | High (rules adapt) |
| Scalability | Difficult | Inherent |
| Novelty | Limited by imagination | Generates unexpected solutions |
| Domain | Algorithm Class | Application |
|--------|----------------|-------------|
| Urban growth | Cellular automata, ABM | Land use simulation, sprawl prediction |
| Structural branching | L-systems, space colonization | Tree columns, dendritic roofs |
| Facade patterning | Reaction-diffusion, CA | Perforated screens, shading panels |
| Space planning | Agent-based, packing | Room layout, furniture arrangement |
| Material distribution | Topology optimization, DLA | Graded density structures |
| Circulation design | Ant colony, shortest path | Corridor networks, staircase placement |
| Acoustic design | Reaction-diffusion, fractal | Diffuser panel geometry |
| Thermal design | Swarm optimization | Ventilation opening placement |
An L-system is a parallel rewriting system G = (V, w, P) where V is the alphabet, w is the axiom (initial string), and P is the production rules. Unlike Chomsky grammars, all rules apply simultaneously, modeling biological growth where cells divide concurrently.
Each variable has exactly one production rule; rules are context-independent.
Algae (Lindenmayer's original): Alphabet: {A,B} | Axiom: A | Rules: A->AB, B->A
String length follows the Fibonacci sequence: A, AB, ABA, ABAAB, ABAABABA.
Koch Curve: Axiom: F | Rule: F->F+F-F-F+F | Angle: 90deg
Fractal dimension log(5)/log(3) = 1.465.
Sierpinski Triangle: Axiom: F-G-G | Rules: F->F-G+F+G-F, G->GG | Angle: 120deg
Dragon Curve: Axiom: FX | Rules: X->X+YF+, Y->-FX-Y | Angle: 90deg
Hilbert Curve: Axiom: A | Rules: A->-BF+AFA+FB-, B->+AF-BFB-FA+ | Angle: 90deg
Multiple rules per predecessor with probabilities summing to 1:
F -> F[+F]F[-F]F (p=0.33)
F -> F[+F]F (p=0.33)
F -> FF-[-F+F+F]+[+F-F-F] (p=0.34)
No two generated trees are identical, yet all share the same structural grammar. Critical for facades with varied but coherent panel geometries.
Rules depend on adjacent symbols: A < B > C -> D (B becomes D only between A and C). AEC application: signal propagation along structural members -- stress information triggers material deposition only where neighbors indicate high stress.
Symbols carry numerical parameters with guard conditions:
A(l,w) : l > 0.1 -> F(l) [+(30) A(l*0.7, w*0.8)] [-(30) A(l*0.7, w*0.8)]
A(l,w) : l <= 0.1 -> (terminal leaf)
Parameters 0.7 and 0.8 control child-to-parent ratios, mapping directly to Murray's law for biological branching.
| Symbol | Action | Symbol | Action |
|--------|--------|--------|--------|
| F | Move forward, draw line | [ | Push state (branch start) |
| f | Move forward, no draw | ] | Pop state (branch end) |
| +/- | Turn left/right by delta | &/^ | Pitch down/up (3D) |
| \// | Roll left/right (3D) | ! | Decrement diameter |
Binary Tree (2D):
Axiom: 0
Rules: 1 -> 11, 0 -> 1[+0]-0
Angle: 45 degrees, Iterations: 7
Produces a symmetric binary tree with 128 terminal branches.
Stochastic Shrub:
Axiom: F
Rules: F -> FF+[+F-F-F]-[-F+F+F] (p=0.5), F -> FF-[-F+F]+[+F-F] (p=0.5)
Angle: 22.5 degrees, Iterations: 4
3D Tree (with pitch and roll):
A -> F(1)[&(30)B][/(120)&(30)B][/(240)&(30)B]
B -> F(0.8)[+(25)$C][--(25)$C]B
C -> F(0.5)[+(20)$C][--(20)$C]
City Block Generator:
X -> F[-X][+X]FX | F -> FF
Angle: 90 degrees
Generates recursive block subdivision resembling organic street networks.
Column Capital (parametric, 3D):
A(h,r) -> F(h,r) [+(60)&(40) B(h*0.3,r*0.6)] [+(180)&(40) B(h*0.3,r*0.6)] [+(300)&(40) B(h*0.3,r*0.6)]
B(h,r) : h > 0.05 -> F(h,r) [+(45)&(30) B(h*0.5,r*0.7)] [-(45)&(30) B(h*0.5,r*0.7)]
Branching Structures: Tree-columns in airports and stations (Stuttgart Airport, Sendai Mediatheque). A 5-rule L-system defines a column branching into 200+ terminal supports for a roof canopy.
Root-Like Foundations: Inverted L-system trees distributing loads through soil following optimized branching angles per Murray's law.
Dendritic Circulation: Corridor systems following L-system branching produce naturally navigable spaces with clear hierarchy.
Fractal Facades: Koch-curve-based facades provide increased surface area for shading while maintaining structural regularity.
Python:
def l_system(axiom, rules, iterations):
current = axiom
for _ in range(iterations):
current = "".join(rules.get(c, c) for c in current)
return current
Grasshopper: String rewriting via text components, Anemone loop for iterations, turtle geometry components for line/curve generation, pipe/mesh for 3D visualization.
A row of binary cells; next state depends on 3-cell neighborhood (8 configurations, 2^8 = 256 rules).
Rule 30 (chaotic): Aperiodic, seemingly random from a single cell. Found on Conus textile shell.
Rule 90 (Sierpinski): XOR of neighbors. Perfect for facade patterning -- regularity with complexity.
Rule 110 (Turing-complete): Proved by Cook (2004). Generates gliders and spaceships. The simplest known universal computer.
Game of Life (B3/S23): Dead cell with 3 neighbors is born; alive cell with 2-3 survives; all others die. Produces gliders, oscillators, guns, and self-replicating patterns.
Urban Growth (B3678/S2345678): Compact blob growth mimicking suburban sprawl. Adjusting to B45/S2345 produces polycentric growth.
Floor Plan Generator (B3/S1234): From random initial conditions, produces room-like enclosed spaces connected by narrow passages.
Von Neumann (4): Orthogonal patterns for rectilinear layouts. Moore (8): Organic, rounded patterns; standard for most 2D CA. Extended Moore (24, radius 2): Smoother boundaries for urban simulation. Hexagonal (6): Isotropic, no directional bias.
Binary (0/1): Simplest case -- cell is active or inactive.
Multi-state (0-N): Enables gradient effects and functional zoning:
Transition rules encode zoning logic: residential adjacent to 3+ commercial cells transitions to mixed-use. Green space cells never transition (protected). Totalistic CA depends only on the sum of neighbor states; outer-totalistic (like Game of Life) depends on center state AND neighbor sum but not arrangement.
Cubic lattice with 6 (von Neumann), 18 (edge-sharing), or 26 (Moore) neighbors.
Structural topology application:
States: solid (1), void (0)
Initial: solid block
Rules: Death: solid cell with < 4 solid Moore-26 neighbors -> void
Birth: void cell with 8-12 solid neighbors -> solid
Produces porous, trabecular bone-like structures exportable as mesh for 3D printing or CNC fabrication.
Urban Growth Simulation: SLEUTH/DUEM models simulate decades of land-use change for infrastructure planning.
Structural Topology: Voxel rules remove low-stress material, approximating optimal distributions.
Facade Patterns: CA grid mapped to facade; cell states determine panel type. Rule 90 produces Sierpinski; Game of Life produces organic patterns.
Python:
import numpy as np
from scipy.signal import convolve2d
def gol_step(grid):
n = convolve2d(grid, np.array([[1,1,1],[1,0,1],[1,1,1]]), mode='same', boundary='wrap')
return ((grid==0) & (n==3) | (grid==1) & ((n==2)|(n==3))).astype(int)
An agent has: position (x,y,z), velocity, state variables (energy, type, memory), behavioral rules executed each timestep, perception radius, and communication mode (direct messaging or stigmergy).
Environments: Grid-based (simple collision, coarse simulations), continuous (realistic pedestrian/vehicle movement, requires KDTree spatial indexing), network-based (agents move along graph edges for transit simulation).
Indirect communication through environment modification. Agents deposit pheromone; it diffuses (Gaussian blur) and evaporates: P(t+1) = P(t) * (1 - rho). Others sense gradients and bias movement toward high concentrations. This is how ant colonies find shortest paths -- and how pedestrians create desire lines.
Three rules applied each timestep:
force = sum((self.pos - neighbor.pos) / dist^2) within separation_radiusforce = avg(neighbor.velocity) - self.velocity within alignment_radiusforce = centroid(neighbors) - self.pos within cohesion_radiusCombined: velocity += w1*sep + w2*ali + w3*coh; clamp(velocity, max_speed); pos += velocity*dt
High w1 = dispersed; high w2 = parallel streams; high w3 = tight swarms; balanced = natural flocking.
Path selection: P(i->j) = (tau_ij^alpha * eta_ij^beta) / sum(tau_ik^alpha * eta_ik^beta) where tau = pheromone, eta = 1/distance. Pheromone update: tau = (1-rho)*tau + Q/L_k for ants using edge.
AEC: Hospital corridor layout optimization. Nodes = rooms (ER, ICU, pharmacy). ACO minimizes total daily staff travel distance, producing a connectivity graph that informs spatial adjacency.
Stigmergic construction: deposit material where pheromone is high; deposits emit pheromone; positive feedback creates pillars, arches, chambers. Translates to robotic construction agents building without centralized control.
Pedestrian Flow: Thousands of agents navigating stations/malls; identify bottlenecks, optimize door placement.
Evacuation: Social force model (Helbing) validates egress timeframes with body-compression physics.
Urban Morphogenesis: Developer/resident agents produce clustering, segregation, gentrification from individual decisions.
Structural Placement: Agents walking force-flow lines deposit material at convergences, reflecting principal stress trajectories.
Adaptive Facades: Each panel is an agent with sensors/actuators, coordinating shading with neighbors.
Tools: Quelea (Grasshopper real-time ABM), NetLogo (visual ABM platform), Mesa (Python framework integrating with compas/ladybug/honeybee).
v_i = w*v_i + c1*r1*(p_i - x_i) + c2*r2*(g - x_i)
x_i = x_i + v_i
w (inertia): 0.9 -> 0.4 over iterations. c1, c2 (cognitive/social): typically 2.0. r1, r2: random [0,1].
AEC: Optimize building orientation, WWR, shading angles via EnergyPlus fitness function. Converges in 50-200 iterations.
Ant System: All ants deposit; simple but slow. Ant Colony System: Best-ant-only with local decay; faster convergence. MAX-MIN: Bounded pheromone prevents premature convergence.
AEC: Pipe routing through ceiling cavities minimizing length while avoiding structural members.
Scout bees (random global search), employed bees (local exploitation), onlooker bees (quality-weighted roulette selection). Abandoned food sources trigger scouting.
AEC: Multi-objective optimization balancing energy performance, structural efficiency, daylight, and cost.
Attractiveness: beta(r) = beta_0 * exp(-gamma*r^2). Brighter fireflies attract dimmer ones; distance-dependent attraction clusters solutions around promising regions.
AEC: Structural member sizing -- each firefly is a set of beam/column cross-sections; brightness = low weight satisfying constraints.
| Criterion | PSO | ACO | Bee | Firefly |
|-----------|-----|-----|-----|---------|
| Continuous variables | Excellent | Poor | Good | Good |
| Discrete/combinatorial | Poor | Excellent | Good | Fair |
| Multi-objective | Fair | Fair | Good | Fair |
| Convergence speed | Fast | Moderate | Moderate | Slow |
| Best AEC use | Parametric opt. | Routing/layout | Multi-objective | Sizing opt. |
Two morphogens -- activator (slow diffusion, self-promoting) and inhibitor (fast diffusion, activator-suppressing) -- produce stable spatial patterns via short-range activation / long-range inhibition: spots, stripes, labyrinths, inverse spots. Found throughout biology: leopard spots, zebra stripes, seashell markings, fingerprints.
du/dt = Du*laplacian(u) - u*v^2 + f*(1-u)
dv/dt = Dv*laplacian(v) + u*v^2 - (f+k)*v
Typical: Du=0.16, Dv=0.08. The (f,k) parameter space maps to distinct regimes:
| f | k | Pattern Type |
|---|---|-------------|
| 0.010 | 0.045 | Spots (mitosis) |
| 0.022 | 0.051 | Spots and stripes |
| 0.030 | 0.057 | Stripes / labyrinthine |
| 0.040 | 0.063 | Worms / meandering |
| 0.050 | 0.065 | Holes (inverse spots) |
| 0.025 | 0.060 | Solitons (isolated spots) |
| 0.014 | 0.054 | Pulsating spots |
Chemical reaction producing concentric target waves and spiral waves. Modeled by Oregonator equations. AEC: spiral/concentric patterns for acoustic diffusers breaking up sound reflections.
Facade Patterning: Concentration field drives perforation density -- dense shading where solar gain is highest, open where views are prioritized.
Structural Porosity: 3D reaction-diffusion determines solid/void in 3D-printed elements, lighter than solid while maintaining load paths.
Ventilation: Opening density correlates with local wind pressure via tuned diffusion parameters.
Acoustic Diffusers: Labyrinthine patterns achieve broadband diffusion without periodicity artifacts.
Discretized Laplacian (5-point): L(u,i,j) = u[i+1,j] + u[i-1,j] + u[i,j+1] + u[i,j-1] - 4*u[i,j]
9-point stencil (more isotropic): weight corners 0.05, edges 0.2, center -1.0.
import numpy as np
def gray_scott_step(u, v, f, k, Du=0.16, Dv=0.08, dt=1.0):
Lu = np.roll(u,1,0)+np.roll(u,-1,0)+np.roll(u,1,1)+np.roll(u,-1,1) - 4*u
Lv = np.roll(v,1,0)+np.roll(v,-1,0)+np.roll(v,1,1)+np.roll(v,-1,1) - 4*v
uvv = u*v*v
return np.clip(u+dt*(Du*Lu-uvv+f*(1-u)),0,1), np.clip(v+dt*(Dv*Lv+uvv-(f+k)*v),0,1)
256x256 runs real-time on CPU; 512+ requires GPU (CUDA/WebGL compute shaders).
Seed at origin; random walkers perform Brownian motion, sticking permanently on cluster contact. Fractal dimension ~1.71 (2D). Produces patterns resembling lightning, river deltas, mineral dendrites, frost.
AEC: Branching structural topologies refined by FEA, green infrastructure networks (branching bioswales).
Attraction points fill target volume (canopy envelope). Tree nodes grow toward nearest points; points consumed within kill distance. Parameters: influence distance, kill distance, step length D, point distribution.
AEC: Column-tree structures for large-span roofs with branch density proportional to local load. More natural branching than L-systems for canopy-filling geometries.
Apollonian gasket: Recursive tangent circle insertion (D~1.31). RSA: Random placement rejecting overlaps; jams at ~54.7% coverage. Force-directed: Repulsive forces between overlapping circles iterate to equilibrium, producing dense organic packings.
def force_pack(circles, iterations=1000):
for _ in range(iterations):
for i, ci in enumerate(circles):
force = [0, 0]
for j, cj in enumerate(circles):
if i == j: continue
d = dist(ci, cj); overlap = (ci.r + cj.r) - d
if overlap > 0:
force[0] += overlap * (ci.x-cj.x)/d
force[1] += overlap * (ci.y-cj.y)/d
ci.x += force[0]*0.1; ci.y += force[1]*0.1
AEC: Column placement (circles = tributary areas), window placement on curved facades, bubble diagrams for space planning.
2D Nesting: Irregular polygons on sheets; NP-hard; bottom-left + NFP heuristics. CNC steel cutting, facade panel nesting. 5-10% efficiency gain = significant cost savings.
Dijkstra: Shortest paths O((V+E)log V) for service routing. A*: Heuristic-guided single-target wayfinding. MST: Minimum-length corridor/utility networks (Kruskal/Prim).
D = log(N)/log(S) for self-similar fractals. Box-counting method: cover pattern with epsilon-boxes, plot log(N) vs. log(1/epsilon); slope = D. Urban analysis: compact cities D~2.0; sprawling cities D~1.3-1.5. Track D over time to quantify sprawl. Skyline D~1.3-1.5 correlates with visual preference.
Contractive affine transformations applied recursively. Barnsley fern: 4 transformations with probabilities (stem p=0.01, leaflets p=0.85, branches p=0.07 each). AEC: decorative screens, tile designs, mullion layouts with parameterized self-similarity.
Hilbert curve: Visits every point in 2^N x 2^N grid preserving locality. AEC: CNC toolpaths, sensor placement, robotic inspection routes.
Peano curve: 3x3 recursive, denser coverage. Z-Order (Morton): Bit-interleaved 2D-to-1D for spatial database indexing.
Historical examples of fractal architecture:
Fractal analysis of cities:
numpy (array ops, convolution), scipy (KDTree, signal processing), matplotlib (visualization), networkx (graph algorithms), compas (AEC geometry framework), shapely (2D polygon ops), trimesh (3D mesh export).
Performance: Vectorize with numpy (100x over Python loops). scipy.spatial.KDTree for O(log n) agent neighbor queries. Preallocate arrays. GPU via cupy/CUDA for grids > 512x512.
Processing (Java): Excellent for real-time interactive visualization. Built-in 2D/3D rendering with straightforward pixel manipulation for CA and RD simulations.
p5.js (JavaScript): Browser-based Processing ideal for client presentations and web demos. WebGL mode enables GPU-accelerated rendering of large simulations. Particularly effective for interactive reaction-diffusion and flocking demonstrations.
Grid resolution vs. computation:
Agent scaling:
Memory management:
Convergence:
| Design Goal | Algorithm | Rationale |
|-------------|-----------|-----------|
| Branching structure | L-system / Space Colonization | Controlled recursion with biological analogy |
| Organic facade pattern | Gray-Scott reaction-diffusion | Tunable Turing patterns with density control |
| Regular-complex pattern | CA (Rule 90, Game of Life) | Deterministic complexity from simple rules |
| Pedestrian flow analysis | ABM (boids + social force) | Captures individual decision-making |
| Structural optimization | PSO / topology-optimized CA | Continuous variable optimization |
| Routing optimization | Ant Colony Optimization | Graph-based combinatorial problems |
| Column/support placement | Circle packing, force-directed | Distributes supports with minimum spacing |
| Panel nesting (fabrication) | 2D bin packing, NFP nesting | Minimizes material waste |
| Urban growth prediction | CA (SLEUTH) or ABM | Captures spatial dynamics of development |
| Ventilation openings | Reaction-diffusion | Organic density variation across surface |
| Multi-objective optimization | Bee Algorithm, NSGA-II | Balanced Pareto front exploration |
| Fractal complexity analysis | Box-counting dimension | Quantifies pattern complexity across scales |
Take abhinavbwj/algorithmic-patterns from the repository into ~/.claude/skills for personal
use, or into .claude/skills inside a project.
The agent identifies a skill by the name field in its header. Two skills with the
same name cannot sit side by side — one of them will be ignored.