First: the recipe IS the equation

You'll see a differential equation further down (the \(\partial v/\partial t = \dots\) bit) and it can look like it demands calculus machinery. It doesn't — but not because it's something other than a differential equation. Operationally this is exactly the recipe you'd guess — every tick, for every cell, do three cheap things and add them up:

1. propagate — leak a little of each chemical into its neighbors (that's the Laplacian);
2. react — consume feedstock where catalyst already is, turning it into more catalyst;
3. feed & kill — top up fresh feedstock everywhere, and remove a slice of catalyst.

Add those three, add the result to the cell's current value, move to the next tick. That's the entire loop — feed, then consume, then spread, just like you pictured. And here's the honest relationship: that loop isn't a stand-in for the differential equation — it is the differential equation, run at finite resolution. “Each cell updates from its neighbors” is what every PDE becomes the moment you put it on a computer; \(\partial v/\partial t = \dots\) is just the compact way to say “how much this cell changes in one tick = spread + react + feed − kill,” and as the cells shrink and the ticks quicken, the recipe converges to the smooth law. (Course 3, Step 6 earns this properly: the grand heat equation turns out to be fifteen beads, each chasing its neighbors' average.) So read every equation below as a recipe, not a derivation — each term is one of those three jobs. On the chip a “tick” is one steps update, with the time-step fixed at 1.

One classifying word is worth knowing here: linear. An equation is linear when every term treats the unknown proportionally — double the concentration, double the term — which is why solutions of linear equations can be added together and still solve it. The propagate and feed & kill jobs are linear; a world with only those is the heat equation, and it can only ever smooth things flat. The react job is the exception: \(uv^2\) multiplies the chemicals together, so doubling both blows the term up eightfold. That single nonlinear term is what flips diffusion from a pattern-destroyer into a pattern-grower — and it's why this course can't be solved by the add-up-the-waves trick that finishes Course 3.

Course 3 built the Laplacian and used it to smooth things out — heat spreading until a rod sits flat. Here the same operator does the opposite: coupled to a reaction, diffusion stops erasing detail and starts growing patterns. (Course 5 will put it to a third use, holding a fluid incompressible.)

The screen shows one of two invisible chemicals. Everywhere starts full of feedstock (drawn dark — you never see it directly). A second chemical, the catalyst (drawn bright), does one thing: it converts feedstock into more of itself. So catalyst spreads into the dark regions, eating as it grows.

What about the grays in between? The catalyst isn't just there-or-not — it's an amount. Bright means dense catalyst, black means none (just feedstock, still invisible), and every shade between is a middling concentration — the moving fronts where catalyst is thickening or thinning. So gray isn't the feedstock showing through or “mixing in”; the feedstock is never drawn at all. Gray is simply less catalyst — which is why the edges, not the flat areas, are where you see the detail.

If that were all, it would just fill the screen. Two things hold it back: catalyst is slowly removed (kill rate \(k\)), and fresh feedstock constantly drips back in (feed rate \(F\)). The pattern is the standoff between growth and removal — and because the catalyst spreads slower than the feedstock refills, that standoff never settles into flat gray. It keeps carving edges. That's the whole trick.

Why the patterns move — and split

Here's the part that trips everyone up: the catalyst kills itself as it advances. Watch a bright front spread. At its leading edge it's pushing into fresh feedstock, so it grows. But right behind it the feedstock is already used up — nothing left to eat — and there the kill term wins, so the trailing edge dies off. The shape isn't sliding across the grid; it's being rebuilt at the front and starved at the back. That's why patterns appear to travel.

Same reason a blob doesn't just swell forever: once it's wide enough, its own middle runs out of feedstock and hollows out, so a solid dot becomes a ring — and the ring pinches into two. That's the “mitosis” look, cells dividing. Growth only survives at the boundary between fed and starved, which is exactly why you see edges and fronts instead of filled shapes.

Two fates: why some colors barely appear

Here's a detail you can catch by staring at the dish: some colors are everywhere, and some seem to have nowhere to live. Load a preset and you'll see broad regions of near-black and broad regions of established colony — but the shades in between only ever show up as a thin rim, a pixel or two wide, sliding across the screen. Whole slices of the color map get almost no screen time.

That's not a rendering quirk. It's the single most important fact about this system: Gray–Scott is bistable. Take one cell and ignore its neighbors for a moment. Two catalyst levels are self-consistent — states the cell can sit at forever:

• extinct (\(v = 0\)) — no catalyst, so nothing is made; feed keeps the cell full of feedstock and it stays empty. Perfectly stable: with \(v\) exactly zero, \(uv^2\) is zero too.
• the colony plateau (\(v \approx 0.2\text{–}0.3\)) — catalyst production and the kill term balance exactly. Consumption holds the feedstock down, which holds production in check. Also stable: nudge it and it comes back.

Between them sits a third balance point — and it's unstable. It's a threshold: a hair below and the kill term wins, so the cell empties out; a hair above and \(uv^2\) wins, so it runs up to the plateau. Nothing can rest there. That's why a cell holding a middling density is always a cell mid-decision, and why those colors only paint the moving edge of a front. The intermediate shades aren't states — they're transits.

This is why the patterns look the way they do. Bistability is what buys you sharp edges: since the middle ground is unstable, the dish is forced to sort itself into "on" and "off" with a thin boundary between, instead of settling into a smooth gradient the way the heat equation would. Every crisp rim you see is a cliff between two attractors. And the reason those rims move — rather than freezing into a final picture — is the diffusion coupling from the previous section: a colony's edge keeps pushing its neighbor over the threshold, while its own interior starves behind it.

And yes — this is Course 3's phase portrait, one dish-cell at a time. There we drew every possible state of a pendulum as a point on a map and let the equation's arrows carry it: stable centers that states spiral into, unstable saddles that the faintest nudge sends careening away. Same picture here, with the axes relabeled to \((u, v)\) — the concentrations of feedstock and catalyst. Extinct and the colony plateau are the stable points; the threshold between them is the saddle. A pendulum "never settles at the top" for exactly the reason a cell never settles at a middling density.

One difference, and it's what makes this course harder than that one: the pendulum was a single point moving on one map. Here every one of the 4,096 cells is its own point on its own copy of the map — and diffusion ties each cell's arrows to its neighbors' positions. The patterns are what 4,096 coupled phase portraits look like from above.

Practical upshot, visible in Step 4's color map: its density anchors are deliberately unevenly spaced. An evenly-spaced ramp would hand a third of its colors to densities that only ever exist on a one-pixel rim.

Every term is one of three jobs

Both chemicals follow the same skeleton — each term does one of three jobs. The middle one is what ties them together:

Read the reaction row across: it's the same quantity, minus for feedstock and plus for catalyst. Every scrap of feedstock the reaction destroys reappears as catalyst — that shared term is why it's two coupled equations, not two unrelated ones. They're joined right there.

Two equations at once, and a supply line

Worth naming what kind of object that table describes, because the name accounts for the behavior. It's a system of two partial differential equations: two unknowns, \(u\) and \(v\), that have to be advanced together, since neither one's rate of change can be computed without the other's current value. Course 3's rod was one equation in one unknown. Three things separate them.

• Two fields instead of one. A single field has nothing to interact with, so the only thing it can do is redistribute itself.
• One nonlinear term — the \(uv^2\) above. Solutions of a linear equation can be added together, which is what makes Course 3 solvable by summing waves and also what makes it incapable of surprise: its modes ignore each other. Here they don't.
• A supply line. The rod is closed. Heat gets moved around, nothing is added, and the only available ending is flat. The supply / removal row is what breaks that: \(F\) drips fresh feedstock in everywhere, indefinitely, and \(F + k\) carries catalyst away. The tank is held permanently away from equilibrium, and every pattern on the screen is paid for by that throughput. Set \(F\) to zero and the patterns don't settle into something static — the catalyst gets consumed with nothing replacing it, and the screen goes dark. Structure here is not a state the system reaches; it's something it has to keep spending on.

There's also a clean way to see where each half comes from. Delete both Laplacians — every cell sealed off from its neighbors, no spreading anywhere — and what remains is a pair of ordinary differential equations in \(u\) and \(v\): two numbers chasing each other in time, with space gone from the problem entirely. That's a phase portrait, the object Course 3, Step 3 built. Put the Laplacians back and every cell's phase portrait is wired to its neighbors'. That's the whole construction — Course 3's phase portrait at each point, plus Course 3's Laplacian connecting the points.

The diffusion ratio (Dv/Du)

Both chemicals spread — but not at the same speed, and that gap is the Dv/Du slider in the playground. We fix the feedstock's speed at D_u = 1 and set the catalyst's to a fraction of it (default 0.45 — catalyst spreads at 45% of the feedstock's rate). It's the one control that isn't about how much, but how fast.

Why it's the make-or-break knob: if both spread equally (ratio near 1), everything blurs together into flat gray — no pattern at all. Because the catalyst is slower, it stays clumped where it already is while its food arrives from farther out — so it can grow, but only hemmed into tight shapes. That mismatch — slow catalyst, fast-arriving feedstock — is Turing's insight: it's the reason a smooth soup spontaneously breaks into spots and stripes. Nudge the ratio down for finer, sharper structure; nudge it up toward 1 and the patterns coarsen and eventually wash out.

How big the blobs get — the diffusion length

There's a single number hiding behind “how big is a spot”: the diffusion length — how far the catalyst can spread before the kill term catches up with it. Roughly \(\ell \sim \sqrt{D / \text{rate}}\): a chemical that diffuses faster, or dies slower, reaches farther before it's spent — and that reach is exactly what sets a blob's radius. Everything you see is about one \(\ell\) wide, because that's the distance over which “grow at the front, starve at the back” plays out.

The catch is the square root. Blob size scales with \(\sqrt{D}\), not \(D\) — so to make spots twice as big you'd need to quadruple the diffusion. And you can't: an explicit step is only stable up to a diffusion ceiling (past it the grid oscillates and blows up), and we already sit right under it (\(D_u = 1\)). Turning the knobs moves you around the \((F, k)\) plane — spots vs. stripes vs. worms — but it can't buy you a bigger \(\ell\). The size is baked into the grid.

The precise version

Same three jobs, written as math — the Gray–Scott system, the exact update the playground and the T-QT firmware run each step. Hover any term for what it does:

Discrete Laplacian on the grid

On a grid, \(\nabla^2 u\) at a cell is “how far below the neighborhood average am I” — a weighted sum of the 8 neighbors minus the cell itself. The word for that arrangement is a stencil: the fixed pattern of neighboring cells an update reads in order to compute one cell's new value. It's the shape of the neighborhood, and the number in its name is how many cells the shape covers.

• 3-point, in one dimension — a cell plus its left and right neighbor. You have already met this one: the bracket in Course 2's derivation, \(\rho(x-h) - 2\rho(x) + \rho(x+h)\), is the 3-point stencil.
• 5-point, in two dimensions — a cell plus north, south, east, west. Drawn out, it's a plus sign. This is the version Course 5 uses.
• 9-point — the same, plus the four diagonals at lower weight, because they sit \(\sqrt{2}\) times farther away.

So “stencil” and “discrete Laplacian” are nearly interchangeable in practice: the stencil is the shape, the Laplacian is what that shape computes. The shape also explains why the same kernel can run in a browser and on a microcontroller unchanged — every cell reads the same relative offsets, so the addresses are predictable and each cell can be computed independently of the others.

This lab (and the firmware it exports to) uses the 9-point stencil: adjacent cells weigh 0.2, diagonals 0.05, center −1. At the edges the neighbors are clamped (zero-flux), so a pattern that reaches the rim exits “off camera” instead of wrapping to the far side.

// identical kernel in the browser and in the LilyGO T-QT firmware
float Laplacian(float[] f, int x, int y)
{
    return 0.2f * (L + R + T + B)
         + 0.05f * (TL + TR + BL + BR)
         - f[x, y];
}