All four previously examined species—Imp, Dwarf, Paper, and Scanner—rely on direct physical destruction: either overwriting enemy memory with their own body or planting lethal DAT bombs to terminate enemy threads. Yet as CoreWar evolved, digital nature mirrored terrestrial biology's most macabre predators. Just as orb-weaver spiders spin sticky webs and parasitoid jewel wasps inject venom directly into a cockroach's brain to turn it into a docile zombie, CoreWar gave rise to "Vampires" and "Imp-Gates" (classified here as Insidiae vorax).

Pioneered by strategists like Robert Martin in the mid-1980s, a Vampire does not try to kill an enemy process at the point of impact. Instead, it hurls live JMP instructions—called "Fangs"—across the arena. Every Fang is mathematically calibrated so that no matter where it lands in the 8,000-cell torus, its jump offset points straight back into the Vampire's "Pit": a parasitic prison chamber that traps, paralyzes, and enslaves the enemy's Program Counter.

A Vampire's hunt begins with the rhythmic calibration of its Fang at cell 0004 (JMP.A 2, 0). On every 3-cycle heartbeat, line 0000 (ADD.F 5, 4) adds the dual constant DAT.F #-8, #8 to the Fang, simultaneously increasing its launch distance (B-field) by +8 while decreasing its jump vector (A-field) by -8. Line 0001 (MOV.I 3, @3) then flings that calibrated Fang out into the arena. The result is an invisible spiderweb of JMP instructions spaced every 8 cells, all pointing directly at cell 0006.

Watching a capture unfold in the vivarium is unforgettable. The moment an enemy warrior's active nucleus (red Program Counter) steps onto one of the Vampire's Fangs—or when an enemy Paper accidentally copies a Fang or spawns a clone on top of one—a long jump arc flashes across the screen. The enemy's red nucleus is yanked out of its own body and teleported straight into the Vampire's Pit (lines 0006–0007: SPL.A 0, <-3 / JMP.A -1)!

Inside the Pit, the captured enemy process is kept alive in a state of forced labor. Forced to execute SPL.A 0 over and over, the abducted thread rapidly forks into dozens of trapped sibling threads, flooding all 64 slots of the enemy's FIFO process queue! Even if the enemy still has healthy colonies elsewhere in memory, up to 63/64ths of its CPU cycles are now monopolized by prisoners churning inside the Vampire's stomach, freezing the enemy's main body in place.

Most diabolically of all, look at the B-operand of the Pit at line 0006: `SPL.A 0, <-3`. Every time a trapped enemy thread executes that instruction, the pre-decrement mode (`<-3`) decrements cell 0003. Thus, the Vampire harnesses its victim's stolen CPU cycles to power a high-frequency Imp-Gate that shreds incoming Imps on contact!

In cybersecurity and systems engineering, the Vampire is a pure archetype of a Control-Flow Hijacking exploit. Rather than causing an immediate segmentation fault (DAT crash), an attacker overwrites a code path or jump table with a redirection instruction (JMP Fang) that diverts the victim's Instruction Pointer (IP/PC) into attacker-controlled shellcode (The Pit).

Once inside the Pit, the organism weaponizes an Operating System Denial-of-Service (DoS) vulnerability known as a Fork Bomb (`SPL.A 0`). Because the MARS virtual machine schedules each warrior's threads via a fair round-robin FIFO queue capped at 64 processes, a single hijacked thread executing `SPL 0 / JMP -1` exponentially spawns trapped child threads until 63 out of 64 queue slots belong to the Pit. The victim's legitimate code is starved of CPU time without ever being directly overwritten.

Finally, the Imp-Gate mechanism (`<-3` on line 0006, or standalone gates like `JMP 0, <-1`) exploits the micro-architectural timing of operand evaluation. In ICWS-94, pre-decrement (`<`) modifies the target cell's B-field during operand resolution. When an Imp (`MOV.I 0, 1`) writes itself into the gated cell, the very next cycle the Gate decrements that cell's B-field from `1` to `0` (`MOV.I 0, 0`), turning the Imp into a harmless stationary loop or invalid instruction before its PC can advance!

In the CoreWar metagame, Vampires are feared predators of Paper swarms and multi-process warriors. While a classic Stone bomber struggles against Paper because each DAT bomb only kills a single thread at a time, a single Vampire Fang stepped on by a single Paper thread turns Paper's greatest strength—multitasking—against itself, clogging Paper's 64-process queue from the inside out.

However, Vampires carry two structural weaknesses. First, their complex 3-stage anatomy requires a larger footprint (8+ lines), making their throwing engine vulnerable to fast, compact Stones before the web is fully spun. Second, because a pure Pit (`SPL 0 / JMP -1`) paralyzes rather than terminates captured threads, a Vampire must eventually finish off its prisoners before the 80,000-cycle clock expires to avoid a draw. Competitive Vampires solve this by mutating their Pit or throwing loop into a lethal DAT "Core Clear" in the endgame, digesting their paralyzed prey.

Together, the five specimens of this Field Guide—Imp, Dwarf, Paper, Scanner, and Vampire—demonstrate how a handful of assembly-like rules in an 8,000-cell Von Neumann ring spontaneously give birth to locomotion, artillery, mitosis, vision, parasitism, and an endless evolutionary arms race.