PBEM v94 n02 (10May94)

Modern Core Wars                                          Greg Lindahl

Core Wars? Didn't I read about that in Scientific American 10 years
ago? Perhaps you remember it, perhaps not. But it's alive and well,
and you can play by mail. Core Wars is a game of battling computer
programs. Put away your battletech toys; assembly language is now the
weapon of choice. Some programming experience is required.

Actually, Core Wars is much more like a wargame than you might think.
The object of this article is to convince you of this.

What sort of assembly language does Core Wars use? It will look
somewhat unusual to anyone. There are only 11 different instructions
(move, jump, data, conditional jump) and 4 addressing modes. All
addresses are relative to the current instruction, and the program
memory is of finite size, but wraps around, so that programs can
pretend that memory is infinite. The starting location of the enemy
program is unknown. The object of the game is to keep your program
running while making the enemy program execute an illegal instruction,
that is, to kill the enemy program.

One of the simplest Core Wars programs is this one, from the original
Scientific American article:

;                             Imp, by A. K. Dewdney
imp     MOV 0, 1            ; This program copies itself ahead one
        END                 ; instruction and moves through memory.

This program moves itself forward through memory: the contents of the
address 0 is the MOV instruction itself, and it gets written into the
next address 1, which, coincidentally, is the instruction which is
executed next. As I said earlier, addresses are relative to the current

Imp has a hard time actually killing another program: if it overwrites
a location in memory and the enemy program tries to execute that
instruction, the enemy will be turned into an Imp. The only way that
Imp can score a kill is to overwrite the other program's data or
otherwise interfere with it such that the other program

A second Core War program from the original article is a "bomber".  It
tries to kill enemy programs by writing illegal instructions all over
memory. If an instruction in the enemy program is overwritten and the
enemy attempts to execute it, the enemy dies.  Bombers must be careful
to not bomb themselves.

While the best defense against a bomber is a good offense, there is a
good defense against the Imp program, often called an "Imp Stomper".
Since Imps can only move forward in memory, a program knows that Imps
will always approach from smaller memory addresses. If a program
repeatedly bombs some fixed location at a smaller address, it can kill
an Imp.

Modern Core Wars has a few more instructions than the Core Wars
described in the original article. The most important new instruction
allows programs to multi-task -- they can create multiple threads of
execution. In order to kill an enemy, you must kill all of its threads.

I will now explain the 5 major strategies employed by modern Core
Warriors. The first is bombing, which I've already described.
An efficient bomber must cover a lot of memory quickly, which means
that bombers leave gaps between their bombs. The best gap size differs
for different enemies, so a bomber designed to fight against many
enemies must compromise and depend on luck.

The second strategy is scanning. The memory in the Core Wars computer
begins initialized to a particular value. A scanner looks around
memory for locations whose values have been changed, hopes it just
found the enemy program, and then bombs nearby these locations. If a
bomber is bombing with the same value that memory is initialized to,
then the scanner will ignore the bombs, and only pay attention to the
bombing program. Bombing with an illegal instruction different from
the initial value is called giving bombs "color", and will make
scanners waste time bombing nothing.

The third strategy is the Imp-spiral, which is a multi-instruction and
multitasking version of our Imp program above. One of the features of
the multitasking in Core Wars is that splitting your program into 2
threads means that each thread only executes half as many instructions
as a single thread would. This means that an Imp Stomper could be
overrun if it is multitasking with anything else. An Imp Spiral
consists of multiple cooperating processes which lay down the
instructions for each other. An enemy program overrun by an Imp Spiral
will be killed unless it happens to have more threads than the spiral.

The fourth strategy is the replicator. Replicators are programs which
are capable of copying themselves to a new location in memory. They
can be thought of as self-moving bombs.

The fifth strategy, which I find the most interesting, is the vampire.
It is possible to bomb memory with JMP instructions. An enemy program
which runs across such an instruction will be "captured", and can be
forced to execute useless code. One particularly nasty implementation
of a vampire sucks the enemy program into code where it not only
splits into many different threads, which slows down all the enemy
threads, but also slowly bombs memory in a fashion which will never
kill the vampire! Unfortunately, vampires have to leave pointers to
their "pits" all over memory, so anti-vampire programs can look for
these pointers and bomb the pits or write useful code over them.

The most successful modern Core Wars programs are often combinations
of two of these five strategies.