kirby's dead land is a mod that puts kirby in dead cells. it does not redraw him. the real game from 2008, kirby super star ultra, runs hidden inside an emulator, sixty times a second, and dead cells borrows its hero: his jump, his sword, his appetite. to wire one game into another like that, the guest has to be known from the inside. so the cartridge was read, end to end. this is what is in there.

5,996 functions · 157 pieces of program · 42 enemies · 4,096 random numbers · 48 hit records

1. dead cells starts a frame
2. the hidden DS runs one frame of kirby's game
3. the mod reads kirby out
   • where he is
   • his sprites
   • his hits
4. dead cells draws him and takes the hits

every number below was measured on that hidden game, on a workbench copy of the emulator, with nothing on screen.¹

a cartridge that is mostly film

the cartridge holds 134 megabytes and the game fills 76 of them. most of that is not game at all. it is fifty-one cutscenes.

the sound is the neat part. 114 pieces of music and 452 effects fit in 1.28 MB, because nothing in there is a recording: it is sheet music and a few short samples, played live by the console. and the file still carries the names its makers gave each one.

a program that arrives in pieces

a DS has four megabytes of memory. the program alone is 5.8. it cannot all be in memory at once, and it never is: 5.3 of those megabytes are cut into 157 overlays, pieces of program that are loaded when they are needed and thrown out when they are not. every enemy is one. so are the bosses.

this is memory while kirby stands in green greens, the first level:

overlay 26 is kirby himself: 2,212 functions in 593 kilobytes. the hero is twice the size of the core of his own game. and at the far end, in 19 kilobytes, sits the smallest thing with a mind in it: a waddle dee.

five chairs for every enemy

each ordinary enemy is a small program of its own, between 1 and 20 kilobytes. and each of those programs was built to sit at one of five fixed places in memory. two enemies built for the same place cannot be in a room together: loading one would write over the other. every room of the original game is musical chairs, with five chairs.

so a waddle dee and a blade knight never share a room, anywhere in the game. green greens seats waddle dee and waddle doo, who are one program, then cappy, bronto burt and twizzy: four chairs, one of each.

this matters to the mod. every dead cells enemy near kirby gets a stand-in inside the hidden game, so that the original's own code decides what his sword touches. the stand-ins are all waddle dees, in chair 2. the table says which real enemies could sit beside them, and which never could. one of them was tried, further down.

each enemy also carries a small record of who it is. read out of all of them, and set against kirby's own 76 points of health:²

what kirby is doing, and how

sixty times a second the game asks one question about kirby: what is he doing? the answer is a number, his action. there are 44. standing is 6, walking is 11, a jump is 13, falling 14, floating 15, being hurt 29 and dying 33.

nearly every action is run by the same five routines. what sets one apart is a single question of its own: which move? a move is the exact way of doing the action. walking has three: plain, with a mouthful, and wading through water. so the game keeps two bookmarks for kirby, the kind of thing he is doing and exactly how, and the second is the one that knows his mouth is full.

the blue road, measured. kirby leaves the ground in a burst, 10.5 pixels in the first frame, then 8.0, 5.4 and 2.9. after that the game takes about a sixth of a pixel off his speed every frame, until he is falling at 3.5 pixels a frame and it lets him fall no faster.

twenty-four costumes

to the program, a copy ability is one pointer. when kirby swallows a blade knight, a single routine says goodbye to the old ability, looks sword up in a list, and swaps the table of moves his actions read from. nothing else about him changes. that is why the mod can hand him any ability: it calls that one routine, and the original does the rest.

each ability was then given the same ten presses, alone in an empty room, and every hit it made was written down.³

and this is one of those moves from the inside. what follows is not a picture of the game. it is sword's standing slash as the program sees it: the hit boxes, frame by frame, exactly where the game put them.

the slash starts over his head, comes down in front from above his hat to under the floor, and then, for two frames, there is a box behind him. the follow-through hits too.

a full mouth

the mod gives kirby a second pocket. dead cells has a key for healing, F, which kirby has no use for, so it holds one of the four abilities that get used up: crash, paint, mike or cook. a press lends him that ability through the same routine a swallow uses, lets him fire it, and hands him back his own.

one moment broke it: kirby with his mouth full. asked what he is doing, the game answers standing, because a full mouth keeps the action numbers of standing, walking and jumping. so the mod saw a kirby standing still, and lent him the crash. if he swallowed then, the swallow won. on the workbench he came out of it with the swallowed ability, and the crash in his pocket was lost.

the game itself is never fooled. kirby's record keeps a byte that the original reads before it picks how he stands: 1 for an empty mouth, 2 for a full one. and the move it then picks, the second bookmark from earlier, is a different one. the mod reads both now, and F waits for the mouth to be empty.

the byte has two more values, for water: 4 with an empty mouth, 5 with a full one. the mod checked only for the 2, so in a pool F could still lend the crash to a full mouth. the fix checks for the 5 as well.

and this is the same moment in the mod, in one of its test runs, against a real dead cells zombie.⁴

the same move can tell more than the mouth: whether kirby is wading, and which of an ability's attacks he is making. the mod asked it only about the mouth, until the two fixes that follow.

the bottom of a pool

kirby and the hero of dead cells do not move at the same pace. so on dry floor the mod lets the original take every step, then carries kirby a little further the same way, until he covers the ground dead cells' hero would. in water it leaves the original's pace alone.

a pool deep enough to swim in has a floor, and kirby can walk along it. to the game that is still walking, action 11, the same number as a stroll in the sun. only the move is different: the wade. so the mod saw a walk and hurried him along the bottom, 1.79 pixels a frame where the game had him at 0.94, with his legs sped up to match.

the wade has a pace of its own. coming in from a run, kirby starts it at 0.375 pixels a frame, gains 3/64 of a pixel every frame, and settles at 0.9375: 56 pixels a second, where a walk on dry floor is 1.375. the fix reads the move, and leaves the wade at the game's own pace, as the mod already did with swimming.

one press, one attack

an ability's attacks are moves too. each of the twenty-four abilities keeps its moves in a table of its own, and the twenty-four tables sit side by side in memory, from cutter's to sleep's, below the moves that every kirby shares. so the move answers two questions at once: is kirby attacking, and with which attack?

to learn how a press turns into an attack, each ability was given the button standing, held down, in the air and from a dash, and every move was written down. a press starts an attack on the frame it is made, or a frame later for fighter. a press made in the middle of an attack is kept until the attack can take its next step: sword's next slash came five, seven or ten frames after it. some attacks go on by themselves, like beam's whip after its wind-up, or cutter's blade coming back. and many presses in the middle of an attack do nothing at all.

that matters because in the mod an ability comes as a dead cells item, and an item can carry extras, such as an arrow that flies with every attack or a cut that bleeds. the mod spent them at every press of the button, even at a press that started nothing. the fix spends them when the game starts an attack for a press. a press waits as long as the attack runs, and ten frames more.

..p...p...p...p...p...p...p...p...p...p...p...p...p...p...p.
                                                            
..1111222222333333333311112222223333333333111122222233333333
                                                            
..x...x.....x.........x...x.....x.........x...x.....x.......

what a hit is made of

every creature in the game starts from four bytes.

here are two enemies, as they are stored:

00 00 10 00

00 14 10 00

that second byte is the whole of kirby's most famous trick. it is also the byte the mod writes on its stand-ins, which is how a dead cells zombie can taste of sword.

dice with 4,096 faces

everything left to chance in the game, 86 places in the program, goes through one routine of two lines:

seed = (seed * 61 + 1401) & 0xFFF;  // twelve bits
return (seed * n) >> 12;            // 0 to n - 1

try it. with the seed at 0, the next seed is

1,401

, and a die of six faces thrown with it shows

3

.

the two numbers are well chosen: the seed walks through all 4,096 values before it comes back to the first. but 4,096 is very few. the whole future of the game's luck is a loop that short, and whoever knows where the seed stands knows every throw to come.

one sixtieth of a second

a DS draws 59.83 frames a second. in each one its main processor has 560,190 ticks to spend, and when the work is done it sleeps until the next. standing still in green greens, kirby's game is mostly asleep.

and almost none of the working part is kirby.

then the room fills. in the mod, each dead cells enemy near kirby is one more stand-in for the original to look after, and kirby may have a helper walking beside him. this is how full the frame gets:

when a frame does not fit, the original does what every console game of its time did: it lets the picture go by and finishes the work in the next one. on a DS that is a moment of slow motion, a lag frame. in the mod it was worse. dead cells went on drawing while the hidden game was half way through its sums, and kirby was shown one tile away from where he stood: a flicker. the mod now waits for the original to finish, which is right, and is still a stutter.

so, an experiment. the console in the mod is not real. its processor can be told it is twice as fast.

the part that makes it usable: with no crowd, and with a crowd of eight, kirby's path through six hundred frames is the same at both speeds, byte for byte. a faster processor changes nothing until the moment the slow one would have dropped a frame.

the emulator's bill

dead cells has 16.7 ms for each of its frames, and the hidden console is paid out of that. it can be run two ways. an interpreter reads the game's instructions one at a time and acts each one out, every time it meets it. a recompiler translates a stretch of them into the host machine's own language once, and runs the translation from then on. the mod used the first, and since 14 october it uses the second.

the last row is a small thing with a large effect. the mod draws kirby itself, from the sprites the original lists, so most of the time nobody looks at the picture the hidden console paints. not painting it saves more than a quarter of what is left.

drawing kirby has a smaller bill of its own. after every frame the mod reads the list of sprites the game wants on screen, 128 of them in a kilobyte, and the 512 bytes of their colours. it read them the way the game's own processor does, one byte at a time: 1,024 knocks on the door for the list alone. the fix copies each one whole.

forty-eight hit records

whatever can hit or be hit in kirby's game borrows a record for it: its four sets of hit boxes and its health, 580 bytes. the records come from one pool, which the game fills with forty-eight at the start of every stage. for the rooms of the original, it was enough.

a stand-in holds one record, for its body, and every hit borrows one more for about seven frames, while the enemy flinches. thirty-one stand-ins, one swing of the sword that hits twenty-four of them, and the pool is empty. the twenty-fourth flinch was handed a record that is not there, address zero, and the game wrote the enemy's health into it all the same.

what came next depended on how the console was run. the game itself tells the processor never to write there, and the interpreter, which keeps that rule as the console does, stopped the processor for good: the hidden game froze in the middle of the fight, and dead cells went on around a kirby who could no longer move. the recompiler does not check the rule. it let the write land in the processor's own fast memory, and six bytes of a routine kept there were quietly overwritten. it was never seen running in play, which is luck, not design.

the mod's answer changes not one instruction of the original. it lets the game build its forty-eight at the start of a stage, then makes sixty-four more, two for every stand-in, out of memory the room does not use, and puts them at the end of the pool. the game hands them out as its own.

a real enemy in the empty chair

one idea in the list below was first set aside without a try: real enemies in the chairs the stand-ins leave free, so that a dead cells enemy tasting of fighter could be a real knuckle joe. the reasons were good on paper. the stand-ins are never drawn, so a real enemy would be as invisible as the waddle dee it replaced. and it would bring everything the stand-in was set up not to have: its own attacks, its own touch that hurts and its own way of dying.

then it was tried. in green greens, where the hidden game runs, chair 3 is the free one, and chair 3 is where knuckle joe, gim, jungle bomb, birdon and tac were built to sit. the game has a routine that gets an enemy ready, its program into its chair and its pictures into sprite memory, the way a new room does. it was called in the middle of play for each of the five, and a stand-in's record was told to be that enemy. each was in place within two frames, its program the same as the cartridge's to the last byte, and the mod took it for a stand-in like any other. then kirby stood still 42 pixels away for five seconds, and tried to swallow it.⁵

it went the way the paper said. a real enemy brings its own program, and the program fights kirby, while the dead cells enemy over it is fighting him too. nobody would see it do so: at the two moments it was checked, the hidden game's list of sprites had no entry for knuckle joe, and none for the stand-in. tamed with the stand-in's program, it gives the ability the stand-in already gives, and keeps a touch of its own. and the free chair seats one kind of enemy, where up to thirty-one dead cells enemies at a time each taste of an ability of their own. the routine stays written down, for a day the mod needs something only a real enemy has, such as one of its sounds.

what it changes in the mod

the first three went into the mod on 14 october, on by default: the translation, the faster processor and the unpainted screen. in the game itself, one run each, the hidden game's frame went from 2.8 ms to 1.5 ms with kirby walking alone, and from 3.6 ms to 1.8 ms among twenty zombies. three more were built and tested the same day, and went in that evening. of the last three, two were built and tested that night and went in on 15 october, and the third was tried and set aside.

how it was read

1. unpack the cartridge its first bytes say where the program, its 157 overlays and its 1,886 files are.
2. take the program apart every piece that is in memory during play, turned back from numbers into instructions: 5,996 functions, with a note of who calls whom and who reads what.
3. doctor the emulator a private copy that counts every instruction it runs, stops at any address, and says who touched a given byte.
4. guess from the reading, then make the game prove it press a button, and watch for the number that changes.
5. write down only what was seen

the disassembly, the doctored emulator and the cartridge stay private. what is here is what they said.⁴

changes

• 15 october 2026 three more parts, the bottom of a pool, one press, one attack and a real enemy in the empty chair, with four more frames of the mod at play. a full mouth has the byte's values for water, the emulator's bill the sprites read whole, and what it changes in the mod two more rows and the idea that was tried. notes 4 and 5 say where the new numbers and frames come from, and move is in the words. the two tables without a title have one now, for readers who hear the page instead of seeing it.
• 14 october 2026 two new parts, a full mouth and forty-eight hit records, with the first frames of the mod at play. what it changes in the mod now says where each idea stands, and has two more. the line under the opening no longer says that no picture is taken from the game, and the notes say where the frames come from.

words

frame

one picture on the screen, and all the work the game does to get to the next: about a sixtieth of a second.

hit box

the rectangle a game tests instead of the drawing. a sword hits when its box overlaps an enemy's, whatever the pixels show.

interpreter

an emulator that reads the guest's instructions one by one and acts each out. simple, exact, and slow.

lag frame

a frame in which the game did not finish its work in time, so the screen showed the old picture again.

move

the exact way kirby does what his action says. walking has three, and every attack of an ability is one. the game names a move by where its description sits in memory.

overlay

a piece of a program kept on the cartridge and loaded into memory only while it is needed. several can be built for the same place, as long as they are never needed together.

recompiler

an emulator that translates the guest's instructions into the host's own, once, and then runs the translation.

stand-in

an enemy of the original game, placed where a dead cells enemy is, so that kirby's own code can find something to hit.

notes

1. nothing here was judged by playing. the hidden game was run with no window, from a saved moment in the first level, and its memory read after each frame. the frames of the mod come from its own test runs, which press the keys by script, with no window either.
2. health, the ability given and the cost of a touch are the numbers stored in each enemy's program. only waddle dee's were watched being put to use.
3. with nobody to hit, a throw has nothing to throw and a charge is let go early, so suplex and plasma show less than they can do.
4. the strip of the slash was drawn by a script, from boxes the game reported. the nine frames of the mod at play come from its test runs: dead cells drew them, the rooms, the water, the zombies and the arrows from its own files, and kirby from the sprites the hidden game listed. they are cropped and doubled, with no smoothing.
5. the wade, the presses and the real enemies were measured with the emulator alone, from a saved moment in green greens, on floors and pools laid out by the tests. the real enemies were loaded by calling the game's own routine between two frames, from a hook in the emulator, and kirby's health was read after every frame. the reads of the sprites were timed from a script. the numbers from the game come from the mod's own test runs.