• 05 Nov, 2025 *

Conway’s Game of Life is often described as a “zero-player game.” You set up an initial pattern, press start, and watch it evolve forever under four simple rules. It’s fascinating but it’s more a simulation than a game. This begs the question though: what would it take to actually play Conway’s Game of Life? I decided to experiment and this post is the result.

For some added context before diving in, the original Game of Life runs on four update rules for each cell:

1. Any live cell with fewer than two neighbors dies (underpopulation).
2. Any live cell with two or three neighbors survives.
3. Any live cell with more than three neighbors dies (overpopulation).
4. Any dead cell with exactly three neighbors becomes alive (reproduction).

Here’s what it looks like:

It’s a simple, deterministic world where complexity emerges in unexpected ways. But because it’s fully automatic, you can only watch. To make it a game, I needed a way to add input without breaking the logic.

Single-player Game of Life

In my single-player version, you can interact with an 8x8 grid by modifying the bottom horizontal row of cells each turn. This row is called the activation zone and it is where external inputs are injected into the simulation. Additionally, the left and right sides of the grid wrap around.

At every step:

• The normal Game of Life rules run.
• Then, before the next step, you can flip any cells you want in that row.

You’re not really controlling creatures; you’re perturbing the system. The fun comes from learning how those perturbations propagate. Even though you only touch one row, you can guide oscillators and gliders toward your target cells.

Goals and scoring

Some cells are marked as goals. The win condition is to make all goal cells alive at the same time.

To turn it into a real puzzle, I also added a scoring system. The idea is to minimize your interference.

Score = (Step Count + Activation Count) × Max Per-Turn Activations

• Step Count: total generations since the start.
• Activation Count: total number of live cells you’ve created in the activation zone.
• Max Per-Turn Activations: the most cells you’ve activated at once.

Low scores mean you solved it with fewer moves and less brute force.

If you want to see it in action, there’s a playable version embedded below. Try lighting up all the goal cells using only a few activations per turn.

The first few runs feel random, but after a while you start recognizing structures you can exploit. It’s strangely satisfying to “aim” a glider through nothing but local flips.

If you’re using a mouse and keyboard, you may need to click into the game window to use hotkeys. Otherwise you can just tap/click on the buttons and cells in the activation zone. The lowest score I’ve managed is 102. Can you do better?

Two-player “Game of Life or Death”

Once the single-player version worked, I wondered what it would look like as a competitive game. That became the Game of Life or Death.

Here’s how it works:

• Live cells belong to either Player 1 or Player 2.
• Each player gets their own activation zone on the left and right edges of the grid. The top and bottom edges wrap around.
• When computing the next state, each player treats the opponent’s cells as dead.
• If both players try to activate the same cell, it stays dead.

Representing the grid is simple: Player 1’s cells are 1, Player 2’s are -1, and dead cells are 0. Each player updates their own grid independently, and then the results are added together. Overlaps cancel out naturally, so conflicting activations annihilate each other.

Scoring and Mana

In this version, the goal cells are shared. For each step that a goal cell is alive, the player who activated it earns a point. After 200 steps, whoever has the most points wins.

To keep things from devolving into spam, each player has a mana pool that limits how often they can activate:

• Mana cap = three-quarters of the grid height (e.g., 6 mana on an 8×8 board).
• Activating a cell costs mana.
• Each step restores one-third of your mana bar.

This makes the game more about timing and prediction than speed. Sometimes it’s better to conserve mana and wait for an opening instead of flooding the board.

The Bot Arena

To test it, I built a version on CodinGame where players can write bots to compete.

Each match runs for 200 steps on an 8×8 grid, with activation zones on the sides and goal cells scattered in the center. Higher divisions expand to 16×16 and 32×32.

The fun part is designing the AI. Some bots play reactively, targeting visible goals. Others plan around emergent behaviors in the Life rules, building gliders and oscillators that drift across the board. It’s surprisingly deep for something based on four lines of logic.

You can try it here:

Final Thoughts

This project started as a curiosity: could you inject player input into a deterministic automaton without breaking it? Turns out you can, and it stays interesting.

The single-player mode feels like solving chaotic puzzles. The two-player version feels like a battle for control over entropy. Both are tiny experiments in how much “game” you can squeeze out of pure simulation.

It’s still the Game of Life, just with a pulse :)

#conway #games #golod #life