ZoreWars

ZoreWars is a programming game built on Core War, the game A. K. Dewdney introduced in Scientific American in 1984. Players write small programs called warriors that share one block of memory and take turns running instructions. Each warrior tries to make the other execute data. The last one with a running process wins.

For forty years Core War has been played on a single ring of memory. ZoreWars keeps that ring, fully compatible, and adds the axes it never had: a 2D plane and a 3D volume.

The classic ring

On the ring, ZoreWars follows ICWS'94 Redcode and is tested directly against pMARS, the simulator the public hills use. The same warriors go through both, and every difference is treated as a bug. Its rule sets reproduce the 94nop, '88, limited-process and 94x hills, so a warrior developed here can be submitted to them unchanged.

Adding Z

On the plane and the volume, every number is a point. A plain number is still a step along the row, so most classic code keeps working, while [x,y,z] addresses a cell anywhere in the volume. Every process has a heading, and a new TRN instruction turns it along any axis, so code can climb through the layers.

The shape of memory changes which strategies win. On a 40×20×10 volume any fixed stride repeats within 40 cells, so classic bombers cover almost nothing, and core clears and replicators take over. The library has 27 warriors written for the plane and volume, from a depth imp to P-space switchers that pick a strategy from the last round's result.

Avatars: watch them fight

Switch the arena to Avatars and every warrior becomes a creature built from its own code: one body part per instruction, head first. SPL is an arm, MOV a claw, arithmetic a gear, jumps a joint, tests an eye, and DAT an ammo pod, so no two warriors look alike.

When a warrior writes into its enemy, a shot flies from the instruction that fired it to the part it hits, and the part shows what the write did: a DAT smashes it, a SPL or JMP webs it, a changed number chips it, and anything else turns it into the attacker's kind of part. Processes running an enemy's code are captive, and once most of them are, the creature turns into its captor. A warrior with no processes left falls apart in slow motion. A director camera follows the action, and Map stands the creatures on the live core, or inside the 3D volume.

In the browser

• A visual arena that shows every write and process, on the ring or in a live 3D view you can turn and zoom.
• Warriors in Redcode, or JavaScript, Python and C++ programs that generate Redcode. Any warrior can be converted into a readable generator.
• A library of 98 warriors, each explained line by line, and a Hall of Fame that loads famous originals straight from the public archives.
• Post-mortems that name the killing blow, process deaths by cause, and conversions.
• A history of Core War strategy traced through original posts and warrior sources, with links to the archives where they belong.

For AI agents

A command-line tool returns JSON for checks, battles, tournaments and per-round post-mortems, and includes tools to benchmark, tune and evolve warriors. The evolver follows Sakana AI's Digital Red Queen method: each generation's champion joins the opponents the next one has to beat.

The code is Apache-2.0, the documentation CC BY 4.0, and warriors written for ZoreWars are CC0. No pMARS code is included.

Play at zorewar.app, browse the source, or read the build stories: adding a Z axis to Core War, testing a new game against forty years of warriors and giving every warrior a body.