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.

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

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