When Code Grows Like Sound Waves

Picture this: you’re layering field recordings of wind through autumn leaves, but instead of manually crafting each transition, you let the sounds evolve according to simple neighbour rules. A quiet moment spawns activity if surrounded by enough energy. A chaotic passage dies back when isolated. This is exactly how cellular automata work—and why they’re perfect for generative music.

John Conway’s Game of Life taught us that complex patterns emerge from laughably simple rules. In JavaScript, we can build a one-dimensional automaton that generates rhythmic patterns:

function evolve(cells, rule) {
    return cells.map((_, i) => {
        const left = cells[i-1] || 0;
        const center = cells[i];
        const right = cells[i+1] || 0;
        const pattern = (left << 2) | (center << 1) | right;
        return (rule >> pattern) & 1;
    });
}

let rhythm = [0,0,0,1,0,0,0];
for (let i = 0; i < 8; i++) {
    console.log(rhythm.map(x => x ? '♪' : '·').join(''));
    rhythm = evolve(rhythm, 30); // Rule 30: chaotic beauty
}

Erlang takes this further with true concurrency—each cell becomes an actor, evolving independently whilst coordinating with neighbours:

cell(State, Neighbours) ->
    receive
        {tick, Pid} ->
            NewState = rule30(query_neighbours(Neighbours)),
            Pid ! {self(), NewState},
            cell(NewState, Neighbours);
        {update, NewNeighbours} ->
            cell(State, NewNeighbours)
    end.

rule30([L,C,R]) -> 
    case {L,C,R} of
        {1,1,1} -> 0; {1,1,0} -> 0; {1,0,1} -> 0; {1,0,0} -> 1;
        {0,1,1} -> 1; {0,1,0} -> 1; {0,0,1} -> 1; {0,0,0} -> 0
    end.

The beauty lies in how local interactions create global patterns. Unlike predetermined sequences, cellular automata generate music that’s both structured and surprising—like watching storm clouds form from water vapour, or hearing how a single sustained drone can birth an entire harmonic landscape through the physics of resonance.