Skip to main content
100%

Python script for creating a Langton's Ant cellular automata

✓ Published0🌍 Public
Aabehmiel
Last edited Mar 28, 2017
Created on Mar 28, 2017

This example visualizes Langton’s Ant cellular automata on a 128-by-128 finite grid, showing the emergent trail of black and white cells as one or more ants move according to a configurable turning rule. The simulation runs up to 11,000 steps, then renders the final board state and ant positions using Matplotlib’s `imshow` with a gray colormap and a red overlay via `numpy.ma` masks. The code defines `Grid` and `Ant` classes in Python, uses NumPy arrays for the board, and saves the output as a PNG image.

AI-generated description

Similar vizzes

Loading thumbnail…

Cellular automata

A one-dimensional cellular automaton stands at the center of this visualization, which arranges all 256 possible nearest-neighbor rules in a grid. The display uses a tile-based procedural map via Polymaps, with a worker script (`cell-worker.js`) computing each rule’s evolution from a random initial state. Color intensity indicates cell state, and zooming reveals the structure of individual rules. The rendering leverages Polymaps’ `po.map`, `po.procedural`, and `po.hash` APIs, while the worker handles the pixel-level computation and postMessage communication, following the example from MathWorld.

Mmbostock
62% match
Loading thumbnail…

Conway's Game of Life

The example implements Conway’s Game of Life on a 64×128 SVG grid, rendering each cell as a rectangle. It shows cellular automaton patterns evolving over time under the standard birth, survival, and death rules, with controls to select sample patterns, start or pause simulation, and edit the grid by clicking cells. The JavaScript uses D3 v3 to bind grid data to SVG rects and to update fills, while the simulation logic is implemented with bitwise operations on typed arrays for efficient neighbor counting and state transitions. Predefined patterns, such as “Planes” and “Symm 4,” are included in a separate data file.

NNPashaP
57% match
Loading thumbnail…

p5 wolfram CA

A p5.js sketch renders a one-dimensional cellular automaton, displaying each generation as a horizontal row of small squares that stack downward over time. The simulation starts with a single active cell in the center of the top row and applies a fixed Wolfram rule set to compute each subsequent generation from the three neighboring cells above. The code uses the p5.js `createCanvas`, `rect`, and `fill` functions to draw the grid, and the result produces a deterministic, rule-based visual pattern that evolves over the canvas height.

PPhilippe Rivière
57% match
Loading thumbnail…

03_cheese_rec.py

This example simulates the melting of a block of cheese over time, displaying each hour as a grid where cheese cells (1) disappear when exposed to air on two or more sides. It reads a text file containing an n×m binary grid, validates the input, and uses a recursive flood-fill algorithm to mark exterior cells, then iteratively updates the grid each turn. The process repeats until no cheese remains, printing the final hour count. The visualization is text-based, with the grid printed row by row for debugging, using only Python standard library functions like `sys.argv`, file I/O, and list operations.

Aanemochore
53% match
Loading thumbnail…

ants_garden

Two identical SVG ants wander randomly across the screen. The scene shows how D3 can import and duplicate vector graphics from an external XML file, using `d3.xml` to load the ant artwork and `document.importNode` to clone it. Each ant is a separate data object tracked with position, angle, and speed; a `d3.timer` drives their movement while `d3.selectAll` and `.attr("transform")` update the SVG transforms. Hovering over either ant pauses its motion, and moving the mouse away resumes it. The visualization relies on SVG animation and the MIT-licensed source from BrunoDumas.

BBrunoDumas
53% match
Loading thumbnail…

Generated using https://github.com/bluemontag/igs-lsgp/, > Random structure generated in 1163.145503053 seconds. Generation method: Optimized Jacobson & Matthews generation method.

A 1000x1000 Latin square generated in 1163 seconds appears as a dense grid of colored cells, visualizing the statistical randomness and constraint satisfaction of the arrangement. The visualization uses d3 to render a canvas-based heatmap, where each cell’s color encodes a value from 0–999. The data comes from an optimized Jacobson and Matthews generation method, with the output shown as a single large matrix.

CCheckroth
52% match
Loading thumbnail…

Mathematical Graphic Patterns

A grid of 30 by 30 small circles continuously shifts and morphs in an animated screensaver-like display. Each circle’s position and size are driven by sine and cosine functions of its grid coordinates and a continually advancing time value, producing swirling, geometric motion. The code uses Canvas drawing APIs such as `getContext('2d')`, `beginPath`, `arc`, and `fill` to render the circles, with colors computed via a custom `rgb` function based on grid position and time. The animation runs through `requestAnimationFrame`, and the canvas resizes to match the window dimensions.

DDhruval Patel
51% match
Loading thumbnail…

Random Traversal

A black canvas displays a maze being generated cell by cell via a random traversal algorithm. White cells mark the growing maze structure, while magenta highlights the current frontier of possible extensions. The animation progresses in steps, using the Canvas API to draw rectangles for cells and connections. The code implements the algorithm with a frontier array and popRandom selection, using d3.v3's timer for animation control.

Mmbostock
51% match