cool to see a few different emergent pieces

Next step after the dividing cells: each amoeba is a bubble of the same foam rule. Its skin pulls taut and it keeps its area. On top of that its edge reaches out:

- By smell: food gives off a smell that spreads and fades. The edge bulges where the smell is stronger than its own average, so a pseudopod reaches towards food and the back pulls in. In blind mode it wanders at random and only finds food by touching it.

- Eat, grow, divide, starve: what it eats becomes area. Living burns that area away. At twice its size it divides, and starved to a third it dies.

Try it: https://geotyper.github.io/taut/amoeba.html

I started with a striped pigment field and five vortices, then let the local cell rules run.

Velocity carries the pigment, pressure redirects the flow, and the navy, cream, and coral bands trace pigment concentration as it stretches and folds.

All those curls develop from the evolving grid.

Made in Phluxel.

I trained a small neural cellular automaton (NCA) to cycle through three 48×48 pixel-art images, embers → phoenix → fire → embers, over and over. Nothing outside the model tells it when to change: no clock input, no seed, no position encoding. It keeps time in its own hidden channels.

• GIF: the model free-running for 10 cycles.
• Error plot: 32 independent copies run for 100 cycles, with the best match to each keyframe staying flat. Run 0's state every 25 cycles is shown next to the targets.
• Attractor loops: a 2D PCA of the full state (color and hidden channels). The clean loop is on the left, a typical run in the middle, and the last 50 cycles of all 32 runs on the right. Over 1,000 cycles every run stays on the same closed loop.

The model was first trained with an external clock as an input, so the loop was easy to learn. The clock was then removed during fine-tuning, so the hidden channels had to take over keeping time. Finally, the loop was settled by training with noise damage, which teaches the model to correct itself over time.

A few days ago I shared Rule Safari, which ranked all 131,072 Life-like rules without being told which ones are famous. This is the part I glossed over: how it decides what "interesting" means.

The first score was wrong. It rewarded big still blobs whose edges flicker forever. They never settle, so they look busy, and their uniform insides compress well, so they look structured. Busy and structured is what Life looks like too.

The fix was one number. Each soup is compared with itself 12 generations earlier. 12 is a multiple of 1, 2, 3, 4, 6 and 12, so any oscillator with one of those periods is back in the same state and cancels out. What survives is change that goes somewhere: ships, growing debris, or noise (first image).

That fraction goes through a curve (second image): 0 below 0.1% of cells changing, full marks from 0.5% to 10%, fading to 0.1 by 35%. Conway's Life sits at 5.2%, HighLife at 3.9%, Day & Night at 1.4%. Seeds churns a third of the board every 12 generations, which reads as noise. The final score is 55% this liveliness and 45% the zoo, where spaceships count most.

The cheap first screen turned out to be a net, not a judge. HoneyLife went into the close study at No. 596 and finished 3rd. IronLife went from 891 to 5th. HighLife scraped into the 1,500 finalists at No. 1,077 and finished 10th. At the other end, Maze and Life without death land near the bottom: from a random soup they lock up fast, which is what this score punishes most.

Where it's still blind: the census only sees creatures up to 16×16 cells and period 16, so Day & Night's spaceships were never caught.

The write-up has a small rule lab: flip the B/S digits, or switch on the 12-generation view and watch the blinkers go grey while the gliders stay lit: Scoring 131072 Universes

Question : what would you measure instead? "Lively, sparse, things that travel" is one definition of interesting. Which rules do you think it ranks wrong, and why?

Try it in the browser: https://geotyper.github.io/taut/cells.html (no install; on a phone it's slow, a desktop is better)

Following up on the soap-film automaton: I gave the 2D foam rule cells that divide. Each cell is a "bubble" that keeps its area. Dividing is just a straight line through the cell's centre, across its long axis (Hertwig's rule), and both halves keep half the area. The films then pull taut on their own.

Everything comes from one local rule: each pixel takes the label most common in a disc around it, weighted by how far its cell is from its target area.

More: https://geotyper.github.io/taut/ has the rest of the project: 2D and 3D foams, films on wire frames, bubbles. The source is at https://github.com/geotyper/taut.

A voxel cellular automaton (idea from prev my post about 2d soap foam) that makes soap films on wire frames: a ring, two rings and otheer. A film on a wire has air on both sides, so I added invisible "cuts" spanning the wire: a cell that reads a neighbour across a cut swaps its label, so a film has to end on the wire.

Runs in the browser, WebGL2, TypeScript.

code: https://github.com/geotyper/taut

Based on Conway's "Game of Life" algorithm, transposed to 3D space, with sound generated for each event. Thanks for watching!

experiment in hyper-skeuomorphic UI design

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

A better view with some motion and insight into a few of the layers that are used to run the Sim and compose the render.

One rule: each cell counts the labels in a disc around it and takes the most common one, with air counting for less. Bubbles grow from seeds, meet, and the borders pull taut into films that join three at a time.
code: https://github.com/geotyper/taut

One small NCA grows 24 plant species and a lawn. Every seed looks the same, and the species is encoded inside the seed.

The video is of the wallpaper running on my laptop. A grass seed drops and the lawn spreads over the dirt. Then seeds fall one at a time down columns that are clear of other plants, and each one grows into whatever it was encoded to be. When there's no room left, that layer recedes toward the horizon and a fresh strip of dirt comes in.

The model wasn't trained with plant to plant interactions in mind, so I space them out so they don't touch.

Every Life-like rule without B0 (131,072 of them) gets two random 40×40 soups and two tiny seeds in empty space. The ~1,500 most promising get bigger soups and a census: every isolated object is replayed alone, and if it returns to its own shape within 16 generations it's catalogued as a still life, an oscillator or a spaceship (with its speed). A full sweep takes about two minutes on a 16-core laptop.

The scoring trick that made it work: compare each soup with itself 12 generations earlier. Every oscillator with period 1, 2, 3, 4, 6 or 12 cancels out, so what's left is change that goes somewhere: ships, growing debris, or noise. The first version scored "never settles and compresses well", and it put boiling blob rules on top.

What it found (seed 1):

- 7 of the top 10 are rules already named on LifeWiki: EightLife (#1), Conway's Life (#2), HoneyLife, IronLife, Pedestrian Life, LowDeath and HighLife. All of them passed the first screen on their own.

- 34 kinds of spaceship across 27 rules, including c/7 diagonal ships in B36/S245, B3/S245 and B38/S02458, and a 13-cell c/8 orthogonal ship in B347/S268.

- Seed 2 reshuffles the order (Pedestrian Life comes first), but Life's family still holds 9 of the top 12.

**Live field guide** (every rule runs in your browser, next to the creatures it caught): https://r-hatim.github.io/rule-safari/

**Code** (Rust, MIT): https://github.com/R-Hatim/rule-safari

The census is tiny next to Catagolue (objects up to 16×16, periods up to 16), so this is a quick map of the rule space, not a serious search. I'd love ideas for better "interestingness" measures, or rules you think it unfairly buried.

I'm a PhD student who models plants by day, and this started as something to stare at that has great patterns from simple rules. A sweep line plays every live cell under it as a pentatonic note, so gliders and oscillators turn into loops.

Other things in it:

- Lookahead colours cells by fate (green lives, red dies, grey is about to be born) and previews 1–55 generations ahead

- Aura colours cells by age, with fading trails

- Rule Lab: HighLife, Day & Night, Seeds, plus 11 puzzles (survive, hold a zone, cross the board)

Free in the browser, nothing to install: https://lifegameproject.com/life.html

iPhone/iPad (free, no ads, no tracking): https://apps.apple.com/app/id6821541367

I'd love to hear which patterns sound best to you XD!

Hello quite new to this community some very cool stuff. I have been investigating this celluar automata, which came about it quite a convoluted way but produces some interesting patterns. Quite happy, as all my previous attempts at making interesting simulations have been floops. It's such a good felling, like exploring a new alien world.

So this one has 14 states, which change based on a lookup matrix that maps each possible pair to a new state. So say state 3 and state 4 gives state 7. An exception is if it goes to 0 or 15 (I call these foribben state), basically as when I allowed these they would completly dominate.

To detimine which 2 neighbours they look at i have a cycle of different pairs each state looks at each turn. I use the morre neighborhood so each cell has 8 neighbours. So say state 1 might look to neighbours (1, 2), (3, 4), (4, 3) and then back again to (1, 2)

In the beginning I tried random neighbours each time, which produces more chaotic blobs that grow and shrink over time. With the fixed cycle of neighbours you get more structure, but as you probably expext many produce random noise or quickly become static/flickering.

A surprising amount though looks interesting, with patterns that change over time. The second image ( I call them sandbars) continually changes, with those arching patterns lengthing, breaking and forming elsewhere remaining me of sandunes.

Lots still to do if I ever get time would like to try some generic algorithms to search more precisely for interesting neighborhood rules and explore different lookup tables.

I would be very interested to know if people have seen a CA like this before for me to also look at.

Here is a GitHub link to a tidied up version of the code for anyone who wants to have a look and make some animations and explore themselves:

https://github.com/FionnWyn42/14state-CA/tree/main

A follow-up to the 2D clustering post, now in a voxel field. Each group of nearby stones gets its own membrane, coloured by cluster.

It is one local rule applied by every cell at once. Nearby stones agree on a common label, and each group's membrane starts as a fat blob and pulls taut around its stones. Membranes of different groups never merge.

Code: https://github.com/geotyper/taut

Continuing experiments with a cellular automaton that stretches rubber bands around clusters of stones. Before, each cell could belong to only one band, so neighbouring bands dented each other. Now a cell holds several bands at once, and the clusters sort themselves into separate layers, so each band reaches its full convex hull and passes over its neighbours.

It is still one local rule, with every cell updating at the same time.

code: https://github.com/geotyper/taut

A follow-up to the 2D rubber band post. Now there is one band per group of stones instead of one around everything.

It is a single local rule: every cell looks only at its 8 neighbours. Nearby stones agree on a common label, and each group gets its own band that pulls taut around it. Bands of different groups never merge.

Code: https://github.com/geotyper/taut/tree/clusters-single-field

i made this rule

(Apologies if bad grammar, English as second language.)

I made a cellular automaton brainstorming in school, and I cannot find if I came up with it first or if somebody else has made this before me.

The rules are pretty simple:

• Each tile can point in 4 directions, they can point in multiple directions.
• An activated tile activates tiles that it points to.
• If multiple tiles try to activate a tile it will not activate, aka a tile turns on if specifically one tiles activates it.

Addisonaly I vibe coded a simulator:

https://xblowdame.github.io/cell_auto/

Does anybody know if this exists?

All primes till 10,000 are represented here, primes are the white squares, reminds me of game of life patterns.

A follow-up to 2D rubber band post. Same idea in a voxel field: a membrane starts as a ball and tightens around a few stones.

The rule is local: a cell stays inside if, along at least one of 49 lines through it, most cells within reach are inside. A direct 3D port of the 2D rule didn't work.

Code: https://github.com/geotyper/taut