Skip to Content
Conway's Game of Life

Same rules, 10+ stacks.

I rebuild Conway's Game of Life when trying a new language or UI library, then compare what each stack makes awkward or easy.

13
versions
12
languages
139
stars
593
commits
Origins

Early versions compared state models.

Elm, ClojureScript, Redux, and LiveScript: same grid, different ways to hold and update state.

2017 / Elm

Elm Game of Life

Elm

A functional baseline: immutable state, explicit updates, and a grid small enough to make the rules teachable.

013 commits
2016 / Clojure

re-frame Game of Life

ClojureScript + re-frame

ClojureScript and re-frame: cells as data, updates as events.

317 commits
2017 / JavaScript

Redux Game of Life

React + Redux

React and Redux with Conway implemented as a reducer: easy to step through in devtools.

66114 commits
2018 / LiveScript

Life LS

LiveScript

LiveScript, compressed hard to see how terse syntax shapes the automaton.

138 commits
Browser Eras

Browser versions followed UI fashion.

ReasonReact, ReScript, Svelte, and Solid: each makes you decide how a cell gets from one generation to the next.

2018 / OCaml

ReasonML Game of Life

ReasonReact

ReasonReact, an early typed React-family take, board and transitions in algebraic types.

8109 commits
2020 / ReScript

ReScript Game of Life

ReScript + React

A ReScript follow-up to the ReasonML version, carrying the typed model into a newer toolchain.

39110 commits
2022 / Svelte

Svelte Game of Life

Svelte

Svelte's reactivity keeps board state and UI updates close together.

1658 commits
2024 / TypeScript

Solid Game of Life

SolidJS

Solid's fine-grained reactivity, later adapted here into the interactive canvas preview.

451 commits
Language Sketches

Later versions tried new languages.

Go, Rust, Gleam, Civet, and RippleJS: small enough to show syntax and runtime differences quickly.

2023 / CSS

Civet Game of Life

Civet

A tiny syntax experiment around the Game of Life idea, represented as a one-commit CSS-primary repo.

21 commits
2024 / Go

Go Game of Life

Go

Go: explicit loops, no framework, a baseline to compare against the UI-heavy versions.

031 commits
2024 / Rust

Rust Game of Life

Rust

Rust, where ownership and mutation choices drive how cells update.

015 commits
2024 / Gleam

Gleam of Life

Gleam

Gleam's typed functional model, kept small enough to compare with the other versions.

027 commits
2026 / TypeScript

Ripple Game of Life

RippleJS

RippleJS, a newer framework; Conway here is a quick read on its reactive model.

09 commits

Same rules, different tradeoffs.

The algorithm stays tiny on purpose. What changes is where state lives, how updates flow, and how much ceremony sits between a cell and its next generation.

Back to work