The largest of the six. System 12 has no BIOS, no CD, no SPU and no pads — so alongside the recompiled MIPS I had to build the board itself: the ROM bank window, Namco's ROM-DMA channel, the KEYCUS protection chip, and an H8/3002 sound sub-CPU driving a 32-voice C352 PCM chip. An instrumented MAME served as a bit-exact oracle so every subsystem could be proven against real behaviour rather than eyeballed.

• Five separate crash addresses were one bug. All of them resolved to a 46-entry fighter-state jump table at 0x800104FC indexed by [S1+0x156]. Rather than assume the base, I confirmed it against six already-resolved switch cases before declaring the 39 targets.
• The performance metrics were lying. guestFps, pumpHz and presentFps all read counters the port itself drives, so they cheerfully reported 60 while the game actually ran at 12. gpuDmaHz was the one honest number, and it exposed an exact 5:1 vsync lock that was also starving the AI.
• Protection chip solved arithmetically. The "exploded fighter" corruption came down to a single missing halfword from the KEYCUS chip; the constant 0x2651 was derived from two table entries rather than brute-forced.
• GPU decode corrected against real hardware: texture-page Y is two bits on this GPU, and CLUT Y is ten bits with bit 15 as the high bit — which is what finally made the portrait grid render.
• Audio built from nothing. The H8/3002 core ran 1.77 billion instructions with zero unimplemented opcodes. SHAR was doing a logical instead of an arithmetic shift, and the C352 loop/reverse flag mapping was proven correct by a 979-key-on census instead of being swapped on a hunch.
• ROM-DMA made bit-identical to MAME across all 84 transfers.

A two-stage boot — the front-end binary LoadExecs the real game — on top of an overlay-banked architecture where thirteen character overlays all live at the same address. An earlier C++ attempt had to be abandoned outright because it had no overlay-banking subsystem, which this game cannot run without.

• The fatality freeze was an interrupt that never arrived. Only VBlank was being dispatched — IRQ 2 (CDROM) never fired. Since the game ships its own interrupt-driven CD driver, an INT2 sat behind an unacknowledged INT3 forever while CdSync spun at roughly 40 million polls per second.
• Every signed 8- and 16-bit value in the game was wrong. A global sign-extension bug in the toolchain emitted LH/LB zero-extended, so a -999 sentinel scan never terminated.
• Two codegen fixes upstream in the recompiler: fall-through-after-jal (functions ending in a call were treated as tail calls, so registers were never restored) cleared 22 landmines; jump-table detection rebuilt on the sltiu bound promoted 343 out-of-boundary targets.
• A shared-bank cross-binding trap: thirteen character overlays at one address were silently binding to each other's symbols — fixed with union entry points.
• Save system reverse-engineered around a broken loader. The game's entire persistent record turned out to be one flat 1,172-byte block, found by tracing mirrored memcpys, and is now shipped directly rather than through the memory-card path.

The 32X is three CPUs at once — a Genesis 68000 plus master and slave SH-2s talking over a mailbox. This one is recompiled by two translators I wrote from scratch, roughly 1,600 lines of Python that decode each opcode straight out of the retail ROM and emit equivalent C. Game data is read from the original ROM at its original offsets and never re-authored.

• The boot blocker was one register write. A single clobber of the $A15104 bank register corrupted the tile decompressor and swept 64 KB of work RAM. One line, and the first real frame appeared.
• The oracle reframed a "hang" as impatience. Comparing against instrumented PicoDrive proved the recompilation's COMM timeline matched hardware exactly — we had simply been stopping at frame 320, and rendering starts at 428.
• Rewrote the compositor as a scanline-accurate Genesis VDP — per-line and per-cell scroll, window plane, true priority order, sprite line limits, shadow/highlight — in pure integer C99, so it drops into the Dreamcast build unchanged. A 26-frame A/B was byte-identical on every attract and menu frame.
• Recovered the SH-2 vector tables and implemented interrupt delivery for both cores.
• Full audio chain brought up and then made cheap: Z80, YM2612, PSG and 32X PWM went from 1.26 ms to 0.10 ms per frame — a 12× win that put audio at 0.6% of the frame budget.
• 60 fps speculative frames: measured, then rejected. Bisecting the interpolated scene words down to the strip-descriptor tail cut the bail rate from 21% to 0.4% — and I still shipped it off by default, because side by side it looked worse than the authentic 20.

The most complete of the six, and the one that is quietly turning into something else. The 6502 is translated ahead of time into C, and the NES hardware it depends on — PPU, APU, MMC3, DMC samples, controllers, battery save — is hand-written from scratch with no third-party emulator code. On top of that, a migration layer is progressively replacing recompiled subsystems with idiomatic C, oracle-tested bit-identical against the original: a recompilation slowly becoming a decompilation.

• Correctness proven, not assumed. 200 million instructions of lockstep against a clean-room 6502 interpreter with zero divergence and zero unknown-target traps, plus an 8,200-frame scripted regression — boot through touchdown — reproducing byte-identical frames. The console builds match the x86 reference exactly.
• Four optimisation rounds took the GBA from 26.8 to 42.9 fps — hardware PSG standing in for the NES APU, hot code in IWRAM, register-resident 6502 state, and an ARM/Thumb interworking veneer that alone was costing 27 scanlines a frame.
• Killed the NES 8-sprites-per-line flicker at the source. Per-down dropouts went from 1,875 to 0 across 400 frames; on-screen figure-count swing fell from 2.7 to 0.09.
• Runs the SNES game's real sound program. An SPC700 + S-DSP core sits inside an NES title, playing the actual sequence data.
• The broadcast layer was measured, not eyeballed: the first-down line lands within 2 px on 98.6% of readings, and 25,373 down-and-distance comparisons produced zero disagreements.
• 1991 rosters verified against an original cartridge — 8,232 fields, no differences.

Built on the NFL Blitz 2000 engine, and the hardest of the six to even begin: the cartridge ships no ELF and no symbol table. Function discovery and libultra identification had to be done from raw disassembly by a tool written for the purpose. It now boots, schedules, DMAs and emits display lists — but the renderer is still a null context that counts those display lists and throws them away, so nothing has been seen on screen yet.

• A whole-game deadlock traced to one unnamed function. Every guest thread was parked in osRecvMesg. The culprit was osPiStartDma under a native PI manager, blocking the segment-2 DMA that everything else was queued behind.
• Found a self-referential thread queue in the runtime. osStartThread on an already-runnable thread made the node point at itself — 4,104,320 queue entries observed before a dedupe guard fixed it.
• Corrected an address-space assumption in librecomp: it assumed ROM is contiguous in RAM, but Blitz lands its code roughly 2 MB away from where the functions were registered.
• Identified and named 61 libultra functions purely by disassembly across VI, PI, SI, AI, SP and RDP, threads and message queues — including the o32 trap where a u64 parameter consumes an aligned register pair and shifts the whole argument list.
• Two upstream-worthy N64Recomp patches and a cop0_status_write fix where an unhandled CU1 bit was calling exit(1).
• Proved the 30 fps cap is by design, not performance — doubling the emulated VI rate still yielded exactly 30 swaps per 60 VI.

The most recent, and the clearest illustration that "it runs" and "it plays" are different milestones. It boots the front-end stub, performs the LoadExec, banks the real game over the top, runs its startup and reaches the true main loop at a steady 60 Hz driving GPU, SPU and DMA without crashing — and then waits forever on a single queued work item that nothing ever dequeues.

• The port was deadlocking against itself. VBlank only ticked when the game called VSync — and this game waits for vblank without calling it. Fixed with a host-time 60 Hz pump polled from the memory-access path, so it runs on the guest thread rather than mutating CPU state from a timer thread.
• ChangeTh was case 0x10: break; — a no-op. No thread the game opened had ever actually run, and this game runs its entire main loop inside one.
• A one-sector decode misalignment meant the recompiler was treating the 2,048-byte executable header as code. Every instruction was plausible, and every one of them was wrong.
• Implemented real interrupt status/mask handling and chain walking across four priority chains; before that, every handler the game registered was unreachable.
• Built three debugging tools that all exploit the fact that memory access happens on the guest thread — a live recompiled-callstack sampler, a write watchpoint, and an indirect-call tracer. The tracer is what proved the queue module is never dispatched at all.
• Solved overlay load addresses statically by clustering call targets and matching content byte-exactly — two independent methods that agreed.

A Sega CD title is two 68000s at once — the Genesis main CPU and the Mega CD sub CPU — talking through a gate array and fighting over shared Word RAM. One code generator serves both; the emitted C is identical, with per-unit macros binding the registers and address space. Adding the second CPU cost almost nothing, which is the entire argument for doing it this way.

• Word RAM banking was the gate to the first frame. Implementing real 1M/2M banking took VRAM from 18,119 to 61,522 bytes written and CRAM from 0 to 58 — the difference between a black screen and a picture.
• A systematic bug hiding in every read-modify-write instruction. Post-increment and pre-decrement addressing were being applied twice and stored to the wrong address. Fixed at eight sites; regenerating six modules changed five emitted lines and took the allocator's failure count from 17 to 0, which is what unblocked character select.
• An overlay slot collision had the intro looping forever on a 512-frame cycle — two different overlay files load at the same address, so dispatch had to become bank-aware.
• Mega CD hardware modelled from evidence, not guesswork: CD-BIOS high-level emulation, gate-array communication with correct per-CPU bit ownership, and the PCM window.
• Full VDP Mode 5 renderer — planes A and B with priority, scroll, and the sprite link list — plus a regression harness that diffs a behaviour signature against a blessed baseline.

The opposite problem from a recompilation: here the guest code is not known ahead of time, so the PS1's MIPS CPU is dynamically recompiled into SH-4 code at runtime and the PlayStation primitive stream is handed to the Dreamcast's PowerVR2 instead of being software-rasterized. It is the piece of work I learned the most from and the one furthest from done.

• Dynarec taken through seven phases — block cache, dispatcher, direct-branch chaining, self-modifying-code invalidation, global hot-register pinning, branch-epilogue shrink and GTE call-out — and proven bit-exact against the interpreter on real SH-4 hardware across all 32 general registers, HI/LO, PC and the RAM window.
• Branch chaining cut dispatcher entries by 667×, and the hot loop went from 32 to 11 SH-4 instructions per iteration — 5.1× cumulative.
• A real hardware bug found by rendering: PS1 GP0 vertices are 11-bit signed, not 16.
• Reverse-engineered the M37702 from MAME and the manual, including the 0x89 multiply/divide prefix and a corrected 16-source interrupt vector table, and got the real C76 sound driver into its steady-state loop.
• Implemented System 11's eight-window ROM banking, which eliminated a derail at roughly 300 million instructions — clean for 800 million afterwards.

FOOTSIES is hifight's open-source spacing trainer, written in Unity and C#. This is not a recompilation — it is a reimplementation of the engine in C, with every frame-data value extracted verbatim from the original Unity asset files: hitboxes, hurtboxes, pushboxes, per-frame movement, cancel windows, damage and stun, guard health, dash and charge timing. Then retargeted across seven consoles. Original game by hifight; ported by oldmanrukus.

• Pixel-exact debug overlay reproducing the original's hitbox, hurtbox and pushbox view — which is also how the frame data was verified rather than assumed.
• Best-of-five ladder against the ported CPU AI, guard bar with guard break, one-hit-KO specials and a practice mode.
• Original additions: a projectile, a raging demon with kanji, a glide and a parry — none of which are in hifight's version.