Programs that copy. Lineages that evolve.
Run every generation. Inspect every instruction.
A live engine for self-replicating programs. Execute, mutate and trace a population on a resource-bounded substrate.
Every signal comes from the running system.
—Live Replication Engine
Executing programs, inherited instructions and resource selection in one observable runtime.
Live Replication Engine
Inspect every program, instruction and resource allocation.
| Program | Gen | Genome | Energy | IP | Copy | Executed | Offspring | Slot | Age |
|---|
Every generation has a source.
Recorded parentage, executable mutations and resource selection.
One ordered execution history.
Events are appended by the local engine at logical tick boundaries.
| Sequence | Tick | Channel | Replicator | Event |
|---|
Copy. Mutate. Execute. Trace.
QUINE is a browser-local runtime for executable, self-replicating instruction programs. A quine is a program that reads and copies its own code; every founder here is one.
01 / Execution model
The engine executes a fixed instruction budget per program on every logical tick. Four founder programs begin with 96 energy units each on a 16 × 16 substrate. Each slot holds an energy reservoir capped at 64 units, replenished by the configured resource rate.
Each instruction costs one energy unit; COPY costs two. HARVEST transfers available slot energy to the program, capped at 512. DIVIDE consumes twelve additional units and splits the remaining energy between parent and child. Division requires a complete copy, at least 48 energy units, free capacity and a free adjacent slot.
02 / Replication and variation
ALLOC creates a daughter buffer. COPY reads one instruction from the executing program into that buffer. Each copied instruction has the configured probability of mutation. IFCOPIED branches when the buffer is complete. DIVIDE creates a new executable program from those exact bytes.
Mutations can disrupt copying, harvesting and control flow. Programs retire on energy depletion, HALT or lifespan exhaustion. Resource competition and differential replication produce selection; the engine does not claim that later programs are more intelligent.
03 / Instruction set
| HARVEST n | Acquire up to n energy units from this slot (0 uses the default of 8). |
| ALLOC | Allocate a copy buffer if none exists. |
| COPY | Copy the next genome instruction, applying seeded mutation. |
| IFCOPIED n | Jump to n when the copy buffer is complete. |
| JMP n / JNZ n | Jump unconditionally, or when register r0 is nonzero. |
| DIVIDE | Allocate a child program and split energy. |
| ADD n / XOR n | Apply signed 32-bit register arithmetic. |
| MOVE n | Attempt a move east, south, west or north (n modulo 4). |
| NOP / HALT | Consume one instruction, or retire this program. |
04 / Determinism
The same engine version, founder source, seed and configuration change history produce the same logical state. Execution order and arithmetic are fixed. Wall-clock tick rate and compute duration are measured locally and are intentionally separate from deterministic results.
Imported and restored runs are recomputed from their inputs and compared against the exported state checksum before loading. This is a local consistency check, with no claim of independent verification or blockchain consensus. Genome checksums identify variants; they are not cryptographic proofs.
05 / Runtime data
Topology, parentage, mutation records, resource levels, population counts, signals and events come from the browser-local engine. QUINE does not call a remote AI model, operate online agent workers, generate inference requests or submit chain transactions.
Each event contains a monotonic sequence ID, logical tick, event type and affected program. Charts retain the latest 240 samples at five-tick intervals. Instruction inspectors retain the last 32 executed instructions per program. Complete domain events and ancestry are retained for the run.
06 / Storage and lifecycle
Runs are saved to this browser every four seconds and on pause, step or background suspension. Opening or reloading the page automatically starts execution, resuming the latest usable saved run after replay validation. If that run is complete, it remains saved and a new default run starts. Hidden tabs suspend computation. Manual imports and saved-run inspection stay paused. A closed browser does not continue computing or accumulate events.
Browser storage can be cleared or evicted. Export a JSON run file for a portable copy. Each run stops at 50,000 ticks, 150,000 recorded events or 60,000 allocated programs to keep local resource use bounded.
07 / QUINE token
$QUINE is the proposed project and community token. This runtime is freely usable without a wallet or token balance. The project token panel displays the configured contract address and trading availability. Token issuance and on-chain actions are outside the local execution engine.
This release provides no staking, token rewards, revenue distribution or claimable balance.
08 / Controls and source
Pause halts logical execution. Step advances one tick. Speed changes scheduling frequency without changing deterministic outcomes. Parameter changes are recorded at tick boundaries. Source edits create a separate run with an origin reference.
Source exposes the VM and scheduler code bundled with this release. Run exports contain source, seed, configuration history, final tick, state checksum and the event journal.