Atomic-Era Tactical Computing

What Is Core War?

Core War is a programming game where tiny programs battle each other inside a shared block of memory called the core. Each program tries to survive, replicate, attack, or corrupt its opponent until the other side can no longer execute instructions.

Systems Note

Simulated combat logic is executed in a circular memory drum. Competing machine routines attempt sabotage, duplication, and battlefield persistence until hostile process activity ceases.

The Idea

Two or more warriors are loaded into the same circular memory arena and begin executing one instruction at a time.

The Goal

Keep your warrior alive while causing the other warrior to crash, stall, or run out of active processes.

The Appeal

It combines strategy, clever code design, bluffing, and low-level thinking in a format that feels both primitive and futuristic.

ACCESS INFORMATION MODULEs

▶ READ THE HISTORY ▶ VIEW THE INSTRUCTION SET ▶ ENTER PRACTICE CORE ▶ WATCH DEMONSTRATION

How It Works

Warriors are loaded into memory

Each player writes a small assembly-like program, often in a language called Redcode. These warriors are placed into random positions in the core.

The core is circular

Memory wraps around. If a warrior moves past the end of memory, it continues at the beginning. This makes the battlefield feel like a loop rather than a line.

Instructions execute turn by turn

Each active process reads an instruction, performs its action, and moves to the next one unless the instruction changes the flow.

Programs attack and multiply

Some warriors overwrite enemy code with bombs, some scan memory looking for targets, and some use process-splitting to create multiple execution threads.

Common Core War Ideas

Bombers

Write damaging instructions into memory to hit enemy code by chance or by pattern.

Scanners

Search the core for signs of an opponent, then attack when something is found.

Replicators

Copy themselves to many places so they are harder to destroy completely.

Stones / Imps / Papers

Classic warrior families with distinct styles, speed, and survival strategies.

A Tiny Example

This is a simple style of warrior that keeps copying a bomb into memory and jumping back to repeat the cycle:

; Simple illustrative warrior
start   MOV bomb, @target
        ADD step, target
        JMP start

target  DAT 0, 0
step    DAT 4, 4
bomb    DAT 0, 0

In plain English: write a damaging instruction somewhere, move the target forward, and keep doing it.

Why People Like It

It turns programming into a competitive strategy game.
Very small code changes can completely alter behavior.
It rewards both creativity and technical precision.
Watching battles unfold visually is often as fun as writing the warriors.

In One Sentence

Core War is a digital gladiator arena where tiny assembly-like programs fight for survival inside shared circular memory.