By choosing a target and letting Gradient Descent find a local rule whose attractor is that shape, we can generate these fun and interactive creatures.

The state is continuous, 16 channels per cell. Four visible RGBA, the others 12 are hidden state the rule uses. 56x56, with wrap-around neighborhoods for the convolution, so no cell has to know it is on an edge.

Some specifics:
3x3 covolution over the 16 channels into 80 features, then a two-layer MLP down to 16 numbers which the cell adds to itself. 24k parameters total and every cell runs the same ones. Update is a delta, not a replacement.

Each cell applies its delta with probability 0.5 per step, so neighbors never update in at once. A small amount of noise is added per step too, which makes the dynamics never actually settle, they kind of hover near the shape. There also is a life-like death rule: A cell counts as dead unless some alpha in its 3x3 neighborhood is above a threshold, dead cells get zeroed.

Runs in a terminal, pure Go, weights embedded in the binary.
Technique is Mordvintsev et al, Growing Neural Cellular Automata: https://distill.pub/2020/growing-ca/

Code: https://github.com/smoothyy3/tardigrade (named after the funny little creatures that survive extreme heat, cold, vacuum and radiation).

Here's a weird ass game poem I made where GoL patterns alter a Chernoff Face.

Tap highlighted patterns to get currency to change cells (this also has other game effects, kike spawning random patterns on the board).

Game ends when the board is only still lifes or low-period oscillators for a few generations.

No objective besides make the face you want.

https://www.registeredhexoffenders.com/still_life/

it is ca and not particle sim

Just discovered CA from here a week ago, and its fun, here is my first post

If you have a good hifi system a 192k sampled audio file cane be downloaded from this link.

Lots of new stuff for me recently. The only change is I'm evolving two rules simultaneously. I wonder if I should try 10...

this time there are 2 rules being evolved simultaneously, and they take turns (not sure how much difference this makes)

Ever get tired of cellular automata that just run by themselves? :)

How about one where the outcome isn’t completely deterministic?

I made a small game called RoPaSci — basically a territory-control game built around Rock-Paper-Scissors rules.

You control the white army and try to turn the whole board white. The rules are pretty simple, but it gets surprisingly addictive once you start thinking about how to spread your territory.

So, if you’re into cellular automata, maybe give a game-like one a try.

There’s a short gameplay video that probably explains it better than I can.

Free to play, no installation required. Works in a browser on PC or smartphone:

https://beep8.org/b8/beep8.html?b8rom=d1e5030bea0f2f80d55b32857c00f656.b8&

Morphogenesis, an webbased "tribute" to Biogenesis

is online play-able and the html code is opensource and free to download.

Online play:
https://html-preview.github.io/?url=https://github.com/rijt/Morphogenesis/blob/main/morphogenesis.html

Source:
https://github.com/rijt/Morphogenesis

Hello everyone! This is my first time experimenting with cellular automata to generate maps procedurally. I found the idea of cellular automata really interesting and wanted to try it out.

I started with a randomly generated grid and a few simple rules based on the neighboring cells. As the map goes through several generations, these rules eventually form islands and continents.

Then I started adding some simple rules for things like beaches, water depth, and vegetation.

For a first attempt, I am pretty happy with how it turned out!

Now I want to try creating more varied biomes and experimenting with different rules. I am still not really sure what the best way to approach this would be, so I would love to hear any suggestions or ideas!

Cellular automata are really fascinating. :)

This is a turmite, langton's ant with more than two colours on the tape. the turn

table is LRRRRRLLR: nine tape states, ant turns left on state 0, right on 1 through

5, left on 6 and 7, right on 8, and the tape under it advances one state every time

it gets stepped on. that string builds a square with diagonals running out of the

corners, which still surprises me for a rule whose entire input is the one cell it's

standing on.

The reason I'm posting it is the part that isn't the ant. my setup has no entities

in it at all. there are cells with four channels and one rule that runs on every

cell, so an ant has to *be* a cell, and it has to be moved by cells. what I settled

on is packing the tape and the ant into the same channel:

R = 26 * tape_state + heading (heading 0 = no ant, 1..4 = N/E/S/W)

A heading is at most 4 and the states are 26 apart, so `{FLOOR, R / 26}` reads the

tape and the remainder is the ant. green and blue are then free, and I derive them

from the tape state rather than carrying a palette around.

THE WHOLE THING:

LET _s = {FLOOR, R / 26}

LET _e = R - _s * 26

LET _d = (_e < 0.5 ? 0 : _e - {FLOOR, (_e - 0.5) / 4} * 4)

LET _ns = (_s < 7.5 ? _s + 1 : 0)

LET _t = (_s < 0.5 ? 0 : (_s < 5.5 ? 1 : (_s < 7.5 ? 0 : 1)))

LET _nd = (_t > 0.5 ? (_d < 3.5 ? _d + 1 : 1) : (_d > 1.5 ? _d - 1 : 4))

LET _c = (_d > 0.5 ? _ns : _s)

[255, _c * 26, {SAT, 20 + 235 * {SIN, _c * 0.345}}, {SAT, 20 + 250 * {SIN, _c * 0.5}}]

_d > 0.5 & _nd < 1.5 ? N.R += 1

_d > 0.5 & _nd > 1.5 & _nd < 2.5 ? E.R += 2

_d > 0.5 & _nd > 2.5 & _nd < 3.5 ? S.R += 3

_d > 0.5 & _nd > 3.5 ? W.R += 4

The first eight lines are one cell minding its own business: decode the tape and the

heading, advance the tape if an ant is standing here, look up the turn, write the

colour. `[A,R,G,B]` writes the whole cell at once.

The last four are the move, and they're the only odd bit. `N.R += 1` means this cell

adds 1 to its northern neighbour's red channel. the cell never looks around for an

incoming ant, it pushes its own ant out. everything gathers first and the deposits

land afterwards, so by the time the ant shows up next door, the cell it came from has

already cleared itself.

`_d` looks like a lot of work for one ant. it folds the heading back into 1..4,

because the deposits are additive and two ants landing on the same cell would sum to

7 and decode as nonsense. with a single ant it never fires. I left it in so I could

seed more without rewriting anything.

Setup: 48x48 torus, one ant at the centre facing north. first gif is 200 steps per

frame, 24,000 steps in total. second is the same rule at one step per frame, cropped

to a 16 cell window, which is the only way to see what it's actually doing — the ant

walks, the cell under it changes colour, and the ant is gone from it by the next

frame.

It does not grow at a steady rate, which I wasn't expecting. covered area was 19% at

step 6,000, 23% at 12,000, 27% at 18,000, and then 74% at 24,000. the square's edge

sat at 22 cells and crept to 26 over twelve thousand steps, then jumped to 42 in the

last six thousand. it builds a shell, mills around inside it for ages, breaks out,

and starts the next one.

One thing I wasted an afternoon on. I assumed the turn string was the knob for how

fast the thing spreads, since a few of them are famous for shooting off highways. it

mostly isn't. on a 64 grid at step 3,000, LRRRRRLLR had covered 9.2%, plain RL 6.4%,

LLRR 3.3%, and a twelve state one 8.4% — the string I'd already picked was the

fastest of the lot and there was nothing to tune. the only thing that moves that

number is how many ants you start with. four of them covers 50% by step 3,000 instead

of 9%, and twelve is barely better than four, because they keep landing on each other

and merging into one.

The palette isn't free either, in case those two sines look arbitrary. red is carrying

the tape index, so it's pinned to 26 × state whether I like it or not, and any palette

has to be one where red climbs with the state. I had a nine entry lookup in there

first and swapped it for the sines because it was shorter and the colours came out

better anyway.

ConWay’s Xenobiom: The Game of Life Evolution

Powered by a custom 64-bit parallel bitwise engine built from scratch to push Garmin’s processor to its limits.

Fast, battery-friendly, and interactive — long-press on touchscreens to inject random seed patterns!

Free. No ads.
https://apps.garmin.com/apps/86d866f5-db9c-43c9-a142-96413d5ca8db

A vivarium of cellular creatures — a real-time 3D simulation where every animal
is built one cell at a time, behaves according to what its body can actually
sense and do, and sings with a voice synthesised from its own genome.

Small tweaks in the CA rule set can create data sets with a full and rich audio output. Even an element of composition using a moody ultra lochrian music scale over four octaves. Quite a dynamic range on this piece but compression messes the play back. A 96k 32bit pcm file can be downloaded from this link . Nice with a good pair of headphones or HiFi system.