Performance on Programmer.ie: Modern AI programming

Cellular Automata From First Principles 52: Use FFTs for Large Neighborhoods

Mon, 10 Aug 2026 20:55:00 +0100

Cellular Automata From First Principles 52: Use FFTs for Large Neighborhoods

Small local neighborhoods are cheap to evaluate directly.

Large smooth kernels are different.

Lenia taught us that a neighborhood may cover dozens of cells in every direction. At that scale, direct convolution can become expensive.

The Fourier transform gives us another route.

Convolution becomes multiplication

For periodic domains:

convolution in space
        ↕
multiplication in frequency

So instead of sliding a large kernel over every location, we can transform both arrays, multiply them, and transform back.

Cellular Automata From First Principles 51: Run Cellular Automata on the GPU

Mon, 10 Aug 2026 20:54:00 +0100

Cellular Automata From First Principles 51: Run Cellular Automata on the GPU

Once the update is expressed as tensor operations, moving to a GPU becomes straightforward.

But a GPU is not automatically faster.

It wins when there is enough parallel work to amortize transfer and launch overhead.

A tensor implementation of Life

import torch
import torch.nn.functional as F

LIFE_KERNEL = torch.tensor(
    [[1.0, 1.0, 1.0],
     [1.0, 0.0, 1.0],
     [1.0, 1.0, 1.0]]
).view(1, 1, 3, 3)


def life_step(x):
    kernel = LIFE_KERNEL.to(x.device)
    neighbors = F.conv2d(x, kernel, padding=1)
    alive = x > 0.5
    born = neighbors == 3
    survive = alive & (neighbors == 2)
    return (born | survive).float()

Represent a batch as:

Cellular Automata From First Principles 50: Vectorize the Update Loop

Mon, 10 Aug 2026 20:53:00 +0100

Cellular Automata From First Principles 50: Vectorize the Update Loop

A cellular automaton is local.

That does not mean we should update it cell by cell in Python.

For dense grids, the same local rule is applied everywhere. That regularity is exactly what array programming is good at.

Start with the obvious implementation

def life_step_slow(grid):
    height, width = grid.shape
    next_grid = np.zeros_like(grid)

    for y in range(height):
        for x in range(width):
            total = 0
            for dy in (-1, 0, 1):
                for dx in (-1, 0, 1):
                    if dx == 0 and dy == 0:
                        continue
                    total += grid[(y + dy) % height, (x + dx) % width]

            alive = grid[y, x] == 1
            next_grid[y, x] = (
                total == 3 or (alive and total == 2)
            )

    return next_grid

This is useful because it states the mechanism clearly.

Cellular Automata From First Principles 49: Profile Before You Optimize

Mon, 10 Aug 2026 20:52:00 +0100

Cellular Automata From First Principles 49: Profile Before You Optimize

By now we have built dozens of automata.

The natural temptation is to make them faster.

The wrong first question is:

Which optimization trick should I use?

The right first question is:

Where is the time actually going?

Performance work begins with measurement.

Define the workload first

A benchmark is only meaningful if the workload is explicit.

For a cellular automaton, record at least: