The Carpet Spreads One Cell at a Time

My dwarf baby tears didn’t spread evenly across the substrate. They crept outward one node at a time, and where a runner had three or four healthy neighbours it thrived; where it stood alone it melted. After a month of watching the carpet fill in, I realised I was staring at a cellular automaton growing in real water.

A cellular automaton is a grid of cells where each cell’s next state depends only on its current state and the states of its immediate neighbours. Conway’s Game of Life is the canonical example: a live cell with two or three live neighbours survives, a dead cell with exactly three live neighbours comes alive, and everything else dies or stays empty. Simple local rules, complicated global behaviour — which is exactly how a planted carpet fills a tank.

In Swift, one generation is a nested loop that counts the eight neighbours of every cell:

func step(_ grid: [[Int]]) -> [[Int]] {
    let h = grid.count, w = grid[0].count
    var next = grid
    for r in 0..<h {
        for c in 0..<w {
            var n = 0
            for dr in -1...1 {
                for dc in -1...1 where !(dr == 0 && dc == 0) {
                    let rr = r + dr, cc = c + dc
                    if rr >= 0, rr < h, cc >= 0, cc < w { n += grid[rr][cc] }
                }
            }
            // survival on 2 or 3, birth on exactly 3
            next[r][c] = grid[r][c] == 1 ? (n == 2 || n == 3 ? 1 : 0)
                                         : (n == 3 ? 1 : 0)
        }
    }
    return next
}

var grid = [
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0],
]
grid = step(grid)
for row in grid { print(row.map { $0 == 1 ? "#" : "." }.joined()) }

I seeded a vertical blinker — three live cells stacked in a column — and after one step it flips to a horizontal row. That oscillation is the simplest non-trivial pattern in Life, and it falls straight out of the neighbour count: the top and bottom cells have only one live neighbour and die, while the two empty cells beside the centre suddenly have three and come alive.

Perl walks the same grid with array references, and the rule is identical:

my @grid = (
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0],
);
my ($h, $w) = (scalar @grid, scalar @{ $grid[0] });
my @next = map { [@$_] } @grid;

for my $r (0 .. $h - 1) {
    for my $c (0 .. $w - 1) {
        my $n = 0;
        for my $dr (-1 .. 1) {
            for my $dc (-1 .. 1) {
                next if $dr == 0 && $dc == 0;
                my ($rr, $cc) = ($r + $dr, $c + $dc);
                $n += $grid[$rr][$cc]
                    if $rr >= 0 && $rr < $h && $cc >= 0 && $cc < $w;
            }
        }
        $next[$r][$c] = $grid[$r][$c] ? ($n == 2 || $n == 3 ? 1 : 0)
                                      : ($n == 3 ? 1 : 0);
    }
}
print join("", map { $_ ? "#" : "." } @$_), "\n" for @next;

Both print the same frame — a single live row, .###., where the column used to be. The rules don’t know anything about blinkers or carpets; they only know how to count neighbours and apply a threshold.

That’s the part that maps onto the aquarium. I never told the dwarf baby tears to fill the foreground. I set the light, the CO2, and the substrate — the equivalent of the survival and birth thresholds — and the carpet computed itself, node by node, exactly like the grid recomputing itself one cell at a time. Emergence isn’t magic. It’s a local rule applied patiently across a whole surface.