📚 Reference · Academic Papers
📅 March 2026
⏱ 10 min
🎓 All levels
Landmark Simulation Papers
Every simulation method has a defining paper. This is a curated reading list of the foundational works — fluid dynamics, particle systems, cloth, rigid body, N-body, reaction-diffusion — with key contributions and practical implementation notes for browser-based simulations.
1. Fluid Simulation
1999
Stable Fluids
Introduced the semi-Lagrangian advection method for
incompressible fluid simulation. Replaces explicit time integration
(which requires tiny dt) with a backwards-tracing advection step
that is unconditionally stable for any timestep. Combined with
pressure projection via Helmholtz decomposition, this is the
foundation of most real-time fluid simulators.
Impl. notes: The "Jos Stam grid fluid" tutorial by
Mike Ash is the standard starting point. Key operations: advect u/v
fields backward along themselves, then project to divergence-free
using a Gauss-Seidel Poisson solver. Runs interactively at 128×128
in JavaScript.
2005
Animating Sand as a Fluid
Introduced FLIP (Fluid-Implicit-Particle), a hybrid
Lagrangian-Eulerian method. Particles carry velocity; a grid handles
pressure and divergence-free projection. Each step: transfer
particle velocities to grid (P2G), project, transfer back (G2P),
advect particles. Produces much less numerical diffusion than pure
grid methods.
Impl. notes: The PIC/FLIP blend (typically 5% PIC +
95% FLIP) prevents instability. The key data structure is a
staggered MAC grid. Starting resource: Bridson's "Fluid Simulation
for Computer Graphics" book.
2. Smoothed Particle Hydrodynamics (SPH)
2003
Particle-Based Fluid Simulation for Interactive Applications
Made SPH practical for real-time graphics. Introduced the
poly6 kernel for density,
spiky kernel for pressure gradient (preventing
particle clustering), and viscosity kernel for
smoothing velocities. Defined the complete SPH pipeline: find
neighbours → compute density → compute forces → integrate.
Impl. notes: Use a spatial hash grid for O(n)
neighbour lookup instead of O(n²). Smoothing radius h ≈ 2× rest
particle spacing. The main instability is the pressure term — use
Tait equation of state (ρ₀=1000, γ=7, B=200) for incompressibility.
2013
Position Based Fluids
Applies Position Based Dynamics (PBD) to SPH-style
fluids. Instead of force-based integration, solves density
constraints directly on particle positions. Highly stable, handles
large timesteps, compatible with the PBD cloth/rigid-body pipeline.
Introduces the tensile instability correction
term (artificial pressure).
Impl. notes: The density constraint: C_i = ρ_i/ρ₀ −
1. Each PBD iteration adjusts positions to satisfy C_i = 0. Requires
3–5 iterations per timestep for visual quality. Pairs well with GPU
implementation.
3. Cloth and Deformable Bodies
1998
Large Steps in Cloth Simulation
Solved the stiffness problem of cloth simulation using
implicit integration. Previous explicit methods
required tiny timesteps to avoid explosion from stiff spring forces.
The implicit method solves a linear system of equations each
timestep, allowing dt up to 50× larger while remaining stable.
Foundation of modern cloth simulation in VFX.
Impl. notes: Requires solving a sparse linear
system (conjugate gradient). For real-time applications, prefer PBD
(Müller 2007) which avoids the linear solve. The Baraff-Witkin
formulation is used in offline renderers (Maya, Houdini).
2007
Position Based Dynamics
Replaced force-based simulation with direct
constraint projection on positions. Unconditionally
stable, artist-friendly (constraints are readable geometric
conditions), and fast enough for games. Handles cloth, soft bodies,
rigid bodies, fluids (PBF), and cables in a unified framework. Used
in Nvidia PhysX, Unity, Unreal.
Impl. notes: Each constraint: C(x₁, x₂) = 0. Solve
by computing Δx = −C(x)/|∇C|². Distance constraint: C = |x₁−x₂| −
rest_len. The stiffness parameter is iteration-count-dependent (use
XPBD — Extended PBD — for time-step-independent stiffness).
4. Rigid Body and Constraints
1997
Impulse-Based Dynamic Simulation of Rigid Body Systems
Formalised impulse-based rigid body simulation.
When two rigid bodies collide, compute an impulse j = −(1+e)·v_rel·n
/ (1/m₁ + 1/m₂ + n·(I₁⁻¹(r₁×n)×r₁ + ...)). Apply impulse to both
bodies. Handles restitution (e) and friction in a unified framework.
Impl. notes: See the game-physics-formulas
reference for the full impulse formula. For joints/constraints, use
the sequential impulse method (Erin Catto, GDC 2006 / Box2D source).
2005
Iterative Dynamics with Temporal Coherence
Introduced Sequential Impulse (SI) and warm
starting for constraint solvers. The basis of Box2D, Bullet, and
most game physics engines. SI iterates over all constraints in
sequence, applying corrective impulses, converging in 8–20
iterations. Warm starting reuses previous frame's impulses as an
initial guess, reducing iterations needed.
Impl. notes: Box2D is open source; the
b2ContactSolver implementation is the canonical
reference. The Baumgarte stabilisation term (β/dt · C) determines
how aggressively position error is corrected.
5. N-Body and Spatial Indexing
1986
A Hierarchical O(N log N) Force-Calculation Algorithm
Reduced gravitational N-body simulation from O(n²) to
O(n log n). Build an octree (3D) or quadtree (2D)
over all particles. For each particle, if a cell is far enough (d/l
< θ, typically θ=0.5), treat the entire cell as a single mass at
its centre of mass. Otherwise recurse into children.
Impl. notes: Build a new tree each frame (particles
move). Key insight: tree insertion is O(log n) per particle, tree
traversal is O(log n) per particle. For 100k bodies: Barnes-Hut
takes ~30ms; direct O(n²) takes ~5000ms.
2005
Optimized Spatial Hashing for Collision Detection of Deformable
Objects
Introduced spatial hashing as an O(n) alternative
to spatial trees for uniform particle distributions. Map a 3D cell
coordinate to a hash table index using a large prime hash function.
Each cell stores a list of particles. For each particle, check only
the 3³=27 neighbouring cells.
Impl. notes: Hash: (x·73856093 XOR y·19349663 XOR
z·83492791) % table_size. Table size = 2× particle count for low
collision rate. Rebuild each frame. This is the standard approach
for SPH neighbour finding.
6. Lattice Boltzmann Method
1998
Lattice-Boltzmann Method for Fluid Dynamics and Beyond
Comprehensive survey that established LBM as a mainstream CFD
method. LBM operates on a
discrete velocity distribution function f_i(x, t)
on a grid. Two operations: collision (relax f toward
equilibrium via BGK) and streaming
(propagate f_i to neighbour in direction i). Macroscopic ρ and u
recovered from moments of f.
Impl. notes: D2Q9 model (2D, 9 velocities) is the
canonical 2D implementation. The τ parameter controls viscosity: ν =
(τ − 0.5) / 3. τ must stay in (0.5, 2) for stability. Extremely
parallelisable — each cell update is independent (ideal for GPU).
7. Reaction-Diffusion and Pattern Formation
1952
The Chemical Basis of Morphogenesis
Showed mathematically that
two interacting chemicals (activator + inhibitor)
can spontaneously form spatial patterns from a uniform state if they
have different diffusion rates. This "Turing instability" explains
animal coat patterns (stripes, spots), finger formation, and many
biological structures.
Impl. notes: The Gray-Scott and Fitzhugh-Nagumo
models are the most common implementations of Turing instability.
See the Gray-Scott GPU tutorial for WebGL implementation. Key
requirement: D_activator < D_inhibitor.
1983
Autocatalytic Reactions in the Isothermal, Continuous Stirred Tank
Reactor
Defined the Gray-Scott model — two coupled PDEs
with feed (F) and kill (k) parameters that produce a rich pattern
zoo depending on the F-k parameter space. The autocatalytic term
u·v² creates the activator-inhibitor dynamics. Spots, stripes,
worms, coral, mitosis — all from two equations.
Impl. notes: See the Gray-Scott GPU tutorial for a
complete WebGL 2 implementation. The Pearson 1993 paper ("Complex
Patterns in a Simple System") provides the definitive F-k parameter
map.
8. Boids, Cellular Automata, and Other Classics
1987
Flocks, Herds, and Schools: A Distributed Behavioral Model
Introduced Boids — three simple rules (separation,
alignment, cohesion) that produce emergent flocking behaviour. Each
boid considers only its local neighbourhood; no global
communication. The basis of all crowd simulation, traffic
simulation, and swarm AI.
Impl. notes: Neighbour radius ~50 px, max turn rate
~5°/frame, weights separation > cohesion ≈ alignment. GPU
implementation: sort boids by grid cell, each boid queries adjacent
cells only.
1970
Mathematical Games: The fantastic combinations of John Conway's
new solitaire game "life"
Conway's Game of Life — the canonical cellular
automaton. Binary states, local 8-neighbour rules, Turing-complete,
self-replicating structures. Demonstrated that complexity arises
from extreme simplicity. Influenced generations of simulation, AI
(neural CAs), and theoretical computer science.
Impl. notes: GPU implementation: pack cells into a
uint texture, use a fragment shader to count live neighbours via 8
texture lookups. Run 1–4 generations per frame. Golly
(golly.sourceforge.net) is the definitive open-source Life
implementation.
2000
Interaction with Groups of Autonomous Characters
Extended Boids with steering behaviours: seek,
flee, arrive, pursuit, evasion, obstacle avoidance, path following,
separation. Formalised as force fields on velocity. Standard
vocabulary of game AI movement.
Impl. notes: Force priority: collision avoidance
> separation > seek/flee > alignment/cohesion. Truncate
force magnitude to max_force each frame. The OpenSteer library is
the reference implementation.
Further Reading:
Bridson, "Fluid Simulation for Computer Graphics" (2nd ed, 2015) —
best textbook for SPH/FLIP/grid fluids. Müller's SIGGRAPH courses on
XPBDand PBD (2017–2021) — free slides on graphics.pixar.com.
"Physically Based Rendering" (PBRT) — Pharr, Jakob, Humphreys — the
rendering counterpart.