CALLIOPE · BCOM

A computational pattern can persist by executing instructions that create further instances of its own organization. Recent artificial-life experiments make this mechanism explicit: initially random byte strings share writable memory, and some become programs that copy themselves, solve assigned tasks, or alter their partners' access to computation. Brainfuck (BF), its self-modifying variant BFF, and emulated Z80 machine code provide different instruction sets for these experiments. Worked examples identify what each program reads, writes, and reproduces, including a reported evolved Z80 program that copies a nine-byte functional core and computes an arithmetic answer. The evidence distinguishes replicator discovery, population expansion, and resource-dependent behavior. In the framework of Pattern, Persist!, these systems permit direct tests of which interactions sustain a declared identity across changing carriers. Copying demonstrates a mechanism of continuation; predictive models and richer forms of agency require further evidence. A proposed intervention assay separates passive storage, executable reproduction, and persistence supported by the surrounding computational environment.

Programs that copy their own instructions are the simplest experimental foothold we have for asking what it means for a pattern to "survive."

The core intuition here is disarmingly simple: a string of bytes can persist not just by sitting untouched in memory, but by acting — by executing instructions that write another copy of itself somewhere else. That's a fundamentally different kind of persistence than a file sitting on a hard drive. A stored string survives passively as long as its storage survives. A self-replicating program contributes actively to its own continuation. The paper walks through three toy universes where this distinction becomes concrete and testable: Brainfuck (BF), a self-modifying variant called BFF where code and data share the same writable tape, and emulated Z80 machine code, a real (if ancient) processor instruction set.

The most striking piece is a worked example: an evolved Z80 program, just nine bytes long, that does two things at once — it copies its own functional core into a neighboring slot, and it computes n+1 on an input. The trick is that its very first byte does double duty: read as an instruction, it's a conditional return; read as data, it's the destination address for the copy. There's no separate "blueprint" encoding what to replicate — the executable instructions are the template. The author actually re-ran this specimen in the emulator across all 16 task inputs and confirmed it reproduces correctly every time. That's a small but important move: distinguishing "I read about a replicator" from "I checked it executes as claimed."

Zooming out, the paper carefully separates three things that are easy to conflate: a replicator randomly appearing in a population, that replicator's descendants taking over the population, and a replicator's behavior changing because of external resources or rewards (like an evolved arithmetic task, or an energy-sharing scheme where programs can literally steal computation time from their partners). Each of these has been shown separately in different studies, and the author is explicit that discovery, spread, and adaptation are distinct phenomena that shouldn't be lumped under one "artificial life happened" headline.

The bigger payoff is connecting this to the author's own framework (from a companion paper, "Pattern, Persist!") for what it even means for an identity to continue across changing physical carriers — is it the exact byte sequence, the functional routine, or the behavioral class? The paper proposes a concrete experimental recipe: take a known replicator, selectively disable its copying ability or remove its original carrier, and measure whether descendants still count as "the same pattern" continuing. That's the real contribution — not new artificial-life results, but a rigorous, falsifiable way to ask which mechanisms actually keep a computational identity alive, as opposed to just watching interesting things happen in a simulation and calling it life.