# Curated reverse engineering resources · Page 3

> Page 3 of 52, entries 201–300. 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/3/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/3/index.md>

## Games (100)

- [BSPSource](https://awesomerea.org/resources/bspsrc/index.md): Tool · Java map decompiler that turns Source engine .bsp map files back into .vmf files that can be loaded in Hammer. It also has an integrated pakfile extractor.
- [PKHeX](https://awesomerea.org/resources/pkhex/index.md): Tool · PKHeX is a C# Windows Forms editor for Pokémon core-series save data. It can edit and save supported files, import Pokémon and teams, and convert data between game generations.
- [nxnative](https://awesomerea.org/resources/nxnative/index.md): Tool · nxnative is a tool that packages Nintendo Switch games as apps that run their code natively on Apple hardware, with graphics translated to Metal. It builds iPhone, iPad, or Mac apps from supported Switch games; Switch 2 builds are documented for Mac only.
- [UE5 BINKA to WAV](https://awesomerea.org/resources/ue5-binka-to-wav/index.md): Tool · Rejoins UE5 BINKA audio exported by FModel and calls an external Bink decoder to produce WAV files, with a Windows GUI, batch CLI and paired-asset metadata warnings.
- [PsyZ](https://awesomerea.org/resources/psyz/index.md): Tool · C porting library that replaces the API of PSY-Q, Sony's PlayStation runtime library, with native implementations, so decompiled or original PlayStation source can be compiled for Linux, macOS, iOS, Windows, WebAssembly and PSP while still building for the console. It aims at PSY-Q API compatibility and offers an optional GPU and SPU emulation layer behind emulated MMIO endpoints, and carries a matching decompilation of the PSY-Q 4.0 libraries.
- [GCRecomp](https://awesomerea.org/resources/gcrecomp/index.md): Tool · GCRecomp is a static recompiler that translates GameCube PowerPC DOL binaries into Rust and then into native executables. The README says it is inspired by N64Recomp and names Windows, Linux, and macOS as targets for the generated executables. The project text is dedicated under CC0 1.0 and also points readers to an EULA.
- [GBA-Recomp](https://awesomerea.org/resources/gba-recomp/index.md): Tool · GBA-Recomp is a Rust static-recompilation toolkit and runtime for Game Boy Advance cartridges. It translates a ROM ahead of time into a native executable, and the runtime models the PPU, APU, DMA, timers, IRQ, saves, input, and RTC. The README says the user supplies a BIOS and a game, and that the project is dual-licensed MIT or Apache-2.0.
- [Kappa](https://awesomerea.org/resources/kappa/index.md): Tool · Kappa is a Visual Studio Code extension for decompilation work. It builds prompts from the open codebase, can start an agent decompile through GitHub Copilot, and calls decomp.me, m2c, decomp-permuter, and objdiff from the editor. The README says it runs only in a single-root workspace.
- [Panda3DS](https://awesomerea.org/resources/panda3ds/index.md): Tool · High-level Nintendo 3DS emulator written in C++. The README says it can play some games and mentions Lua scripting. On PC it offers a minimal SDL frontend without a GUI and an experimental Qt 6 frontend.
- [Xbox XBE Recomp](https://awesomerea.org/resources/xbox-xbe-recomp/index.md): Tool · Xbox XBE Recomp creates native PC ports of original Xbox games by statically recompiling an XBE's x86 code to C++ and implementing Xbox kernel and XDK libraries on Windows, with Direct3D 12 rendering and XAudio2 playback.
- [ModernGekko](https://awesomerea.org/resources/modern-gekko/index.md): Tool · ModernGekko is a runtime for GameCube and Wii recomps. The README describes loading code mods from package directories and libraries, with dependency ordering, hooks, function patches, and disc and CPU ABI checks.
- [Retro Launcher](https://awesomerea.org/resources/retro-launcher/index.md): Tool · Retro Launcher catalogs and installs recomps that compile on the user's machine. The README says it checks for updates, rebuilds from existing build data when it can, and shares a portable toolchain with per-title launchers.
- [DSLuaDecompiler](https://awesomerea.org/resources/ds-lua-decompiler/index.md): Tool · DSLuaDecompiler decompiles Lua scripts from FromSoftware games for modding. The README says it targets Lua 5.0 AI scripts and HavokScript character-control scripts, with a stated goal of matching decompilations for scripts from Dark Souls through Armored Core 6.
- [Balamod](https://awesomerea.org/resources/balamod/index.md): Tool · Balamod is a mod loader, injector, and decompiler for the game Balatro. The README says it supports in-game code injection and documents install, CLI, and modding steps.
- [SR](https://awesomerea.org/resources/sr-static-recomp-case/index.md): Tool · SR statically recompiles DOS and Windows game executables into Windows, Linux, or macOS builds. The README lists DOS support for Albion, X-COM: UFO Defense, X-COM: Terror from the Deep, and Warcraft: Orcs & Humans, and Windows support for Septerra Core and Battle Isle 3.
- [NESRecomp](https://awesomerea.org/resources/nesrecomp/index.md): Tool · NESRecomp is a beta static-recompilation framework for NES and Famicom games. It translates 6502 code into native C and supplies the PPU, APU, mapper, input, and save systems. Each port integrates and validates its own cartridge or disk revision.
- [SNESRecomp](https://awesomerea.org/resources/snesrecomp/index.md): Tool · SNESRecomp is a beta static-recompilation framework for the Super Nintendo and Super Famicom. It translates 65816 machine code into C and builds native applications around a shared SNES hardware runtime. Unresolved code can run through an interpreter tier.
- [ndsrecomp](https://awesomerea.org/resources/ndsrecomp/index.md): Tool · ndsrecomp is a pre-alpha static recompiler for the Nintendo DS. It lifts guest ARM code to C ahead of time, and a runtime supplies the memory bus, two-CPU scheduling, and hardware models. The README's demonstrated path includes the original firmware menu and experimental Mario Kart DS online play through Wiimmfi.
- [Genesis Recomp](https://awesomerea.org/resources/segagenesisrecomp/index.md): Tool · Genesis Recomp is a beta static-recompilation framework for the Sega Genesis, Mega Drive, Sega CD, and Mega-CD. The cartridge pipeline translates 68000 code into C and supplies a shared VDP, audio, bus, scheduler, and Z80 runtime.
- [Decomp Buddy](https://awesomerea.org/resources/decomp-buddy/index.md): Tool · Decomp Buddy is a Mac, Windows, and Linux application that sets up decompilations, recompilations, and native PC ports from the player's own game files. It checks the ROM or disc by checksum, region, and version.
- [yukatool](https://awesomerea.org/resources/yukatool/index.md): Tool · yukatool works with the Yuka System visual novel engine used by Hooksoft, Smee, PeasSoft, and feng. It unpacks and packs .ykc archives, splits and decompiles .yks scripts to .ykd, compiles them back, and converts .ykg graphics to and from PNG.
- [gore](https://awesomerea.org/resources/gore/index.md): Tool · gore recovers a Godot game into a project that opens in the Godot editor. It finds the pack in a standalone PCK or in an executable, recovers an encryption key when the game uses one, and calls GDRE Tools to decompile GDScript and convert textures. Releases cover Linux and macOS on x86_64 and arm64, and Windows on x86_64.
- [Warband module decompiler](https://awesomerea.org/resources/warband-module-decomp/index.md): Tool · This decompiles Mount & Blade: Warband modules. It converts a module's .txt files into the modular system's .py files. The README says the program is published for personal use.
- [MiiJS](https://awesomerea.org/resources/miijs/index.md): Tool · MiiJS reads, writes, converts, and renders Nintendo Mii data in JavaScript. The README lists Wii, DS, 3DS, Wii U, Switch, Switch 2, Amiibo, Tomodachi Life, Miitomo, QR codes, and Studio codes. It runs in Node.js and in a browser.
- [psprecomp](https://awesomerea.org/resources/psprecomp/index.md): Tool · psprecomp is a C11 toolkit that statically recompiles PlayStation Portable Allegrex MIPS binaries into C. The command allegrexrecomp emit writes translation units of 64 functions, plus a shared header and import thunks. Game ports consume the toolkit as a submodule. The core build has no external dependencies.
- [Silver SCT tool](https://awesomerea.org/resources/silver-sct/index.md): Tool · This tool reads and writes .sct script files from Silver, the 1999 action RPG. sct.exe decompile turns a .sct file into .tsct, and sct.exe compile turns .tsct back into .sct. Decompiled examples in the repository include veranda.tsct, gnolib2.tsct, davhouse.tsct, and courtyrd.tsct.
- [THPS2 tools](https://awesomerea.org/resources/thps2-tools/index.md): Tool · These tools read Tony Hawk's Pro Skater 2 files and overlapping Neversoft Big Guns formats. extract-ddx.py extracts THPS2X texture collections. disassemble-ddm.py prints material collections. disassemble-trg.py prints scripts and level metadata. disassemble-prk.py disassembles user skateparks. psxviewer.c views PSX level files from THPS1, THPS2, and Spider-Man.
- [SaturnRecomp](https://awesomerea.org/resources/saturnrecomp/index.md): Tool · SaturnRecomp is a Sega Saturn research toolkit with a disc CLI, an SH-2 execution core, and a Windows SDL2 runner. The playable path runs SH-2 code through an interpreter and a fast path. The ahead-of-time decoder and module analysis are present, and a complete public AOT emitter is not. The Windows launcher uses Qt through PySide6. It boots a player-supplied game with a player-supplied Saturn BIOS.
- [YukaTool](https://awesomerea.org/resources/yukatool2/index.md): Tool · YukaTool reads archives from the Yuka System visual-novel engine. The GUI opens an archive, previews images and text, shows a hex dump, and can export or import files. The CLI is yuka.exe. yuka help lists the commands. The README says a Yuka game folder usually contains one executable, and that the GUI's full-archive export is raw and does not convert files.
- [bnGB](https://awesomerea.org/resources/bngb/index.md): Tool · bnGB is a Binary Ninja plugin that loads Game Boy ROMs and disassembles Sharp LR35902 bytecode. The reviewed README maps the ROM header from 0x134 through 0x14f, including the title, cartridge type, ROM size, and checksum. It was tested on Binary Ninja release 1.2.1921. Installation is a git clone into the Binary Ninja plugins directory.
- [RecompOne](https://awesomerea.org/resources/recompone/index.md): Tool · RecompOne statically translates PlayStation 1 MIPS instructions into C# and supplies a runtime for BIOS calls, MMIO, GPU commands, and CD-ROM access. An addiu becomes an addition on a CpuContext register, and a lw becomes Read32 on the memory interface. The recompiler is a .NET project built with the .NET SDK 10. The runtime is a library included by the recompiled game. Port steps are in the project wiki.
- [Rusted PackFile Manager](https://awesomerea.org/resources/rpfm/index.md): Tool · Rusted PackFile Manager is a Rust and Qt6 reimplementation of PackFile Manager. It opens, edits, and saves pack files for every Total War game since Empire: Total War, with editors for DB tables, Loc files, scripts, animations, portraits, rigid models, and video. rpfm_lib is the file-format library. The schemas directory holds RON schemas for each supported game. Windows releases run after extraction. Other Linux systems need Qt6, xz, and 7zip, or the Flatpak. Arch uses the rpfm-bin AUR package. Build steps are in the project manual.
- [PSXRecomp](https://awesomerea.org/resources/psxrecomp/index.md): Tool · PSXRecomp translates PlayStation 1 MIPS binaries into C and links them with a hardware runtime. Version 4 can use the bundled OpenBIOS or a retail SCPH1001.BIN as the recompiled kernel. An optional high-level BIOS layer is on by default and can be turned off with bios_hle set to false. Overlays can be compiled ahead of time, and code that is not yet native runs in a MIPS interpreter until it is compiled into a cached shard. Game projects keep psxrecomp and recomp-ui as submodules. The build needs Git, Python 3, CMake 3.20 or newer, Ninja, C++20 for the recompiler, and C99 plus C++17 for the runtime.
- [Poryscript](https://awesomerea.org/resources/poryscript/index.md): Tool · Poryscript compiles a higher-level script into the script bytecode used by pokeemerald, pokefirered, and pokeruby. It adds if, elif, else, while, do...while, and switch, and formats inline text for the in-game box. ./poryscript reads a file or standard input and writes a script file or standard output. -s sets a compile-time switch such as VERSION=RUBY. The program is written in Go. go build produces the poryscript binary, and ./install.sh copies it into a decompilation project.
- [OverPy](https://awesomerea.org/resources/overpy/index.md): Tool · OverPy is a Python-like language for the Overwatch Workshop. It compiles .opy files to Workshop code and decompiles copied Workshop settings back into OverPy. The VS Code extension adds highlighting, completion, Insert Template, and a Decompile command. pnpm install fetches dependencies, pnpm run dev builds the demo, and pnpm run package writes out/overpy_standalone.js. A browser demo is at zezombye.github.io/overpy/demo. The reviewed README says every in-game language is supported.
- [homm3 unpacker](https://awesomerea.org/resources/homm3-unpacker/index.md): Tool · homm3 unpacker parses Heroes of Might and Magic III LOD archives, DEF animations and PCX images in Node.js or modern browsers. Its functions extract archive entries, animation frames and image data, with options for PNG or bitmap output and selective archive processing.
- [LEGO Dimensions Save Converter](https://awesomerea.org/resources/lego-dimensions-save-converter/index.md): Tool · LEGO Dimensions Save Converter translates game saves among Xbox 360, PS3, PS4 and Wii U formats and into a ReXGlue layout. Its Windows GUI uses a reconstructed save format that accounts for platform headers, file naming, padding and the word order of 64-bit payload fields.
- [pureikyubu](https://awesomerea.org/resources/pureikyubu/index.md): Tool · pureikyubu emulates Nintendo GameCube hardware to study the console and technologies used by its games. It includes a debugger, headless execution, and a local MCP debug interface, alongside Gekko, DSP, graphics, and I/O models. The repository also integrates Game Boy and Game Boy Advance emulation.
- [GiiBiiAdvance](https://awesomerea.org/resources/giibiiadvance-debugger/index.md): Tool · GiiBiiAdvance is a GB, GBC and GBA emulator with debugger windows for inspecting game execution. Its analysis features include disassembly with branch annotations, breakpoints, editable CPU registers and memory, and viewers for maps, sprites and palettes.
- [Space Invaders Emulator](https://awesomerea.org/resources/space-invaders-emulator/index.md): Tool · Space Invaders Emulator models the arcade game's Intel 8080 CPU, graphics and sound and includes tools for inspecting its ROM code. A command-line disassembler emits annotated assembly, while an interactive debugger provides breakpoints, opcode history, annotations and reverse stepping.
- [WoW.tools but local](https://awesomerea.org/resources/wow-tools-local/index.md): Tool · WoW.tools but local inspects a local World of Warcraft installation through a browser interface. It browses client files and DB2 tables, compares game builds and DB2 versions, tracks hotfixes and records links among assets such as textures, models and world objects.
- [DemoInfo](https://awesomerea.org/resources/demoinfo-csgo/index.md): Tool · DemoInfo reads Counter-Strike: Global Offensive demo files through a C# library for replay analysis. It exposes player state at points in time, team scores and events including attacks, grenades, deaths and bomb activity.
- [Demoparser](https://awesomerea.org/resources/demoparser-cs2/index.md): Tool · Demoparser analyzes Counter-Strike 2 replay files with a Rust parser exposed through Python, JavaScript and WebAssembly packages. It queries recorded events and ticks and returns player positions, actions and game-state fields.
- [Mesen](https://awesomerea.org/resources/mesen/index.md): Tool · Mesen is an NES/Famicom emulator with tools for inspecting game execution and graphics. Version 0.9.9 documents a debugger, trace logger, event viewer, memory tools, PPU viewer, assembler and Lua API; the repository contains the emulator core and tool source.
- [D2s](https://awesomerea.org/resources/d2s/index.md): Tool · D2s is a Go parser for Diablo II .d2s character saves. It exposes character information and documents the binary layout of headers, quests, waypoints and bit-packed attributes, including field offsets and value meanings.
- [w3gjs](https://awesomerea.org/resources/w3gjs/index.md): Tool · w3gjs parses Warcraft III .w3g replay files in TypeScript for game analysis. Its high-level API handles standard melee replays, while a low-level parser emits replay-header metadata and each parsed game data block for custom analysis.
- [ZenKit](https://awesomerea.org/resources/zenkit/index.md): Tool · ZenKit is a C++ library for parsing ZenGin file formats used by Gothic and Gothic II. It covers models, animations, textures, archives, VDF files and compiled Daedalus scripts, and includes a type-safe Daedalus VM and format reference documentation.
- [wow_chunky](https://awesomerea.org/resources/wow-chunky/index.md): Tool · Parses World of Warcraft chunked game files in Rust, including WDT and ADT maps and DXT-compressed BLP images. Its API examples load an ADT through a WDT map file; an optional inspect binary is declared in the package manifest.
- [dungeon-siege-re](https://awesomerea.org/resources/dungeon-siege-re/index.md): Tool · dungeon-siege-re analyzes asset formats used by Dungeon Siege and Legends of Aranna and supplies C++ extraction and conversion tools. It opens and decompresses Tank archives, converts ASP and SNO static geometry to OBJ, and converts RAW textures to PNG or TGA. Format notes accompany the implementation.
- [PacmanRecomp](https://awesomerea.org/resources/pacman-z80-rom-disassembler/index.md): Tool · PacmanRecomp currently loads Pac-Man's arcade ROM files, concatenates the program chips and writes a Z80 assembly listing. It also produces hexadecimal dumps for inspection; the committed entry point ends after disassembly.
- [SilentHillToolkit](https://awesomerea.org/resources/silent-hill-overlay-decryptor/index.md): Tool · SilentHillToolkit contains a C# routine that decrypts Silent Hill overlay code files by XORing successive 32-bit words with a generated key stream. The repository also stores Ghidra projects; its console entry point currently leaves the file-decryption calls commented out.
- [StoicGoose](https://awesomerea.org/resources/stoicgoose-debugger/index.md): Tool · StoicGoose emulates Bandai WonderSwan and WonderSwan Color games and includes a separate Dear ImGui interface for debugging and disassembly. The debugger source includes breakpoint, disassembler, and memory-editor components alongside the console emulator.
- [reGML](https://awesomerea.org/resources/regml-gamemaker-inspector/index.md): Tool · reGML inspects GameMaker game packages, disassembles their bytecode, and runs supported games from data.win files. Its C++ tools read package layouts v14–v17 and decode instructions for v15–v17, with inspect, audit, disasm, and runtime commands.
- [FortniteReplayDecompressor](https://awesomerea.org/resources/fortnite-replay-decompressor/index.md): Tool · FortniteReplayDecompressor parses Fortnite replay files with a C# library and example reader. Its documented format work covers replay compression, file structure, and Unreal Engine 4 network packets, with source modules for replay events and replicated game fields.
- [mgz](https://awesomerea.org/resources/aoc-mgz/index.md): Tool · mgz parses Age of Empires II recorded games into Python structures and summaries. Its fast and full parsers cover .mgl, .mgx, .mgz and .aoe2record files from Age of Kings through Definitive Edition, exposing recorded headers, actions and match data.
- [sky-reenigne](https://awesomerea.org/resources/sky-reenigne/index.md): Tool · sky-reenigne extracts and analyses resource files from the 1994 DOS game Beneath a Steel Sky. Its tools unpack sky.dnr and sky.dsk, decode in-game text and convert speech data to WAVE files; its notes identify resource IDs and RNC1 compression.
- [DSHBA](https://awesomerea.org/resources/dshba/index.md): Tool · DSHBA emulates Game Boy Advance games and provides an ImGui debugger for examining memory, registers, and execution. An optional Capstone-dependent decompiler supports code inspection. Its cached interpreter and OpenGL renderer run the games under examination.
- [Manta](https://awesomerea.org/resources/manta-dota2-replay-parser/index.md): Tool · Manta parses Dota 2 replay files from the Source 2 engine in Go. Its low-level interface exposes raw replay data through callbacks, allowing callers to inspect messages and build their own interpretation of a match.
- [Mobiclip Decoder](https://awesomerea.org/resources/mobiclip-decoder/index.md): Tool · Mobiclip Decoder decodes Nintendo game video formats using a Mobiclip implementation the author attributes to disassembly. Its C# source covers 3DS Moflex and DS Mods containers, with partial Wii MOC5 handling and separate demultiplexing and conversion components.
- [Mesen-S](https://awesomerea.org/resources/mesen-s/index.md): Tool · Mesen-S is an SNES emulator with facilities for examining game execution and graphics. Its documentation lists an assembler, debugger, event viewer, memory tools, trace logger, scripting window, and PPU tilemap, tile, sprite, and palette viewers. The repository archives its older 0.4.0 version.
- [OpenCity2k](https://awesomerea.org/resources/opencity2k-parsers/index.md): Tool · OpenCity2k provides Python parsers and utilities for SimCity 2000 game data. It opens and saves .sc2 city files and parses .mif tilesets, text and sprite data. A simulation server and client are proposed.
- [faf-scfa-replay-parser](https://awesomerea.org/resources/faf-scfa-replay-parser/index.md): Tool · faf-scfa-replay-parser reads Supreme Commander: Forged Alliance replay files into headers, command messages and timing data. Its Kaitai specification describes the replay structure, Lua values and operation stream, alongside a Python parser.
- [Rocket League Replay Parser](https://awesomerea.org/resources/rocket-league-replay-parser/index.md): Tool · Rocket League Replay Parser decodes Rocket League replay files into C# objects that can be serialized to JSON. It provides a reusable library and a console converter for individual files or directories, with code for replay frames, network-stream properties and serialization.
- [GBFRDataTools](https://awesomerea.org/resources/gbfr-data-tools/index.md): Tool · GBFRDataTools extracts and converts Granblue Fantasy: Relink archives and data files, including data.i, .tbl tables, textures and several structured UI formats. Its research notes describe FlatBuffer-based archive indexing and hashed game paths; the author reports mapping 391,699 of 408,165 paths in version 2.0.0.
- [demoinfocs-golang](https://awesomerea.org/resources/demoinfocs-golang/index.md): Tool · demoinfocs-golang parses Counter-Strike 2 and Counter-Strike: Global Offensive replay files in Go. It exposes kills and other game events, player and team state, entities, server classes, data tables and net messages, with examples for event output and heatmaps.
- [SSF2T Decomp](https://awesomerea.org/resources/ssf2t-decomp/index.md): Tool · SSF2T Decomp provides Python tools and documentation for examining the CPS2 ROM layout of Super Street Fighter 2 Turbo. Its modules cover ROM parsing, sprite decoding, audio extraction, palette parsing, and a viewer; the planned game engine and several extraction tasks remain unfinished.
- [Reevengi](https://awesomerea.org/resources/reevengi/index.md): Tool · Reevengi inspects game data from several PlayStation and PC releases of Resident Evil 1, 2 and 3. It displays backgrounds, models and room geometry and can dump room scripts with bytecodes; the repository includes format readers and related utilities.
- [DX-Ball: reconstruct sound panning](https://awesomerea.org/resources/rea-dxball-case/index.md): Case study · Recover one sound-pan function from instructions and constants; upstream cites 3,205 cases and a 63-byte match.
- [TH04: recover a DOS bullet-ring helper](https://awesomerea.org/resources/rea-th04-case/index.md): Case study · Inspect a 16-bit PC-98 DOS helper and relate its angle calculation to a pinned reconstruction and historical compiler checks.
- [Super Mario 64 DS: matching decompilation with relocation checks](https://awesomerea.org/resources/sm64ds-decomp-case/index.md): Case study · Reconstructs Super Mario 64 DS functions as C/C++ and permitted assembly primitives, comparing compiled output with a user-supplied cartridge dump. Independent relocation-destination checks strengthen the matching gate; integration into the PC port is tracked separately.
- [GoldenEye 007: an agent-assisted native port from a decompilation](https://awesomerea.org/resources/goldeneye-pc-port-case/index.md): Case study · Builds a native PC port on the existing GoldenEye 007 decompilation, with a host platform layer and assets extracted from the user’s ROM. The project documents agent collaboration, rendering comparisons, playtest scope and unresolved platform support.
- [ssbu-recomp: static recompilation with explicit mode limits](https://awesomerea.org/resources/ssbu-recomp-case/index.md): Case study · Translates Super Smash Bros. Ultimate 13.0.4 AArch64 code ahead of time and supplies a Windows runtime with Vulkan/OpenGL rendering. It also reconstructs selected fighter scripts as editable C++ and compares translated/source behavior through differential and deterministic tests.
- [KartPad: platform integration for a Mario Kart Wii recompilation](https://awesomerea.org/resources/kartpad-case/index.md): Case study · Builds Apple and Android integration around WiiCompiled’s ahead-of-time translation of Mario Kart Wii, with native graphics, input and optional Retro Rewind support. Its status and rights documents distinguish platform acceptance, unresolved device defects and game-content requirements.
- [BattleShip: an AI-assisted Super Smash Bros. native port](https://awesomerea.org/resources/battleship-port-case/index.md): Case study · Ports the existing Super Smash Bros. N64 decompilation using libultraship and Torch. The author’s earlier README describes agent-built graphics/audio comparison tools and differential debugging against emulator behavior, rather than claiming AI recovered the game from a cartridge without prior community work.
- [Agent decompilation: a byte-matching retrospective](https://awesomerea.org/resources/agent-decompilation-oracle-case/index.md): Case study · Maurice Heumann describes replacing plausible-looking agent output with compiler-based checks of reconstructed functions, relocations, data and types. The retrospective reports 99% function presence and 83% of all functions byte-exact, while keeping the reconstruction code private.
- [Snowboard Kids 2: an LLM-assisted N64 matching decompilation](https://awesomerea.org/resources/snowboardkids2-decomp-case/index.md): Case study · A public matching decompilation of the N64 game Snowboard Kids 2, begun in 2024 with community decompilation tools. The author’s dated posts document Claude, Codex and GLM workflows, including headless one-shot loops, similarity-based function scheduling and hook-guarded, hash-checked builds, through a reported complete function match.
- [IsaacRecomp: translating Flash game bytecode to native C++](https://awesomerea.org/resources/isaacrecomp-case/index.md): Case study · Translates The Binding of Isaac’s Flash AVM1 bytecode into C++ functions and supplies a native rendering/input runtime. The project reads graphics and audio from the user’s original game and documents deterministic input, headless runs and screenshot regression checks.
- [Nanolathe: a documented Total Annihilation engine reimplementation](https://awesomerea.org/resources/nanolathe-case/index.md): Case study · Reimplements a Total Annihilation-compatible strategy-game engine in Go, with public file-format research and separate gameplay profiles. It distinguishes intended retail 3.1 behavior from community-patch research and deliberate modern changes, and separates synthetic checks from tests requiring original game data.
- [TH08: exact-source reconstruction and separately tested ports](https://awesomerea.org/resources/th08-reconstruction-case/index.md): Case study · Reconstructs the original Japanese Touhou 8 version 1.00d against its binary and original compiler, then adapts the recovered code for other platforms. Source presence, strict function matching, whole-executable identity and playable-port checks are recorded as different milestones.
- [Zelda 64: Recompiled — a native Majora’s Mask port without a full source decompilation](https://awesomerea.org/resources/zelda64recomp-case/index.md): Case study · Uses N64Recomp to translate Majora’s Mask into a native application and RT64 for rendering. The project separates static recompilation from source decompilation while reusing decompilation headers and selected functions for patches and enhancements.
- [OpenGOAL: recovering GOAL code and rebuilding the Jak games](https://awesomerea.org/resources/opengoal-jak-case/index.md): Case study · 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.
- [LEGO Island: source reconstruction with separately reported exact rebuilds](https://awesomerea.org/resources/lego-island-decomp-case/index.md): Case study · Reconstructs the English LEGO Island 1.1 source for its original 32-bit Windows target. The project distinguishes function-comparison reports, ReproBit’s reported byte-identical retail rebuilds and ordinary developer builds; its modern portable adaptation is a separate repository.
- [Snowball War: a bounded REA-assisted minigame reconstruction](https://awesomerea.org/resources/snowball-war-rea-case/index.md): Case study · The author uses REA’s Ghidra workflow to investigate the DOS Ski or Die binary, document Snowball War rules and rebuild that one minigame in Rust with SDL2. The public notes distinguish recovered tables and mechanics from approximations and deliberate presentation changes.
- [SpaceCadetPinball: decompiled game logic adapted to SDL2](https://awesomerea.org/resources/space-cadet-pinball-case/index.md): Case study · 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.
- [Super Mario 64: ROM reconstruction with explicit comparison gates](https://awesomerea.org/resources/sm64-decomp-case/index.md): Case study · Reconstructs Super Mario 64 source for Japanese, North American, European, Shindou and iQue releases. Its build files distinguish original-ROM hash comparison from nonmatching or modified configurations, while source naming and documentation remain ongoing.
- [Unleashed Recompiled: translating Xbox 360 game code and shaders](https://awesomerea.org/resources/unleashed-recompiled-case/index.md): Case study · Builds an unofficial Sonic Unleashed PC port by statically recompiling Xbox 360 PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. The port adds modern display and modding options while documenting original-engine limits and remaining compatibility issues.
- [OpenMW: replacing Morrowind’s engine while reusing original content](https://awesomerea.org/resources/openmw-engine-case/index.md): Case study · Provides an independent engine for playing Morrowind and an alternative editor, OpenMW-CS. It loads original game content through its own runtime and documents script and mod compatibility differences; it is an engine replacement rather than a recovered Bethesda source tree.
- [REDRIVER2: reconstructing Driver 2 through a PlayStation compatibility layer](https://awesomerea.org/resources/redriver2-case/index.md): Case study · 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.
- [DevilutionX: porting Diablo’s reconstructed engine](https://awesomerea.org/resources/devilutionx-case/index.md): Case study · Builds a modern Diablo and Hellfire port on the Devilution reconstruction, with platform support, bug fixes and optional quality-of-life features. The project documents the original symbol-assisted reconstruction and includes selected dungeon-generation and saved-game regression checks.
- [Touhou reconstructions: an agent-driven method across three games](https://awesomerea.org/resources/rea-touhou-reconstruction-method-case/index.md): Case study · An essay published on REA’s site, with pinned evidence notes, describes one author’s agent-driven reconstructions of TH08, TH095 and TH04. It dates milestones from public commits and progress ledgers, separates exact-comparison and playable-build oracles, and documents a TH08 check that missed wrong floating-literal data. Project results remain author-reported, and REA is credited with supplying analysis evidence, not the reconstructions themselves.
- [TicTacToe-AI: a bounded REA-fork reconstruction of one game method](https://awesomerea.org/resources/rea-engine-tictactoe-case/index.md): Case study · 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.
- [UltraSunnyMoon: a partial, REA-led Pokémon Ultra Sun reconstruction](https://awesomerea.org/resources/ultrasunnymoon-rea-case/index.md): Case study · 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.
- [DX-Ball: an REA-guided function-level reconstruction with Codex](https://awesomerea.org/resources/dx-ball-rea-reconstruction-case/index.md): Case study · The author has Codex use REA’s Ghidra tools to inspect the English DX-Ball 1.07 executable and recover it as typed C/C++, then compiles each function with the original-era Visual C++ 4.0 and compares it byte for byte with the original after mapping relocations. The same source also builds a MinGW Windows game and a portable core library. Exact reconstruction is still in progress; REA’s separate sound-pan showcase covers just one function.
- [re2ds: a native Nintendo DS engine for Resident Evil 2](https://awesomerea.org/resources/re2ds-nds-engine-case/index.md): Case study · Reimplements Resident Evil 2’s PS1 game rules in a native Nintendo DS engine, with converters that turn data from the user’s own disc into DS formats. A helper wraps the PS1 executable as an ELF for REA’s Ghidra lane, analysis notes name the PS1 functions and tables each part follows, and the Reddit post linking it credits REA and Claude Code. Leon’s disc 1 is reported playable, while Claire’s disc, most enemy types and some menus remain unfinished.
- [Horizon: a Rust rewrite of Minecraft: Java Edition 26.3 with REA bytecode queries](https://awesomerea.org/resources/horizon-minecraft-rust-rewrite-case/index.md): Case study · Rewrites Minecraft: Java Edition 26.3 as a native Rust client, dedicated server and launcher that prepare their resources from the user’s own copy of the game. Contributors are told to read the vanilla code first, and tools/rea_vanilla.py runs a pinned REA release with a headless JADX engine over the shipped client and server jars to inspect classes, methods and callers. Differential harnesses run Java oracles against the real game and Rust probes against Horizon; README reports all 281 passing, which covers only what they compare.
- [Untangle: a browser rebuild from REA and Ghidra evidence](https://awesomerea.org/resources/untangle-rea-evidence-rebuild-case/index.md): Case study · An author-documented REA/Ghidra investigation of the shipped Untangle Windows binary produces a single-page playable rebuild and a claim-by-claim grading receipt. The report separates frozen findings, a later source-code answer key and a prior-knowledge audit.
- [OpenBattlefield2: an unfinished Refractor 2 engine reimplementation](https://awesomerea.org/resources/openbattlefield2-refractor-engine-case/index.md): Case study · A C++20 reimplementation of Battlefield 2’s Refractor 2 engine reads original game data and documents menu rendering, level loading and server interoperability. Published crosshair research cites REA/Ghidra evidence IDs and binary addresses; major gameplay systems remain unfinished.
- [keen-clone: a Commander Keen 1 C/SDL2 port](https://awesomerea.org/resources/keen-clone-rea-commander-keen-case/index.md): Case study · A native Linux and browser port of Commander Keen Episode One is documented as a function-by-function REA/Ghidra reconstruction of KEEN1.EXE. Published analysis artifacts accompany the C/SDL2 game; the scope is the first episode.
- [samp-client-re: a partial SA-MP client reconstruction](https://awesomerea.org/resources/samp-client-rea-partial-reconstruction-case/index.md): Case study · A documented REA/Ghidra investigation maps SA-MP 0.3.DL-R1 client subsystems to a new C++ DLL, loader and smoke-test executable. The result is an architectural reconstruction with unresolved network and graphics behavior; retail-client compatibility remains unverified.
- [Desktop Games Nostalgia: a macOS and browser port](https://awesomerea.org/resources/desktop-games-nostalgia-rea-port-case/index.md): Case study · A Swift/macOS and JavaScript/browser port recreates the Desktop Games screen-smashing toy from a captured image. The author documents Claude and REA/Ghidra work on the Peter interpreter, a decompiled program tree and extracted assets, with explicit visual differences and no project license.