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.

Cellular automata have the issue that they easily die out or spiral out to fill the whole canvas, and particle life doesnt change the particles.

A cellular automata with constant total population, or sources of population at small populations and so on could prevent it from dying out.

Particle life with changes like fusion and splitting, where certain colors have certain density or energy that is the combination of the fusing parent particles would be like a chemestry simulation and could become extremely interactive and emergent.

I cant program, so it would be an honor if some of you would make something cool like that.

last time I posted a growth rule where a new cell takes the mean colour of its living neighbours, and someone asked in the comments whether colours done that way have to end up

converging. short answer is yes, if you keep averaging. an average is a contraction and grey is the only fixed point it has.

so here's the version that can't converge, because it never does arithmetic on a colour at all. a cell picks one of its four neighbours at random and becomes it:

LET _k = {FLOOR, RN * 0.015625}

LET _pr = (_k < 1 ? N.R : (_k < 2 ? E.R : (_k < 3 ? S.R : W.R)))

LET _pg = (_k < 1 ? N.G : (_k < 2 ? E.G : (_k < 3 ? S.G : W.G)))

LET _pb = (_k < 1 ? N.B : (_k < 2 ? E.B : (_k < 3 ? S.B : W.B)))

_pr + _pg + _pb >= 40 & RN < 128 ? [255, _pr, _pg, _pb]

RN is a fresh 0-255 random per cell per step. _k is that over 64, so 0-3, picking north/east/south/west. the bit that matters is that _k is bound once, so all three channels read

the same neighbour. pick a parent per channel instead and you've quietly reinvented mixing. the >= 40 test means you only copy a neighbour that's actually alive, which is what

lets the colonies eat the black field instead of the black field eating them. RN < 128 is just a coin flip for whether a cell updates this step.

setup: 128x128 torus, solid black, 24 single pixels of random bright colour, captured every 5th step.

this is the voter model, and it's the same drift as the last one but on a full lattice instead of only along a growing front. the count of distinct colours on screen was 24 at

fill, 22 at step 1500, 14 at step 5000. it only ever goes down. lineages get wiped out, nothing new ever appears, and nothing blends, so every pixel you're looking at is an exact

copy of one of the 24 seeds handed along some chain of neighbours. spatial standard deviation was 59 at fill and 61 at step 5000, ie it isn't fading, it's just losing colours.

the difference from the averaging one shows up where two regions meet. averaging gives you a soft seam. copying gives you a boundary that random walks, which is why these edges

look torn instead of drawn.

I got the same thing wrong twice before it worked. I kept the old growth rule (empty cells take the mean of their neighbours) and only made living cells copy, figuring the growth

half didn't matter. it does. averaging at colonisation makes every single cell a slightly different colour, so you're starting with ~16000 distinct alleles rather than 24, and

voter coarsening in 2d is logarithmic, so it just sits there as confetti indefinitely. it has to be copying all the way down.

also, in that thread I said that keeping the mutation running on living cells would settle into patches that keep shifting. I went and ran it properly afterwards and it doesn't.

you get a washed out pastel haze, standard deviation sliding from about 11 down to 9 over a thousand steps and still going. diffusion plus white noise is still a linear system,

there's nothing in it that separates one colour from another, so it just finds a low contrast equilibrium and sits in it. copying is what I should have said.

it does have an ending, for what it's worth. one colour eventually takes the whole grid, in about N log N steps, so somewhere near 160k for this size. it never passes through

grey on the way, which was the actual question.

https://extra-sugar-extra-salt.neocities.org/particle_life_3D

you can play with it yourself, it's just a thing I made with Claude. i messed with it for a while adding quality of life stuff and more customization options.

it's set up to be pretty easy to start playing with, but with options to get more complicated if you want. depending on the capabilities of your device, you can get pretty good performance.

things like this, the hard part is that the number of calculations that have to happen tends to go up exponentially with the number of particles. by limiting interaction distance, we at least pull the reins back on that effect a bit, and by using your GPU, you can see that at least for me (4070 Super) you can get up around 50k particles which is way better than what I ever did with my own hand-coded python particle simulations like this.

It's interesting how it does seem to form different animals and fish and stuff with organs in their bodies.

Growth is the boring half of this rule: an empty cell with at least one living

neighbour comes alive with about a 9% chance per step. The half I actually care

about is that **colour is inherited** — a new cell takes the mean colour of its

*living* neighbours and adds a small random nudge.

LET _live = {COUNTNZ, MOORE.R}

LET _pr = {SUM, MOORE.R} / _live

LET _pg = {SUM, MOORE.G} / _live

LET _pb = {SUM, MOORE.B} / _live

R + G + B < 40 & _live > 0 & RN < 24 ?

[255, {CLAMP, _pr + RN * 0.22 - 28, 45, 255},

{CLAMP, _pg + RN * 0.22 - 28, 45, 255},

{CLAMP, _pb + RN * 0.22 - 28, 45, 255}]

Reading it: `MOORE` is the 8 surrounding cells. `{SUM,…}/{COUNTNZ,…}` averages

over only the *living* ones — averaging over all 8 would count empty cells as

black and drag every lineage toward grey. `RN` is a fresh 0–255 random per cell

per step, so `RN < 24` is the ~9% colonisation chance and `RN * 0.22 - 28` is a

mutation centred on zero. The `[A,R,G,B]` literal writes the whole cell at once,

and there's no else branch, so cells that fail the test are just left alone.

Setup: 128×128 torus, black field, 5 random spores, captured every 4th step.

Colour is a random walk along each growth front, and once two fronts separate they

can never mix again — so lineages diverge, for the same reason isolated

populations do. The hard seams are where two lineages that parted long ago finally

run into each other.

Two things I got wrong first, in case you try it:

* Inheriting `{MAX, …}` instead of the mean. Every generation then picks the

brightest parent, and the whole field burns out to white within a few hundred

steps.

* The mutation has to be genuinely zero-mean. My first attempt was

`RN * 0.10 - 12`, which looks symmetric but drifts +0.75 per generation — enough

to wash all the colour out from underneath you.

Rules are plain text like this in the editor I built (Phluxel); the RGB channels

*are* the cell state, which is why colour can carry a heritable trait at all.

Happy to answer anything about the syntax.

I built a cellular automaton based on my theory of how distinctions form, interact, and leave structural residue: The Prime Move Theory.

The cells cycle through:

SPLIT → TENSION → FAILED MERGE → SCAR → DECAY → VOID

The system tracks the ratio between successive generations of scars:

b(k+1) / b(k)

In the current implementation, the ratio appears to converge toward φ ≈ 1.618.

The interesting part is that φ isn’t hard-coded as the target. It’s something I’m observing from the behavior of the system.

You can interact with it:

• Click SEED to plant a SPLIT
• Watch the system evolve
• Watch the generational scar ratio
• See what happens as the system approaches φ
• The source is open

Live demo:
https://chrissabo1975.github.io/PrimeMovePublic/

Foundational paper:
https://zenodo.org/records/18998546

These are my first attempts at building cellular automata, so I’m very much interested in criticism, alternative explanations, or ways to test whether the convergence is actually meaningful.

I’m not presenting this as proof of the theory. I’m trying to find out what the mechanism actually does.

Would love to hear what you think.

https://sliderules3d.mysterysystem.com/

My dream came true seeing my automata in my room!

On Meta Quest 3 try with lower than 100x100x100 cells. The presets are not finalized and I need to go through them (lots of variations), but some may be too busy to track nicely.

I’d be curious how it works on PC VR setup or if it works at all.

There's extending and retracting rods are very curious to me. I've seen them come up a lot in 2D automata (usually a 3x1 base with a line in the middle extending out) and now I'm seeing something very similar in 3D automata (usually a 3x3 base with a line in the center extending out).

It's interesting to note how two of these objects colliding directly with each other seems to do some kind of phase transition that just changes their direction by 90º bug it also makes them slightly longer (see yellow part).

Centre square in video shows the sensing zone and outer square show the harmonic influence zone which affects the timbre of the sensing pixels.

Compression messes the play back but a 96k 24bit pcm file can be downloaded from this link . Nice with a good pair of headphones or HiFi system.

the day and night cellular automaton on a random grid looks like a planet being formed from random noise

So, way back in 2008 we made a procedural game for an indie games contest, based on a mix of Freeman Dyson's trees and Astrochicken concept, Phillip K Dick's "Autofac" story, and my own fascination with cellular automata.

The idea was that lost colonies of self-replicating terraforming units would eventually come into conflict with other offshoots of the same original units, and end up in a perpetual war for resources.

That eventually became the game Eufloria and now also Eufloria 2, but the same basic principles behind it are still adhered to.

I even made a mod recently where the game plays itself, and you can just observe them in their hunter/prey cycles as they fight over resources.

Hi everyone,

I am sharing a novel dynamical system I’ve been developing called SNS-CA (Structural Numerical Symmetry Cellular Automaton).

Traditional cellular automata (like Conway's Game of Life or Rule 30) are strictly bound to the von Neumann-Ulam paradigm: a cell's state is dictated entirely by its spatial neighbors. SNS-CA departs from this rule. In this system, cells do not interact with each other at all. Instead, emergence and evolution are driven purely by the internal arithmetic symmetry of the number held by each cell.

How it works:

At each iteration, a cell processes its numerical state N through three deterministic operations:

1. Splitting the number N into m parts.
2. Multiplying each part by a scalar k.
3. Comparing the transformed result with the true mathematical product ( N⋅k ) by analyzing their prefixes and suffixes.

Depending on the structural match, the cell transitions to one of five theoretical states:

🟡 F (Full): Complete match (perfect arithmetic symmetry).

🟢 B (Boundary): Match at both the start and the end.

🔴 E (End): Match only at the suffix.

🔵 S (Start): Match only at the prefix.

⚫ N (No): No matches found (the cell transitions to the zero state).

Emergent Behavior:

Simulations reveal a fascinating self-organizing dynamic. The system rapidly converges toward stable arithmetic symmetry. Early transient states (like E) quickly resolve into highly stable, persistent patterns of Full (F) and Boundary (B) symmetry. This suggests that arithmetic symmetry acts as a fundamental attractor in this state space, allowing complexity and stability to arise purely from number theory rather than spatial geometry.

I have open-sourced the complete Julia implementation and published a conceptual paper detailing the framework.

Source Code (GitHub):.jl)

Concept Paper & DOI (Zenodo):

I would love to hear the community's perspective:

1. Has anyone observed similar convergence behavior in other arithmetic dynamical systems (e.g., Kaprekar routines)?
2. What parameter spaces ( m,k ) would you recommend exploring to uncover new classes of emergent behavior or phase transitions?

Thank you for your time and insights!

AUTHOR: Mikhail Yuryevich Yushchenko

Date: 09.08.2026

https://reddit.com/link/1vzmhg2/video/0fm14xzgrtih1/player

SNS-CA simulation (m=2, k=3, 100×100 grid, 300 steps). The system rapidly converges from transient states ( Red) toward stable arithmetic symmetry — predominantly Full (🟡 Golden) and Boundary (🟢 Green) matches.

Disclaimer: This is NOT a mathematical proof of the Collatz Conjecture. This is a generative, systems-philosophy model that uses Collatz trajectories as a core mechanism for simulating artificial life, entropy, and complexity.

The Core Idea: Collatz as Aging, Not Death

In classic mathematics, the Collatz Conjecture states that any positive integer N under the rule:

* N / 2 (if even)

* 3N + 1 (if odd)

...eventually collapses into the 4 \to 2 \to 1 cycle.

Standard mathematics views 1 as the end of the line. In this theoretical model, 1 is not death — it is an entropy reset and a point of mutation.

We treat numbers not as static values, but as living branches (genomes) evolving through time.

How the Evolutionary Engine Works

The model operates through three fundamental mechanics:

* Gravational Collapse (Aging):

Each active branch starts at any arbitrary number N (from small numbers up to millions). The standard Collatz rule acts as environmental gravity/aging, gradually collapsing the branch's complexity down toward 1.

* Point Mutation at 1 (Rebirth):

When a branch reaches 1, it undergoes a phase transition. Instead of terminating, it triggers a mutation with a set probability, launching a completely new random value N_{\text{new}} and starting a fresh life cycle.

* Multiplicative Resonance (X^k Complexity Jump):

If k independent branches hit the exact same number X on the same step, they don't just pass each other. They experience resonance (symbiosis) and merge into a single super-branch:

This exponential jump propels the newly formed hybrid into massive values, protecting it from immediate collapse and giving it a much longer life cycle.

Python Simulation Code

Here is a clean, working implementation of the engine. You can run it directly to see mutations and resonance events in real time:

import random

from collections import defaultdict

class Branch:

def __init__(self, branch_id, start_value):

self.id = str(branch_id)

self.value = start_value

self.is_active = True

def step(self, mutation_rate=0.6, max_mutation_val=10_000_000):

if not self.is_active:

return

# 1. Entropy Reset (Point Mutation at 1)

if self.value == 1:

if random.random() < mutation_rate:

old_val = self.value

self.value = random.randint(1_000_000, max_mutation_val)

print(f" 🧬 MUTATION! Branch [{self.id}]: 1 ➔ {self.value:,}")

else:

self.is_active = False

return

else:

# 2. Collatz Trajectory (Aging / Compression)

if self.value % 2 == 0:

self.value //= 2

else:

self.value = 3 * self.value + 1

def run_evolutionary_collatz(start_values, steps=25):

branches = [Branch(f"B{i+1}", val) for i, val in enumerate(start_values)]

print("🧬 STARTING EVOLUTIONARY COLLATZ ENGINE")

print(f"Initial Branches: {[f'[{b.id}]: {b.value:,}' for b in branches]}\n")

for tick in range(1, steps + 1):

active = [b for b in branches if b.is_active]

if not active:

print(f"\n⏹ All branches terminated at step {tick}.")

break

print(f"⏱ STEP {tick}:")

# Step A: Advance active branches

for b in active:

b.step()

# Step B: Group by current value to detect resonance

value_map = defaultdict(list)

for b in branches:

if b.is_active and b.value > 1:

value_map[b.value].append(b)

# Step C: Multiplicative Resonance (X^k)

for val, cluster in value_map.items():

k = len(cluster)

if k > 1:

cluster_ids = "+".join([b.id for b in cluster])

super_val = val ** k

print(f" ⚡️ RESONANCE! {k} branches [{cluster_ids}] met at {val:,}!")

print(f" Formula: {val:,}^{k} ➔ Super-Branch: {super_val:,}")

# Merge branches into one super-branch

main = cluster[0]

main.id = f"({cluster_ids})"

main.value = super_val

for merged in cluster[1:]:

merged.is_active = False

if __name__ == "__main__":

random.seed(42)

# Start with 5 large macro-branches

run_evolutionary_collatz(

start_values=[1_258_641, 4_839_201, 9_102_847, 2_501_938, 7_492_018],

steps=20

)

System Dynamics Takeaway

This model shifts the narrative from pure arithmetic to information dynamics:

* 1 represents LUCA (Last Universal Common Ancestor) or the Big Bang — a state of zero entropy from which novelty explodes.

* Collatz rules represent deterministic physics drawing systems toward simplicity.

* X^k Resonance mirrors endosymbiosis: identity creates complexity spikes that keep the system alive across generational cycles.

What are your thoughts on using simple mathematical attractors as baseline physics for generative life models? Would love to hear your feedback on the code or mechanics!

I refresh every once in a while to show how random the shapes can get, but it's worth noting how cool these are when they play out too. This is just my ordinary slide rules setup, no special programming.. just kind of worked out this way when I tried different rules.

Itch: https://aeuludag.itch.io/cellular-swarm

Source: https://github.com/aeuludag/CellularSwarm