Diffusion Across a Grid of Copper Atoms

The vinegar fumes in my fuming chamber don’t oxidize the bronze uniformly. They start where the humidity concentrates—corners, drip points, places where condensation pools—then spread outward through adjacent regions. Twenty-four hours later, the patina has propagated across the entire surface, but you can still read the history of its diffusion in the colour gradients.

This is cellular automata: a grid where each cell’s next state depends on its current state and its neighbours’ states. John Conway made the concept famous with the Game of Life in 1970, but the technique had been developing since the 1940s when Stanislaw Ulam and John von Neumann used it to model crystal growth at Los Alamos. By the 1980s, cellular automata were everywhere—modelling traffic flow, forest fires, and yes, corrosion.

The rule for patina diffusion is simpler than Conway’s Life: a clean cell becomes oxidized if any neighbour is already oxidized and there’s enough “humidity” (we’ll model this as a threshold). Once oxidized, a cell stays oxidized.

function diffusePatina(grid, humidity = 0.3) {
  const rows = grid.length, cols = grid[0].length;
  const next = grid.map(row => [...row]);
  for (let r = 0; r < rows; r++) {
    for (let c = 0; c < cols; c++) {
      if (grid[r][c] === 0) { // clean copper
        const neighbours = [[r-1,c],[r+1,c],[r,c-1],[r,c+1]]
          .filter(([nr,nc]) => grid[nr]?.[nc] === 1).length;
        if (neighbours > 0 && Math.random() < humidity) next[r][c] = 1;
      }
    }
  }
  return next;
}

The JavaScript version iterates through the grid synchronously—each cell checks its neighbours, decides its next state, and we swap the whole grid at once. Clean and predictable.

Erlang takes a different approach. Each cell becomes a process. Neighbours communicate by message passing. When a cell oxidizes, it tells its neighbours “I’ve turned green,” and they decide whether to follow.

-module(patina).
-export([cell/2]).

cell(clean, Neighbours) ->
  receive
    oxidize -> [N ! {oxidized, self()} || N <- Neighbours], cell(oxidized, Neighbours);
    {oxidized, _} -> case rand:uniform() < 0.3 of
      true -> [N ! {oxidized, self()} || N <- Neighbours], cell(oxidized, Neighbours);
      false -> cell(clean, Neighbours)
    end
  end;
cell(oxidized, Neighbours) ->
  receive _ -> cell(oxidized, Neighbours) end.

The Erlang version has no global tick. Oxidation ripples outward asynchronously as messages propagate between processes—closer to how the actual chemistry works, where molecules don’t wait for a universal clock.

Both implementations produce spreading patterns, but they expose different assumptions about time. The synchronous JavaScript model assumes all cells update simultaneously; the asynchronous Erlang model lets causality flow through the system at its own pace. On actual bronze, reality is closer to Erlang: the fumes reach different regions at different times, and the reaction front crawls outward from wherever they landed first.

The grid after 50 iterations might look like:

· · · · ● ● ● · · ·
· · · ● ● ● ● ● · ·
· · ● ● ● ● ● ● · ·
· ● ● ● ● ● ● ● ● ·
· · ● ● ● ● ● ● · ·
· · · ● ● ● ● · · ·

—an irregular blob spreading from a seed point, just like the blue-green bloom on my bronze disc.