Reverse-engineering case studies.

lks_decomp develops source for the USA RO3EXJ Wii release of Little King's Story. Its configuration builds from a user-supplied disc image, generates objdiff project data, and supports source-to-original object comparison on Windows, macOS and Linux.

Lufia2Decomp reconstructs Lufia II: Rise of the Sinistrals game logic as a portable C library for SNES recompilation consumers. Its CPU-state and memory adapters preserve observable routine behavior, and a resource tool decodes compressed data from an owner's ROM. The author reports 2,305 functions marked verified by original-ROM differential checks.

Luigi's Mansion (3DS) Decompilation recovers C source from the Nintendo 3DS release, with implemented formatter, startup, runtime and game-state functions. Its tools extract a user-provided decrypted dump, generate ARM disassembly and run headless Ghidra analysis; the main game entry remains unfinished.

Luigi's Mansion decomp reconstructs source for four GameCube releases: USA Rev 0, Japan Rev 0 and PAL Revs 0 and 1. The repository supplies game C and C++ files, symbols and per-version build configurations, with Ninja builds and objdiff support starting from a user-supplied disc image.

The project reconstructs code for the PlayStation release of Lunar 2: Eternal Blue Complete, identified as SLUS_010.71. Its build extracts code and data from the user's game files and rebuilds boot.dat, while C sources, symbols and an asm-differ workflow support continued function work.

mkp reconstructs source for Magiczna kula Papatki and its Magnum Engine v2.0 engine. The current effort focuses on the engine, using original gratka3d.exe and ME2.dll files with objdiff reports to track decompilation changes.

This is a SkoolKit disassembly of Manic Miner for the ZX Spectrum. skool2html.py sources/mm.skool builds the HTML disassembly. skool2asm.py sources/mm.skool writes mm.asm for an assembler. The published HTML is at skoolkid.github.io/manicminer, with a hexadecimal view and a decimal view.

Mario Artist Paint Studio Decompilation reconstructs code from the Nintendo 64DD game's disk image. Its build setup uses a specific user-provided D64 dump, splat extraction and a MIPS toolchain; the repository contains reconstructed C source and headers.

Mario Bros. reconstructs assembly for the Z80 arcade game, beginning with the marioja MAME ROM set. It uses GNU Z80 binutils for CPU code and asm48 for sound code; graphics data is outside the project's stated scope.

Mario Golf 64 is an early N64 decompilation project with a ROM split configuration, symbol and relocation data, assembly for unmatched functions and a small amount of reconstructed C. Its build generates nonmatched assembly and links a ROM from the user's local base image.

Mario Party 1 US Decomp reconstructs the US Nintendo 64 game's code as buildable C sources. Its build uses a user-provided big-endian .z64 ROM, runs setup and make, and provides comparison controls in the Makefile.

mp3 partially decompiles the US Nintendo 64 release of Mario Party 3 into C source. Its build extracts a user-provided big-endian ROM and reassembles the game; the author describes fully decompiled overlays that can be edited and rebuilt. The repository is archived.

Mario Party 5 is reconstructed as a work-in-progress GameCube decompilation for the USA Rev 0 release. The project uses a user-owned disc image, Python configuration and Ninja builds; its source tree contains C code and symbol maps for the main program and REL modules.

MarioParty6 partially decompiles the GameCube game Mario Party 6. Its two C source files cover random-number routines and dynamic-module loading, with headers, a symbol map and a script that compiles the source files.

Mario Party 7 is an early decompilation of the USA Rev 0 GameCube release GP7E01. The repository contains split and symbol maps plus a small amount of reconstructed C, and its build uses the player's disc image with Python and Ninja. The README describes object comparisons through objdiff.

MSM-decomp begins a source reconstruction of Mario Sports Mix for the European RMKP01 Wii release. It provides game-specific configuration, one C++ game source file, build scripts and an objdiff workflow driven by the user's disc image.

Mario Superstar Baseball reconstructs source for the US GameCube release GYQE01. Its workflow extracts main.dol and aaaa.dat from the user's game, decompresses REL modules, configures a ninja build, and compares compiled objects with objdiff. The project describes itself as unfinished.

Mask 3: Venom is a partial assembly reconstruction of the ZX Spectrum game MASK III: VENOM Strikes Back. Its address-labelled assembly files cover game routines, and the source is described as compilable with SjASM+.

Mega Man 1 Disassembly supplies compilable assembly for the US Mega Man and Japanese Rockman releases. Its cc65 and make build combines the repository's assembly with banks 0–3 and part of the level data extracted from the player's original ROM.

mgstts contains partial reconstructed C source for METAL GEAR SOLID: THE TWIN SNAKES. Its game-specific code includes region-selected stage character entries and a documented 24-bit string-hash routine, alongside headers named for game data formats.

DreadComp is an in-progress hand decompilation of Metroid Dread that recreates game source code in C++. The repository includes initial source files, build tooling and symbol data; building requires assets and the version 2.1.0 executable from the user's own game copy.

Metroid II reconstructs Metroid II: Return of Samus as Game Boy assembly across separate ROM banks. The project identifies a target ROM hash, names mgbdis as a disassembly tool and provides a make-based assembly build.

mine-a1.1.2_01-rev prepares a user-supplied Minecraft Alpha a1.1.2_01 JAR for study with Windows batch scripts and repository patches. Its setup uses IntelliJ and a Java 8 SDK, and the author notes using an MCP patch to correct decompilation artifacts. The work is described as incomplete.

Money Idol Exchanger is a banked assembly disassembly of the Game Boy game. Its RGBDS Makefile assembles the sources into game.gb, and the project specifies an MD5 goal for comparing the resulting ROM.

Ms. Pac-Man reconstructs assembly source and data layouts for the 1993 Namco/Now Production NES release. The repository separates maze and screen layout data from the main disassembly and directs users to extract graphics from their own ROM before assembling with CC65.

MultiBootSystem reconstructs source for the main menu of the Zelda: Ocarina of Time Master Quest GameCube disc. Its build uses the user's extracted main.dol, Python and ninja, with objdiff configuration for comparing rebuilt objects.

mnsg is an in-progress decompilation of Mystical Ninja Starring Goemon for Nintendo 64. It includes game-specific C files, symbol and split maps, and scripts that extract assets from a user-supplied US ROM before building a new ROM.

n64dd reconstructs the Nintendo 64 Disk Drive component found in an Ocarina of Time ROM as C and assembly. Its scripts extract a user-supplied NTSC US ROM, produce disassembly and build the component; the Makefile provides an MD5 comparison mode for output.

Need for Speed 4: High Stakes is the subject of an unfinished effort to translate game disassembly into C source. The repository contains game, frontend, and PlayStation related C and C++ files, while the author leaves much of the work on its TODO list.

prsche-disasm recovers C/C++ source for Need for Speed: Porsche Unleashed from its Windows x86 binaries. It indexes original modules and addresses, studies resource formats, and compares recovered functions with recorded original inputs, state, outputs, and ABI behavior. The recovered C++ modules build separately, but the full game does not yet link into a playable executable.

Need for Speed: Underground reconstructs source for the GameCube game's GNDP8P prototype dated September 10, 2003. Its build configuration, symbols, and split definitions support object-by-object comparison with objdiff after extracting the user's game executable.

This is a work-in-progress decompilation of Neon Genesis Evangelion 64. The ROM is named evangelion.z64. The documented steps are make setup, then make.

pik2wii reconstructs source for the USA Wii release of New Play Control! Pikmin 2. Its workflow extracts the user's game files, builds with Ninja, and uses objdiff to compare source objects; a separate nonmatching mode produces a modifiable DOL.

nfsu2_decomp rewrites logic from the PS2 PAL release of Need for Speed: Underground 2 as native Linux C++ and uses the user's disc data at runtime. The implementation replaces PS2 graphics and audio paths with OpenGL and SDL2, reads ZDIR.BIN and ZZDATA archives, and documents recovered vehicle physics and file decoding. The project describes its current build as a playable prototype.

Ninja Cop reconstructs assembly for the GBA releases Ninja Cop and Ninja Five-O and provides commands to build both ROM versions. The author reports that all code has been disassembled; code and data documentation, graphics extraction, and readable strings remain unfinished.

Ocarina of Time 1.0 Disassembly records the NTSC 1.0 Nintendo 64 game's code as assembly files for documentation. The project splits actor routines and the central code file into named sections, with a file map showing memory addresses and subsystem purposes.

Ogrebattle64 decompiles the North American release of the game using a user-provided ROM. Its build process extracts assets from baserom.z64 before running make, and a separate make target generates an m2c context file for function work.

Onegai Monsters explores decompilation of the N64 game through source files and a build that extracts data from a user-supplied .z64 ROM. The author describes the effort as minimal and unlikely to become a full decompilation.

OpenBarnyard reconstructs C++ source for the Windows game Barnyard and its TOSHI 2.0 engine. The repository contains game and engine source, progress tooling and Windows project generation scripts.

Reconstructs readable GOAL code from the original Jak binaries and compiles it with a new GOAL compiler for modern PCs. Its workflow combines a specialized decompiler, manually supplied type information, asset extraction and an interactive development runtime.

OpenHuey rebuilds Haunting Ground for the PlayStation 2, 2005, SLUS_210.75, for PC. The executable SHA-1 is e0867d2ec83e6e2fccf147ad9e645a9a662d1c15. The C decompilation is functional rather than byte-matching. The openhuey program plays the story, rooms, cutscenes, items, menu, saves, endings, and the Hewie minigame.

OpenIsolation is an early-stage project to reverse-engineer Alien: Isolation's libraries and game code. Current work centers on the CATHODE core library; its C++ source and notes cover original binaries, symbols, class-layout recovery, and platform variants.

OpenJPOG decompiles Toshi engine 1.0 and Jurassic Park: Operation Genesis. The Windows build uses Visual Studio 2019 or 2022. The README says the progress images do not yet mark every finished function.

OpenLW recreates Sonic Lost World from Ghidra decompilations of its Wii U and PC versions. Its source aims to reproduce the PC game’s structure and records function addresses; the repository also hosts LWAPI bindings for PC DLL mods. The author describes the recreation as a major work in progress.

OpenRakis is a work-in-progress reverse-engineering project for Cryo's Dune. The README describes the PC DOS floppy and CD layouts, an asm directory for the original x86 DOS assembly, and an 8086 16-bit real-mode IDA setup for DNCDPRG.EXE with entry CS 1ED.

OpenWINGS studies the DOS game Wings v1.40 and reconstructs flight, terrain collision, landing and damage behavior in portable C. Ghidra analysis, symbol maps and DOSBox-X traces support tick-by-tick differential checks; the author reports eight functions verified so far.

OUO reconstructs the Ultima Online demo server from UoDemo.exe as a C99 program for POSIX systems. Its function-by-function workflow uses disassembly of the original executable, while added server systems and protocol changes support later Ultima Online clients.

Outlaw for the Atari 2600 (Atari, 1978) is reverse-engineered into commented 6502 source that compiles with DASM. Named RAM variables cover the playfield arrays, scores, bullets in each gun, sound state and obstacle positions, and the commented code walks through the score and magazine display, the main four-line display kernel, gun reloading, select handling, movement and bullet bouncing.

OutRun 2006 Coast 2 Coast is ported from a C++ reconstruction of its PC executable to Switch, Apple silicon macOS, PS5 homebrew and Xbox Developer Mode. Some functions remain translated from x86 while others are handwritten; each platform has native graphics, audio, input and file layers. The port reads tables and game data from the user's Steam installation.

Rewrites code from Bloodborne’s PS4 executable (CUSA03173 with update 1.09) as readable C++, one function at a time, aiming at a native PC source port on a clean-room runtime of its own. It is a functional rather than matching decompilation: each replacement is hooked in, compared with the original machine code on recorded and generated inputs, and independently reviewed. Work is at an early stage: README reports 21 of 157,757 functions verified, and the game does not yet run on Paleblood’s own runtime.

This repository is a work-in-progress decompilation of Paper Mario: The Thousand-Year Door, Japanese version G8MJ01, based on symbol maps from the Paper Mario 2 demo. The README says it aims at the same functionality rather than a 1:1 match.

This decompiles PaRappa the Rapper. The player extracts an ISO into iso/. XA and STR files must use 2336-byte sectors. The included syncstrip tool cuts 2352-byte sectors from jPSXdec down to 2336. Compile steps follow PSXFunkin without its ISO make targets.

nddemo decompiles the Peach's Castle Tech Demo using C and C++ source alongside address-annotated assembly. The repository includes a Makefile for the NDDEMO build.

Pheenix documents a disassembly of the ZX Spectrum game using SkoolKit. The repository contains SkoolKit source, control and reference files, plus scripts that build browsable hexadecimal and decimal HTML listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.

Piglet's Big Game reconstructs source for the USA and PAL English GameCube releases of the game. Its build takes the user's disc image, and its objdiff configuration supports comparisons between rebuilt objects and the original.

Begins a C decompilation of the PlayStation game Pipe Dreams 3D, with source files, a splat configuration, symbols, and a MIPS cross-build Makefile. Users place their own BIN/CUE game image in the GAME directory; a full build guide remains pending.

Activision's 1982 Atari VCS game Pitfall! is disassembled into labeled and commented 6502 assembly (version 0.9). Notes explain how a reversible LFSR generates the 255 jungle scenes, which bits of the random number select ground objects, scene type, tree pattern and wall position, and how the nine-stripe display kernel draws Harry, the liana, holes, ladder and wall; assembler switches add optional optimizations, screensaver code and a training mode.

pokemonstadium reconstructs the US Nintendo 64 Pokémon Stadium ROM as a work-in-progress mix of assembly and C source. Its setup extracts a user-supplied baserom.z64, and its Makefile assembles the extracted material into a ROM.

Pokepark Wii decomp reconstructs source for the USA Rev 0 Wii release of Pokepark Wii. The repository has game source files and R8AE01 build configuration; its workflow reads the user's disc image, generates build files and uses Ninja and objdiff for source comparison.

The Pokémon FireRed disassembly project contains an early assembly reconstruction of the GBA game. Its Makefile combines local ROM input with assembly source, assembles and links it with the ARM toolchain, and produces a GBA file for comparison.

This reconstructs the European base release of Pokémon Moon for the Nintendo 3DS. The title ID is 0004000000175E00 and the product code is CTR-P-BNEA, title version 0. Retail code.bin has SHA-256 fbe0ce6da21542542f49645fff78ba1b7e5e7cc172ce4daceeb5c26ab54adba1. Retail static.crs has SHA-256 e18db06b0609739e8e62cd4786c6b2da838d20347050e4c2ac822bf35c016957. The manifest lists 2,984 source-backed functions out of 18,945, including 298 exact ARM matches.

pokemonsnap reconstructs source for the US Nintendo 64 release of Pokémon Snap. Its setup uses a user-supplied ROM, runs extraction and disassembly through configure.py, and rebuilds a ROM with Ninja. The repository contains game C and assembly files, build configuration, and comparison tooling.

The project partially reconstructs the USA 1.0 release of Pokémon Stadium 2 as C source for research. It includes game and math source units, symbol-address lists, a ROM build recipe using baserom.z64, and a diff script.

Reconstructs the DOS v1.3 Pool of Radiance engine in portable C, supported by overlay analysis, format readers and isolated runs of the original for behavior comparisons. Documented readers cover DAX, GEO, ECL, EGA and save-related structures; the gameplay reconstruction remains in progress.

Princess Maker 4 is a work-in-progress hand decompilation of the Japanese Nintendo DS game. It reconstructs C source using symbol and relocation configuration and extracts required assets from a user-supplied decrypted ROM.

Prototype incrementally reconstructs functions from the 2009 PC game's engine DLL as readable C++. A proxy xinput1_3.dll redirects calls to replacement functions; the project saves Ghidra annotations and checks replacement behavior against the original at runtime. The author reports 28 replaced functions.

pso-gc decompiles Phantasy Star Online Episode I & II for GameCube. The project contains assembly, source code, headers, tools and Makefile-based build files for the game.

This repository decompiles Quest 64. The US ROM is named baserom.us.z64. The build is ./configure and ninja.

Reimplements the engine of Oddworld: Abe’s Oddysee and Abe’s Exoddus as an open-source replacement executable that runs from the user’s own game folder. The team decompiled the original executables and replaced their functions incrementally, using injected DLLs that hook reimplemented code into the patched retail executable, then rewrote the result into a standalone cross-platform engine. The project site says both games are playable in their entirety, with bug fixes and windowed, high-resolution and controller play.

The Radio Helicopter project reconstructs source for the European RGCPGT Wii release, also known in the Americas as MiniCopter: Adventure Flight. It includes game-specific build configuration, source files and symbol maps for Ghidra and Dolphin, and builds from the user's disc image.

Rampage documents the ZX Spectrum game's code as a SkoolKit disassembly. Its source tree contains the .skool listing and reference files, with a script to generate a browsable HTML version.

RAC2Decomp studies the PAL PlayStation 2 release of Ratchet & Clank 2: Going Commando and translates observed engine behavior into C. Its workflow uses Ghidra for static analysis and the PCSX2 debugger for runtime traces; the repository includes code and notes on boot state, graphics initialization, and text rendering.

Rayman Arena is an early C++ reconstruction of routines from the PC game, with a Frida patch that replaces game routines. Its documented workflow calls for decompiling with Ghidra, cleaning up the output with Clang tools, and editing it by hand.

Reconstructs C++ source for Plants vs. Zombies on PopCap’s open-source SexyAppFramework, starting from an earlier community decompilation of version 0.9.9 and adding functionality reversed from the Game of the Year edition, with functions annotated by GOTY addresses. The project also modernizes the engine with current C++ and is replacing the DirectDraw and Direct3D 7 renderers with GLFW. It builds a fan executable that runs from an original game folder, aiming at a modernized, extensible game rather than an identical binary.

Re47 reconstructs source from the executable and DLLs of Hitman: Codename 47, using IDA Pro and the GOG game release as a reference. The author reports partial progress across modules, aims for a compilable game build, and states that byte-accurate matching is not currently pursued.

Real War decompiles the 2001 PC game into C source, mapping files and symbols to virtual executable addresses. Its tools diff functions, rebuild the executable, verify the result, and inspect the game's BIGFILE, BSE, KVAG, SPT, and TGC asset formats.

A labeled and commented 6502 assembly listing reconstructs Red vs. Blue, a 1981 Atari 2600 multi-sprite demo that later became RealSports Football. The listing labels the vertical sync and timer loop, the display kernel for the red and blue animated players, eight animation frames of player graphics, and the horizontal-position and sprite-copy tables. A comment marks a frame-timing counter that has no effect on the animation rate.

reDM2 reconstructs the DOS release of Dungeon Master II in C from its shipped SKULL.EXE executable. It separates game code from linked libraries and compares ported functions with the originals using Unicorn emulation, memory-write checks, and captured game-state snapshots. The author reports that some functions remain blocked by missing emulator capabilities.

REDPRO2 is a partial C++ decompilation of the US v1.3.0 release of New Super Mario Bros. U. It began with the graphics system and expanded into other game systems for research and documentation; the source tree includes graphics, actor, enemy and player modules.

Translates reverse-engineered Driver 2 MIPS routines into C/C++ and uses Psy-X/Psy-Cross to adapt PlayStation interfaces for desktop systems. The project documents symbol-assisted Ghidra/IDA work alongside intentional bug fixes and gameplay changes.

REFLEC BEAT plus reconstructs Objective-C and C++ source for version 4.5.8 of the iOS rhythm game. The project uses Objective-C metadata, C++ RTTI, embedded strings, and original path fragments to organize the recovered routines; a separate OpenAPI file describes requests observed in the client. Building requires a user-supplied IPA for game assets.

ReFreedomFighters reconstructs Freedom Fighters file formats and PC executable functions, with Python decoders for audio, textures, scripts, scenes, and navigation data. It also supplies C++ function ports and game-specific RE helpers. The author reports 12,703 published ports tested against the original, while documenting checker gaps and pending rechecks.

Reko-Btech investigates the 1988 MS-DOS game Crescent Hawks: Inception using Reko decompilation project files. Its findings describe run-length encoding in ICN and CMP images and two layout schemes for MTP map files. Following the project requires the user's own game executable and data files.

ReMoM reconstructs Master of Magic from its original executables by disassembling and translating game code to C. Its engine builds for modern platforms and loads LBX resources and CONFIG.MOM from the user's original version 1.31 copy.

Resident Evil 1 for PC Decompilation reconstructs the 1997 game’s logic from Ghidra analysis of its executable and runs it on Windows and Linux. The port replaces the original Marni System’s DirectX 5 implementation with Direct3D 11 or OpenGL rendering and corresponding audio and video layers. The author reports that the full game is playable and that 1,716 of 1,717 game logic functions are implemented.

This is a work-in-progress decompilation of Resident Evil: Code: Veronica X for the GameCube. The supported version is GCDE08, the USA release. The player copies a disc image into orig/GCDE08, then runs python configure.py and ninja.

Retro-Sonic 3D Decompilation reconstructs Retro-Sonic 3D: Sky Worlds in C++ and adds a mod loader. Its default build replaces the original DirectX 7 renderer with OpenGL and SDL; running it requires assets from the 2005 demo.

These notes decompile Azel: Panzer Dragoon RPG, also called Panzer Dragoon Saga, for the Sega Saturn. The disc 1 progress table lists 1ST_READ.PRG at 74.70 percent (1,908 of 2,554 bytes) and MENUEN.PRG at 54.39 percent (26,624 of 48,944 bytes).

Rewritten is a functional C++ decompilation project for Minecraft Legacy Console Edition Title Update 2 on Xbox 360. It aims to recreate the game's behavior without byte matching; the contribution notes describe using a patched TU2 XEX with Ghidra or IDA Pro.

This is a work-in-progress decompilation of Rhythm Heaven Fever. The supported version is SOME01, the USA release. The player extracts sys/main.dol to orig/SOME01, then runs python configure.py and ninja.

This repository is a work-in-progress decompilation of Rhythm Heaven for the Nintendo DS. The supported version is YLZE01, USA revision 0. The tree contains no game assets or assembly.

The Ridge Racer 64 decompilation project records ROM splits, symbols and linker settings for the USA Nintendo 64 release. Its Makefile runs splat and builds a new ROM from a user-supplied original; the author describes the effort as an attempt.

Activision's 1982 Atari VCS game River Raid is disassembled into labeled and commented 6502 assembly (version 0.9). Notes explain how random river sections of 16 blocks ending in a bridge are generated, how one fuel tank, enemy or house is placed per block, how a two-line kernel repeated twelve times draws each 32-line block with hardware-only collision checks, and how the score lives directly in the display pointers; switches add screensaver code and a training mode.

Road Rash for 3DO reconstructs the USA release as functional C source targeting the 3DO DevKit. The repository covers game and runtime routines and documents behavior-preserving changes to road rendering, animation decoding, simulation and audio paths.

Robotron: 2084 is a SkoolKit disassembly of the ZX Spectrum game. The repository stores the SkoolKit source and control files and provides a script to generate browsable hexadecimal or decimal listings.

This repository is a decompilation of the Nintendo 64 game Rocket: Robot on Wheels. The US ROM is named baserom.us.z64.

RockmanDash-Decomp partially reconstructs the Japanese Nintendo 64 release of Rockman Dash as C source. Its segment map assigns ROM offsets to C, assembly and data, and the source files combine recovered functions with assembly placeholders.

Rockstar Table Tennis Decompilation reconstructs the Xbox 360 game's PowerPC functions as C++. Its source tree includes function maps, vtable data, initialization-flow findings and an MCP server that exposes decompilation context to contributors. The author reports 3,413 functions decompiled out of 13,545.

Rood Reverse is a reverse engineering of Vagrant Story for the PlayStation. The README describes splitting and building with make, then decompiling individual functions, including scratches created with make decompme.

RSDKv2 Decompilation is a decompilation of Retro Engine v2, the engine used by the 2008 Sonic Nexus demo. The README adds a built-in mod loader, a settings.ini file, and debug keys, and it builds with CMake. Running it requires Sonic Nexus 2008 demo assets, which are left out of the repository.

Reconstructs Retro Engine v3, the engine behind the 2011 Sonic CD remaster, as a native C++ source port for Windows, Linux, macOS and Android. The engine runs the game's own scripts and assets from an official release, which the repository does not ship, and adds a mod loader, a settings file with remappable controls, support for the mobile versions' updated scripts and extra developer-menu debug keys. Its license describes the code as mostly functionally the same as the original rather than byte-matching; the same team's RSDKv5 decompilation is listed as a separate case.

Decompiles Retro Engine (RSDK) v4, the engine behind Sonic the Hedgehog and Sonic the Hedgehog 2 (2013), together with the games’ natively coded menus, and builds it for Windows, Linux and Android. The engine runs the game scripts contained in the official releases’ data files, which users must supply. The project adds a script compiler, a mod loader and an experimental online mode for Sonic 2’s 2P VS; it is the predecessor of the same group’s RSDKv5 decompilation.

Reconstructs the Retro Engine (RSDK) v5 and v5 Ultimate runtime, the engine that runs Sonic Mania’s game code, and builds it for Windows, Linux, Switch and Android. RSDKv5U can also run RSDKv3 and RSDKv4 games such as Sonic CD and Sonic 1 & 2. The project adds a mod loader, a shader compiler and extra Windows backends, and ships no game data.

Rumble Fighter reconstructs parts of the game's Windows executables in C++. The project reports function coverage and similarity for rumblefighter.exe, RumbleLauncher.exe and Home.exe, and builds with CMake, NMake and an MSVC installation.

sctools contains an approximate, nonmatching C decompilation of nsf.exe and a C++ tool that extracts files from Sega Channel game distribution images.

sead is a decompilation of the engine and libraries developed by Nintendo EAD, now EPD, as found in New Super Mario Bros. U and other games. The README describes engine/ as the standard library, nw_ptcl as a wrapper around NintendoWareForCafe Eft, and agl as the graphics library. It says a byte-identical rebuild is out of reach without the NSMBU compiler, and the current goal is matching functionality and efficiency.

sead reconstructs Nintendo EAD engine and library code found in New Super Mario Bros. U and other games. Its C++ tree covers framework, containers, graphics, audio and file devices, with a current goal of matching the original functionality rather than its compiled bytes.

SegaSonic The Hedgehog reconstructs the Sega System 32 arcade game's NEC V60 and Z80 programs as readable C. Its tools disassemble and decompile code, extract assets from the user's MAME ROM set, and compare game, video and sound behavior with reference runs frame by frame. The author reports Windows play for the SDL2 port; Linux and macOS builds had not been tried.

Severed Chains rewrites Legend of Dragoon from its assembly into Java and adds a modding API. The README says the game is fully playable with no known crashes. Java 25 is required. Disc images go in the isos directory, and Gradle configures the IntelliJ project. Assets are extracted from those images at runtime. Controllers, including rumble, and keyboard controls are supported.

Shadowgate 64 is an N64 disassembly and source reconstruction for the North American release. Its configuration splits a hash-checked user ROM into code segments, while the displayed C file still incorporates assembly functions.

shadowheartsdecompilation reconstructs C++ source for the core runtime classes of the PS2 game Shadow Hearts. It covers CThread, CTimer, CPoller, CPolling, CPolObj, CDrawObj, CDrawPolling, CDraw, CApp, CPause, FVector and Matrix, with each method annotated with its address in the original executable and written against Emotion Engine kernel calls and hardware timer registers.

Rewooled reconstructs the PC game Sheep, Dog 'n' Wolf from machine-code analysis and runs it on Windows, macOS and Linux using SDL3. Its source covers the game engine, objects, input and rendering, while the runtime reads assets from the user's game copy.

skcollectioncport reconstructs the Windows game Sonic & Knuckles Collection as C and C++ source. It covers player and character objects, per-zone objects, the game, opening and stage-select modes, save data, collision and scrolling, map and sprite-pattern tables, and a Win32 front end whose functions are decompiled from the PC executable by address, including the software VDP renderer, sound, registry and controller handling.

This project reconstructs the 32-bit SkiFree version 1.04 in C. It was developed with Visual Studio 6 and aims to be byte-compatible with the original. The README says all code and data have been converted to C, and exact matching of every function and data segment is still open.

SMB Vanilla reconstructs the gameplay of Super Mario Bros. and Super Mario Bros. 2 Japan in C. It runs against a user-supplied ROM for level and graphical data and aims to preserve original behavior, including many glitches. The author reports both games are beatable; refactoring of Ghidra-derived code, tests, and some audio remain unfinished.

SMBDIS.ASM reconstructs the NES game Super Mario Bros. as a single commented 6502 assembly file of about 16,000 lines. It names the PPU, APU and joypad registers and the game RAM variables, comments routines such as the sound engine, player movement and enemy handling, and lays out the metatile graphics table, level, enemy object, area object and music data; it assembles with x816 once the user supplies the character ROM data and an iNES header.

smt-decomp is a work-in-progress decompilation of the PlayStation version of Shin Megami Tensei 1. Its workflow extracts files from a player-supplied game copy and generates assembly for function-matching work. A future PC port of the classic series is the stated goal.

This is an early decompilation of Snowboard Kids for the Nintendo 64, US release. baserom.us.z64 has SHA-1 1583bacc9046a360df8ea4d536942155247e154c. make decomp writes a work-in-progress tree under decomp, using splat and m2c. The README says the project cannot rebuild a ROM yet.

This is a disassembly of Sonic 3D Blast. The README says the files are under IDCFILES, and it names IngameMode, LoadLevel, InitLevel, RunLevel, and RunSonic. Commercial use is prohibited.

doldecomp/sadx reconstructs Sonic Adventure DX for GameCube across eight prototype, demo and retail versions. Its build uses extracted game DOL and REL files, builds DOLs and disassembles REL modules as the decompilation progresses.

Sonic CD Decompilation reconstructs C source for the version of Sonic CD included in Sonic Gems Collection. The repository also contains an SDL launcher with game file loading, graphics and audio support.

Reconstructs Sonic Mania’s game code in C and builds it with the separately decompiled RSDKv5 or RSDKv5U engine for Windows, Linux, Switch and Android. Assets must come from an official Sonic Mania (Plus) release; the project adds a mod loader and can build several retail versions. Its license describes the code as mostly functionally the same as the original, not byte-matching.

Sonic Riders Tournament Edition decompiles the GameCube tournament edition derived from Sonic Riders USA. The repository combines C++ and assembly sources and builds a main.dol with devkitPro, CMake and a customized libOGC. The work remains in progress.

SR2 reconstructs source for the September 2007 PlayStation 2 prototype of Sonic Riders: Zero Gravity. Its Python and Ninja build uses an ELF supplied by the user, and objdiff compares reconstructed objects against the original. Architecture notes describe the game’s task and object system.

Sonic the Fighters is being reconstructed from its Model2b arcade code, with a mostly assembly-language disassembly intended for function-by-function conversion to C/C++. A Makefile and extraction script use the user's schamp and sfight ROM archives to build program binaries and extract supported data.

Converts the reverse-engineered Space Cadet pinball game into compilable C++ for desktop platforms. The README identifies the Windows XP executable and public PDB, a Full Tilt executable, and the work of recovering structures, naming variables and adapting the decompiled routines.

Reconstructs parts of the Sparkplug Engine and Winx Club game code for PC and PS2 while documenting engine systems and resource formats. Its knowledge base covers SMO/FFPS, SAN, STX and PCK, alongside source and programs for inspecting game resources.

SPEED RE reconstructs routines from the SPEED engine using Need for Speed Underground 2 PC v1.2 as its reference. It documents recovered physics, collision, camera and HUD code, compares some functions byte-for-byte or through bounded execution, and runs an incomplete Linux driving demo on a user's installation.

Reconstructs C++ components of the Wii U game Splatoon from its Gambit.rpx executable. The workflow verifies a user dump, extracts strings and RTTI, uses Ghidra for static analysis, and configures objdiff for function comparison; the tree includes game and library source files.

Splitting Images provides SkoolKit disassembly sources for the ZX Spectrum game also known as Split Personalities. Its source and control files support generated HTML listings in hexadecimal and decimal forms.

spore-decomp reconstructs behaviour from Spore's SporeApp.exe in portable C++17, currently covering DBPF, RefPack and name hashing. It annotates reimplemented functions with original addresses and provides Ghidra scripts plus a Unicorn harness for differential tests against a user's game copy. The source tree also includes matching experiments and progress records.

Spyro the Dragon reconstructs selected PlayStation game functions as readable C for behavioral comparison. The workflow compares compiled instruction counts, places replacement functions in extra RAM and redirects original entry points to test them in PCSX-Redux.

SSX 3 reconstructs source for the USA Rev 0 GameCube release as an unfinished decompilation. Its configuration uses a user-supplied disc image to prepare a Ninja build, while objdiff compares rebuilt objects with the original game.

This is a work-in-progress decompilation of a debug build of Star Fox Adventures, version GSAP01, file default.dol. The README says that file is on Interactive Multi-Game Demo Disc - July 2002 (USA) and is unused there. It was built for an internal debug environment, writes to addresses used for debug tracing, and expects an RGBA framebuffer at a fixed address. The README says the code will most likely not compile yet, and that the build does not boot on a console or an emulator.

Star Fox Adventures kiosk default.dol is a work-in-progress reconstruction of the executable found in the game's kiosk ROM. The repository includes C sources, GameCube SDK headers, split and symbol configurations, and Python/ninja build instructions using a user-provided executable.

Starmaster for the Atari 2600 (Activision, 1982) is disassembled with DiStella v2.0 and then analyzed, named and commented into readable 6502 source. Named constants describe the 6x6 sector map, starbases, enemy IDs, star field, warp and laser timing and enemy fire distance, and an OPTIMIZE switch swaps in code improvements the author identified while studying the routines.

Starquake reconstructs the BBC Micro game's assembly and provides a Beebasm command to generate a bootable disc image from decoder.asm. The README also points to an online BBC Micro environment for loading the resulting disc.

Street Fighter Alpha 3 MAX: Decomp reconstructs the PSP game's functions as readable C inside a native PC runtime. Functions not yet decompiled are translated from the PSP program during the build, while parity tests compare selected runs frame by frame. The author reports 412 of 14,881 functions decompiled; the US ULUS-10062 disc supplies the program and assets.

Stuntman PC translates the PlayStation 2 game's program into C++ and runs it through a native host with Vulkan graphics. It builds from a user-owned European SLES-50288 disc image, while the bundled PS2 port engine supplies analysis, lifting, behavior checks and replacements for console services.

This disassembles the Supaplex speed-fix executable SPFIX63.EXE. The repository has the assembly and an IDA database. It builds in DOSBox with TASM 4.1 after the original Supaplex files are extracted into build/.

SupComDecomp presents a C++ reference decompilation of the base Supreme Commander: Forged Alliance executable. It uses class type information, vestigial DLL symbols and assertion paths to recover names and source structure; the author states that the source does not compile.

Super Columns provides a disassembly of the Sega Game Gear game. The author says it came from Emulicious and can be reassembled with WLA-Z80 and WLALINK. The repository includes the main assembly file, data includes and a shell build script.

smb3 disassembles the initial Family Computer release of Super Mario Bros. 3 and adds C-like annotations for branches and loops. An extraction script obtains assets from a headered iNES ROM before building with the cc65 6502 toolchain.

Super Mario RPG reconstructs the SNES game's code as assembly with ROM maps and supporting scripts. The framework extracts assets from a user-supplied ROM, then assembles the game with Asar; its build script lists US and Japanese ROM options.

Super Monkey Ball Jr. provides a minimal, buildable disassembly of the GBA game. Its make build uses a user-provided USA ROM named baserom.gba and devkitarm.

SUPERCOPTER is a decompiled source reconstruction of the MS-DOS game in Turbo Pascal. The repository contains Pascal source, a reference source file and an include file. The author identifies Turbo Pascal 3.01A and Borland's Graph library as the original build environment.

SW_RACER_RE maps and reimplements selected functions from Star Wars Episode I: Racer to support game modifications. Symbol files and Ghidra scripts record recovered addresses, while a dinput.dll hook can replace original functions with reconstructed code during play.

chipfact is an annotated disassembly of the 1984 computer game Technician Ted. Its SkoolKit sources cover the game and its loader, with separate room-format and loader notes in the repository.

jman-decomp reconstructs C++ source for the Windows 3.1 version of The Journeyman Project Turbo!. It includes game-specific classes, build material and version metadata for English releases 1.0 and 1.1, with later porting as its stated purpose.

Rebuilds the 1990 Amiga version of System 3's The Last Ninja Remix in C++, loading game data from the user's ADF disk images of the original. The source includes an ADF disk reader, actor, enemy, room, level and HUD code, and keeps disassembly labels such as sub_46A2 and word_14D6 for the routines and variables it reproduces. The first level is completable.

A work-in-progress hand decompilation recreates source for the Nintendo DS game The Legend of Zelda: Spirit Tracks. Its build accepts an owned base ROM for asset extraction and lists Japanese, European and US releases, with Europe Revision 0 as the default.

The Need for Speed's 3DO release is reconstructed as a C codebase targeting the 3DO DevKit. Its build extracts assets from the user's game image and links the reconstructed executable into a new ISO. The author targets functional equivalence rather than a byte-identical rebuild.

ts2c reconstructs the US Wii build of The Sims 2 Castaway through disassembly and decompilation. The repository contains hundreds of assembly files organized by original code unit and a Makefile targeting a rebuilt main.dol.

The Sims Bustin' Out GameCube decompilation targets the USA Rev 0 G4ME69 release. It combines decomp-toolkit build configuration, initial C files, and custom scripts that infer possible symbol matches from another GameCube decompilation. The author describes the split mapping as very early and largely heuristic.

The SpongeBob SquarePants Movie Game project reconstructs source for the GGVE78 NTSC game release. Its C and C++ tree, split and symbol configuration, and Ninja build operate on a user-supplied disc image; objdiff supports comparison of rebuilt objects.

The Way of the Exploding Fist presents a SkoolKit disassembly of the ZX Spectrum game. Its source files and scripts generate browsable hexadecimal and decimal HTML views.

The World Ends With You reconstructs the Nintendo DS game's code for its US and Japanese releases. The project builds from user-supplied ROMs and documents asset formats including PACK archives, graphics, text, fonts and tables.

The author’s REA fork, posted as rea-engine and since renamed RE-Agent, decompiles the shipped .NET executable of the GPL-licensed TicTacToe-AI game, recompiles the recovered C# and resources, and repairs one decompiler error against the original IL. A differential probe runs original and rebuilt code on all 19,683 board assignments for one status method and compares six form renders. The report passes only that method; the whole game remains partial.

tokimemo is a work-in-progress reconstruction of Tokimeki Memorial: Forever With You for PlayStation version 1.1. It records executable segments and symbol addresses in a PS1 splat configuration, with assembly source and a Makefile for rebuilding the target executable.

wotwdecomp reconstructs the GameCube game Tom and Jerry: War of the Whiskers with C++ and assembly and builds a specified main.dol. Its Makefile combines reconstructed functions, remaining assembly, and the required GameCube toolchains. The author describes the build as experimental because unresolved hardcoded pointers prevent shifting it for general changes.

cdcEngine reconstructs C++ source for the engine used by Tomb Raider: Legend. The code includes game loop, archive filesystem, rendering, sound, and scene components, with a Premake configuration for an x86 windowed application.

tomb3 reconstructs the PC Tomb Raider 3 game as C++ source. Its changelog reports a completed decompilation and newly compiled executable, alongside renderer changes, gameplay fixes, and support for the game's original installed data.

TOMB4 reconstructs source for the PC version of Tomb Raider 4. The repository contains C and C++ game routines, Windows build projects, a changelog of game fixes and installation instructions that use an existing game installation.

Tomodachi Life is the target of an early 3DS decompilation with C++ source, symbol splits, and a build pipeline. The setup uses the USA Rev 1 code.bin and exheader together with armcc; the source tree currently contains only a small amount of reconstructed code.

TomodachiLifeDecomp begins reconstructing the US 1.0 Nintendo 3DS release of Tomodachi Life. Its C/C++ sources and symbol files are paired with scripts to build code.bin, compare symbols through asm-differ, and calculate progress. The author describes it as an early work in progress.

thug2-decomp reconstructs Tony Hawk's Underground 2 for PC as readable C++ across engine, game, rendering, scripting, and networking subsystems. The author says rewritten functions were checked against the original's behavior; the resulting executable runs using data from the user's game installation and includes source-level fixes and additions.

Travel With Trashman provides SkoolKit disassembly sources for the ZX Spectrum game. Its source and control files support generated HTML listings in hexadecimal and decimal forms.

This recreates the source of Tube, the 1994 DOS game from Bullfrog, using Hex-Rays and IDA Pro. The result builds as a 32-bit program with SDL2. Windows uses build_windows.bat, Linux uses build_linux.sh, and the web build uses build_web.bat. The README also lists OpenWatcom 1.9 for a DOS DPMI build. It says the original code uses 32-bit pointers, so this tree does not build as 64-bit.

The Turtles in Time SNES disassembly covers the USA, European PAL and Australian PAL ROMs of Teenage Mutant Ninja Turtles IV. It uses the author's SNES ROM framework and an asset extraction script that reads the user's clean ROM.

TWD · Source Recovery reconstructs selected functions from The Walking Dead: Season One as C++ replacements for an experimental hybrid runtime. It publishes geometry, hash and symbol code, comparison harnesses, analysis scripts and progress reports. The author reports 14 replacements among 18,299 recognized functions; the standalone source engine remains unfinished.

This is a work-in-progress decompilation of Ty the Tasmanian Tiger. The supported version is GTYE69, the USA release. The player extracts sys/main.dol to orig/GTYE69, then runs python configure.py and ninja.

u5d reconstructs C source for Ultima V: Warriors of Destiny and compares it with the MS-DOS v1.16 program at the assembly-semantic level. The author reports that the modern version can be played through to the ending using original game data. The author reports approximately 95% matching for ULTIMA.EXE, excluding assembly functions, and approximately 95% for the overlays.

The author uses a pinned REA build with Ghidra to analyze a user-supplied Pokémon Ultra Sun base executable, rebuild it byte for byte from split objects, and swap in two small compiled C runtime routines. Both replacements are behavior-tested but nonmatching and every other byte stays original; one recorded input movie drives the original and hybrid builds to the same bedroom movement in the Azahar emulator. Retail compiler identity, exact matching, module loading and broader gameplay remain open.

This is an in-progress decompilation of Vandal Hearts for the PlayStation, US release. The executable is SLUS_004.47, checksum 596bb082a2de5f1fe977dd3d7e160b03. The README also lists ASPSX.EXE v2.21 from PSY-Q v3.3, checksum e3ae8aea2623b916f89384bf70f55487, and LIB34.ZIP, checksum d25fd757e944a05369e8fb003a007dd2.

vc64-decomp disassembles and partly decompiles the Wii N64 Virtual Console build targeting the North American Super Mario 64 release. Its build combines PowerPC assembly and C sources into a Wii .app file.

Venture for the Atari 2600 (Coleco) is reverse-engineered into commented 6502 source with a DASM build command that writes a listing, symbol table and binary. Comments document the screen region used for rooms, sprite timesharing in the moving-wall room, monster status values, shot range, collision handling and per-room playfield offsets, and every graphics table carries a visual comment of its pixels; two RAM bytes are marked unused by the original code.

VeryFat Dungeon is a work-in-progress decompilation of Wii Fit Plus for the USA Rev 0 Wii release. It holds C and C++ reconstruction sources, symbols and split configuration. A build made from the user's disc image produces objects that can be compared with the original using objdiff.

VETTE! 2026 rebuilds the DOS racing game in C++20 and SDL3 from disassembly and documented format research. The original runs in a built-in emulator while native routines are added and compared incrementally; the port also reads optional PC-98 and Macintosh art and sound from the user's copies.

Recovers Virtua Fighter 2 Version 2.1’s Sega Model 2A i960 program into portable, non-matching C17, accepting each recovered path only when it matches a reference i960 executor at controlled boundaries. The repository adds ROM validation, i960 and 68000 analysis tools, a bounded Model 2A hardware model and snapshot-based differential runners. README states that it is not yet a playable port; match flow, combat, physics, AI, rasterization and much of the audio remain open.

Virtua Tennis decomp reconstructs the Dreamcast game's executable from a user-provided disc, first establishing a byte-matching assembly baseline and then substituting C for game functions. Its tools generate function tests and asset maps for models, textures, text and audio. The author reports C has been written for every function with a C form, with behavioral equivalence as the completion criterion.

This is a decompilation of Virtual Pro-Wrestling 2 (バーチャル・プロレス2 〜王道継承〜) for the Nintendo 64. An unmodified Z64 ROM named baserom.z64 has SHA-1 82dd25a044689eab57ab362fe10c0da6388c217a. make setup extracts the ROM. make builds it. The README says the project is still in progress.

monty is a SkoolKit disassembly of the 1984 ZX Spectrum game Wanted: Monty Mole. The repository includes separate skool sources for the game and loader, plus control files and a build script.

War Storm reconstructs source for Sudden Strike II 2.2 from the game's original binaries. Its code covers the launcher, three resolution-specific renderer modules, menu, and game components, while the author describes a complete playable implementation and 64-bit support as future goals.

Wario World reconstructs the US GameCube game's code through an in-progress decompilation and disassembly. The repository provides assembly, linker configuration and a build workflow; the author reports that the current disassembly can be reassembled.

Way of the Samurai 2 runs the PS2 game's hand-decompiled MIPS functions as native C++ with OpenGL and SDL2 host layers. It loads data from the user's NTSC-U disc and includes a reconstructed Sol script compiler and VM; the author reports play through to the ending with visual and timing limits.

WCW/nWo Thunder reconstructs source for the PlayStation game from a work-in-progress disassembly. Its build takes SLUS_007.79, WGAME.BIN and WMENU.BIN from the user's disc and checks generated binaries against expected checksums.

westbank presents a SkoolKit disassembly of West Bank, the ZX Spectrum version of Bank Panic. It stores the annotated skool source and scripts for generating hexadecimal or decimal HTML disassembly pages.

Wii Play reconstructs C and C++ source for the Wii game's USA Rev 1 release. Its build takes a local disc image, and its objdiff configuration lets contributors compare rebuilt objects while source and symbol files change.

ogws is a work in progress decompilation of Wii Sports. The README names one supported version, US Revision 1, and points build steps to docs/getting_started.md after the disc is dumped.

Decompiles the USA Wii U release of The Wind Waker HD function by function into readable C++ in zeldaret/tww’s style, and verifies each function by running it beside the original, statically recompiled from the user’s own copy, comparing return values, memory writes and calls on generated and recorded inputs, with coverage and mutation checks. README reports 28,244 of the game’s 39,713 functions verified, including 22,068 of 22,215 GameCube-derived functions. The code calls undecompiled functions by address, so it runs only inside the ZeldaWWHDRecomp port, not as a standalone game build.

WinFish decompiles Insaniquarium Deluxe 1.1 from the Windows executable. The README says the result is fully playable and still has bugs. The solution WinFish.sln uses the Visual Studio 2022 v142 toolset. A 32-bit build needs bass.dll from the original game, plus the data, properties, and fishsongs folders copied beside the solution.

Wobbledogs reconstructs the Steam Windows game's managed assemblies by decompiling IL with ILSpy and recompiling the resulting C# with Roslyn against the game's Mono profile. Scripts export assemblies from an owned install, repair documented decompiler artifacts, package a runnable tree, and compare code and boot behavior. The author reports a 69.80% code match.

World of Goo is an unfinished decompilation of the European WiiWare release WGOP. The repository contains game-specific C++ source and build configuration; its workflow extracts a user-provided WAD, builds with Python and ninja, and compares rebuilt objects with objdiff.

Xenosaga Episode I decomp reconstructs source for the NTSC-U PlayStation 2 release and builds its SLUS_204.69 ELF. The repository contains game C files, symbols and build configuration; its build starts from an executable extracted from the user's game disc.

Ogre-Decomp is an in-progress decompilation of the PlayStation 2 game Yakuza. Its script runs splat splitting, assembly delinking and MWCC compilation, while configuration maps the game's main and game overlays and records target hashes.

Begins a decompilation of Yoshi's Island DS USA 1.0 using DSD and Ghidra. The repository contains ROM configuration and symbol files for the ARM9 and overlays, with a small C source tree for recovered code.

Yoshi's Story Decompilation reconstructs the US Nintendo 64 game's code in C and assembly. The repository provides source files, extraction and build commands, and a workflow that starts from a user-provided .z64 base ROM.

Yoshi's Woolly World is an early decompilation of the game with C++ source and headers in the repository. Its build instructions use Green Hills Software MULTI PowerPC v5.3.27 and a Python compile script; assembly diffing and match calculations remain on the task list.

Disassembles the Commodore 64 Zaxxon cartridge in Kick Assembler syntax and rebuilds its two banks and four CHIP sections into a CRT image. The author explains the mirrored $9000 memory window and includes it in the assembly for debugger breakpoints.

Zombie Revenge decomp reconstructs the European Dreamcast game's executable with C and a disc-derived assembly baseline. Its tools split functions, map assets, run directed equivalence cases and build a replacement executable; the author reports 65.8% instruction test coverage over functions eligible for C translation.