---
title: "Curated reverse engineering resources · Page 16"
url: https://awesomerea.org/resources/page/16/
updated: 2026-11-10
type: page
---

# Curated reverse engineering resources · Page 16

> Page 16 of 52, entries 1,501–1,600. 5,191 tools, projects, integrations, case studies, and references for websites, games, apps, native binaries, firmware, and communication protocols.

Source-reviewed means descriptions were checked against primary documentation. Each entry page lists the full requirements and sources; this page shows their counts and the review date.

- HTML: <https://awesomerea.org/resources/page/16/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/16/index.md>

## Games (100)

- [SimCity SNES Disassembly: US ROM disassembly](https://awesomerea.org/resources/simcity-snes-disassembly-case/index.md): Case study · SimCity SNES Disassembly provides assembly sources for the US Super Nintendo release of SimCity. Its asset-extraction script uses a clean, headerless copy of the supported ROM supplied by the user, and the project uses version 1.0.1 of the author's SNES ROM framework.
- [OpenDance Engine: recreating Just Dance gameplay in GML](https://awesomerea.org/resources/opendance-just-dance-case/index.md): Case study · OpenDance Engine recreates Just Dance gameplay in GameMaker Language using hand-written code and findings from the UbiArt Framework and Bluestar Engine. It reads UbiArt CKD and Bluestar JSON files, plays video and audio, and implements KaraokeClip, PictogramClip, GoldMoveEffectClip and MainSequence support.
- [Harry Potter and the Half-Blood Prince: function-level Windows decompilation](https://awesomerea.org/resources/harry-potter-half-blood-prince-decomp-case/index.md): Case study · Harry Potter and the Half-Blood Prince — Decompilation reconstructs functions from the Windows hp6.exe as C and readable MASM, then compares rebuilt machine code with the executable. A Capstone-based tool emits C candidates from x86 control flow; the author reports 4,689 exact function matches among 10,992 inventoried functions.
- [Viva Piñata Recomp: a ReXGlue native Windows port](https://awesomerea.org/resources/viva-pinata-recomp-case/index.md): Case study · Viva Piñata Recomp translates the original Xbox 360 game's code into C++ with ReXGlue and builds a native Windows program. It includes a launcher, game-version checks and Direct3D 12 or Vulkan rendering modes; the author reports menu, garden and save functionality on the documented disc version.
- [Conker's Bad Fur Day: function-matched N64 decompilation](https://awesomerea.org/resources/64cbfd-conker-decomp-case/index.md): Case study · 64CBFD reconstructs code and data for the Nintendo 64 game Conker's Bad Fur Day from a user-provided US ROM. Its build extracts game sections, rebuilds C functions and compares linked instructions with the retail image; the author reports separate converted and byte-exact function counts.
- [Tiger Woods PGA Tour 2004: a matching GameCube decompilation](https://awesomerea.org/resources/tiger-woods-pga-tour-2004-decomp-case/index.md): Case study · tw2004 reconstructs the USA revision 0 GameCube main.dol of Tiger Woods PGA Tour 2004 as C source. Its build compares the output with the retail executable; the author reports byte-identical matching for all 7,647 functions, while naming and documentation work continues.
- [TH10: reconstructing Mountain of Faith 1.00a](https://awesomerea.org/resources/th10-reconstruction-case/index.md): Case study · TH10 reconstructs the Japanese 1.00a executable of Mountain of Faith as source checked against native code. It records function boundaries, origins and exact comparisons separately, while the complete Windows i386 build and runtime behavior remain open.
- [Project Gotham Racing 2: an Xbox XBE static recompilation](https://awesomerea.org/resources/pgr2-recomp-case/index.md): Case study · pgr2-recomp ports the original Xbox release of Project Gotham Racing 2 to Windows by statically recompiling its x86 XBE code. The port reimplements Xbox graphics, audio and system services and documents executable variants, XDK libraries and game-specific GPU command behavior.
- [Skate 2 PC Recompilation: an Xbox 360 game port through ReXGlue](https://awesomerea.org/resources/skate-2-pc-recompilation-case/index.md): Case study · Skate 2 PC Recompilation translates the Xbox 360 release of Skate 2 into a native Windows build with the ReXGlue SDK and a user-supplied disc image. Its title-specific configuration adds missed function entry points and a jump-table override, while SDK patches address rendering and runtime faults.
- [Breath of Fire GBA: a European-version decompilation](https://awesomerea.org/resources/breath-of-fire-gba-decomp-case/index.md): Case study · bof_old decompiles the European multilingual Game Boy Advance port of Breath of Fire into C and assembly. Its build uses a user-provided baserom.gba, devkitARM and agbcc, and lists the SHA-1 of the resulting ROM for comparison.
- [Jungle King: a labeled arcade Z80 disassembly](https://awesomerea.org/resources/jungle-king-z80-disassembly-case/index.md): Case study · Documents a Z80 disassembly of the arcade game Jungle King, with labeled routines and memory-mapped input and video notes. A Python script applies post-processing changes to converted assembly.
- [Monster Truck Madness: a static recompilation of the second game](https://awesomerea.org/resources/monster-truck-madness-2-recomp-case/index.md): Case study · Monster Truck Madness statically lifts Monster Truck Madness 2's Monster.exe to C with pcrecomp and runs it on a 32-bit Windows host. The repository includes function cataloging, code generation and DirectDraw presentation code; the author reports that scripted input can start and drive a race, while a complete race remains unfinished.
- [OpenCross: reconstructing the Chrono Cross engine](https://awesomerea.org/resources/opencross-case/index.md): Case study · OpenCross rebuilds a native C++20 engine for Chrono Cross that reads an owner's Radical Dreamers Edition installation. It implements game rules and file-format importers, with documented comparisons against the original game and Ghidra scripts for examining the PC executable and PlayStation code.
- [Moto Racer Recomp: a native Moto Racer port built by static recompilation](https://awesomerea.org/resources/moto-racer-recomp-case/index.md): Case study · Moto Racer Recomp translates the original Moto Racer Windows executable from a user's GOG installer into C and compiles a native program on the user's computer. Its runtime implements the Windows, DirectDraw, Direct3D, DirectSound and CD audio interfaces used by the game, with builds for Apple Silicon macOS, Windows x64 and x86-64 Linux.
- [Odin Sphere Leifthrasir - PC Port: running the PS4 game code on PC](https://awesomerea.org/resources/odin-sphere-leifthrasir-pc-case/index.md): Case study · Odin Sphere Leifthrasir - PC Port runs the PS4 game's original x86-64 code on a native PC runtime that replaces PS4 system libraries and uses a shadPS4-derived Vulkan renderer. Its installer accepts user-provided packages for specified USA, Japanese, European and Hong Kong builds, and scans selected eboot.bin builds for executable sites.
- [OpenSWE1R: porting Star Wars: Episode I Racer with runtime code replacement](https://awesomerea.org/resources/openswe1r-case/index.md): Case study · OpenSWE1R ports the Windows x86 release of Star Wars: Episode I Racer by patching replacement open-source code into the game at runtime. It combines x86 CPU emulation with implementations of the Windows functions the game uses. Unreplaced functions still execute from the original game binary, and game art comes from the user's copy.
- [BLACK PC port: running Xbox game code on Windows](https://awesomerea.org/resources/black-pc-case/index.md): Case study · BLACK PC port runs the Xbox release of BLACK on Windows by loading the user's default.xbe and executing its x86 game code. A native loader replaces Xbox kernel, graphics, audio and input services, while project notes record analysis of the executable.
- [Virtua Tennis: a disc-local Dreamcast decompilation](https://awesomerea.org/resources/virtua-tennis-dreamcast-decomp-case/index.md): Case study · 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.
- [dndserver: a replacement Dark and Darker server](https://awesomerea.org/resources/dndserver-case/index.md): Case study · dndserver reconstructs a Python server for the Dark and Darker Playtest 5 client. It implements accounts, characters, inventory and lobby features, with an HTTP discovery step leading the client to a TCP lobby server; its development guide calls for packet analysis and protobuf knowledge.
- [Tekken 3 Recompiled: hybrid recompilation and native port research](https://awesomerea.org/resources/tekken3recompiled-case/index.md): Case study · Tekken 3 Recompiled combines a playable hybrid recompilation of the US PlayStation game with an early native PC port. Its tools inspect local BNS, ARC, TIM, VAB, model, XA, and STR data, while the native slice currently uses procedural stage and fighter stand-ins.
- [Rampage Arcade: Z80 disassembly and graphics decoding](https://awesomerea.org/resources/rampage-arcade-disassembly-case/index.md): Case study · Rampage Arcade studies the Z80 program ROM of the 1986 MCR-3 arcade game, covering startup, input, sound, sprites, level decoding and hardware interaction. Python scripts and a batch file convert graphics from user-supplied ROMs into images.
- [Skate 3 Port: an Android ARM64 static recompilation port](https://awesomerea.org/resources/skate-3-port-android-case/index.md): Case study · Skate 3 Port adapts an Xbox 360 Skate 3 static recompilation to Android ARM64, linking the translated PowerPC game code against a Vulkan runtime. Its Android launcher validates and extracts a player's ISO, while the fork adds touch controls, graphics settings and runtime changes. The project is experimental, with visual bugs, missing effects and device-specific performance issues listed as expected limitations.
- [007: Nightfire - XBE Recomp: an Xbox game recompiled for PC](https://awesomerea.org/resources/007-nightfire-xbe-recomp-case/index.md): Case study · 007: Nightfire - XBE Recomp ports the original Xbox game to native Windows through Xbox XBE Recomp. It builds from the user's USA or Europe game files and adds configurable graphics, keyboard and mouse input, controller support, and texture dumping.
- [Starwing 3DS: a Nintendo 3DS adaptation of Star Fox](https://awesomerea.org/resources/starwing-3ds-case/index.md): Case study · Starwing 3DS ports the reconstructed Star Fox / Starwing engine to Nintendo 3DS with dual-screen presentation, console input, SPC audio and local processing of a user-supplied SNES ROM. It builds on Starfox Enhanced and related reconstruction work; the author describes the release as experimental.
- [Kingdom Hearts 2 Final Mix: an in-progress PS2 main-ELF decompilation](https://awesomerea.org/resources/kingdom-hearts-2-final-mix-decomp-case/index.md): Case study · Kingdom Hearts 2 Final Mix reconstructs C++ source for the PlayStation 2 game's main ELF. Contributors add function symbols and implementations, rebuild with the project's compiler setup, and compare objects in objdiff. The author reports recovering class definitions and file layout from an E3 kiosk demo PS3 port of Kingdom Hearts 2.
- [FrontierVM 3: a 68000-to-native Frontier: Elite II port](https://awesomerea.org/resources/glfrontier-elite-ii-case/index.md): Case study · FrontierVM 3 translates a separately supplied 68000 disassembly of the Atari ST Frontier: Elite II into native C or i386 assembly. The repository includes assembler, disassembler and host code, plus an experimental OpenGL renderer alongside the original software rendering path.
- [Metroid Prime Remastered: a Switch static recompilation for Windows](https://awesomerea.org/resources/metroid-prime-remastered-recomp-case/index.md): Case study · Metroid Prime Remastered Recomp builds a Windows port from the user's Switch version 1.0.0 dump by translating game code to C++ ahead of time. Its runtime replaces Switch services and maps NVN graphics to Vulkan; the repository includes game-specific build files, symbols and validation notes.
- [Scooby-Doo: Re-Masked: a static recompilation of Scooby-Doo! Unmasked](https://awesomerea.org/resources/scooby-doo-re-masked-case/index.md): Case study · Scooby-Doo: Re-Masked statically translates the GameCube release of Scooby-Doo! Unmasked to C++ with WiiCompiled for a Windows port. Its runtime handles console graphics, audio and system calls, while the launcher extracts game data from the user's disc image.
- [Luigi's Mansion: a GameCube static recompilation and boot investigation](https://awesomerea.org/resources/luigis-mansion-recomp-case/index.md): Case study · Luigi's Mansion uses gcrecomp to translate the GameCube game's PowerPC DOL into C++ and supplies a Windows host with DOL loading, symbol import and GameCube OS replacements. Its boot trace records startup through static constructors and video interrupts, then an unresolved run-queue stall.
- [fireemblem7u: a matching decompilation of the GBA Fire Emblem release](https://awesomerea.org/resources/fireemblem7u-decomp-case/index.md): Case study · fireemblem7u reconstructs the USA/Australia GBA release of Fire Emblem as C source that rebuilds a SHA-1-checked ROM. The author reports byte-matched game functions, while scripts extract graphics, music and other data from the player's ROM; a separate host build runs decompiled C on macOS.
- [SpaghettiKart: an Android port of Mario Kart 64](https://awesomerea.org/resources/spaghettikart-android-case/index.md): Case study · SpaghettiKart's Android fork brings Mario Kart 64 to Android. Its app validates a user-provided US ROM and extracts an mk64.o2r archive on the device; the repository includes Android launcher, input and touch-control code.
- [Max Payne Recomp: an Apple Silicon port through static recompilation](https://awesomerea.org/resources/max-payne-recomp-case/index.md): Case study · Max Payne Recomp ports Max Payne 1.05 to Apple Silicon macOS by translating its 32-bit x86 executable and DLLs into C and compiling them for arm64. A native host maps Windows calls to Metal, SDL3, and AVFoundation; the user's own game files supply the binaries and assets.
- [Theme Park: a static recompilation of the DOS game](https://awesomerea.org/resources/theme-park-static-recomp-case/index.md): Case study · Theme Park statically recompiles Bullfrog's 1994 DOS game into a native Windows and Linux program using pcrecomp to translate its 32-bit code to C. The project adds a DOS/4GW host, display and sound layers, TCP support for the game's network mode, save states, and scripted conformance runs. The author reports lifting 6,517 functions and passing six conformance milestones.
- [Crash Bandicoot: a matching PlayStation decompilation](https://awesomerea.org/resources/crash-bandicoot-matching-decomp-case/index.md): Case study · Crash Bandicoot Decompilation reconstructs the North American PlayStation game's executable as C and compares compiled functions and the rebuilt image with retail bytes. Its workflow uses function probes, relocation-aware comparison and a full executable SHA-1 check; it also includes a GOOL Lisp bytecode decompiler and assembler.
- [Lode Runner: a byte-exact ZX Spectrum disassembly](https://awesomerea.org/resources/lode-runner-spectrum-disassembly-case/index.md): Case study · Lode Runner is mapped as named, documented ZX Spectrum 48K assembly covering the loader, play loop, actor states, editor, and data. The build uses SjASMPlus and checks a byte-exact output with embedded MD5 references or a binary diff against the original.
- [ReCompiled Steel: a Real Steel static recompilation with Vulkan rendering](https://awesomerea.org/resources/recompiled-steel-case/index.md): Case study · ReCompiled Steel builds native Windows, Linux and Android versions of Xbox 360 Real Steel through ReXGlue static recompilation. Its game-specific Vulkan renderer consumes the Xbox command stream and shaders translated ahead of time; game code and shader caches are generated from the user's copy.
- [OpenXWA: reimplementing Star Wars: X-Wing Alliance](https://awesomerea.org/resources/openxwa-case/index.md): Case study · OpenXWA reimplements the 1999 game Star Wars: X-Wing Alliance as a native Windows, macOS and Linux program that reads an original installation. Its code covers game systems, OPT models and digital iMUSE audio, with classic and enhanced graphics modes and modern input options. The author reports that the original functions outside multiplayer have been reimplemented.
- [Hong Kong 97: a SNES game disassembly](https://awesomerea.org/resources/hong-kong-97-disassembly-case/index.md): Case study · Hong Kong 97 is a rough disassembly of the SNES game with separate main-program and APU assembly files.
- [Rhythm Tengoku Arcade: SH-4 decompilation and asset-format reconstruction](https://awesomerea.org/resources/rhythm-tengoku-arcade-decomp-case/index.md): Case study · Reconstructs parts of Rhythm Tengoku Arcade's SH-4 program as C and assembly and implements round-trip tools for DTPK audio packages, STX textures and layered data ROMs. The author reports exact rebuilds for selected functions and asset packages while the game-code reconstruction remains partial.
- [RROP: a static recompilation of Rings of Power](https://awesomerea.org/resources/rrop-rings-of-power-case/index.md): Case study · RROP statically translates the Sega Genesis Rings of Power 68000 and Z80 programs into C for native Linux and Windows builds. Its runtime models console memory, video, input and sound, while game-specific additions provide widescreen rendering, font replacement and saves.
- [The Oregon Trail: matching Win32 executable and DLL reconstruction](https://awesomerea.org/resources/oregon-trail-win32-decomp-case/index.md): Case study · This matching decompilation reconstructs C++ functions from the 1996 Windows release of The Oregon Trail, targeting Oregon32.exe and OREGON32.DLL. It compares functions compiled with Visual C++ 4.0 against the originals while accounting for relocated operands; the author reports 35,926 recovered instructions out of 64,499 inventoried.
- [Breath of Fire III decompilation: matching the US PlayStation release](https://awesomerea.org/resources/breath-of-fire-iii-decompilation-case/index.md): Case study · Breath of Fire III decompilation reconstructs the US PlayStation game's executable and loaded modules as C89 source checked against original bytes. It uses GCC 2.7.2-PSX and maspsx for matching, with emulator observations, game-format notes, and tools for inspecting text, audio, and graphics.
- [Unciv: a Civilization V gameplay remake](https://awesomerea.org/resources/unciv-civ-v-case/index.md): Case study · Unciv recreates Civilization V gameplay as a moddable Android and desktop game built with LibGDX. Its roadmap identifies Gods & Kings and Brave New World mechanics that remain to be added.
- [Zoids Saga Fuzors: a byte-matching GBA decompilation](https://awesomerea.org/resources/zoids-saga-fuzors-decomp-case/index.md): Case study · Zoids Saga Fuzors is reconstructed as C and assembly code for the Japanese Game Boy Advance release. The verifier compiles each listed region at its original address and compares the bytes with the user's ROM; a native build takes remaining bytes from that ROM. The author reports 1,384 byte-matched regions, including 1,330 C functions.
- [Alien vs Predator: Atari Jaguar 68000 code reconstructed in C](https://awesomerea.org/resources/alien-vs-predator-jaguar-c-decompilation-case/index.md): Case study · Alien vs Predator (Atari Jaguar) — C Decompilation reconstructs the game's ordinary Motorola 68000 behavior as readable C. The code covers gameplay, audio control, files, rendering orchestration and save support, with host service interfaces for Jaguar-specific operations.
- [Touhou 11: instruction-level C++ reconstruction](https://awesomerea.org/resources/touhou-11-reconstruction-case/index.md): Case study · Reconstructs Touhou 11 v1.00a in C++ and compares rebuilt code with the original using objdiff and reccmp. The author reports 360 of 1,094 functions strictly matched; a browser-port layer is present but its stated development gate remains pending.
- [FreeSims: recreating The Sims 1 engine](https://awesomerea.org/resources/freesims-case/index.md): Case study · FreeSims recreates The Sims 1 engine in C# and runs on files from the user's original game installation. Its SimsVille source covers game content loading, characters, houses and a neighborhood, with build instructions for Windows and Linux.
- [REminiscence: a Flashback engine reimplementation](https://awesomerea.org/resources/reminiscence-flashback-case/index.md): Case study · REminiscence reimplements the engine of the 1992 game Flashback and runs on data files from the user's DOS, Amiga, Macintosh or PC-98 release. Its SDL-based code handles game logic, graphics, cutscenes, audio and saves, with command-line options for scaling, widescreen display and language.
- [MangosZero: reconstructing Vanilla World of Warcraft servers](https://awesomerea.org/resources/mangoszero-server-case/index.md): Case study · MangosZero reconstructs the authentication and world servers for Vanilla World of Warcraft clients 1.12.1 through 1.12.3. Its C++17 server reads client data with StormLib and stores game and account data in MySQL or MariaDB.
- [wipEout Rewrite: reimplementing the 1995 PlayStation game](https://awesomerea.org/resources/wipeout-rewrite-case/index.md): Case study · wipEout Rewrite reimplements the 1995 PlayStation racing game in C. It provides SDL2 and Sokol platform backends, OpenGL and software rendering options, and expects original game textures and models to be supplied separately.
- [Open Sosaria: reconstructing the 1981 Apple II Ultima engine](https://awesomerea.org/resources/open-sosaria-ultima-case/index.md): Case study · Open Sosaria reimplements the 1981 Apple II Ultima engine in C99 for modern PCs. It parses the player's DOS 3.3 disk images, reconstructs game systems from observed behavior, and synthesizes some audio from disassembled 6502 timing loops; the author reports that the game can be completed.
- [parasite-eve-decomp-port: matching decompilation and native Linux port of Parasite Eve](https://awesomerea.org/resources/parasite-eve-decomp-port-case/index.md): Case study · parasite-eve-decomp-port contains a matching C decompilation of parts of Parasite Eve's USA PlayStation executable and a native Linux port that runs decompiled game code. Builds extract remaining assembly and data from the user's Disc 1 image; the author reports that a native-only release plays through Day 1 and reaches the opening of Day 2.
- [crazytaxi: statically recompiling the Dreamcast game](https://awesomerea.org/resources/crazy-taxi-static-recomp-case/index.md): Case study · crazytaxi statically translates the Dreamcast game Crazy Taxi from SH-4 machine code to native x86-64 C using dcrecomp and the user's disc image. Its repository adds game-specific entry points, bring-up code and a smoke test; the author reports that initialization reaches a persistent wait loop before any frame is drawn.
- [mcdub3-nx: recompiling Midnight Club 3 for modern platforms](https://awesomerea.org/resources/mcdub3-nx-case/index.md): Case study · mcdub3-nx lifts the original Xbox code of Midnight Club 3: DUB Edition and Remix into C with xboxrecomp. It provides native versions for Nintendo Switch, Linux, macOS, Windows and Android, with game-specific runtime and graphics fixes. Players supply their own disc files; the Android APK loads extracted game files.
- [Donkey Kong Country: a USA v1.0 SNES disassembly](https://awesomerea.org/resources/donkey-kong-country-1-disassembly-case/index.md): Case study · Donkey Kong Country reconstructs assembly for the USA v1.0 SNES release. The repository includes ROM, RAM, and SPC700 maps plus scripts that extract assets from the user's clean, headerless ROM for use with the disassembly.
- [rac-rs: a static recompilation of Ratchet & Clank for PC](https://awesomerea.org/resources/rac-rs-case/index.md): Case study · rac-rs ports the 2002 PlayStation 2 Ratchet & Clank to PC by statically recompiling code from the user's disc into Rust. A Rust PS2 CPU core runs the translated game logic, while native code handles graphics, audio, input and saving; selected rewritten functions are compared with original game memory.
- [The Legend of Zelda: a work-in-progress NES disassembly](https://awesomerea.org/resources/legend-of-zelda-nes-disassembly-case/index.md): Case study · zeldasource disassembles the NES release of The Legend of Zelda into banked assembly files. Its CC65 build uses an original iNES ROM supplied by the user and checks the rebuilt image against an MD5 checksum.
- [OpenATDeluxe: an Airline Tycoon Deluxe remake with original-data import](https://awesomerea.org/resources/openatdeluxe-case/index.md): Case study · OpenATDeluxe rebuilds Airline Tycoon Deluxe as a Godot project that imports images from a user-provided installation. Its format notes describe .gli graphics archive headers and RGB565 image data; the airport and player character are implemented, while gameplay remains unfinished.
- [Vigilante8-xport: a PlayStation decompilation port](https://awesomerea.org/resources/vigilante-8-xport-case/index.md): Case study · Vigilante8-xport reconstructs routines from the PlayStation game Vigilante 8 in C for a native port. Its startup code loads the original SLUS_005.10 boot image and BIOS, mounts a disc image, and connects game routines to PlayStation runtime services.
- [Eltale Monsters: a ROM-based decompilation](https://awesomerea.org/resources/eltale-monsters-decomp-case/index.md): Case study · Eltale Monsters is a decompilation built from a user-provided base ROM. The repository contains C and assembly sources and instructs users to build with configure and Ninja.
- [Super Monkey Ball: a GameCube disassembly and decompilation](https://awesomerea.org/resources/super-monkey-ball-decomp-case/index.md): Case study · Super Monkey Ball Decompilation reconstructs code from the NTSC-U GameCube release of Super Monkey Ball as C and assembly. The project builds supermonkeyball.dol and specifies the target file's SHA-1 hash; the reconstruction remains in progress.
- [smw: a Super Mario World engine reimplementation](https://awesomerea.org/resources/smw-case/index.md): Case study · smw reimplements Super Mario World's game logic as a native program using levels and images extracted from the user's ROM. It also runs an emulated version in the background, compares RAM state every frame, and saves a snapshot when the states diverge.
- [BeetleRecomp: a static recompilation of Beetle Adventure Racing!](https://awesomerea.org/resources/beetlerecomp-case/index.md): Case study · BeetleRecomp translates the USA N64 release of Beetle Adventure Racing! from MIPS machine code into C with N64Recomp and runs it through a native host using RT64. It uses a symbol-rich ELF and overlay metadata built from BeetleDecomp, and includes game-specific C hooks, a launcher and runtime services for input, audio and saves.
- [Aster Native: a Green Lantern Xbox 360 recompilation port](https://awesomerea.org/resources/aster-native-green-lantern-case/index.md): Case study · Aster Native is an experimental port framework whose first game module targets the Xbox 360 release of Green Lantern: Rise of the Manhunters. It prepares user-supplied game data, generates a ReXGlue port locally and applies game-specific runtime and graphics patches; the author reports reaching early gameplay on Linux.
- [Verdite3: a King's Field II static recompilation port](https://awesomerea.org/resources/verdite3-kings-field-ii-case/index.md): Case study · Verdite3 ports the North American PlayStation release of King's Field II, numbered King's Field III in Japan, to PC through RecompOne static recompilation. Its game-specific maps and patches cover the main executables and area modules, with changes to rendering, controls, pacing, and saves.
- [Milon's Secret Castle: an annotated NES disassembly](https://awesomerea.org/resources/milons-secret-castle-disassembly-case/index.md): Case study · Milon's Secret Castle reconstructs the US NES game as annotated assembly that builds with asm6f. A verification script compares the built ROM with the original, while Mesen Lua scripts visualize doors, movement, hitboxes and room secrets.
- [Shox: Rally Reinvented: a function-level PlayStation 2 matching decompilation](https://awesomerea.org/resources/shox-rally-reinvented-decomp-case/index.md): Case study · shox-rr-decomp reconstructs C++ functions from the PlayStation 2 game Shox: Rally Reinvented. It uses the SN Systems GCC 2.95.2-EE toolchain through a Wine container and compares candidate objects with locally assembled retail references, checking machine-code bytes and relocations. The author reports a partial inventory of matched functions.
- [Five Nights at Freddy's: Help Wanted: a Vive 1.0.11 code reconstruction](https://awesomerea.org/resources/help-wanted-vive-decomp-case/index.md): Case study · The project reconstructs code for Five Nights at Freddy's: Help Wanted Vive 1.0.11 in an Unreal Engine project. Its stated aim is functional parity with the game; the author says gameplay remains incomplete and some features may fail.
- [LADX-Decompile: a C reconstruction of Link's Awakening DX](https://awesomerea.org/resources/ladx-decompile-case/index.md): Case study · LADX-Decompile translates Game Boy Color Link's Awakening DX routines into C, organized by cartridge bank and subsystem. Tests compare memory changes with behavior described in the original disassembly; the author reports 906 verified standalone routines across the 4,298-routine whole-game inventory.
- [Open Wages: a Wages of War engine reimplementation](https://awesomerea.org/resources/open-wages-case/index.md): Case study · Open Wages reimplements the Wages of War: The Business of Battle engine in Rust and SDL2 using observed game behavior and parsers for the original data files. It covers mercenary hiring, contracts, isometric maps and tactical combat, with executable and format analysis recorded alongside the code.
- [Tag Force 5 Decompilation: matching the PSP game's code](https://awesomerea.org/resources/tag-force-5-decomp-case/index.md): Case study · Tag Force 5 Decompilation reconstructs C source for the PSP release ULES-01474 of Yu-Gi-Oh! 5D's Tag Force 5. Its workflow extracts the user's ISO, analyses Allegrex code with Ghidra and splat, and compares Metrowerks-compiled functions against target assembly with relocation-aware diffs. The author reports 15 of 16 text functions matched in rel_movie_viewer.
- [SSX Tricky: an Xbox static recompilation for Windows](https://awesomerea.org/resources/ssx-tricky-pc-port-case/index.md): Case study · SSX Tricky: PC Port translates the Xbox game's code to C with xboxrecomp and runs it as a native Windows program using Direct3D 11, XAudio2 and XInput. The repository contains game-specific port code and notes on gameplay systems and asset formats. Its regeneration script translates code from the user's USA disc, while additional fixes and recovered functions are needed to reproduce the tested build.
- [Virtua Cop 2: investigating PC game assets](https://awesomerea.org/resources/re-virtua-cop-2-case/index.md): Case study · The Virtua Cop 2 investigation examines the 1997 PC game's asset files with parsers, ImHex patterns and a browser explorer. The explorer displays models and textures from a selected game directory and offers experimental browsing of stage maps in P_STG*.BIN files.
- [Club Penguin Game Day: a work-in-progress DOL reconstruction](https://awesomerea.org/resources/club-penguin-game-day-decomp-case/index.md): Case study · Reconstructs the US revision 0 DOL of Club Penguin Game Day through a buildable assembly tree and PowerPC linker configuration. The project is marked work in progress and requires a clean original DOL plus the specified compiler, linker and devkitPPC assembler.
- [Star Fox Enhanced: an SDL3 port of reconstructed Star Fox code](https://awesomerea.org/resources/star-fox-enhanced-case/index.md): Case study · Star Fox Enhanced ports UltraStarFox to a native C++ and SDL3 program for Star Fox and Star Fox EX. It separates fixed game simulation from presentation frame rate and reconstructs runtime assets locally from supported retail ROM revisions supplied by the player.
- [OpenRED: recreating Guilty Gear -Strive-'s battle system](https://awesomerea.org/resources/openred-case/index.md): Case study · OpenRED recreates Guilty Gear -Strive-'s battle system in an Unreal Engine project. Its C++ source covers battle states, events, objects and managers, with the aim of approximating the core logic.
- [reblue: recompiling Blue Dragon from DVD 1](https://awesomerea.org/resources/reblue-xbox360-blue-dragon-case/index.md): Case study · reblue uses ReXGlue to recompile Blue Dragon from game files extracted from DVD 1, then builds a native executable with game-specific file, memory and patch code. The author reports that this part is barely playable and that support for the full game remains in progress.
- [Mario Party 7: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/mario-party-7-decomp-case/index.md): Case study · 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.
- [Sonic Riders Tournament Edition: a GameCube decompilation](https://awesomerea.org/resources/sonic-riders-tournament-edition-case/index.md): Case study · 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.
- [Super Metroid: a C# translation and playable port](https://awesomerea.org/resources/super-metroid-csharp-port-case/index.md): Case study · A C# translation of Super Metroid implements the game's movement, combat, rooms, menus, rendering and audio. The Windows application extracts required resources from the user's Japan/USA NTSC v1.0 ROM, while original addresses and regression tests guide behavioral comparison. The author reports that it is playable from beginning to end.
- [Four Swords Adventures: a byte-matching GameCube decompilation](https://awesomerea.org/resources/four-swords-adventures-decomp-case/index.md): Case study · fsa reconstructs The Legend of Zelda: Four Swords Adventures for GameCube as byte-matched source. Its build checks compiled game and library units against the original main.dol; the author reports partial game-code matching and a byte-identical linked DOL for the completed split units. Library code is partly imported from other decompilation projects.
- [Freeserf.net: porting The Settlers I remake to C#](https://awesomerea.org/resources/freeserf-net-settlers-case/index.md): Case study · Freeserf.net ports and extends the freeserf remake of The Settlers I in C#. It loads the player's original DOS or Amiga data, adds AI logic and provides desktop and Android builds with experimental local multiplayer.
- [Final Fantasy VIII Recompiled: a PlayStation setup and recompilation candidate](https://awesomerea.org/resources/final-fantasy-viii-recompiled-case/index.md): Case study · Final Fantasy VIII Recompiled packages a title-specific PSXRecomp recipe and recomp-ui setup host for building from the user's SLUS-00892 PlayStation disc. The candidate includes game configuration and seed functions; first-run setup and gameplay checks remain pending.
- [PokemonRedAndBlueRecomp: static recompilation of Pokémon Red and Blue](https://awesomerea.org/resources/pokemon-red-blue-recomp-case/index.md): Case study · PokemonRedAndBlueRecomp translates the Game Boy code of Pokémon Red and Blue into C with a fork of gb-recompiled and compiles it as a native x64 program. It loads game data from the user's ROM and falls back to an interpreter for code paths missed by static analysis.
- [NFS CARBON 360 DECOMP: an Xbox 360 static recompilation for Android](https://awesomerea.org/resources/nfs-carbon-360-android-recomp-case/index.md): Case study · NFS CARBON 360 DECOMP translates the Xbox 360 release of Need for Speed Carbon from PowerPC code to C++ for Android ARM64 and Windows x64 builds. Its game-specific analysis maps Direct3D functions and shader containers for a Vulkan renderer; the author reports complete scene rendering on one Android device, with full races still untested.
- [Ultima V Redux: recreating Ultima V from original game data](https://awesomerea.org/resources/ultima-v-redux-case/index.md): Case study · Ultima V Redux recreates Ultima V: Warriors of Destiny in Go using files from the player's MS-DOS PC copy. The engine adds modern presentation and a Debug Workbench, while companion guides describe game mechanics, compatibility formats and differences from the original.
- [Green Beret: a documented ZX Spectrum disassembly](https://awesomerea.org/resources/zx-spectrum-green-beret-disassembly-case/index.md): Case study · Green Beret documents reverse-engineered assembly for the 1986 ZX Spectrum conversion. Its notes explain an eight-character scrolling region, reusable sprite masks and compressed level-map blocks, alongside the assembly source.
- [OpenDana: a C11 reimplementation of Solomon's Key 2](https://awesomerea.org/resources/opendana-case/index.md): Case study · OpenDana reimplements the NES puzzle game Solomon's Key 2 / Fire 'n Ice with a deterministic C11 core and SDL2 front end. It imports levels, graphics, text and audio from the user's European ROM and adds a level editor, save states and JSON/PNG mods.
- [rsc-server: reconstructing a RuneScape Classic server](https://awesomerea.org/resources/rsc-server-runescape-classic-case/index.md): Case study · rsc-server reconstructs a RuneScape Classic server for the web-based rsc-client and Java mudclient204. Its Node.js implementation handles game packets over TCP or WebSockets, persists world data through rsc-data-server and adds quests, skills and interactions through plugins. The README also describes a browser worker mode.
- [MojoRecomp: native ports of the Crash Bandicoot Titans games](https://awesomerea.org/resources/mojorecomp-crash-titans-case/index.md): Case study · MojoRecomp recompiles Xbox 360 game code for a native Windows runtime and launcher focused on the Crash Bandicoot Titans games. Crash of the Titans is listed as playable using a user-provided ISO; Crash: Mind Over Mutant remains in development. The repository contains runtime code, recompiler patches and localization deltas.
- [Fire Emblem: a partial NES disassembly of Shadow Dragon and the Blade of Light](https://awesomerea.org/resources/fe1-case/index.md): Case study · fe1 reconstructs part of the NES game Fire Emblem: Shadow Dragon and the Blade of Light as assembly. WLA-DX builds a ROM with a listed SHA-1, using bytes from the user's original ROM where disassembly is unfinished; the tree includes code, data, memory layouts, and build rules.
- [Snowboard Kids: an early matching Nintendo 64 disassembly](https://awesomerea.org/resources/sonicdcer-snowboard-kids-case/index.md): Case study · The sk project reconstructs the US Nintendo 64 Snowboard Kids ROM from a user-supplied original, using static or dynamic analysis to build a source base. Its present work is described as mostly disassembly; the build workflow extracts needed assets and assembly locally and checks the rebuilt ROM against an MD5 hash.
- [Melee-X: a native original Xbox port of Super Smash Bros. Melee](https://awesomerea.org/resources/melee-x-case/index.md): Case study · Melee-X ports the Super Smash Bros. Melee decompilation to the original Xbox, compiling game code for its Pentium III and mapping GameCube graphics calls to the NV2A GPU. It implements platform services for input, audio, disc access and saves, and reads game data from the player's NTSC-U 1.02 disc image. The author reports four-player play and notes occasional crashes.
- [engge 2: a Thimbleweed Park engine remake](https://awesomerea.org/resources/engge2-thimbleweed-park-case/index.md): Case study · engge 2 reimplements the Thimbleweed Park adventure engine in Nim. It runs on ThimbleweedPark.ggpack1 and ggpack2 copied from a player's game installation, with optional save files and DLC packs. Its source includes game logic, scripting, scene rendering and ggpack handling.
- [Konami Viper: statically recompiling Thrill Drive 2 and GTI Club 2](https://awesomerea.org/resources/konami-viper-recomp-case/index.md): Case study · Konami Viper statically recompiles PowerPC code from Thrill Drive 2 and GTI Club 2 arcade dumps into C for native executables. Its shared runtime models the Viper board's Voodoo3 graphics, sound, I/O, CF card and timekeeper, with game profiles for several regional versions.
- [DK64Recomp-NX: a Switch port of Donkey Kong 64](https://awesomerea.org/resources/dk64recomp-nx-case/index.md): Case study · DK64Recomp-NX brings Donkey Kong 64 to Switch by translating its N64 MIPS code to C ahead of time. It adapts the existing PC recompilation with a GLideN64 OpenGL renderer, Switch OS services and a different threading model.
- [Foxhollow: a native Star Fox Adventures port](https://awesomerea.org/resources/foxhollow-star-fox-adventures-case/index.md): Case study · Foxhollow builds a native Star Fox Adventures port from the SFA decompilation and Aurora compatibility layer. It reads the user’s game disc, and the author reports the Mac, Windows and Linux builds are fully playable.
- [Lufia II Recompiled: a native SNES recompilation](https://awesomerea.org/resources/lufia-ii-recompiled-case/index.md): Case study · Lufia II Recompiled builds a native version of the SNES game from a user-supplied US ROM with snesrecomp. Game-specific control-flow files guide compilation, while the host supplies input, saves, audio, and SDL or OpenGL rendering; Vulkan is an optional build choice.
- [Clockwork: native Yo-kai Watch 3DS games by static recompilation](https://awesomerea.org/resources/clockwork-yo-kai-watch-case/index.md): Case study · Clockwork builds native PC versions of the Yo-kai Watch Nintendo 3DS games by translating each game's ARM code to C ahead of time. Its SDL3 runtime replaces console hardware and services, while the launcher unpacks and builds modules from a player's decrypted cartridge dumps. The repository also documents findings from Yo-kai Watch 2: Psychic Specters.
- [Plants vs. Zombies: Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/pvz-console-edition-case/index.md): Case study · pvz-console-edition converts the Xbox 360 Plants vs. Zombies release into a native Windows program by translating its PowerPC code to x86-64 with ReXGlue. It imports the user's XBLA package or disc image and adds mouse controls across menus, gameplay, mini-games, and local multiplayer.