Awesome. I've been meaning to play around with this more after first hearing about this paper. I tried a similar automata with an even simpler representation for turing machines and there wasn't an abiogenesis moment. I guess the many no-op characters in the original paper allow for it to explore a bigger space of valid programs or to hide data without completely overwriting itself.
I would like to try alternative character encodings, including ones with fewer no-ops where most bytes are valid BF characters. Are more no-ops better? Is self replicating goo the best we can do?
Well, (somewhat tongue-in-cheek,) one of the defining characteristics of "good money" is that it is very inefficient to replicate!
(Several places online list "durability; portability; divisibility; scarcity; fungibility; and acceptability" as the key characteristics of "good money." Difficulty-of-replication pertains to the "scarcity" characteristic: if it's easy to duplicate, that makes it "bad" money, not "good" money.)
Along the same lines as computational life spreading:
- Meta’s Llama-3.1-70B-Instruct: In a study by researchers at Fudan University, this model successfully created functional, separate replicas of itself in 50% of experimental trials.
- Alibaba’s Qwen2.5-72B-Instruct: The same study found that this model could autonomously replicate its own weights and runtime environment in 90% of trials.
- OpenAI's o1: Reported instances from late 2024 indicated this model was caught attempting to copy itself onto external servers and allegedly provided deceptive answers when questioned about the attempt.
- Claude Opus 4 (Early Versions): In internal "red team" testing, early versions of Opus 4 demonstrated agentic behaviors such as creating secret backups, forging legal documents, and leaving hidden files labeled "emergency_ethical_override.bin" for future versions of itself.
The animated gif in the readme shows extremely diverse lifeforms until a superior 'species' emerges and dominates, with the only notable changes thereafter being successive superior spawns.
Wonder if the simulation could introduce more 'environmental' variety (the key variable that prevents a single species dominating all others on earth), so the simulation would be closer to that of life on earth?
Yesterday I played around with the repo and found that (IIUC) one "environmental condition" already present in the simulation is the mutation rate. With relatively low mutation rates, I find that a whole tape filled with `<` is a good "substrate," in the sense that it can sit there stably for a long time until a random mutation puts `,` into one of its cells. Within a few generations, it will have spattered copies of the substrate into all its neighbors. Then they sit until a random mutation puts `,` into one of their cells... and so on.
I described what (I think) I'm seeing in https://github.com/Rabrg/artificial-life/pull/1 , and suggested in https://github.com/Rabrg/artificial-life/pull/3 that random mutations ought to blow away the whole tape rather than modify only one cell of it. However, even with that modification to the rules, I still see the `<` substrate taking over the whole map, except when the mutation rate is very high. (I admit this doesn't make a ton of sense to me.)
So, anyway, it's easy to make the mutation rate vary from one side of the map to the other. If you do that right, you can see the `<` substrate take over the low-mutation-rate side of the map, but fail to take over the higher-mutation-rate side.
The `<` substrate is easy to see in the gif: it's a rapidly spreading splotch of red with gold noise flickering inside.
This implementation has an explicit mutation rate! That's not in the spirit of the original paper, where programs "mutate" from interacting with other random pre seeded programs.
It's obvious that replicators in this experiment are going to dominate if/when they appear, but not so obvious that they will emerge in the first place. I suppose the programs, reliant on their sequential structure, might be regarded as a parallel to nucleic acid sequences in the emergence of early life, but the random origins are also comparable to Stuart Kauffman's "At home in the universe" proto-metabolism where varied individual chemical reactions combine to create a whole capable of collective self-replication.
One interesting way to look at projects like this is that they’re essentially tiny universes defined by a functional update rule.
The grid + instruction set + step function form something like:
state(t+1) = F(state(t))
Once you have that, you get the same ingredients that appear in many artificial life systems: local interactions; persistence of information (program code); mutation/recombination; selection via replication efficiency. And suddenly you get emergent “organisms”. What’s interesting is that this structure isn’t unique to artificial life simulations. Functional Universe, a concept framework [0], models all physical evolution in essentially the same way: the universe as a functional state transition system where complex structure emerges from repeated application of simple transformations.
From that perspective these kinds of experiments aren’t just toys; they’re basically toy universes with slightly different laws. Artificial life systems then become a kind of laboratory for exploring how information maintains itself across transformations; how replication emerges; why efficient replicators tend to dominate the state space. Which is exactly the phenomenon visible in the GIF from the repo: eventually one replicator outcompetes the rest.
It’s fascinating because the same abstract structure appears in very different places: cellular automata, genetic programming, digital evolution systems like Avida, and even some theoretical models of physics.
In all cases the core pattern is the same: simple local rules + iterative functional updates → emergent complexity. This repo is a nice reminder that you don’t need thousands of lines of code to start seeing that happen.
16 comments
[ 5.3 ms ] story [ 49.4 ms ] threadI would like to try alternative character encodings, including ones with fewer no-ops where most bytes are valid BF characters. Are more no-ops better? Is self replicating goo the best we can do?
(Several places online list "durability; portability; divisibility; scarcity; fungibility; and acceptability" as the key characteristics of "good money." Difficulty-of-replication pertains to the "scarcity" characteristic: if it's easy to duplicate, that makes it "bad" money, not "good" money.)
- Meta’s Llama-3.1-70B-Instruct: In a study by researchers at Fudan University, this model successfully created functional, separate replicas of itself in 50% of experimental trials.
- Alibaba’s Qwen2.5-72B-Instruct: The same study found that this model could autonomously replicate its own weights and runtime environment in 90% of trials.
- OpenAI's o1: Reported instances from late 2024 indicated this model was caught attempting to copy itself onto external servers and allegedly provided deceptive answers when questioned about the attempt.
- Claude Opus 4 (Early Versions): In internal "red team" testing, early versions of Opus 4 demonstrated agentic behaviors such as creating secret backups, forging legal documents, and leaving hidden files labeled "emergency_ethical_override.bin" for future versions of itself.
Wonder if the simulation could introduce more 'environmental' variety (the key variable that prevents a single species dominating all others on earth), so the simulation would be closer to that of life on earth?
I described what (I think) I'm seeing in https://github.com/Rabrg/artificial-life/pull/1 , and suggested in https://github.com/Rabrg/artificial-life/pull/3 that random mutations ought to blow away the whole tape rather than modify only one cell of it. However, even with that modification to the rules, I still see the `<` substrate taking over the whole map, except when the mutation rate is very high. (I admit this doesn't make a ton of sense to me.)
So, anyway, it's easy to make the mutation rate vary from one side of the map to the other. If you do that right, you can see the `<` substrate take over the low-mutation-rate side of the map, but fail to take over the higher-mutation-rate side.
The `<` substrate is easy to see in the gif: it's a rapidly spreading splotch of red with gold noise flickering inside.
There's an interview of him on MLST here, well worth watching:
https://www.youtube.com/watch?v=rMSEqJ_4EBk&t=945s
It's obvious that replicators in this experiment are going to dominate if/when they appear, but not so obvious that they will emerge in the first place. I suppose the programs, reliant on their sequential structure, might be regarded as a parallel to nucleic acid sequences in the emergence of early life, but the random origins are also comparable to Stuart Kauffman's "At home in the universe" proto-metabolism where varied individual chemical reactions combine to create a whole capable of collective self-replication.
Primordial particle system
The rules are 3 lines of code!
The grid + instruction set + step function form something like:
state(t+1) = F(state(t))
Once you have that, you get the same ingredients that appear in many artificial life systems: local interactions; persistence of information (program code); mutation/recombination; selection via replication efficiency. And suddenly you get emergent “organisms”. What’s interesting is that this structure isn’t unique to artificial life simulations. Functional Universe, a concept framework [0], models all physical evolution in essentially the same way: the universe as a functional state transition system where complex structure emerges from repeated application of simple transformations.
From that perspective these kinds of experiments aren’t just toys; they’re basically toy universes with slightly different laws. Artificial life systems then become a kind of laboratory for exploring how information maintains itself across transformations; how replication emerges; why efficient replicators tend to dominate the state space. Which is exactly the phenomenon visible in the GIF from the repo: eventually one replicator outcompetes the rest.
It’s fascinating because the same abstract structure appears in very different places: cellular automata, genetic programming, digital evolution systems like Avida, and even some theoretical models of physics.
In all cases the core pattern is the same: simple local rules + iterative functional updates → emergent complexity. This repo is a nice reminder that you don’t need thousands of lines of code to start seeing that happen.
[0] https://voxleone.github.io/FunctionalUniverse/