whatisgithub

What is game_of_life_asc?

antedotee/game_of_life_asc — explained in plain English

Analysis updated 2026-05-18

0TypeScriptAudience · developerComplexity · 2/5Setup · easy

In one sentence

An infinite version of Conway's Game of Life where the simulation rules run in a tiny WebAssembly module, with a minimal interface that colors cells by how long they have survived.

Mindmap

mindmap
  root((repo))
    What it does
      Runs Game of Life
      Infinite grid
      Colors cells by age
    Tech stack
      AssemblyScript
      WebAssembly
      SolidJS
      TypeScript
    Use cases
      Draw and simulate patterns
      Load glider gun pattern
      Study Wasm compiled logic
    Audience
      Developers
      Wasm learners
      Curious hobbyists

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Draw a starting pattern by hand and watch Conway's Game of Life play out on an infinite grid.

USE CASE 2

Load a Gosper glider gun or an R-pentomino from the built-in pattern library to see a known behavior unfold.

USE CASE 3

Study how the simulation logic is written in AssemblyScript and compiled to a small WebAssembly module.

USE CASE 4

Deploy the project as a static site since the build step compiles the Wasm engine automatically.

What is it built with?

TypeScriptAssemblyScriptWebAssemblySolidJSViteTailwind

How does it compare?

antedotee/game_of_life_asc0xradioac7iv/tempfs7vignesh/pgpulse
Stars000
LanguageTypeScriptTypeScriptTypeScript
Setup difficultyeasymoderatemoderate
Complexity2/53/54/5
Audiencedeveloperdeveloperdeveloper

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · easy Time to first run · 30min

Requires Node.js 18+ and a WebAssembly compile step (npm run asbuild) before the dev server reflects engine changes.

No license information is provided in the README.

So what is it?

This project is an implementation of Conway's Game of Life, a classic simulation where a grid of cells lives or dies each step based on four simple rules about how many neighbors it has. There is nothing to win or steer. A person draws a few starting cells, presses play, and watches the rules produce patterns on their own: shapes that flip back and forth forever, shapes that crawl diagonally across the grid, and shapes that fire off a new crawling shape every so often. What sets this version apart is how the simulation itself is built. The actual rule calculations run entirely inside a small WebAssembly module, compiled from a language called AssemblyScript, rather than being computed in the browser's regular JavaScript. The interface layer, written with the SolidJS framework and TypeScript, only handles drawing cells and reacting to mouse input. The simulation runs on an infinite plane rather than a fixed size grid, so there is no edge to run into, and live cells are tracked using a hash set so the grid can grow without limit. The interface itself is intentionally simple and mostly black and white, with color reserved for the cells themselves. A cell is colored based on how long it has been alive: newly created cells appear warm, and cells that survive many generations gradually shift toward a cooler blue tone, so long lived stable shapes look visually different from freshly changing areas. The README suggests a few things to try, such as drawing cells by hand, loading a pre-built pattern called a glider gun from a built-in pattern library, or dropping in a five-cell starting pattern called an R-pentomino and watching it run for over a thousand generations before settling down. There is also a dark mode that recolors the whole scene. To run it locally, a person needs Node.js 18 or newer, then installs dependencies, compiles the WebAssembly engine from its AssemblyScript source, and starts the development server. The project includes an automated test suite that checks the simulation behaves correctly for known patterns like a blinker, a block, and a glider. It builds as a static site, so it can be deployed to a static hosting platform such as Vercel, and the production build step recompiles the WebAssembly engine automatically.

Copy-paste prompts

Prompt 1
Explain how the AssemblyScript code in this repo's field.ts is compiled into the WebAssembly module used by the simulation.
Prompt 2
Walk me through the npm run asbuild and npm run dev commands in this repo and what each one does.
Prompt 3
Based on this repo's README, describe how cell age controls the color shown for each live cell.
Prompt 4
Suggest a new starting pattern I could add to this repo's pattern library and how I would format it as RLE data.

Frequently asked questions

What is game_of_life_asc?

An infinite version of Conway's Game of Life where the simulation rules run in a tiny WebAssembly module, with a minimal interface that colors cells by how long they have survived.

What language is game_of_life_asc written in?

Mainly TypeScript. The stack also includes TypeScript, AssemblyScript, WebAssembly.

What license does game_of_life_asc use?

No license information is provided in the README.

How hard is game_of_life_asc to set up?

Setup difficulty is rated easy, with roughly 30min to a first successful run.

Who is game_of_life_asc for?

Mainly developer.

Open on GitHub → Ask about another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.