Old 8-bit binaries taken apart byte by byte and commented, with the tools to rebuild them: nothing gets claimed that the binary does not show, and the source has to give the original back, byte for byte. Right now that means 64 MSX games.
64 games for the MSX, 8 off cassette tapes and 56 off cartridges, taken apart byte by byte and commented. 64 of them are finished: every byte accounted for, and the source giving the original back byte for byte. The ones still in progress say so.
Konami's first MSX cartridge. The game is a table of thirty-two screens, not a map, and what kills you is not the height you fall to but the height you fell from. The vine is nine drawings, each ending with the three bytes that say where its tip is.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,448 of code, 8,936 of data · 513 routines · commented to 29.7%
Three different builds of this cartridge are taken apart here, each in its own folder, and all three reassemble byte for byte. The attract mode is a recording: 64 bytes carrying the joystick's own bits, read one every 32 frames. And NEW ZEALAND is spelled out inside for a research base nobody visits.
16,384 bytes · 0 unexplained · three builds, all byte for byte · main listing: 5,947 of code, 10,437 of data · commented to 24.0%
RepositoryWebsitewhich build is which is not settled
Konami's arithmetic cartridge. The five levels are five scripts of three to five bytes, the digit that gets hidden depends on the one you can see, and the fruit gets thrown back and forth between the monkey and the crabs.
16,384 bytes · 0 unexplained · reassembles byte for byte · 8,962 of code, 7,422 of data · 498 routines · commented to 25.9%
The plane does not move: it turns, one step at a time between sixteen directions, and only the drawing in use is in video memory. The shots and the end-of-era machine are not sprites but screen characters that read the cell before writing themselves into it. And the attract mode flies by reading the cartridge's own code.
16,384 bytes · 0 unexplained · reassembles byte for byte · 8,911 of code, 7,473 of data · 593 routines · commented to 23.4% · measured in openMSX: the interrupt takes 50.1% of the frame
Half the size of any other Konami cartridge here, and it carries the very same sound player as Time Pilot: 163 bytes with only three different. Logs and cars do not spend a single sprite — four pre-generated versions of every drawing, shifted two pixels at a time — and the whole attract mode fits in fifteen bytes.
8,192 bytes · 0 unexplained · reassembles byte for byte · 4,880 of code, 3,312 of data · 314 routines · commented to 25.6%
The main thread does nothing: it hooks the interrupt and settles into a jr $ forever, so the whole game runs inside the video hook. It shares 400 bytes with Athletic Land and not one run of bytes with Frogger, from the same year and the same 8 KB. And the letters are not even in the cartridge: they are copied from the BASIC ROM.
8,192 bytes · 0 unexplained · reassembles byte for byte · 5,783 of code, 2,409 of data · 407 routines · commented to 24.2%
Collision physics in the eight kilobytes the game uses: trigonometry by slope, a twelve-byte square root that rounds, and 45° bounces done by swapping the two velocity components, without one multiplication. There are only seven balls — the eighth entry is the point you aim at — and the attract mode plays by writing the fire button into the same variables where the player’s keys land.
16,384 bytes · 0 unexplained · reassembles byte for byte · 5,343 of code, 11,041 of data · 333 routines · commented to 39.3%
The whole game runs inside the interrupt — the deal, the scoring, the screens — while the main program is an ei / jr $ that never gets the machine back. And the computer does not play mahjong: its thirteen tiles are written into the cartridge one away from completion, and the tile it throws is drawn from the wall and then filtered so it looks like a human discard. Even the empty slot in its face-down hand is theatre.
32,768 bytes · 0 unexplained · reassembles byte for byte · 15,432 of code, 17,336 of data · 1,001 routines · commented to 30.7%
Almost nothing here is drawn: the screens are scripts that get interpreted, and the large letters are manufactured by stretching the small ones. The 400 metres does not exist in the arcade — it is the 100 metres label with one glyph changed. And the stopwatch was worked out for 60 Hz, so in Europe a «12.00» is really 14.4 seconds.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,335 of code, 7,049 of data · 569 routines · commented to 33.4%
Four new events on the previous cartridge’s program: 83.4 % of its instructions are here, and the motor that span the hammer over there is the one that lifts the high jumper. What belongs to this one fits in 1,519 bytes — and in the first event’s label, which reads 110 HURDLERS, with the typo written into the ROM.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,872 of code, 6,512 of data · 647 routines · commented to 29.9%
The whole game lives inside the interrupt: INIT hooks H.KEYI and sits forever on a jr $. Five circus acts chosen by a single byte, and the ring drawn from the cartridge's tables, frame by frame, without one byte differing from the emulator.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,894 of code, 8,490 of data · 576 routines · commented to 47.1%
RepositoryWebsiteThe five acts drawn from the cartridge's tables, with Charlie and the obstacles: 0 bytes different from openMSX.
The level lives in VRAM: each stage's script goes up to 0x3B80, behind the sprite attributes, and the screen doubles as the map. Nine stages drawn from the cartridge's tables without one cell differing from the emulator.
16,384 bytes · 0 unexplained · reassembles byte for byte · 8,537 of code, 7,847 of data · 628 routines · commented to 47.4%
RepositoryWebsiteThe tree's nine stages, whole, drawn from each stage's script: 0 cells different from openMSX in 156 dumps.
A 92-column bakery whose machines change from one stage to the next, an eight-minute working day, and the raccoons the listing called carts, drawn from the ROM without one byte differing from the emulator.
16,384 bytes · 0 unexplained · reassembles byte for byte · 8,097 of code, 8,287 of data · 535 routines · commented to 46.9%
RepositoryWebsiteThe baker's fourteen poses, the three raccoons and the bakery of each stage, drawn from the ROM: 0 bytes different from openMSX in 16 dumps.
Its four events are written into the ROM as plain text — DIVING, TRAMPOLINE, LONG HORSE, HORIZONTAL BAR — and two players take turns by swapping the whole block of state. Unlike its Hyper Olympic siblings, it carries no hidden Konami mark.
16,384 bytes · 0 unexplained · reassembles byte for byte · 5,953 of code, 10,431 of data · 386 routines · commented to 25.1%
Before you play, it asks you two things: which kid you want and what it is called — ten letters that come out of the factory saying ANNA LEE, written in next to the three lives. It is another Konami cartridge recompiled, and it still carries 439 bytes of that game's scenery that nothing here reads.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,981 of code, 8,403 of data · 562 routines · commented to 24.5%
Skeet shooting, archery and weight lifting. The bow scores with Pythagoras and no square root, against ring radii already squared; the clays are not random but read bit by bit from two tables; and a lift is good only when three judges’ lights come on, one every 0x20 frames.
16,384 bytes · 0 unexplained · reassembles byte for byte · 6,956 of code, 9,428 of data · 500 routines · commented to 22.7%
The road is pseudo-3D with no 3D: each strip is picked from a table of shapes indexed by the curve ahead. And hidden at the tail of the ROM, in katakana, is Konami’s house mark — RC-718 — the signature Manuel Pazos found.
16,384 bytes · 0 unexplained · reassembles byte for byte · 6,446 of code, 9,938 of data · 428 routines · commented to 22.8%
The screen’s three thirds painted with a single loop that reads its own output, the colour table kept underneath the pattern table, and every player built from five stacked sprites. The chair umpire has three faces so he can follow the ball with his eyes.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,882 of code, 8,502 of data · 492 routines · commented to 32.4%
There are no levels: one 1,920-row stage that repeats. And the fine scroll is not computed but stored — every landscape strip is kept in eight versions, the same one started zero to seven rows lower. The giant enemy has no body sprites either: the background draws it.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,086 of code, 9,298 of data · 461 routines · commented to 32.1%
Nine holes in 16 KB, and every one of them stored once: the same bytes are read as a VRAM script to paint the plan view and as data to build the grid that knows fairway from bunker. The wind is rolled from the memory refresh register, and the ball’s height is never stored anywhere — it is the gap between its two sprites.
16,384 bytes · 0 unexplained · reassembles byte for byte · 8,665 of code, 7,719 of data · 558 routines · commented to 35.4%
The script’s address written behind the CALL itself, the twelve teams of the 1984 Japanese league hidden in twelve letters, and a computer opponent that plays by writing into the joystick slot. The menu demo plays itself, and it is silent on purpose.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,618 of code, 6,766 of data · 629 routines · commented to 44.5%
The cartridge’s two builds collated instruction by instruction: 95% of their bytes differ and 97% of their instructions match. What actually changes is a mask that the hard one makes depend on the level — and the fact that only that one carries Konami’s hidden mark.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,494 of code, 8,890 of data · 568 routines · commented to 44.0%
The colour table kept underneath the pattern table, the explorer’s position in twenty-four bits, and eighty-seven bytes of code hidden behind a push. Sprite flicker is shared out on purpose, and the stone changes colour every four rooms.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,803 of code, 6,581 of data · 651 routines · commented to 45.5%
The house’s secret bonus —5730 points, which read go-na-mi in Japanese—, an attract mode that is not AI but a recorded game of 77 keypresses, and a game that keeps no collision map: it reads the screen to find out where you can walk.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,789 of code, 8,595 of data · 512 routines · commented to 53.0%
It scrolls one pixel at a time in a video mode with no scroll register: the background sits in video memory eight times over, each copy a pixel lower, and the whole screen is rewritten every frame. That costs three quarters of the machine's time, measured in the emulator, and the road of every stage fits in 328 bytes.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,099 of code, 7,285 of data · 675 routines · commented to 23.1%
A game that stores nowhere where the road is —it reads it off the screen—, a routine hidden inside its own pointer table, and two builds that differ by a single byte.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,797 of code, 8,587 of data · 482 routines · commented to 55.1%
A table whose right half is not stored anywhere —it is drawn by mirroring the left one byte by byte—, forty frames each carrying the pointer to its own patterns right behind it, and the whole of table tennis scoring written in BCD.
16,384 bytes · 0 unexplained · reassembles byte for byte · 7,676 of code, 8,708 of data · 548 routines · commented to 64.3%
RepositoryWebsiteThe densest listing in the series.
A 1985 football game that calls offside —and only from level 3 up against the machine—, twelve players that are not sprites but 3x3 tile patches over an eighty-column pitch held in RAM, and an aim that is never computed: it is looked up in two tables.
32,768 bytes · 0 unexplained · reassembles byte for byte · 20,116 of code, 12,652 of data · 1,213 routines · commented to 36.5%
RepositoryWebsiteThe same cartridge also came out as Konami’s Football: one instruction out of 9,755 differs.
Four events and four different ways of moving the screen: a circuit that is not in VRAM but in two RAM windows, a runway stored twice to move half a tile at a time, half a sheet of ice mirrored by hand, and a cyclist who is not a sprite but four tiles with eight one-pixel copies. Plus a demo nobody plays: it is a recording.
32,768 bytes · 0 unexplained · reassembles byte for byte · 14,410 of code, 18,358 of data · 931 routines · commented to 34.5%
RepositoryWebsiteThe world records live in RAM, because the game overwrites them.
A hundred rooms and not one repeats, in 32 KB, and none of them is drawn: each room is eighty bytes pointing at 8x4 tile blocks, and those blocks share tails and can be asked for mirrored. And the name of each round is its own password: the very bytes that paint the caption are the ones you type to get there.
32,768 bytes · 0 unexplained · reassembles byte for byte · 17,422 of code, 15,346 of data · 1,176 routines · commented to 36.9%
RepositoryWebsiteAll one hundred rooms drawn from the ROM, and 64,000 tiles in 2,983 bytes.
Not a game: the cheat cartridge. It plugs in beside another one, works out which game it is by adding up 256 bytes of its ROM, and patches that game’s start-up in RAM to take over its interrupt. Its “cheat active” light is the CAPS LED.
16,384 bytes · 0 unexplained · reassembles byte for byte · 10,522 of code, 5,862 of data · 663 routines · commented to 22,1 %
RepositoryWebsiteThe only commercial MSX cartridge whose entire job is to read and modify another cartridge. It recognises 28 games.
Six opponents out of three figure archives, and still six faces. There are six names in the table at 0x5661 and the figures come out of a table of three words, but every opponent figure hides one piece more that only the second round paints: SANCHESS's long hair, CHINA KHAN's pigtail, MOAI Jr.'s face —and only the moai changes colour. And the scorecard is kept upside down — it adds up faults and finishes with 10 - faults, which is the ten-point must system of real boxing.
32,768 bytes · 0 unexplained · reassembles byte for byte · 6,932 of code, 25,836 of data · 475 routines · commented to 52.6%
It looks for its own first part in the next slot. Before installing the interrupt hook it scans the four slots and takes two 16-byte sums, and it tells the two builds of Yie Ar Kung-Fu (RC-725) apart. Inside, half a screen: the scenery is drawn only on the left and the right half is the same patterns with all eight bits reversed.
32,768 bytes · 0 unexplained · reassembles byte for byte · 13,725 of code, 19,043 of data · 1,027 routines · commented to 40.9%
Konami left two typos in its cosine tables. A cosine quadrant can only go down; these two go up once each, and the value that goes up is precisely the only one that departs from the function. Inside there is also a cheat that asks for left and right at once — impossible on a joystick — and hands over twenty-six lives.
32,768 bytes · 0 unexplained · reassembles byte for byte · 15,233 of code, 17,535 of data · 985 routines · commented to 22.4%
Only half a ship is in the ROM. Each sprite pattern stores its left half; the right half is worked out by flipping every byte bit for bit, which is why everything that flies in this game is symmetric. And the demo is a recorded game: twenty-eight joystick readings fed in through the player's own door, with the Z80's R register set to zero so the randomness comes out the same every time.
32,768 bytes · 0 unexplained · reassembles byte for byte · 14,406 of code, 18,362 of data · 1,000 routines · commented to 41.4%
Not a game: a synthesizer that computes every note sample by sample on the Z80 and plays it through an 8-bit DAC. The seven screens, the sixteen TONE EDITs and the fourteen waves, drawn from the ROM and checked against openMSX down to zero; the engine written anew gives the sixteen tones byte for byte, and what reaches the DAC is checked too. Plus the pitch, which is a loop of cycles with thirteen paddings, the noise that comes from the BIOS, and the tape with seven SAMPs that came with the cartridge.
32,768 bytes · 0 unexplained · reassembles byte for byte · 16,229 of code, 16,539 of data · 1,187 routines · commented to 43.6%, none below 10%
Twelve stages of Gradius in a 128 KB MegaROM, and the terrain is not in video memory: it is 22 rows of 32 cells in RAM, shifted one column left by hand every scroll step with 22 ldirs. That is what lets the twelve maps on the site be drawn from the ROM and checked against the cartridge running. There is no random generator anywhere in the 128 KB: the stars, the falling rocks and the out-of-step blinking all come out of the Z80’s R register.
131,072 bytes · 0 unexplained · reassembles byte for byte · 25,471 of code, 105,601 of data · 1,540 routines · commented to 23.4% · 12 maps
Two hidden keyboard codes: NORIKO and KAZUMI. They turn on a CONTINUE that does not exist without them, and the proof is in the watcher itself: the nine keys it polls are exactly the letters needed to spell those two names and no others. And the gambling machine is a real slot machine — the cherry takes five of sixteen slots and is the only symbol that pays on its own. And the good ending or the bad one —the princess alive or dead— does not depend on how you play: it depends on how many times you pause, a finding of Manuel Pazos’s that is pinned down here in the binary.
131,072 bytes · 0 unexplained · reassembles byte for byte · 32,317 of code, 98,755 of data · 1,526 routines · commented to 44.7%
The first MSX2 in the series: Dracula’s whole castle, drawn from the ROM. The 156 rooms with what each one hides, Simon, the enemies and the six bosses, checked against openMSX down to zero bytes. There are 33 hidden vendors who do not always sell: what happens depends on how many times you hit them. And Dracula is half sprite and half drawing: the body is copied by the VDP.
131,072 bytes · 0 unexplained · reassembles byte for byte · 29,786 of code, 101,286 of data · 1,909 routines · commented to 49.4%
A 140-screen island, drawn from the ROM, with what every screen hides: 15 passages, 37 pieces of scenery that can be removed, the items and who talks. Mitchel, the 55 named enemies and five bosses that are not sprites, painted by the VDP and checked against openMSX down to zero bytes. Three endings that depend on the days and on how many times you continue, and an axe that only works against one enemy.
131,072 bytes · 0 unexplained · reassembles byte for byte · 37,983 of code, 93,089 of data · 2,414 routines · commented to 40.1%
The cubes roll like dice: each one is one of the 24 rotations of a cube, and a stage is cleared with five finished in a row, not by painting the pyramid. The 50 stages, the bonus stage and the duel drawn from the ROM and checked against openMSX down to zero bytes. A two-player duel settled by rock, paper, scissors, a hidden life and a moai.
32,768 bytes · 0 unexplained · reassembles byte for byte · 11,743 of code, 21,025 of data · 788 routines · commented to 78.1%
With King Kong 2 next to it, it boots King Kong 2 and saves its game to tape with F4. Seventeen cheat passwords, one named after a designer in the credits and one in lower case that can never be typed. The six stages, their rooms and the 18 gates that join them drawn from the ROM and checked against openMSX.
131,072 bytes · 0 unexplained · reassembles byte for byte · 32,229 of code, 98,843 of data · 1,944 routines · commented to 40.4%
Seven stages of seven areas, 124 screens, drawn from the ROM street by street. The 21 interiors with their prices, Goemon, Ebisumaru and 30 enemy types, and the 42 secret passages walked in first person, all checked against openMSX down to zero. Plus four password keywords, two words to type in the pause, a stage menu with Q*bert or the Game Master next to it, and Konami's hidden mark written in the game's own hiragana.
131,072 bytes · 0 unexplained · reassembles byte for byte · 28,724 of code, 102,348 of data · 1,678 routines · commented to 42.5%, none below 10%
The castle and ten worlds, all 321 rooms, drawn from the ROM and laid out by their neighbours. Popolon and Aphrodite, the sprite sets, the ten bosses (character mosaics, not sprites), the 47 items and the shops, all checked against openMSX down to zero. Plus the black rooms that turn out to be hints and shops, ZEUS in the pause to continue, the character sitting on a cup with F2, and what Q*bert next to it gives you.
131,072 bytes · 0 unexplained · reassembles byte for byte · 53,613 of code, 77,459 of data · 3,423 routines · commented to 40.1%, none below 10%
All of Outer Heaven from its tables: 235 rooms in 9 zones, joined by their lifts, 154 doors, 64 actor types, Metal Gear and the Hind D, drawn from the ROM. The rooms match Manuel Pazos’s reference images point for point (thank you, Manuel); the check against openMSX is still to be done. And five passwords in the pause, tape saving with F5, what each item does, and Metal Gear, which only falls to sixteen bombs in order.
131,072 bytes · 0 unexplained · reassembles byte for byte · 35,620 of code, 95,452 of data · 2,190 routines · commented to 46.8%, none below 10%
The twelve stages built from their maps, the five bosses from their records, the 65 enemy types, the ship with its weapons and the seven that can be captured, all drawn from the ROM. And what changes with the cartridge in the other slot: three words in the pause with Q*bert alongside, the equipment kept with The Maze of Galious, the ship turned penguin with Penguin Adventure. Plus three secret stages and the way back through the planets.
131,072 bytes · 0 unexplained · reassembles byte for byte · 41,242 of code, 89,830 of data · 2,630 routines · commented to 43.4%, none below 10%
The first MegaROM in this series, with the Konami SCC mapper and the SCC sound chip: sixteen 8 KB pages the game swaps in and out, so there is not one listing but sixteen. The depth of the road is not perspective: SCREEN 2 keeps three pattern banks, one per third of the screen, and the cartridge loads different drawings under the same index at the top and at the bottom. And its 21 circuits are lists of pieces that can be rewritten — there is an editor to do it, and it runs in the browser.
131,072 bytes · 100% explained · reassembles byte for byte · 31,591 of code, 99,481 of data · 1,953 routines · commented to 24.2% · 21 circuits
The five ruins from their tables: the 20 stages with what each screen holds, the antechambers, the outside map, the stage bosses, the enemies, and Wit and Cles with their four moods, all drawn from the ROM. And what each mood changes: a double jump, walking on thin air, a different shot or blow. Plus what four other Konami cartridges give in the other slot, and the texts in Japanese and English.
131,072 bytes · 0 unexplained · reassembles byte for byte · 41,458 of code, 89,614 of data · 2,536 routines · commented to 40.1%, none below 10%
A cartridge without a single Z80 instruction: inside is a 246-line MSX-BASIC program the interpreter runs straight out of the ROM, and the boot trick is that the cartridge also carries the interpreter’s variable table from a real session. The nine holes fit in 4,000 bytes of coordinates, and the game has no terrain map: it asks the screen what colour the ground under the ball is painted.
16,384 bytes · 0 unidentified · retokenises byte for byte · 9,041 of BASIC program, 4,000 of course · 246 lines · 100 % of them commented
RepositoryWebsitethe nine holes on its site are drawn from the ROM by running the program’s own drawing subroutines in Python
The smallest cartridge in this series, and the whole game fits inside it without a single sprite: the bomber, the monsters, the bombs and the flames are all name-table tiles. There is no map data structure either — the game reads the tile number, and three comparisons carry the lot. Its cartridge header is code: INIT points at 0x4004, where STATEMENT, DEVICE and TEXT should be.
8,192 bytes · 0 unexplained · reassembles byte for byte · 3,557 of code, 4,635 of data · 200 routines, none under 10% · commented to 50.2%
RepositoryWebsiteevery fourth stage the game drops the bombs for you — and hides a different prize under the bricks, chosen by the very same mask
An eighteen-hole course, par 72 and 6,430 metres, in 16 KB: a hole fits in three hundred bytes because its header is its palette — the table starts three bytes early so the opcode’s own nibble lands on it. The cartridge builds three trigonometry tables in RAM at boot, and the wordmark loads by calling into the middle of an instruction, where the operand runs as xor a.
16,384 bytes · 0 unexplained · reassembles byte for byte · 6,065 of code, 10,319 of data · 358 routines · commented to 42.0%, none below 10%
Three-on-three basketball on a 56-column court seen through a 32-column window, with no hardware scrolling. Every player is four sprites (hair, skin, shirt, skin) and the flicker is deliberate: seven groups sorted by depth, shown forwards and reversed on alternate frames. The computer teams are generated by level, teams are saved to tape as a BSAVE, and the whole court, the 160 poses and six screens are drawn from the ROM and checked against openMSX down to zero bytes.
32,768 bytes · 0 unexplained · reassembles byte for byte · 20,642 of code, 12,126 of data · 1,289 routines · commented to 43.2%, none below 10%
Two eighteen-hole courses, thirty-five real tour professionals and a full course editor, in 32 KB. The opponent does not compute its shot: it rehearses it with the real physics and retries until it likes the result. The terrain is decided by the pixel, read straight out of the VRAM. And what the editor saves is the 1984 cartridge’s own file, byte for byte.
32,768 bytes · 0 unexplained · reassembles byte for byte · 14,186 of code, 18,582 of data · 903 routines · commented to 44.4%, none below 10%
Eighteen holes stored as ten layouts: eight of them are used twice, once mirrored, and the flag is bit 7 of the same byte whose low nibble is the par. What look like sprites are not — the VDP only ever holds ten, five of them the ball at five sizes; everything else is tile indices, decompressed, spread apart and then running-summed in 16 bits.
32,768 bytes · 0 unexplained · reassembles byte for byte · 8,185 of code, 24,583 of data · 435 routines · commented to 37.0%, none below 10%
RepositoryWebsiteits title screen is drawn without its text, and that is not a bug: the text comes from the machine's own font
It does not fit in the RAM an MSX booted into BASIC can see, so it hides twenty-six kilobytes underneath the BASIC ROM. And riding inside it, a 1984 machine code monitor by the same author: its back door still wired to CTRL+STOP, its command table buried under the game’s own screen records, and in the single-step buffer the last instruction it ever ran before someone saved the tape.
58,334 bytes · 0 unexplained · reassembles byte for byte · 20,299 of code, 37,597 of data · 1,308 routines · commented at 33.0%, no routine below 10%
RepositoryWebsiteThe 26 screens on its site are not screenshots: they are drawn from the tape’s own bytes.
The game turned out to be written in BASIC: a tokenised MSX-BASIC program 63 lines long, with 45 bytes of Z80 at the end to start the interpreter, and a scrolling engine seventeen bytes long. Of the 34,239 bytes on the tape there are 1,566 whose contents nobody has identified, published as a WANTED poster with every measurement next to it.
34,239 bytes · 100% accounted for · reassembled and re-tokenised byte for byte · only 997 bytes of machine code, commented to 37.7% · 1,566 bytes unidentified
The punishment for cheating never fires, and not because they meant it that way: they forgot to initialise the flag that triggers it, the only variable in the game that is read but never set. And the only published cheat for the game, from a 1988 book, has a typo — B4CC for 84CC — confirmed in an emulator.
40,449 bytes · 100% accounted for · reassembles byte for byte · 553 routines, 73 data blocks · commented to 35.8% · 29 screens drawn from the binary
The game loads on top of the ROM: all 42,645 bytes go into page 0, where the MSX BIOS lives, and the 35 KB of graphics and maps stay hidden underneath it, uncovered for an instant each time a level loads. That one decision is why this disassembly is several listings and not one. 135 bytes never execute.
42,645 bytes in the game block · 0 unexplained · the modules reassemble byte for byte and the rebuilt tape has the same sha256 · 4,588 of code, 38,057 of data · commented to 32.7%
The tape carries not one program but two, and both live at the same addresses — which is why this is five listings and not one. The BIOS never reads them: a 88-instruction loader that outlives both halves pulls them off the tape by hand, and the two bytes at 0xD300 are not code but a pointer back to it. The second half plays out inside a 128×52 tile cutaway of the caravel, with the cargo you bought drawn stowed in the hold.
66,016 bytes · 0 unexplained · five listings, the whole tape byte for byte · 15,504 of code, 50,512 of data · 733 routines · commented at 26.7%, no routine below 10%
RepositoryWebsite7,564 bytes on this tape are read by nobody: the tape records fixed-size blocks, so whatever was in memory got recorded behind the program.
There is no map inside: the jungle's 255 screens come out of an eight-bit shift register, and the 32 treasures are exactly the 32 scenes of one kind. The vine is drawn frame by frame onto a bitmap in RAM, so the rope you see is arithmetic, not a graphic.
16,384 bytes · 0 unexplained · reassembles byte for byte · 9,467 of code, 6,917 of data · 337 routines · commented to 24.5%
A track in perspective that is drawn nowhere at all: the routine that paints it rewrites itself on every row with the pixels it needs, and what is stored are fourteen lists of indices into a table of rows. Five bands repainted at five different rates make the depth — no division, no table, not one multiply.
38,299 bytes · 0 unexplained · the tape reassembles byte for byte · 6,556 of code, 31,743 of data · 355 routines · commented to 30.8%
RepositoryWebsiteThe loader does not read the tape: it builds a bridge on the stack and rewrites it three times.
A ZX Spectrum conversion that brought the Spectrum's tape system across with it, not just the graphics: Spectrum blocks instead of the MSX's own, a loader that reimplements LD-BYTES with the same register interface, and RAM mapped into pages 1 and 2 to get the flat 48K the Spectrum has as standard. And it is multiload: two different programs on one cassette.
93,861 bytes · 100% accounted for · five listings, all byte for byte · 1,148 routines · commented to 31.2%
The seven rounds, 255 screens built from their maps with their enemies and bosses, Rastan in his three layers, the dragon stage the game skips and an ending it never draws, all drawn from the ROM. In the header, a test cheat: byte 0x4010 set to 1 and key 7 jumps to the next stage.
262,144 bytes · 0 unexplained · reassembles byte for byte · 29,820 of code, 232,324 of data · 1,406 routines · commented to 46.1%, none below 10%
A ZX Spectrum conversion that brought the whole tape system across — Spectrum blocks, a hand-written LD-BYTES — along with the colour attribute glued behind every map tile, which is why they are nine bytes long and not eight. It even brought the beeper sound engine, and then nothing ever calls it: the four places that ask for a sound effect all land on a bare ret, and of the MSX’s PSG only the two joystick registers are ever written. The game is silent.
62,261 bytes · 0 unexplained · five listings, all byte for byte · 11,814 of code, 50,191 of data · 766 routines · commented at 29.7%, no routine below 10%
RepositoryWebsitethe loading screen on its site is not a screenshot: it is drawn from the tape, credits and all
Every project follows the same rule: nothing gets claimed that the binary does not show. make extracts the game from the tape or the cartridge, traces the code from its real entry points, generates the commented listings, then reassembles them and demands the original back, byte for byte.
That test settles whether a listing can be trusted, but not whether it is right: if graphics are read as instructions, the bytes still come out identical and only the listing lies. So each project carries a second, different check — a budget where every byte has to be either code the tracer genuinely reaches, or a data range with a name and an explanation — plus tests that check what the documentation says against the binary.
The comments live apart from the listings, anchored to the address they describe, so they survive a re-analysis of the binary. And much of what is claimed was not deduced by reading but measured with the openMSX emulator: watchpoints on memory to see which code touches each variable, and sampling the program counter during play to know what actually executes.
No tape or cartridge image is distributed in any of these repositories. To rebuild a project you need your own copy of the game; each repository states the sha256 it expects.
Not a game: the measurements. What the disassemblies look like when you put all of them side by side and measure again instead of trusting what each one says about itself — which is how you find out that the same routine goes by twelve names, and that four published figures had quietly gone stale.
What comes out of looking at all of them at once. Every figure here is measured again against the listings the repositories publish today, never copied from a README — and that alone found four cards quoting a density their own listing no longer gives. It also shows that the joystick read is thirty-six identical bytes in eighteen cartridges going by twelve different names, and that seventeen cartridges carry Konami’s hidden mark, all seventeen matching the catalogue number their card publishes.
249,851 instructions · 81,234 comments · 32.5 % across the series · 0 routines below 10 % · 1,465,115 bytes of binary