Gray-Scott Reaction-Diffusion

Presets

How to use:
- Click and drag on the canvas to add reactants
- Choose presets to see different patterns
- Use WASD keys to pan, or mouse wheel to zoom

Parameters

Feed Rate ($F$): 0.055 Rate at which chemical U is fed into the system

Kill Rate ($k$): 0.062 Rate at which chemical V is removed from the system

Diffusion U ($D_U$): 1.0 How fast chemical U spreads across the surface

Diffusion V ($D_V$): 0.5 How fast chemical V spreads across the surface

Speed (steps/frame): 8 Number of simulation steps computed per frame

Noise Injection: 0.00 Applies random noise at each step

Boundary Condition How chemicals behave at the edges of the grid

Map Mode (F/k gradients) Varies feed and kill rates across the grid to visualize effects of different k and F values

Visuals

Laplacian Stencil Pattern used to calculate diffusion from neighbors

Gradient Preset Pre-made color schemes for visualization

Color Gradient

Custom gradient editor: drag handles or add new colors

3D Emboss Effect Adds depth by simulating lighting and shadows

Zoom: 1.0x Magnification level (use mouse wheel to adjust)

Pan X: 0.0 Horizontal view position (use A/D keys)

Pan Y: 0.0 Vertical view position (use W/S keys)

Controls

Introduction

The Gray–Scott model is a reaction–diffusion system used to look at how simple chemical interactions can generate complex patterns. It describes the evolution of two chemical species, U and V, diffusing across a surface while undergoing an autocatalytic reaction. Unlike linear diffusion equations, which smooth out disturbances, the Gray–Scott system is highly nonlinear and can produce stable spots, stripes, waves, and other very interesting Turing patterns.

Because of its non-linear nature, we must simulate the system numerically. Here, we simulate it on a 2D grid using finite difference approximations for the diffusion terms and explicit time-stepping for the reactions. Almost like a cellular automaton, but instead of having discrete states, each cell holds continuous concentration values for chemicals U and V.

Reaction–Diffusion Model

The Gray–Scott system models a simplified autocatalytic reaction:

U + 2V → 3V (autocatalysis)
V → P (decay)

Here, U is fed into the system at a constant rate, while V is the reactant that autocatalytically converts U into more of itself. Because of these interactions and imbalances, small changes in the concentrations of U and V can grow and lead to complex patterns.
When diffusion is included and the system is treated as a continuous 2D medium, the concentrations U(x,y,t) and V(x,y,t)—meaning 'the concentration of U or V at position (x,y) and time t'—evolve according to the following pair of partial differential equations:

$$ \frac{\partial U}{\partial t} = D_U \nabla^2 U - UV^2 + F(1 - U) $$

$$ \frac{\partial V}{\partial t} = D_V \nabla^2 V + UV^2 - (F + k)V $$

, where D_U and D_V are the diffusion rates of species U and V, F is the feed rate of U; and k is the kill rate of V. $\nabla^2$ is the Laplacian operator, which captures how the concentration at a point differs from its neighbors, which is how we derive diffusion.

The first term, $\ D_\_ \nabla^2 U \ $, is what represents our diffusion, and is what causes the chemicals to spread out over time. The second term, $\ \pm UV^2 \ $, represents the autocatalytic reaction where species U is consumed to produce more of species V. The third term in each equation represents the feed and removal rate of chemicals from the system. This maintains a non-equilibrium state, which is necessary for forming those interesting patterns.

Numerical Integration

Because the system has no closed-form solution, we approximate the PDEs to simulate the reaction-diffusion process over discrete time steps. We represent the 2D surface as a grid of cells, where each cell holds the information about the concentrations of U and V present at that location. The Laplacian operator $\ \nabla^2\ $ is approximated using a finite difference stencil. This simulation uses a 9-point stencil for better accuracy, but other stencils (like 4-point cross or even a diagonal) can also be used.

To evolve the system in time, we step time by a small increment via the forward Euler method:

\[ U^{t+\Delta t}_{i,j} = U^t_{i,j} + \Delta t \left( D_U \nabla^2 U^t_{i,j} - U^t_{i,j} (V^t_{i,j})^2 + F(1 - U^t_{i,j}) \right) \] \[ V^{t+\Delta t}_{i,j} = V^t_{i,j} + \Delta t \left( D_V \nabla^2 V^t_{i,j} + U^t_{i,j} (V^t_{i,j})^2 - (F + k) V^t_{i,j} \right) \]

Or, in regular people terms, we compute the new concentration of U and V at each grid cell (i,j) by taking the current concentration, adding the effects of diffusion (via the Laplacian), the reaction term, and the feed/kill terms, and then just scale it up by a small time step $\ \Delta t\ $ for every iteration. Because each grid point depends only on its immediate neighbors, the computation is highly parallelizable. Therefore, this simulation uses GPU acceleration via WebGPU compute shaders to efficiently compute the updates for all grid cells simultaneously. Neat!