Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction

Brainfuck is largely a joke for most developers, but in certain kinds of research it is taken very seriously due to its ease of implementation. I think this is probably the most interesting paper involving it: https://arxiv.org/abs/2406.19108 > In this paper we take a step towards understanding how self-replicators arise by studying several computational substrates based on various simple programming languages and machine instruction sets.

Computational Life Reactor (CLR) is an interactive browser implementation by Alex Borger of the computational-life experiments studied by Agüera y Arcas and collaborators https://arxiv.org/abs/2406.19108. Random byte tapes are repeatedly paired and executed in the BFF language, allowing self-replicating programs to emerge without a fitness function or explicit selection process. CLR provides live population visualizations, frequency and compression measurements, and a step-by-step execution sampler. The simulation runs locally using WebAssembly and parallel browser workers. A great 12 minutes introduction into the topic featuring CLR is provided by Johannes Martin (Number Cruncher) on YouTube https://youtu.be/w9_fWcNeITg

There have been experiments in "digital primordial soup", where primitive programs are cultivated under conditions with evolutionary pressure. Computational Substrates: How Well-formed, Self-replicating Programs Emerge from Simple Interaction - https://arxiv.org/abs/2406.19108 Brainfuck, Forth, Subleq, and most recently Z80 assembly programs with mutations, interactions, and self-modification. Z80 has an LDIR instruction that copies a block of data from one location in memory to another, which allows the "organisms" to reach/discover reproduction quicker and more reliably in repeated experiments. As soon as that happens, it inevitably takes over the "world". Hm, sounds more like "Lord of the Flies" than Rings.

This is every cool research. Do you have any idea why the authors chose Z80 as the program language? I have seen other studies in the same spirit that use simpler toy languages like Brainfuck (https://arxiv.org/abs/2406.19108) and I wonder if you could get higher execution speed if you didn't have to execute so much emulator code. The programs/genomes are extremely tiny. I would be very interested to see what kind of hardware is needed to scale this approach up. How long until we can feed in giant corpuses of text and evolve these little organisms to predict the next letter?

It's an implementation of Google's research https://arxiv.org/abs/2406.19108 Previous discussions: https://news.ycombinator.com/item?id=40820022 https://news.ycombinator.com/item?id=41080435 Since author hasn't setup a github.io link, you can try it using githack https://rawcdn.githack.com/znah/zff/3e58d9742681bc3358059052...

https://arxiv.org/abs/2406.19108 Here's a direct link to the paper. I have not read it yet but the abstract reminds me of a recent post discussing using brainfuck as a way to do program synthesis.

Synthetic and generated data might not be garbage. Consider random chess positions. Those are generated,yet there's an engine out there that has objectively a higher chance of winning from that position. There was also a paper on persistent computer programs after running random data iteratively over millions of cycles. This doesn't even have a 'goal'. which by itself is very interesting because of how similar it feels to how organisms develop by the act of persisting after a few billion years. That is to say I largely agree with the premise that you can train and improve alot by absense of data. But if your original dataset is garbage, then training over and over might get limited by a hidden nash equilibrium that the algoritm can't escape due to lack of new information. Obligatory Anton petrov: https://www.youtube.com/watch?v=L_IWVZPmc-E Paper: https://arxiv.org/pdf/2406.19108

See also: https://arxiv.org/abs/2406.19108 > We show that when random, non self-replicating programs are placed in an environment lacking any explicit fitness landscape, self-replicators tend to arise. We demonstrate how this occurs due to random interactions and self-modification, and can happen with and without background random mutations. We also show how increasingly complex dynamics continue to emerge following the rise of self-replicators.

This paper? https://arxiv.org/abs/2406.19108 I've read it many times. It introduced me to the idea of using self-modifying programs. I've built several prototypes that use their exact instruction set, but I haven't found a way to guide the evolution in a desired direction yet. The self-modifying aspect can be quite destructive to the genome.