# Awesome REA Case Studies [← Back to the README](../README.md#resources) · **English** · [简体中文](cases.zh-CN.md) **442 case studies**, grouped by section. ## Contents - [Website](#website) (13) - [Game](#game) (239) - [App](#app) (72) - [Native Binary](#native-binary) (8) - [Firmware and Hardware](#firmware-and-hardware) (19) - [Protocol](#protocol) (91) ## Website [↑ Contents](#contents) - [**Power BI API Scraper: decoding a published report query format**](https://github.com/artemiyDev/powerbi_api_scraper) - Power BI API Scraper reconstructs the web client's undocumented query and response format for published reports. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/power-bi-report-query-case/)} - [**Sheypoor MCP: mapping marketplace APIs from browser traffic**](https://github.com/FarhamAghdasi/sheypoor-mcp) - Sheypoor MCP implements a client and MCP server for the Sheypoor classifieds site using API behavior documented from browser traffic. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sheypoor-mcp-case/)} - [**ZCode-Android: reconstructing the ZCode remote-control client**](https://github.com/Damianjiang/ZCode-Android) - ZCode-Android recreates ZCode remote control on Android from captured traffic and analysis of its official web page. _{Case study · Independent reconstruction · Also: App, Protocol · [Full entry](https://awesomerea.org/resources/zcode-android-case/)} - [**Terminal: a Rust terminal informed by TradingView chart research**](https://github.com/michaelshimeles/terminal) - An independent Rust market interface uses REA browser-scenario research on public logged-out TradingView chart interactions. _{Case study · Mixed workflow · Also: App · [Full entry](https://awesomerea.org/resources/terminal-tradingview-rea-chart-case/)} - [**Littlebird.ai static home-page rebuild**](https://github.com/AkashNaickar/crdb-sample-frontend) - Rebuilds the Littlebird.ai home page in plain HTML/CSS/JavaScript from captured markup and assets, with source-wired mobile navigation, FAQ toggles, scroll reveals and OS-dependent call-to-action presentation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/littlebird-static-rebuild-case/)} - [**Ruffle: a Rust reimplementation of Adobe Flash Player**](https://github.com/ruffle-rs/ruffle) - Reimplements Adobe Flash Player in Rust so that SWF content, from ActionScript 1/2 (AVM1) to ActionScript 3 (AVM2), runs in a native desktop player or in browsers through WebAssembly, as a self-hosted script or a browser extension. _{Case study · Independent reconstruction · Also: Game · [Full entry](https://awesomerea.org/resources/ruffle-flash-player-case/)} - [**Dinosaur runner: an REA-inspected speed rule rebuilt with Codex**](https://github.com/zhxunzh84/rea-dino-reverse-engineering) - The author uses REA’s MCP browser tools to passively capture the JavaScript loaded by wayou’s open-source T-Rex Runner page, then has Codex rebuild its acceleration rule in one self-contained HTML5 Canvas game. _{Case study · Mixed workflow · Also: Game · [Full entry](https://awesomerea.org/resources/rea-dino-runner-community-case/)} - [**whatsapp-web-reveng: documenting the legacy WhatsApp Web protocol**](https://github.com/sigalor/whatsapp-web-reveng) - Documents and reimplements the WebSocket protocol WhatsApp Web used while browser sessions mirrored a paired phone: QR pairing, Curve25519/HKDF key setup, AES/HMAC-protected binary messages, the token-based node encoding and end-to-end media encryption. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/whatsapp-web-reveng-legacy-protocol-case/)} - [**BaoCut Design: porting reconstructed canvas and design-system editors**](https://github.com/JimLiu/baocut/tree/7aa049e82e1367da013b7aba80f0b79033fa04ad/packages/design-runtime) - Documents BaoCut’s design-canvas and design-system editors, which the project says it ported 1:1 from TypeScript reconstructions of Claude Design’s editors and hosts in agent sessions with annotation and export. _{Case study · Independent reconstruction · Also: App · [Full entry](https://awesomerea.org/resources/baocut-design-canvas-case/)} - [**REA in Claude Code: an isolated static-analysis A/B trial**](https://zenn.dev/keigoly/articles/8738d8d241b5a1) - A Japanese field report connects REA 6.4.0 to Claude Code in a separate project directory, denies 43 of its 170 tools and common shell launch forms, and compares REA-enabled and REA-disabled runs on two real tasks: an Electron terminal’s packaged files and a saved HAR capture. _{Case study · Mixed workflow · Also: App · [Full entry](https://awesomerea.org/resources/rea-claude-code-isolated-ab-case/)} - [**BaoCut Slides: adapting an interactive web editor**](https://github.com/JimLiu/baocut/tree/b8585e0c8d7a82bdee9f0ed019cf6edb075e41c1/packages/slides-runtime) - Documents BaoCut’s interactive slide editor, whose author says the implementation draws on Claude Slides. _{Case study · Independent reconstruction · Also: App · [Full entry](https://awesomerea.org/resources/baocut-slides-editor-case/)} - [**Dinosaur runner: recovering one acceleration rule**](https://github.com/morluto/rea/blob/c360cfcd6d7901514b16dd6113eba2e0b0fdf422/website/evidence/calculator-and-dino.md#dinosaur-speed) - REA’s documented teaching case inspects the HTTP t-rex-runner edition and reconstructs its speed-update rule. _{Case study · Official REA · Also: Game · [Full entry](https://awesomerea.org/resources/rea-dinosaur-speed-case/)} - [**rauchg.com: rebuilding an RSC blog from captured Flight output**](https://github.com/boyang-hu/website-rebuild-skill/blob/ac60c9d8a2ab40045a89b5403c3457f1404e92b3/skills/website-rebuild/references/rsc-reconstruction.md) - Documents a website-rebuild-skill case that decodes browser-delivered React Server Component Flight streams, reconstructs a buildable Next project and compares its output with a captured site. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rauchg-rsc-reconstruction-case/)} ## Game [↑ Contents](#contents) ### Matching decompilations and disassemblies (69) - [**3S Decomp: a byte-compared PS2 decompilation of Street Fighter III: 3rd Strike**](https://github.com/crowded-street/3s-decomp) - Decompiles the PlayStation 2 executable of Street Fighter III: 3rd Strike from Street Fighter Anniversary Collection into C that period Metrowerks and EE GCC compilers rebuild, then compares the rebuilt executable word by word with the user’s original. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sfiii-3rd-strike-ps2-decomp-case/)} - [**Agent decompilation: a byte-matching retrospective**](https://momo5502.com/posts/2026-10-09-game-decompilation/) - Maurice Heumann describes replacing plausible-looking agent output with compiler-based checks of reconstructed functions, relocations, data and types. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/agent-decompilation-oracle-case/)} - [**Animal Crossing: matching GameCube decompilation**](https://github.com/ACreTeam/ac-decomp) - Reconstructs Animal Crossing’s GameCube code as C and C++ source that rebuilds the USA release’s main executable and its foresta.rel module. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/animal-crossing-gamecube-decomp-case/)} - [**Animal Crossing: Wild World: matching Korean DS decompilation with differential runtime checks**](https://github.com/banatic/acww-decomp) - Reconstructs the ARM9 game code of Animal Crossing: Wild World’s Korean DS release as one C or C++ source per function, checked against the user’s ROM with the original Metrowerks compiler and linker. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/animal-crossing-wild-world-decomp-case/)} - [**Animal Forest: an in-progress matching N64 decompilation**](https://github.com/zeldaret/af) - Rebuilds the Japanese Nintendo 64 release of Animal Forest (Dōbutsu no Mori) from C code reverse-engineered from the ROM, combined with assets and assembly extracted from a user-supplied ROM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/animal-forest-n64-decomp-case/)} - [**BFM-decomp: Brave Fencer Musashi matching decompilation**](https://github.com/Druthulu/BFM-decomp) - Documents an agent-assisted reconstruction of the USA PlayStation game with a pinned compiler and whole-binary SHA-1 gates. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/bfm-decomp-case/)} - [**Breath of the Wild: per-function matching decompilation of the Switch executable**](https://github.com/zeldaret/botw) - Reimplements part of Breath of the Wild’s Switch v1.5.0 main executable in C++ and checks each function against the original machine code. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/botw-decomp-case/)} - [**Castlevania: Symphony of the Night: matching decompilation across PlayStation, PSP and Saturn builds**](https://github.com/Xeeynamo/sotn-decomp) - Recreates C source for Castlevania: Symphony of the Night from its PlayStation, PSP and Saturn binaries, aiming for code that compiles byte for byte to the original game files. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sotn-matching-decomp-case/)} - [**DX-Ball: an REA-guided function-level reconstruction with Codex**](https://github.com/N0zoM1z0/dx-ball) - 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. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/dx-ball-rea-reconstruction-case/)} - [**DX-Ball: reconstruct sound panning**](https://rea.tools/showcase/dx-ball/) - Recover one sound-pan function from instructions and constants; upstream cites 3,205 cases and a 63-byte match. _{Case study · Official REA · Also: Binary · [Full entry](https://awesomerea.org/resources/rea-dxball-case/)} - [**Final Fantasy VII: a matching PlayStation decompilation**](https://github.com/Xeeynamo/ff7-decomp) - Reconstructs C source for the US PlayStation release of Final Fantasy VII, aiming for code that compiles back to the original main executable and its game overlays. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ff7-ps1-matching-decomp-case/)} - [**GoldenEye 007: matching Nintendo 64 decompilation for three releases**](https://github.com/n64decomp/007) - Reconstructs GoldenEye 007’s Nintendo 64 code as C source that rebuilds the US, Japanese and PAL ROMs. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/goldeneye-007-matching-decomp-case/)} - [**Gran Turismo 4: an agent-assisted PS2 engine matching decompilation**](https://github.com/gustavocanepa/gt4-decomp) - Decompiles Gran Turismo 4’s PS2 engine executable (CORE.GT4, NTSC-U v1.01) into one C or C++ source per function for Sony’s ee-gcc 2.96, matching public libraries such as newlib and Expat from their own source. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/gran-turismo-4-matching-decomp-case/)} - [**Halo 2: an agent-assisted matching decompilation of an LTCG Xbox build**](https://github.com/kirklandsig/halo2-decompiled) - A work-in-progress matching decompilation of Halo 2 for the original Xbox: contributors write C and C++ that the period compiler, building the whole program with link-time code generation, must turn back into the retail executable's bytes function by function. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/halo2-matching-decomp-case/)} - [**Himuro: a matching Fatal Frame PS2 decompilation**](https://github.com/Mikompilation/Himuro) - Reconstructs Fatal Frame’s PS2 executable as C for the US, EU and Japanese releases, built with the original EE-GCC 2.9 toolchain and checked by SHA-1 against the user’s own executables. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/himuro-fatal-frame-decomp-case/)} - [**ICO decompilation: byte-identical PAL and Japanese PlayStation 2 boot ELFs**](https://github.com/nathanialf/ico) - Rebuilds the boot ELFs of ICO’s PAL (SCES-50760) and Japanese (SCPS-11003) PlayStation 2 discs from one source tree with the game’s original compiler versions, and checks that every loaded byte and the whole ELF file match the disc’s SHA-1. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ico-matching-decomp-case/)} - [**Kingdom Hearts 358/2 Days: a matching Nintendo DS decompilation**](https://github.com/Yokimitsuro/khdays-decomp) - Reconstructs the ARM9 program and overlays of the EU Nintendo DS release of Kingdom Hearts 358/2 Days as C that recompiles byte for byte with CodeWarrior. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/kingdom-hearts-days-matching-decomp-case/)} - [**LEGO Island: source reconstruction with separately reported exact rebuilds**](https://github.com/isledecomp/isle) - Reconstructs the English LEGO Island 1.1 source for its original 32-bit Windows target. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lego-island-decomp-case/)} - [**Majora’s Mask: matching US N64 decompilation**](https://github.com/zeldaret/mm) - Recreates a C source base for The Legend of Zelda: Majora’s Mask from information in the game and static or dynamic analysis, then rebuilds the US Nintendo 64 ROM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zelda-mm-decomp-case/)} - [**Mario Kart Wii: an in-progress matching decompilation of the PAL release**](https://github.com/snailspeed3/mkw) - A work-in-progress matching decompilation of Mario Kart Wii that targets the PAL release (RMCP01), rebuilding main.dol and the StaticR.rel module from C and C++ with Metrowerks compilers and checking both against stored SHA-1 values. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mario-kart-wii-decomp-case/)} - [**Mario Kart: Double Dash!!: a matching GameCube decompilation of the debug build**](https://github.com/doldecomp/mkdd) - A work-in-progress 1:1 decompilation of Mario Kart: Double Dash!! _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mario-kart-double-dash-decomp-case/)} - [**Mario Party 4: matching GameCube decompilation of the USA releases**](https://github.com/mariopartyrd/marioparty4) - Reconstructs Mario Party 4’s GameCube main executable and REL modules as C source that rebuilds both USA releases. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mario-party-4-decomp-case/)} - [**MediEvil decompilation: an early checksum-gated PlayStation project**](https://github.com/MediEvilDecompilation/medievil-decomp) - Decompiles the US PlayStation release of MediEvil toward C source that rebuilds its main executable, game executable and 26 overlays. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/medievil-decomp-case/)} - [**Metroid Prime: the PrimeDecomp matching GameCube decompilation**](https://github.com/PrimeDecomp/prime) - Reconstructs C++ source for Metroid Prime’s GameCube executable and its NES-emulator module so that CodeWarrior builds match the originals, across the USA, Korean, PAL and Japanese releases, with early configurations for demo discs and three Wii releases. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/primedecomp-metroid-prime-decomp-case/)} - [**MinecraftLCE: an early-stage Minecraft: Nintendo Switch Edition decompilation**](https://github.com/GRAnimated/MinecraftLCE) - Decompiles Minecraft: Nintendo Switch Edition v1.0.17, a Legacy Console Edition release, into C++ that is compared function by function with the original executable using a patched Clang 4.0.1 and the open-ead Switch decompilation tools. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/minecraft-lce-switch-decomp-case/)} - [**Ocarina of Time: decompilation with MD5-checked ROM builds for 16 versions**](https://github.com/zeldaret/oot) - Recreates a C source base for Ocarina of Time that rebuilds 16 Nintendo 64, GameCube and iQue Player ROM versions, using information from the game and static and dynamic analysis. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ocarina-of-time-decomp-case/)} - [**Paper Mario: matching Nintendo 64 decompilation for four releases**](https://github.com/pmret/papermario) - Reconstructs Paper Mario’s Nintendo 64 code as C source that rebuilds the US, Japanese, PAL and iQue ROMs. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/paper-mario-matching-decomp-case/)} - [**Paper Mario: The Thousand-Year Door: an early matching GameCube decompilation**](https://github.com/doldecomp/ttyd) - A work-in-progress matching decompilation of Paper Mario: The Thousand-Year Door that targets the Japanese Rev 0 GameCube release (G8MJ01), rebuilding MarioSt.dol and 31 REL modules with the original Metrowerks compilers and checking each against a stored SHA-1. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/paper-mario-ttyd-decomp-case/)} - [**Perfect Dark: matching Nintendo 64 decompilation**](https://github.com/n64decomp/perfect_dark) - Reconstructs Perfect Dark’s Nintendo 64 code with a documented matching-ROM build. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/perfect-dark-matching-decomp-case/)} - [**Petari: a matching Super Mario Galaxy decompilation**](https://github.com/SMGCommunity/Petari) - Reconstructs Super Mario Galaxy’s Wii code as C++ that rebuilds, object by object, against main.dol files extracted from the user’s own Japanese, North American, PAL or Korean disc. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/petari-smg-decomp-case/)} - [**Phantom Hourglass: an early-stage matching Nintendo DS decompilation**](https://github.com/zeldaret/ph) - Recreates C++ source for The Legend of Zelda: Phantom Hourglass by hand-decompiling its European and US Nintendo DS releases, using the dsd toolkit to delink code from a user-supplied ROM and rebuild the ROM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/phantom-hourglass-ds-decomp-case/)} - [**Pikmin 2: a fully matched GameCube decompilation across five releases**](https://github.com/projectPiki/pikmin2) - A fan decompilation of Pikmin 2 that rebuilds main.dol for five GameCube releases (USA retail, two USA demos, PAL and Japan) with the original Metrowerks compilers, checking each against a stored SHA-1. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pikmin-2-matching-decomp-case/)} - [**pokecrystal: a matching Pokémon Crystal disassembly**](https://github.com/pret/pokecrystal) - Reconstructs the Game Boy Color game Pokémon Crystal as RGBDS assembly, with graphics, maps and data stored as editable sources. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokecrystal-disassembly-case/)} - [**pokered: a matching Pokémon Red and Blue disassembly**](https://github.com/pret/pokered) - Reconstructs the Game Boy games Pokémon Red and Blue as RGBDS assembly, with graphics and data kept as editable source files. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokered-disassembly-case/)} - [**pokeruby: a matching Pokémon Ruby and Sapphire decompilation**](https://github.com/pret/pokeruby) - Reconstructs the Game Boy Advance games Pokémon Ruby and Sapphire as C source built with pret's agbcc compiler, alongside assembly data scripts and editable graphics. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokeruby-decomp-case/)} - [**Pokémon Emerald: a matching Game Boy Advance decompilation**](https://github.com/pret/pokeemerald) - Reconstructs Pokémon Emerald for the Game Boy Advance as buildable C source, with game scripts and data kept as assembler directives. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokemon-emerald-decomp-case/)} - [**Pokémon FireRed and LeafGreen: a matching Game Boy Advance decompilation**](https://github.com/pret/pokefirered) - Reconstructs the English Game Boy Advance releases of Pokémon FireRed and LeafGreen as buildable C source, with game scripts and data kept as assembler directives. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokemon-firered-leafgreen-decomp-case/)} - [**Pokémon HeartGold and SoulSilver: a work-in-progress, checksum-matched DS disassembly**](https://github.com/pret/pokeheartgold) - Rebuilds the US Nintendo DS releases of Pokémon HeartGold and SoulSilver from a work-in-progress disassembly in which part of the code has been decompiled to C. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokemon-heartgold-soulsilver-disassembly-case/)} - [**Pokémon Platinum: a checksum-matched Nintendo DS decompilation**](https://github.com/pret/pokeplatinum) - Reconstructs the US Nintendo DS release of Pokémon Platinum as C source that rebuilds revision 1 by default and revision 0 on request. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokemon-platinum-decomp-case/)} - [**pw: a matching decompilation of the Pokéwalker firmware**](https://github.com/lumirth/pw) - Reconstructs as C the firmware of the Pokéwalker, the pedometer accessory for Pokémon HeartGold and SoulSilver, for its Renesas H8/38606 microcontroller. _{Case study · Independent reconstruction · Also: Firmware · [Full entry](https://awesomerea.org/resources/pokewalker-matching-decomp-case/)} - [**Ratchet & Clank: a matching PS2 decompilation with a documented agent workflow**](https://github.com/OpenRAC/rac1-decomp) - Reconstructs C source for SCES\_509.16, the PAL v2.00 PlayStation 2 executable of Ratchet & Clank (2002), with every function linked at its retail address. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rac1-matching-decomp-case/)} - [**re4: a byte-identical decompilation of the Resident Evil 4 GameCube debug build**](https://github.com/adonis-singh/re4) - Reconstructs C and C++ source for the two-disc Resident Evil 4 GameCube debug prototype (G4BE08) and rebuilds main.dol and all 114 REL overlays with the compilers the README names, checking every output against a SHA-1 list. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/re4-gamecube-debug-decomp-case/)} - [**sead: a decompilation of Nintendo’s first-party C++ standard library**](https://github.com/open-ead/sead) - Decompiles sead, the C++ standard library that Nintendo statically links into its first-party games, covering containers, heaps, strings, math, file devices, threads, the game framework and graphics. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sead-nintendo-library-decomp-case/)} - [**Skyward Sword: Wii decompilation with hash-checked relinking**](https://github.com/zeldaret/ss) - Reconstructs C++ source for The Legend of Zelda: Skyward Sword’s Wii main.dol and REL modules, starting from the user’s NTSC-U 1.0 (SOUE01) disc files. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/skyward-sword-decomp-case/)} - [**Sly Cooper and the Thievius Raccoonus: matching PlayStation 2 decompilation**](https://github.com/TheOnlyZac/sly1) - Reconstructs source code for SCUS\_971.98, the NTSC-U PlayStation 2 executable of Sly Cooper and the Thievius Raccoonus, as a work-in-progress matching decompilation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sly1-matching-decomp-case/)} - [**Snowboard Kids 2: an LLM-assisted N64 matching decompilation**](https://github.com/cdlewis/snowboardkids2-decomp) - A public matching decompilation of the N64 game Snowboard Kids 2, begun in 2024 with community decompilation tools. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/snowboardkids2-decomp-case/)} - [**Snowboard Kids: an agent-assisted N64 matching decompilation**](https://github.com/cdlewis/snowboardkids-decomp) - A matching decompilation of the original Nintendo 64 Snowboard Kids that rebuilds SHA1-identical North American and Japanese ROMs from a user-supplied ROM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/snowboardkids-matching-decomp-case/)} - [**Sonic Advance 1 & 2: a matching GBA decompilation with widescreen ports**](https://github.com/SAT-R/sa2) - Reconstructs Sonic Advance and Sonic Advance 2 for the Game Boy Advance as C that rebuilds six hash-listed ROMs with SAT-R’s agbcc fork, and compiles the same code into widescreen SDL ports for Linux, macOS and Windows plus PSP and PS2 builds. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sonic-advance-1-2-decomp-port-case/)} - [**Sonic Advance 3: an AI-assisted match of one enemy module**](https://gambiconf.substack.com/p/development-journey-on-game-decompilation) - Macabeus’s dated study describes prompting Claude Sonnet 3.5 and DeepSeek R1 with assembly, similar decompiled functions and structs to write matching C for Marun, one enemy module of the community Sonic Advance 3 GBA decompilation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sa3-marun-ai-decomp-case/)} - [**Star Fox 64: a complete matching Nintendo 64 decompilation**](https://github.com/sonicdcer/sf64) - Reconstructs C source for the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 that, compiled with the IDO compiler through a static recompilation, rebuilds a ROM with the published MD5; the README badge counts all 2,951 functions as matching. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sf64-matching-decomp-case/)} - [**Super Mario 64 DS: matching decompilation with relocation checks**](https://github.com/tangosdev/sm64ds-decomp) - Reconstructs Super Mario 64 DS functions as C/C++ and permitted assembly primitives, comparing compiled output with a user-supplied cartridge dump. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sm64ds-decomp-case/)} - [**Super Mario 64: ROM reconstruction with explicit comparison gates**](https://github.com/n64decomp/sm64) - Reconstructs Super Mario 64 source for Japanese, North American, European, Shindou and iQue releases. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sm64-decomp-case/)} - [**Super Mario Odyssey: per-function matching decompilation of the Switch executable**](https://github.com/MonsterDruide1/OdysseyDecomp) - Reconstructs C++ source for Super Mario Odyssey’s Switch 1.0 main executable and checks each function against the original AArch64 machine code with the shared nx-decomp-tools checker. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/odyssey-decomp-case/)} - [**Super Mario Sunshine (USA): an AI-assisted matching decompilation fork**](https://github.com/chasem-dev/sms-english) - Extends the doldecomp Super Mario Sunshine decompilation to the North American GMSE01 release. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sms-english-gmse01-decomp-case/)} - [**Super Mario Sunshine: an in-progress matching GameCube decompilation**](https://github.com/doldecomp/sms) - Reconstructs Super Mario Sunshine’s C++ source so that the original Metrowerks compiler reproduces byte-identical object files for four GameCube releases and the Switch 3D All-Stars build. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sms-matching-decomp-case/)} - [**Super Smash Bros. Brawl: an early matching Wii decompilation**](https://github.com/doldecomp/brawl) - A work-in-progress matching decompilation of Super Smash Bros. Brawl that targets the USA Rev 2 Wii release (RSBE01\_02), splitting main.dol and 126 REL modules from a user-supplied disc image and checking the rebuilt binaries against stored SHA-1 values. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/smash-bros-brawl-decomp-case/)} - [**Super Smash Bros. Melee: a matching GameCube decompilation with a shiftable build**](https://github.com/doldecomp/melee) - A matching decompilation of Super Smash Bros. Melee's US 1.02 release (GALE01) that rebuilds main.dol from C with the original Metrowerks compilers and checks it against the retail SHA-1. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/melee-matching-decomp-case/)} - [**Syphon Filter: The Omega Strain — matching PS2 executable decompilation**](https://github.com/zm2283145/syphon-filter-omega-strain-decomp) - Reconstructs much of the NTSC-U PlayStation 2 executable of Syphon Filter: The Omega Strain as C; with the remaining functions kept as split assembly, the build reproduces the retail SCUS\_972.64 byte for byte. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/syphon-filter-omega-strain-decomp-case/)} - [**TH04: rebuilding Lotus Land Story’s four PC-98 programs from source**](https://github.com/N0zoM1z0/th04) - Reconstructs source for the Japanese PC-98 Touhou 4: Lotus Land Story and rebuilds all four DOS programs, MAIN.EXE, OP.EXE, MAINE.EXE and ZUN.COM, with a pinned Borland toolchain under Wine. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th04-reconstruction-case/)} - [**TH08: exact-source reconstruction and separately tested ports**](https://github.com/N0zoM1z0/th08) - Reconstructs the original Japanese Touhou 8 version 1.00d against its binary and original compiler, then adapts the recovered code for other platforms. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th08-reconstruction-case/)} - [**TH095: function-level reconstruction of Shoot the Bullet 1.02a**](https://github.com/N0zoM1z0/th095) - Reconstructs source for the original Japanese Touhou 9.5: Shoot the Bullet 1.02a executable, accepting function exactness only through reproducible byte comparison of pinned Visual C++ .NET 2003 builds against one hash-attested target. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th095-reconstruction-case/)} - [**The Minish Cap: a GBA decompilation targeting five ROMs**](https://github.com/zeldaret/tmc) - Recreates a C source base for The Legend of Zelda: The Minish Cap from information in the game and static or dynamic analysis, building five Game Boy Advance ROMs: USA, EU, JP and two demos. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zelda-tmc-decomp-case/)} - [**The Sims: Bustin' Out: an AI-driven partial GBA matching decompilation**](https://github.com/DaBrown95/tsbodp) - Rebuilds the USA/Europe Game Boy Advance release of The Sims: Bustin' Out byte for byte while gradually replacing ROM regions with matching C compiled by agbcc. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sims-bustin-out-gba-decomp-case/)} - [**The Wind Waker: a GameCube decompilation with hash-checked relinking**](https://github.com/zeldaret/tww) - Reconstructs source for The Wind Waker’s GameCube executable and REL modules across the USA/Korea, PAL and Japanese releases and a Japanese kiosk demo. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wind-waker-decomp-case/)} - [**Touhou 6: reconstructing Embodiment of Scarlet Devil 1.02h source**](https://github.com/GensokyoClub/th06) - Reconstructs C++ source for the Windows executable of Touhou 6: Embodiment of Scarlet Devil version 1.02h, aiming at an exact rebuild with the original Visual Studio .NET 2002 and DirectX 8 toolchain. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th06-decomp-case/)} - [**Touhou 7: reconstructing Perfect Cherry Blossom 1.00b source**](https://github.com/some100/th07) - Reconstructs C++ source for the Windows executable of Touhou 7: Perfect Cherry Blossom 1.00b and its custom.exe configuration tool, built with the original Visual Studio .NET 2002 and DirectX 8 toolchain and compared function by function with the user’s originals through reccmp. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th07-decomp-case/)} - [**Twilight Princess: a decompilation with fully matching GameCube code**](https://github.com/zeldaret/tp) - Reconstructs Twilight Princess source that compiles back to binaries identical to the originals, building GameCube, Wii and Nvidia Shield releases from one codebase through conditional compilation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/twilight-princess-decomp-case/)} - [**Underworld Exhumed: reconstructing Ultima Underworld I and II**](https://github.com/abedegno/underworld-exhumed) - Pairs reconstructed DOS sources with native ports of Ultima Underworld I and II. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/underworld-exhumed-case/)} - [**wii-ipl: a decompilation of the Wii Menu (System Menu 4.3)**](https://github.com/koopthekoopa/wii-ipl) - A work-in-progress decompilation of the Wii Menu, the console’s System Menu (IPL), targeting version 4.3 in its USA, European, Japanese and Korean builds. _{Case study · Independent reconstruction · Also: Firmware · [Full entry](https://awesomerea.org/resources/wii-menu-ipl-decomp-case/)} ### Non-matching decompilations (19) - [**c1: a C port of PlayStation Crash Bandicoot**](https://github.com/wurlyfox/c1) - Ports the original PlayStation Crash Bandicoot game code to C function by function; its coding standard labels functions with the addresses of their original implementations. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/crash-bandicoot-c1-port-case/)} - [**Firefighter: a decompiled DOS game ported to Rust**](https://gitlab.com/esr/firefighter) - Eric S. Raymond’s terminal port of Firefighter, Eben Sprinsock’s 1985 DOS shareware game. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/firefighter-rust-port-case/)} - [**Halo: Combat Evolved: an incremental re-implementation patched into the original Xbox executable**](https://github.com/halo-re/halo) - A research project re-implementing the original Xbox Halo: Combat Evolved in C, one function at a time. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/halo-ce-xbox-reimplementation-case/)} - [**keen-clone: a Commander Keen 1 C/SDL2 port**](https://github.com/carlhako/keen-clone) - A native Linux and browser port of Commander Keen Episode One is documented as a function-by-function REA/Ghidra reconstruction of KEEN1.EXE. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/keen-clone-rea-commander-keen-case/)} - [**Metroid Dread: a hand decompilation in progress**](https://github.com/tsuyoi-w/DreadComp) - DreadComp is an in-progress hand decompilation of Metroid Dread that recreates game source code in C++. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dreadcomp-case/)} - [**OpenGOAL: recovering GOAL code and rebuilding the Jak games**](https://github.com/open-goal/jak-project) - Reconstructs readable GOAL code from the original Jak binaries and compiles it with a new GOAL compiler for modern PCs. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opengoal-jak-case/)} - [**Paleblood: a functional decompilation of Bloodborne with its own runtime**](https://github.com/Yharnam-Hunters/Paleblood) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/paleblood-bloodborne-functional-decomp-case/)} - [**R.E.L.I.V.E.: an Oddworld Abe’s Oddysee and Abe’s Exoddus engine reimplementation**](https://github.com/AliveTeam/alive_reversing) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/relive-oddworld-abe-engine-case/)} - [**re-plants-vs-zombies: decompiling and modernizing Plants vs. Zombies GOTY**](https://github.com/Patoke/re-plants-vs-zombies) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/re-plants-vs-zombies-decomp-case/)} - [**REDRIVER2: reconstructing Driver 2 through a PlayStation compatibility layer**](https://github.com/OpenDriver2/REDRIVER2) - Translates reverse-engineered Driver 2 MIPS routines into C/C++ and uses Psy-X/Psy-Cross to adapt PlayStation interfaces for desktop systems. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/redriver2-case/)} - [**RSDKv3 Decompilation: Sonic CD (2011) on a reconstructed Retro Engine v3**](https://github.com/RSDKModding/RSDKv3-Decompilation) - Reconstructs Retro Engine v3, the engine behind the 2011 Sonic CD remaster, as a native C++ source port for Windows, Linux, macOS and Android. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rsdkv3-sonic-cd-decomp-case/)} - [**RSDKv4 Decompilation: Retro Engine v4 and the Sonic 1 & 2 (2013) menus**](https://github.com/RSDKModding/RSDKv4-Decompilation) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rsdkv4-sonic-1-2-decomp-case/)} - [**RSDKv5 Decompilation: reconstructing Retro Engine v5 and v5U**](https://github.com/RSDKModding/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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rsdkv5-engine-decomp-case/)} - [**Sonic Mania: a game-code decompilation for the RSDKv5 engine**](https://github.com/RSDKModding/Sonic-Mania-Decompilation) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sonic-mania-decomp-case/)} - [**SpaceCadetPinball: decompiled game logic adapted to SDL2**](https://github.com/k4zmu2a/SpaceCadetPinball) - Converts the reverse-engineered Space Cadet pinball game into compilable C++ for desktop platforms. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/space-cadet-pinball-case/)} - [**TicTacToe-AI: a bounded REA-fork reconstruction of one game method**](https://github.com/heaven-hm/re-agent/tree/develop/benchmarks/tictactoe) - 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. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/rea-engine-tictactoe-case/)} - [**UltraSunnyMoon: a partial, REA-led Pokémon Ultra Sun reconstruction**](https://github.com/tylergraydev/UltraSunnyMoon) - 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. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/ultrasunnymoon-rea-case/)} - [**vf2-decomp: differentially validated Virtua Fighter 2 recovery**](https://github.com/celsowm/vf2-decomp) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/vf2-decomp-differential-recovery-case/)} - [**Wind Waker HD decompilation: functions verified against the recompiled Wii U game**](https://github.com/ZeldaWWHDDecomp/wwhd) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wind-waker-hd-decomp-case/)} ### Static recompilations (48) - [**Banjo: Recompiled — an N64Recomp Banjo-Kazooie native port**](https://github.com/BanjoRecomp/BanjoRecomp) - Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Banjo-Kazooie into a native port on N64ModernRuntime, rendered by RT64 and extended with mod support. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/banjo-recompiled-case/)} - [**C2C: hybrid recompilation and hand decompilation of Crash Bandicoot 2**](https://github.com/ughman/c2c) - An early reverse-engineering effort on PlayStation Crash Bandicoot 2 that converts the engine’s MIPS machine code directly into a very large C file and runs it against a modified PCSX-R emulator library for hardware I/O. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/c2c-crash2-hybrid-recompilation-case/)} - [**Castlevania 64: Recompiled — a beta static-recompilation port**](https://github.com/RevoSucks/CV64Recomp) - Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Castlevania into a native PC port rendered with RT64. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cv64-recompiled-case/)} - [**Conker's Bad Fur Day: Recompiled — an N64Recomp native port**](https://github.com/sciaschi/CBFD-Recompiled) - Statically recompiles the US Nintendo 64 release of Conker’s Bad Fur Day with N64Recomp into a native Windows, Linux and macOS port on N64ModernRuntime and RT64. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cbfd-recompiled-case/)} - [**CPS-2 Recomp: static recompilation of Capcom CPS-2 and CPS-1 arcade games**](https://github.com/tmcleroy/cps2recomp) - Translates the 68000 game programs and Z80 sound programs of Capcom arcade boards ahead of time into C++ and runs them on a machine model written for the project, with an interpreter for code that has not been translated. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cps2recomp-arcade-static-recomp-case/)} - [**Crash Bandicoot 2 Recompiled: a PSXRecomp native build**](https://github.com/Zumbo06/Crash2Recomp) - A Windows launcher that uses the PSXRecomp recompiler and runtime to translate the user’s Crash Bandicoot 2: Cortex Strikes Back disc to C and compile it locally, so the game runs as native code with an emulated PlayStation hardware layer. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/crash2recomp-case/)} - [**Dead Rising 2: Case West — a sibling Xbox 360 XBLA static recompilation port**](https://github.com/wivi514/Dead_Rising_2_Case_West_Xenon_Recomp) - Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA epilogue Dead Rising 2: Case West by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dead-rising-2-case-west-recomp-case/)} - [**Dead Rising 2: Case Zero — an Xbox 360 XBLA static recompilation port**](https://github.com/wivi514/Dead_Rising_2_Case_Zero_Xenon_Recomp) - Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA game Dead Rising 2: Case Zero by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dead-rising-2-case-zero-recomp-case/)} - [**Devil May Cry: an experimental PS2 static recompilation**](https://github.com/Gui-Tora/dmc-recomp) - dmc-recomp translates the PlayStation 2 PAL release of Devil May Cry into native PC code through PS2Recomp and a project runtime. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dmc-recomp-case/)} - [**DKC1Recomp: static recompilation of Donkey Kong Country**](https://github.com/elliotttate/DKC1Recomp) - Statically recompiles the North American v1.0 SNES release of Donkey Kong Country into native Windows, macOS and iOS applications with a pinned fork of snesrecomp, which translates 65816 code to C and links it against a modelled SNES hardware runtime. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dkc1-recomp-case/)} - [**DOAXVB Native PC Port: statically recompiling Dead or Alive Xtreme Beach Volleyball**](https://github.com/NoRain211/doaxvb-re) - Lifts the original Xbox executable of Dead or Alive Xtreme Beach Volleyball to C with a fork of xboxrecomp and links it with a hand-written runtime that replaces kernel imports, audio and key Direct3D 8 and DirectSound APIs. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/doaxvb-native-port-case/)} - [**Donkey Kong 64: Recompiled — an N64Recomp native port**](https://github.com/Rainchus/Donkey-Kong-64-Recompiled) - Uses N64Recomp to statically recompile the US Nintendo 64 release of Donkey Kong 64 into a native port, with RT64 as the renderer. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dk64-recompiled-case/)} - [**Driver Recompiled: a psxrecomp setup host that builds the game locally**](https://github.com/alexbeavs-ps1-ports/driver-recomp) - Packages a psxrecomp static-recompilation project for Driver (PlayStation, USA) as a setup host: releases carry the recompiler, runtime and a recomp-ui launcher, and the player’s machine generates and compiles the game from the user’s own disc image. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/driver-recomp-setup-host-case/)} - [**FFTARecomp: static recompilation of Final Fantasy Tactics Advance**](https://github.com/Jorge262007/FFTARecomp) - Recompiles the user’s Final Fantasy Tactics Advance (USA) Game Boy Advance ROM ahead of time into native code for Windows, Linux and Steam Deck, building on JRickey’s gba-recomp toolkit. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/fftarecomp-gba-static-recomp-case/)} - [**God of War PS2 static recompilation: a native Windows port via PS2Recomp**](https://github.com/KIexster/god-of-war-recomp) - Statically recompiles the MIPS R5900 code of the NTSC-U PlayStation 2 God of War executable (SCUS-97399) to C++ with PS2Recomp and builds it as a native Windows program. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/god-of-war-ps2-recomp-case/)} - [**IsaacRecomp: translating Flash game bytecode to native C++**](https://github.com/whylurking/IsaacRecomp) - Translates The Binding of Isaac’s Flash AVM1 bytecode into C++ functions and supplies a native rendering/input runtime. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/isaacrecomp-case/)} - [**KartPad: platform integration for a Mario Kart Wii recompilation**](https://github.com/chrissotraidis/kartpad) - 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. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/kartpad-case/)} - [**King Kong Recompiled: an AI-developed Xbox 360 static recompilation**](https://github.com/TekRantGaming/king-kong-recompiled) - Translates the Xbox 360 release of Peter Jackson's King Kong into native Windows code with the ReXGlue static-recompilation SDK, adding a launcher and display, control and graphics options. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/king-kong-recompiled-case/)} - [**LASRecomp: Link’s Awakening static recompilation**](https://github.com/peiikai/LASRecomp) - A native desktop reconstruction of the 2019 Switch version of Link’s Awakening using static recompilation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lasrecomp/)} - [**Little Planet: Sonic CD recompiled from a matching disassembly**](https://github.com/carlosrmz009/littleplanet) - Disassembles every executable file on the Sonic CD disc from runtime coverage and recursive descent, reassembles them byte-identically, and translates the code statically to C on a from-scratch Mega-CD runtime that replaces the BIOS with a high-level implementation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/little-planet-sonic-cd-recomp-case/)} - [**Lost Odyssey Recomp: statically recompiling an Xbox 360 RPG into native ports**](https://github.com/freefrank/LostOdysseyRecomp) - Translates Lost Odyssey’s Xbox 360 PowerPC executable with patched XenonRecomp tooling and runs the generated code on a native runtime that renders through Direct3D 12, Vulkan or Metal. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lost-odyssey-recomp-case/)} - [**MarioKart 64: Recompiled — a native port through N64Recomp static recompilation**](https://github.com/sonicdcer/MarioKart64Recomp) - Statically recompiles the US Nintendo 64 release of Mario Kart 64 into a native Windows, Linux and macOS application with N64Recomp, rendering through RT64. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mariokart64-recompiled-case/)} - [**MediEvil Recomp: a PlayStation static recompilation to C#**](https://github.com/BlackLabelHQ/MediEvilRecomp) - Statically recompiles the North American PlayStation release of MediEvil into C# with the RecompOne recompiler and runtime. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/medievil-recomp-case/)} - [**Mega Man X Recompiled: a snesrecomp static recompilation**](https://github.com/mstan/MegaManXSNESRecomp) - Statically translates the 65816 CPU code of the SNES Mega Man X (USA Rev 1) to C with the snesrecomp framework; the PPU, audio, DMA and other hardware run in the framework’s runtime, and a LakeSnes-derived interpreter executes whatever the static pass cannot prove. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/megaman-x-snes-recomp-case/)} - [**Melee Unlocked: a Windows source port and static recompilation of Melee**](https://github.com/Hero88go/melee-unlocked) - A beta Windows build of Super Smash Bros. Melee (NTSC 1.02) with two engines: a source port that compiles the doldecomp decompilation as a native library, and a static recompilation that translates the retail DOL's PowerPC code and Slippi's Gecko codes into C++. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/melee-unlocked-case/)} - [**Pinyon Shift: a ShiftGlue static recompilation of Forza Horizon for PC**](https://github.com/arcanite24/pinyon-shift) - Builds a native port of the Xbox 360 release of Forza Horizon by translating its PowerPC executable ahead of time into C++ with ShiftGlue, the author’s fork of ReXGlue, and compiling it on the player’s machine from their own disc. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pinyon-shift-forza-horizon-recomp-case/)} - [**Project Arwing (2): Star Fox 2 recompiled from a matching disassembly**](https://github.com/carlosrmz009/arwing2) - Rebuilds Star Fox 2 from a coverage-seeded 65816 and SuperFX disassembly that reassembles to the original ROM, then translates it statically to C for native Windows, macOS and Linux builds. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/project-arwing-2-star-fox-2-recomp-case/)} - [**Project Arwing: Star Fox recompiled from a matching disassembly**](https://github.com/carlosrmz009/arwing) - Disassembles Star Fox’s 65816 and SuperFX code from runtime coverage and recursive descent, reassembles it into the original ROM, then translates it statically to C on a from-scratch SNES runtime for Windows, macOS and Linux. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/project-arwing-star-fox-recomp-case/)} - [**RaceWave46: an AI-assisted Wave Race 64 recompilation for Windows**](https://github.com/DomazinUS/RaceWave46) - Recompiles the USA Rev 1 Nintendo 64 release of Wave Race 64 into a native Windows application with N64Recomp and RSPRecomp, on modified copies of the N64ModernRuntime, RecompFrontend and RT64 stacks. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/racewave46-wave-race-64-recomp-case/)} - [**Saints Reborn: a ReXGlue static recompilation of Saints Row**](https://github.com/whompay/SaintsReborn) - An unofficial native Windows port of Saints Row (Xbox 360, 2006) that statically recompiles the game's PowerPC executable to C++ for x86-64 with the ReXGlue SDK, which also reimplements the console's kernel, GPU (on Direct3D 12), audio and input. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/saints-reborn-recomp-case/)} - [**Savage Wind Recomp: statically recompiling The Legend of Zelda: Breath of the Wild**](https://github.com/Revivedx/SavageWindRecomp) - Savage Wind Recomp is an in-progress static recompilation of the Nintendo Switch version of The Legend of Zelda: Breath of the Wild for Windows and Linux. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/savagewindrecomp/)} - [**SF2Recomp: statically recompiling Shadow Fight 2 for native platforms**](https://github.com/bipinkrish/sf2recomp) - SF2Recomp converts a user's Shadow Fight 2 Nintendo Switch game files into native builds for Linux, Windows, macOS, and Android. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sf2recomp-case/)} - [**Sin & Punishment: a work-in-progress N64 static recompilation**](https://github.com/maximilianoide/sin-punishment-recompiled) - Sin & Punishment: Recompiled uses N64Recomp and RSPRecomp to build an experimental native C++ port from a user-supplied Japanese N64 ROM and the repository's symbol maps, with RT64 rendering. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sin-punishment-recompiled-case/)} - [**Skate 3 Recomp: a native Xbox 360 recompilation through ReXGlue**](https://github.com/mchughalex/skate3recomp) - Recompiles the Xbox 360 version of Skate 3 into native Windows, Linux and macOS builds with a Skate-specific fork of the ReXGlue SDK. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/skate3-recomp-case/)} - [**Snap64 Recomp: a static-recompilation port of Pokémon Snap**](https://github.com/JackandBeans/Snap64Recomp) - Uses N64Recomp to statically recompile the US Nintendo 64 release of Pokémon Snap into a native Windows, Linux, Steam Deck and macOS port rendered with RT64. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/snap64-recomp-case/)} - [**SpeedBreaker: statically recompiling Need for Speed: Most Wanted for Xbox 360**](https://github.com/SpeedBreakerProject/speedbreaker) - Translates the Xbox 360 executable of Need for Speed: Most Wanted (2005) into native C++ with a patched XenonRecomp and runs it on a project runtime that stands in for the console’s kernel, Xenos GPU, XMA audio and controllers. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/speedbreaker-nfs-most-wanted-case/)} - [**Spider-Man 2 PS2 Recomp: a static recompilation checkpoint**](https://github.com/saltyboosack-blip/Spider-Man-2-PS2-Recomp) - Spider-Man 2 PS2 Recomp applies static recompilation to the USA PlayStation 2 release SLUS-20776 for native PC execution. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/spider-man-2-ps2-recomp-case/)} - [**ssbu-recomp: static recompilation with explicit mode limits**](https://github.com/Denkishi/ssbu-recomp) - Translates Super Smash Bros. Ultimate 13.0.4 AArch64 code ahead of time and supplies a Windows runtime with Vulkan/OpenGL rendering. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ssbu-recomp-case/)} - [**Starfox 64: Recompiled — an N64Recomp static-recompilation port**](https://github.com/sonicdcer/Starfox64Recomp) - Uses N64: Recompiled to statically recompile the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 into a native port for Windows, Linux and macOS, rendered with RT64. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/starfox64-recompiled-case/)} - [**SVR2011-Recomp: a ReXGlue recompilation of WWE SmackDown vs. Raw 2011**](https://github.com/shaneomac1337/SVR2011-Recomp) - Translates the Xbox 360 executable of WWE SmackDown vs. Raw 2011 to C++ ahead of time with ReXGlue and builds it as a Windows program on a Vulkan runtime derived from Xenia. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/svr2011-recomp-case/)} - [**SymphonyRecomp: a RecompOne static recompilation of Symphony of the Night**](https://github.com/BlackLabelHQ/SymphonyRecomp) - Statically recompiles the North American PlayStation release of Castlevania: Symphony of the Night into C# with BlackLabelHQ’s RecompOne, whose runtime simulates the BIOS, memory-mapped I/O, GPU and CD-ROM so the game runs natively without a console BIOS. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/symphonyrecomp-case/)} - [**The Darkness Recomp: an Xbox 360 static recompilation with a native D3D11 renderer**](https://github.com/portingpete/The-Darkness-Recomp) - Builds a native Windows x64 port of The Darkness by translating its Xbox 360 executable to C++ ahead of time with a patched XenonRecomp. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/the-darkness-recomp-case/)} - [**The Simpsons Wrestling Recompiled: a psxrecomp PlayStation static recompilation**](https://github.com/TekRantGaming/simpsons-wrestling-recompiled) - Translates the PlayStation game’s MIPS code to C with a pinned psxrecomp fork and builds Windows and Linux programs on its hardware-modelling runtime, with a launcher and a game-specific plugin. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/simpsons-wrestling-recompiled-case/)} - [**The Two Towers Recompiled: an original Xbox static-recompilation port**](https://github.com/Gumpolas/TooTawersRecomp) - Statically recompiles the x86 code of The Lord of the Rings: The Two Towers (Xbox, USA, 2002) into C with the bundled xboxrecomp toolkit, producing native Windows, Linux and experimental macOS builds. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/two-towers-recompiled-case/)} - [**Unleashed Recompiled: translating Xbox 360 game code and shaders**](https://github.com/hedge-dev/UnleashedRecomp) - Builds an unofficial Sonic Unleashed PC port by statically recompiling Xbox 360 PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/unleashed-recompiled-case/)} - [**Weeping of the Empire: statically recompiling Tears of the Kingdom for Windows**](https://github.com/daniel-madrid-07/weeping-of-the-empire) - Weeping of the Empire builds a native Windows port of The Legend of Zelda: Tears of the Kingdom from the user's Switch game dump. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/weeping-of-the-empire-case/)} - [**Wind Waker HD Recomp: a native port by static recompilation of the Wii U game**](https://github.com/ZeldaWWHDRecomp/ZeldaWWHDRecomp) - Statically recompiles The Wind Waker HD’s Wii U PowerPC code to C ahead of time, reimplements the Cafe OS libraries the game uses and implements GX2 graphics on Metal or Vulkan, producing native macOS, Linux, Windows and Android builds without a Cemu runtime. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wind-waker-hd-recomp-case/)} - [**Zelda 64: Recompiled — a native Majora’s Mask port without a full source decompilation**](https://github.com/Zelda64Recomp/Zelda64Recomp) - Uses N64Recomp to translate Majora’s Mask into a native application and RT64 for rendering. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zelda64recomp-case/)} ### Ports of reconstructed source (33) - [**2 Ship 2 Harkinian: a native Majora’s Mask port built on the decompilation**](https://github.com/2ship2harkinian/2ship2harkinian) - Builds native Windows, Linux and macOS versions of The Legend of Zelda: Majora’s Mask from an adapted copy of the zeldaret/mm decompilation, with libultraship reimplementing N64 SDK functions. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/2ship2harkinian-mm-port-case/)} - [**3SX: a native Street Fighter III: 3rd Strike port continuing the PS2 decompilation**](https://github.com/crowded-street/3sx) - Builds Street Fighter III: 3rd Strike as native C for Windows, macOS and Linux, continuing the 3s-decomp PS2 decompilation, with SDL3 for video, input and audio and GekkoNet for rollback netplay. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/3sx-third-strike-native-port-case/)} - [**Animal Crossing: a native PC port of the GameCube decompilation**](https://github.com/flyngmt/ACGC-PC-Port) - Runs Animal Crossing’s decompiled GameCube C code natively on 32-bit x86, replacing the GX graphics API with an OpenGL 3.3 translation layer and console services with SDL2-based platform code. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/animal-crossing-pc-port-case/)} - [**Atlantis Native: porting the Atlantis and Atlantis II engines to Rust**](https://github.com/ripleyXLR8/atlantis-native) - Atlantis Native ports the reverse-engineered CryOmni3D Atlantis engine to Rust for Atlantis: The Lost Tales and Atlantis II. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/atlantis-native-case/)} - [**BattleShip: an AI-assisted Super Smash Bros. native port**](https://github.com/JRickey/BattleShip) - Ports the existing Super Smash Bros. N64 decompilation using libultraship and Torch. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/battleship-port-case/)} - [**Budokai Tenkaichi 3: a native PC port built on a matching decompilation**](https://github.com/z3xox/Tenkaichi3Decomp) - Compiles the decompiled code of Dragon Ball Z: Budokai Tenkaichi 3 (PS2, USA release SLUS-21678) for PC on a new renderer, sound, input and platform layer rather than an emulator. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/tenkaichi3-pc-port-case/)} - [**Cosmo: a native port of Cosmo's Cosmic Adventure**](https://github.com/digows/cosmo) - Cosmo ports the reconstructed source of Cosmo's Cosmic Adventure: Forbidden Planet to macOS, Linux and Windows. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cosmo-native-port-case/)} - [**CTR Turbocharged: a PC sourceport built on the Crash Team Racing decompilation**](https://github.com/CameronRedmore/Crash-Team-Racing-Turbocharged) - Extends the Crash Team Racing: High Octane sourceport, which derives from the CTR Native port of the CTR-ModSDK PlayStation decompilation, into Windows and Linux builds with a native 3D renderer, selectable aspect ratios and frame rates up to 240 FPS. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ctr-turbocharged-port-case/)} - [**d2mac-linux: porting the Diablo II Mac executable to 32-bit Linux**](https://github.com/jaenster/d2mac-linux) - d2mac-linux ports the Diablo II 1.14d Mac executable to 32-bit Linux by converting its i386 Mach-O container to ELF and reimplementing imported Darwin, Carbon and AGL interfaces in Zig. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/d2mac-linux-case/)} - [**DevilutionX: porting Diablo’s reconstructed engine**](https://github.com/diasurgical/DevilutionX) - Builds a modern Diablo and Hellfire port on the Devilution reconstruction, with platform support, bug fixes and optional quality-of-life features. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/devilutionx-case/)} - [**DiabloWeb: a WebAssembly browser port built on Devilution**](https://github.com/d07RiV/diabloweb) - Runs Diablo in web browsers by compiling a stripped-down fork of Devilution, the community reconstruction of the game’s original source, to WebAssembly behind a React front end. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/diabloweb-devilution-wasm-port-case/)} - [**Dusklight: a native Twilight Princess port built on the decompilation**](https://github.com/TwilitRealm/dusklight) - Reimplements Twilight Princess as a native application for desktop and mobile platforms, building on the zeldaret/tp decompilation and the Aurora GameCube/Wii compatibility layer. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dusklight-twilight-princess-port-case/)} - [**Ghostship: a libultraship native port of Super Mario 64**](https://github.com/HarbourMasters/Ghostship) - Builds Super Mario 64 as a native PC, Switch and Android program by compiling decompilation-style game source against the libultraship platform library. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ghostship-sm64-port-case/)} - [**GoldenEye 007: an agent-assisted native port from a decompilation**](https://github.com/jkdansereau/goldeneye-pc-port) - Builds a native PC port on the existing GoldenEye 007 decompilation, with a host platform layer and assets extracted from the user’s ROM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/goldeneye-pc-port-case/)} - [**ico-pc: a native ICO port compiled from the PS2 decompilation**](https://github.com/nathanialf/ico-pc) - Compiles the decompiled C of the PlayStation 2 game ICO natively for Windows, Linux, Android, iPhone and Apple-silicon Macs, with host code standing in for the PS2 hardware and Sony libraries. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ico-pc-port-case/)} - [**Kingdom Hearts 358/2 Days: native PC port built on a matching decompilation**](https://github.com/Yokimitsuro/khdays-port) - Compiles the C of the khdays-decomp matching decompilation for Windows x64 and supplies a native platform layer for the Nintendo DS hardware, SDK services and sound driver. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/khdays-native-pc-port-case/)} - [**LEGO Island, portable: a multi-platform port of the decompiled source**](https://github.com/isledecomp/isle-portable) - Adapts the LEGO Island decompilation into a portable build for desktop, mobile, console, DOS and Web targets. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lego-island-portable-case/)} - [**Lighthouse: a Banjo-Kazooie PC port built on the decompilation**](https://github.com/HarbourMasters/Lighthouse) - A native Windows, Linux and macOS port of Banjo-Kazooie that compiles game C sources, many tagged with their Banjo-Kazooie decompilation file paths, against libultraship, a reimplementation of the N64 SDK. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lighthouse-banjo-kazooie-port-case/)} - [**LineWars II: a portable SDL3 reconstruction**](https://github.com/fredangstadt-lang/LineWarsII-SDL) - Provides an SDL3 backend for a portable-C reconstruction of the 1994 DOS game. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/linewars-ii-sdl-case/)} - [**Metaforce: a Metroid Prime engine reimplementation rebuilt on the decompilation**](https://github.com/AxioDL/metaforce) - Started in 2015 as a reverse-engineered reimplementation of the Metroid Prime engine, Metaforce has been rewritten on top of the PrimeDecomp matching decompilation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/metaforce-metroid-prime-case/)} - [**Metroid Prime Port: an AI-assisted native port of the PrimeDecomp decompilation**](https://github.com/Odrannnn/MetroidPrimePort) - Compiles the PrimeDecomp decompilation of Metroid Prime’s game and engine code as native C++20 for Linux, Windows and Android, with an experimental macOS build. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/metroid-prime-port-case/)} - [**MikuPan: a native Fatal Frame PC port built on the Himuro decompilation**](https://github.com/Mikompilation/MikuPan) - Ports the PS2 game Fatal Frame to native PC builds without emulation; its repository description names the Himuro decompilation as its basis. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mikupan-fatal-frame-port-case/)} - [**PaperBoat: a native Paper Mario port built on the decompilation**](https://github.com/HarbourMasters/PaperBoat) - Compiles Paper Mario decompilation sources, credited to the pmret and Paper Mario DX projects, into a native US-version application on libultraship. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/paperboat-paper-mario-port-case/)} - [**Pokémon Platinum PC Port: a native port built on the pret decompilation**](https://github.com/cybervisi0n/pokeplatinum) - Builds native 64-bit Windows and Linux executables of Pokémon Platinum from a fork of pret’s decompilation, replacing NitroSDK with the author’s libntr libraries; the same tree keeps the DS ROM build and an experimental Switch target. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pokemon-platinum-pc-port-case/)} - [**Salamander UEFI: a disassembly-based UEFI port of the NES game**](https://github.com/MikeWuPing/UEFI_Salamander) - Salamander UEFI ports the NES game Salamander to a native UEFI Shell application by translating its 6502 disassembly into a platform-independent C core. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/salamander-uefi-case/)} - [**Ship of Harkinian: a native Ocarina of Time port built on the decompilation**](https://github.com/HarbourMasters/Shipwright) - Builds Ocarina of Time as a native PC application from the OoT decompilation’s source, with libultraship standing in for the N64 libultra SDK and DirectX 11, OpenGL or Metal rendering. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ship-of-harkinian-oot-port-case/)} - [**sm64ex: an enhanced Super Mario 64 PC port from the decompilation**](https://github.com/sm64pc/sm64ex) - Builds native Super Mario 64 executables from decompiled source, extending the sm64-port fork of the n64decomp reconstruction with renderer, input, camera, save-format and external-data options. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sm64ex-pc-port-case/)} - [**SpaghettiKart: a native Mario Kart 64 port built on decompiled source**](https://github.com/HarbourMasters/SpaghettiKart) - Builds a native Mario Kart 64 port for Windows, Linux, macOS and Switch from source that keeps the Mario Kart 64 decompilation’s file layout, running on libultraship’s reimplemented N64 SDK. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/spaghettikart-mk64-port-case/)} - [**Starship: a Star Fox 64 PC port built from the decompilation**](https://github.com/HarbourMasters/Starship) - A native PC port of Star Fox 64 that compiles the game's decompiled C code against libultraship, an N64 porting library that reimplements libultra and renders through Fast3D. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/starship-sf64-pc-port-case/)} - [**Super Mario Sunshine: a native PC port from an AI-assisted decompilation**](https://github.com/chasem-dev/sms-pc-port) - Builds a native PC port of Super Mario Sunshine’s North American release from a pinned matching-decompilation fork, adding a host platform layer for graphics, disc, audio, input and OS services. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sms-pc-port-case/)} - [**TH08 Web: a WebAssembly port built from reconstructed source**](https://github.com/N0zoM1z0/th08-web) - Compiles the reconstructed C++ source of the Japanese Touhou 8 1.00d release to WebAssembly with Emscripten, adding WebGL 2 rendering, Web Audio, browser input and IndexedDB saves behind the game’s D3D8-, DirectSound- and DirectInput-shaped interfaces. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/th08-web-wasm-port-case/)} - [**TonyWasAProSkater: a THPS1 native port forked from a matching decompilation**](https://github.com/LANCommander/TonyWasAProSkater) - Ports Tony Hawk’s Pro Skater (PlayStation, USA) to native Windows and Linux builds from a fork of an in-progress matching decompilation of the retail executable. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/thps1-decomp-native-port-case/)} - [**Vandal Hearts: native PC port built on matching decompilations**](https://github.com/HalmyLyseas/VandalHearts-PcPort) - Builds on shao113’s matching decompilation of PlayStation Vandal Hearts, adds a Japanese matching tree, and carries both through to a native Windows and Linux port. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/vandal-hearts-pc-port-case/)} ### Engine reimplementations (47) - [**Age of Empires Free Software Remake: a re-implementation on the original data**](https://github.com/FolkertVanVerseveld/aoe) - Re-implements Microsoft’s Age of Empires and its Rise of Rome expansion as a cross-platform C++17 engine on SDL2 and OpenGL that loads the original game’s DRS archives and language.dll resources. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/aoe-free-software-remake-case/)} - [**Bravo: a reverse-engineered Minecraft server**](https://github.com/bravoserver/bravo) - Reimplements the server side of Minecraft’s Alpha- and Beta-era multiplayer in Python on Twisted; its documentation calls it a reverse-engineered implementation written from scratch, credits network traffic dumps and says general Minecraft data went to a community wiki. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/bravo-minecraft-server-case/)} - [**Chariot: Age of Empires engine reimplementation**](https://github.com/ChariotEngine/Chariot) - Chariot is an open-source effort to reimplement the engine of the original Age of Empires (1997). _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/chariot/)} - [**CoD4 Rewrite: Rust/Bevy reconstruction**](https://github.com/Nilbong/COD4-Rewrite) - A Rust/Bevy reconstruction of Call of Duty 4 multiplayer systems, using assets from a local game installation. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/cod4-rewrite-reconstruction-case/)} - [**CorsixTH: an open reimplementation of Theme Hospital**](https://github.com/CorsixTH/CorsixTH) - Reimplements the engine of Bullfrog’s 1997 Theme Hospital, with game logic in Lua and C++ for graphics, sound, movies and pathfinding, on top of the original game’s data files. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/corsixth-engine-case/)} - [**Cursed Lands: a Godot engine for Evil Islands and Lost in Astral**](https://github.com/TheWWWorm/CursedLands) - Cursed Lands reimplements the engine for Evil Islands and Lost in Astral in Godot, reading maps, models, audio, scripts and tables from the player's own game copy. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cursed-lands-case/)} - [**Desktop Games Nostalgia: a macOS and browser port**](https://github.com/ucodia/desktop-games-nostalgia) - A Swift/macOS and JavaScript/browser port recreates the Desktop Games screen-smashing toy from a captured image. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/desktop-games-nostalgia-rea-port-case/)} - [**FreeRS42: reimplementing Ricochet Xtreme**](https://github.com/NuVelocity/FRS42) - FreeRS42 is a C++ project to reimplement the PC game Ricochet Xtreme using the NuVelocity engine. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/freers42-ricochet-xtreme-case/)} - [**GunZRs: a Rust reimplementation of GunZ: The Duel**](https://github.com/OpenRsG/GunZRs) - A Rust/Bevy port reads GunZ: The Duel files from the user's installation and provides native releases, browser build tooling, screenshots and a documented REA/Ghidra investigation framework. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/gunzrs-rea-rust-reimplementation-case/)} - [**Horizon: a Rust rewrite of Minecraft: Java Edition 26.3 with REA bytecode queries**](https://github.com/ludovic111/horizon) - 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. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/horizon-minecraft-rust-rewrite-case/)} - [**impacto: a reimplementation of the MAGES. visual-novel engine**](https://github.com/CommitteeOfZero/impacto) - Reimplements the MAGES. visual-novel engine, used by the Science Adventure and Memories Off series, in C++ with OpenGL, running supported titles from the user’s original data files through per-game Lua profiles in one binary. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/impacto-mages-engine-case/)} - [**IW4L: a Rust runtime that plays Modern Warfare 2 from the user’s installed game**](https://github.com/vladtrc/iw4L) - Implements a standalone runtime for Call of Duty: Modern Warfare 2 (2009) in Rust on Bevy and wgpu, loading maps, models, textures and weapons from the user’s installed game through native FastFile readers and translating its Direct3D 9 shaders to WGSL. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/iw4l-mw2-rust-runtime-case/)} - [**Jazz² Resurrection: a native C++ reimplementation of Jazz Jackrabbit 2**](https://github.com/deathkiller/jazz2-native) - Reimplements Jazz Jackrabbit 2 (1998) as a native C++ game on an extensively modified nCine engine, converting the user’s original game files into its own cache on first start. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/jazz2-resurrection-engine-case/)} - [**Kinoko: reimplementing Mario Kart Wii’s physics engine for exact ghost replay**](https://github.com/vabold/Kinoko) - Re-implements Mario Kart Wii’s physics engine in C++ as a command-line simulator, continuing stblr/Hanachan’s goal of perfectly accurate time-trial ghost replay. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/kinoko-mkwii-physics-reimplementation-case/)} - [**LBA2 Remake: a Little Big Adventure 1 and 2 reimplementation in TypeScript and Three.js**](https://github.com/LBALab/lba2remake) - Reimplements the engine of Little Big Adventure 2, and now also Little Big Adventure 1, in TypeScript, Three.js and React so that it runs in a browser on resources imported from the user’s copy of the game. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lba2remake-little-big-adventure-case/)} - [**Legend of Legaia: a Rust port with disc-local browser tooling**](https://github.com/AndrewAltimit/legend-of-legaia-re) - A from-scratch Rust port of the North American PlayStation Legend of Legaia includes native/browser play, asset extraction and disc patching. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/legend-of-legaia-rust-port-case/)} - [**libd2: Diablo II 1.14d engine-core libraries**](https://github.com/jaenster/libd2) - Zig libraries reconstructing Diablo II 1.14d seeded maps, item generation, saves, simulation rules and network formats. _{Case study · Independent reconstruction · Also: Binary, Protocol · [Full entry](https://awesomerea.org/resources/libd2-engine-core-reconstruction-case/)} - [**librw: a re-implementation of the RenderWare Graphics engine**](https://github.com/aap/librw) - Re-implements a large part of the RenderWare Graphics middleware API as a portable C++ library that reads and writes its DFF model and TXD texture files for PS2, D3D8, D3D9 and Xbox and is meant to convert them between platforms. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/librw-renderware-reimplementation-case/)} - [**MechRewired: rebuilding MechWarrior 2 from original game data**](https://github.com/deanthecoder/MechRewired) - MechRewired rebuilds the MechWarrior 2: 31st Century Combat experience around data imported from a user's DOS copy. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/mechrewired-mechwarrior-2-case/)} - [**Nanolathe: a documented Total Annihilation engine reimplementation**](https://github.com/nanolathe-gg/nanolathe) - Reimplements a Total Annihilation-compatible strategy-game engine in Go, with public file-format research and separate gameplay profiles. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/nanolathe-case/)} - [**nfs-mw: a Rust reconstruction of Need for Speed: Most Wanted**](https://github.com/47PADO47/nfs-mw) - nfs-mw reconstructs Need for Speed: Most Wanted 2005 PC v1.3 in Rust using data read from the user's installation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/nfs-mw-case/)} - [**NuVelocity Engine: reimplementing Reflexive's Velocity Engine**](https://github.com/NuVelocity/NuVelocity) - NuVelocity Engine reimplements Reflexive Entertainment's Velocity Engine as a C++ and SDL3 game engine. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/nuvelocity-engine-case/)} - [**OpenAWE: an open reimplementation of Remedy’s Alan Wake engine**](https://github.com/OpenAWE-Project/OpenAWE) - Reimplements Remedy Entertainment’s Alan Wake engine, later known as Northlight, in C++ and OpenGL, aiming to run Alan Wake and Alan Wake’s American Nightmare portably from the user’s game data, with Quantum Break and possibly Control as later goals. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openawe-alan-wake-engine-case/)} - [**OpenBattlefield2: an unfinished Refractor 2 engine reimplementation**](https://github.com/Moxnatiy/OpenBattlefield2) - A C++20 reimplementation of Battlefield 2’s Refractor 2 engine reads original game data and documents menu rendering, level loading and server interoperability. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/openbattlefield2-refractor-engine-case/)} - [**OpenDiablo2: Diablo 2 engine reimplementation**](https://github.com/OpenDiablo2/OpenDiablo2) - OpenDiablo2 is a cross-platform ARPG engine written in Go that supports playing Diablo 2. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opendiablo2/)} - [**OpenLara: Tomb Raider engine reimplementation**](https://github.com/XProger/OpenLara) - Open-source engine for classic Tomb Raider, with a WebGL build and a standalone release. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openlara/)} - [**OpenLF2: a Little Fighter 2 engine reimplementation**](https://github.com/OpenLF2/OpenLF2) - OpenLF2 reimplements Little Fighter 2 v2.0a as a playable C++ and Lua engine. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openlf2-case/)} - [**OpenMW: replacing Morrowind’s engine while reusing original content**](https://github.com/OpenMW/openmw) - Provides an independent engine for playing Morrowind and an alternative editor, OpenMW-CS. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openmw-engine-case/)} - [**OpenRA: an engine reimplementation reimagining early Westwood RTS games**](https://github.com/OpenRA/OpenRA) - Provides a C# engine for early Westwood real-time strategy games, with mods that reimagine Command & Conquer: Red Alert, Tiberian Dawn and Dune 2000. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openra-engine-case/)} - [**OpenRCT2: an open re-implementation of RollerCoaster Tycoon 2**](https://github.com/OpenRCT2/OpenRCT2) - Re-implements RollerCoaster Tycoon 2, originally written in x86 assembly, as a C++ engine that runs on the original game’s data. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openrct2-engine-case/)} - [**OpenRiseOfNations: a native macOS engine reimplementation**](https://github.com/ben-wright-1/OpenRiseOfNations) - Reimplements the Rise of Nations: Extended Edition engine as a native macOS app with a Metal renderer, a deterministic simulation, a computer opponent and a compatible BigHugeScript compiler and virtual machine, loading art, maps, rules and scripts from the user’s own Windows installation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openriseofnations-engine-case/)} - [**OpenRW: an open re-implementation of the Grand Theft Auto III engine**](https://github.com/rwengine/openrw) - Re-implements Rockstar Games’ Grand Theft Auto III (2001) as a cross-platform C++ engine that runs on the data of a legitimate PC copy. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openrw-gta3-engine-case/)} - [**OpenSC4: an early open-source reimplementation of SimCity 4**](https://github.com/OpenSC4-org/OpenSC4) - Reimplements SimCity 4 as a Godot project in GDScript that reads DBPF archives, region folders and city saves from the user’s own SimCity 4 installation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opensc4-simcity-4-reimplementation-case/)} - [**OpenTomb: Tomb Raider engine reimplementation**](https://github.com/opentomb/OpenTomb) - OpenTomb is an open-source reimplementation of the classic Tomb Raider engine for playing levels from Tomb Raider 1–5 and custom TRLE levels. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opentomb/)} - [**OpenXcom: an open-source clone of X-COM: UFO Defense and Terror from the Deep**](https://github.com/OpenXcom/OpenXcom) - Reimplements MicroProse’s UFO: Enemy Unknown (X-COM: UFO Defense) and X-COM: Terror from the Deep as a C++/SDL engine that runs on the user’s original game resources. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openxcom-engine-case/)} - [**P.T. for PC: a behavior-based engine reimplementation that reads the PS4 data**](https://github.com/LoreanXavier/pt-pc) - Reimplements P.T.’s game logic in C++ on a new Vulkan engine that reads levels, models, textures, sounds, scripts and cutscenes from the user’s own PS4 copy at run time. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pt-pc-port-case/)} - [**re2ds: a native Nintendo DS engine for Resident Evil 2**](https://github.com/eray1605/re2ds) - 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. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/re2ds-nds-engine-case/)} - [**San Andreas Unity: a GTA San Andreas engine reimplementation in Unity**](https://github.com/in0finite/SanAndreasUnity) - Reimplements the Grand Theft Auto: San Andreas engine in Unity (C#), loading the archives, RenderWare models and textures, collision, animations, audio, text and item definitions from the user’s own PC installation. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/san-andreas-unity-engine-case/)} - [**sh23ds: a native 3DS reconstruction of Silent Hill 2**](https://github.com/ankushKun/sh23ds) - sh23ds rebuilds Silent Hill 2: Director's Cut as a native C engine for Nintendo 3DS using the player's PC game data. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/sh23ds-case/)} - [**SiegeFX: a Dungeon Siege engine reimplementation in alpha**](https://github.com/codingncaffeine/SiegeFX) - A C#/.NET 10 engine loads Dungeon Siege's original archives, scripts and models, with published alpha builds and an audit/parity ledger. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/siegefx-dungeon-siege-engine-case/)} - [**Skate 3 Rust Engine: a Bevy rewrite built on Skate 3 reverse-engineering research**](https://github.com/SK8-ENGINE/skate-3-rust-engine) - Reimplements Skate 3’s skating, tricks, grinds and offboard movement in a new Rust and Bevy engine that runs on assets converted from the user’s own Xbox 360 copy, adding difficulty settings and a .skate custom-map format. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/skate-3-rust-engine-case/)} - [**Snowball War: a bounded REA-assisted minigame reconstruction**](https://github.com/tuunanet/rea-ski-or-die-reconstruction) - 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. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/snowball-war-rea-case/)} - [**Thyme: Command & Conquer Generals: Zero Hour reimplementation**](https://github.com/TheAssemblyArmada/Thyme) - Thyme is an open source reimplementation of Command & Conquer Generals: Zero Hour. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/thyme/)} - [**touhou-engine: a Python reimplementation of Touhou gameplay**](https://github.com/SaigyoujYuyuko/touhou-engine) - touhou-engine reimplements Touhou danmaku gameplay in Python, with TH07: Perfect Cherry Blossom as its reference game. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/touhou-engine-case/)} - [**Untangle: a browser rebuild from REA and Ghidra evidence**](https://github.com/az9713/untangle-rebuild) - 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. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/untangle-rea-evidence-rebuild-case/)} - [**xoreos: an open reimplementation of BioWare’s Aurora engine family**](https://github.com/xoreos/xoreos) - Reimplements BioWare’s Aurora engine and its later derivatives as a portable C++ engine that runs on the user’s installed game data, targeting nine games from Neverwinter Nights to Dragon Age II. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/xoreos-aurora-engine-case/)} - [**z2rs: an incremental Rust reconstruction of Zelda II checked against an emulator**](https://github.com/troyedwardsjr/z2rs) - Rebuilds Zelda II: The Adventure of Link (NES) in Rust for desktop, browser and Android by replacing the game’s 6502 routines one at a time. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/z2rs-zelda2-reconstruction-case/)} ### Other methods and analyses (23) - [**ArkWeb: a two-game movement and collision experiment**](https://github.com/luki-1/ArkWeb) - Runs Spider-Man Remastered and Arkham Knight together, streaming Gotham collision into Spider-Man’s physics world and compositing his rendered frame into Arkham. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/arkweb-two-game-case/)} - [**Batla 3D server emulator (2015 client)**](https://github.com/Serega25511s/Batla-3D-server-emu) - C# server emulator for the 2015 Steam client of Batla 3D, covering HTTP account, shop and room services and Lidgren UDP gameplay. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/batla-3d-server-emulator-case/)} - [**bf-private-server: a Brave Frontier revival server**](https://github.com/joppe2001/bf-private-server) - bf-private-server recreates a self-hosted server for Brave Frontier client version 2.19.6. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/bf-private-server-case/)} - [**D2R Mobile: rehosting Diablo II: Resurrected’s Switch program on Apple devices**](https://github.com/jhaizhou-ops/d2r-mobile) - Runs the Nintendo Switch release’s own aarch64 program natively on iPhone, iPad and Apple silicon Macs, rewriting only instructions that depend on the Horizon kernel and supplying its system services and the NVN graphics API on Metal. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/d2r-mobile-switch-rehost-case/)} - [**Destiny 2 build 86657: Sunrise/Dawn reconstruction research report**](https://github.com/isinternets/d2-research) - A dated research report on the Sunrise/Dawn reconstruction of the archived Destiny 2 build 86657 client, which emulates platform sign-on and the examined Bungie service contracts locally and adds reconstructed mission host policy. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/destiny2-build-86657-reconstruction-report-case/)} - [**DLSSNR-AMD: reimplementing DLSS 5 neural rendering for RDNA4**](https://github.com/mochizuki0323/DLSSNR-AMD) - Reimplements the neural-rendering network of NVIDIA’s DLSS 5 library as Vulkan compute shaders for AMD RX 9000 (RDNA4) cards and supplies it to games through an NGX-compatible core and ReShade or Vulkan-layer routes. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/dlssnr-amd-neural-rendering-case/)} - [**Does reverse engineering need a bigger model? General and specialist models in Touhou reconstruction**](https://rea.tools/blog/reverse-engineering-models/) - An essay on REA’s site by N0zoM1z0 (13 October 2026) uses dated Touhou reconstruction commits to ask whether exact function matching needs a larger general model, a compiler-specialist model or better retrieval. _{Case study · Official REA · Also: Binary · [Full entry](https://awesomerea.org/resources/rea-bigger-model-essay-case/)} - [**FH2MP: reconstructed Forza Horizon 2 online services**](https://github.com/Charelene/FH2MP) - FH2MP restores Forza Horizon 2 multiplayer with a replacement server based on protocol behavior recovered from the Xbox One game client. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/fh2mp-case/)} - [**game-and-watch-patch: Nintendo Game & Watch custom firmware**](https://github.com/BrianPugh/game-and-watch-patch) - Custom firmware for the Mario and Zelda Game & Watch consoles that patches new C code into the user's own stock firmware backups, so the original firmware runs alongside the retro-go emulator. _{Case study · Independent reconstruction · Also: Firmware · [Full entry](https://awesomerea.org/resources/game-and-watch-patch-cfw-case/)} - [**GTA Mode: reverse-engineering SimCity 3000 Unlimited for a native plugin**](https://github.com/DenisSergeevitch/simcity3000-gta-mode) - GTA Mode is a native plugin that adds direct control of spawned citizens and cars to SimCity 3000 Unlimited. _{Case study · Also: Binary · [Full entry](https://awesomerea.org/resources/simcity-3000-gta-mode-case/)} - [**inFAMOUS Second Son native PC port**](https://github.com/HayatoG/iss_pc) - Runs the PS4 inFAMOUS Second Son’s own x86-64 code natively on Windows and Linux: a runtime reimplements the PS4 system libraries the game uses, and a shadPS4-derived core translates its GPU commands and shaders to Vulkan. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/infamous-second-son-pc-port-case/)} - [**Left 4 Dead 2: recovering the AI Director's behavior**](https://github.com/zeljkovranjes/l4d2-director-system-research) - This Left 4 Dead 2 study reconstructs the AI Director's pacing, intensity, encounter placement and music rules from an identified x86 server.dll and sanitized runtime traces. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/l4d2-director-research-case/)} - [**MTG Arena Collection Export: reconstructing the Frontdoor collection request**](https://github.com/Ikreb1/mtg-arena-collection-export) - MTG Arena Collection Export reconstructs the Frontdoor request needed to export owned cards from Magic: The Gathering Arena. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/mtg-arena-collection-export-case/)} - [**OpenPigeon: reconstructing GamePigeon iMessage game messages**](https://github.com/time-attack/OpenPigeon) - OpenPigeon is a TypeScript codec for reading GamePigeon iMessage game state and encoding caller-supplied moves for eleven turn-based games. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/openpigeon-case/)} - [**ProjectCane: a native PC port of Sly Cooper and the Thievius Raccoonus**](https://github.com/theclub654/ProjectCane) - Rebuilds the NTSC PlayStation 2 release of Sly Cooper and the Thievius Raccoonus as a native C++ game for Windows and Linux, running on data extracted from the player's own disc image. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/projectcane-sly1-pc-port-case/)} - [**retruxx: reverse-engineered Hard Truck Apocalypse**](https://github.com/mindflower/retruxx) - retruxx is a reverse-engineered Hard Truck Apocalypse project that builds the game executable and separate renderer, input, and sound DLLs. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/retruxx/)} - [**samp-client-re: a partial SA-MP client reconstruction**](https://github.com/NathanKanaeru/samp-client-re) - A documented REA/Ghidra investigation maps SA-MP 0.3.DL-R1 client subsystems to a new C++ DLL, loader and smoke-test executable. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/samp-client-rea-partial-reconstruction-case/)} - [**scvk: replacing SimCity 4's renderer with Vulkan**](https://github.com/aspctt/scvk) - scvk reconstructs SimCity 4's renderer interface as a native Vulkan DLL loaded through the game's GZCOM plugin system. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/scvk-case/)} - [**TH04: recover a DOS bullet-ring helper**](https://rea.tools/showcase/th04/) - Inspect a 16-bit PC-98 DOS helper and relate its angle calculation to a pinned reconstruction and historical compiler checks. _{Case study · Official REA · Also: Binary · [Full entry](https://awesomerea.org/resources/rea-th04-case/)} - [**tMock-Server: reconstructing Terraria server handshakes**](https://github.com/StardustVulpine/tMock-Server) - tMock-Server is an unfinished C++ reimplementation of the Terraria server's initial network flow. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/tmock-server-case/)} - [**Touhou reconstructions: an agent-driven method across three games**](https://rea.tools/blog/touhou-reconstruction/) - An essay published on REA’s site, with pinned evidence notes, describes one author’s agent-driven reconstructions of TH08, TH095 and TH04. _{Case study · Official REA · Also: Binary · [Full entry](https://awesomerea.org/resources/rea-touhou-reconstruction-method-case/)} - [**Uncharted: The Nathan Drake Collection native Windows port**](https://github.com/bc160201983/Uncharted-The-Nathan-Drake-Collection-PC-port) - Runs the PS4 Uncharted: The Nathan Drake Collection’s own x86-64 executables natively on Windows: a runtime supplies the PS4 system libraries and a shadPS4-derived Vulkan renderer executes the GPU work. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/uncharted-collection-pc-port-case/)} - [**Void Client: rebuilding the Starblast.io client**](https://github.com/Senko74/Void-Client) - Void Client is an unfinished JavaScript rewrite of the Starblast.io browser game client based on study of its network protocol. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/void-client-case/)} ## App [↑ Contents](#contents) - [**AOL 7.0 Retro Server: reconstructing the P3 server session**](https://github.com/pioneerman2k1/AOL7-Retro-Server) - AOL 7.0 Retro Server implements local Python servers for the 2001 AOL 7.0 client. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/aol7-retro-server-case/)} - [**Benro Polaris Firmware Patcher: rebuilding camera control and mapping the app protocol**](https://github.com/blaineam/benro-polaris-firmware-patcher) - Benro Polaris Firmware Patcher investigates the Polaris camera controller and repacks a user-supplied firmware image with a newer libgphoto2 stack and targeted pgphoto changes. _{Case study · Independent reconstruction · Also: Firmware, Protocol · [Full entry](https://awesomerea.org/resources/benro-polaris-firmware-patcher-case/)} - [**CADCraft: a clean-room CAD and drafting application in Rust**](https://github.com/storytold/cadcraft) - The authors describe CADCraft as an open-source, clean-room computer-aided design and drafting application built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cadcraft-case/)} - [**Clickwill: reconstructing iPod library database editing**](https://github.com/jakubwarzecha00/clickwill) - Clickwill reconstructs direct editing of iPod classic and iPod nano music libraries in a Swift Mac app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/clickwill-case/)} - [**ddg-tenor-bridge: replacing Gboard's Tenor search endpoint**](https://github.com/hxreborn/ddg-tenor-bridge) - ddg-tenor-bridge redirects Gboard's Tenor GIF searches to a service that returns DuckDuckGo animated-image results in Tenor v2 response form. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ddg-tenor-bridge-case/)} - [**DesignCraft: a clean-room page layout and publishing studio in Rust**](https://github.com/storytold/designcraft) - The authors describe DesignCraft as an open-source, clean-room page layout and desktop publishing studio built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/designcraft-case/)} - [**EffectCraft: a clean-room motion graphics and compositing studio in Rust**](https://github.com/storytold/effectcraft) - The authors describe EffectCraft as an open-source, clean-room motion graphics and visual effects studio built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/effectcraft-case/)} - [**FigCraft: a clean-room interface design and prototyping tool in Rust**](https://github.com/storytold/figcraft) - The authors describe FigCraft as an open-source, clean-room interface design and prototyping tool built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/figcraft-case/)} - [**FilmCraft: a clean-room nonlinear video editor in Rust**](https://github.com/storytold/filmcraft) - The authors describe FilmCraft as an open-source, clean-room nonlinear video editor built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/filmcraft-case/)} - [**grsimwrite-mac: reconstructing GRSIMWrite for macOS**](https://github.com/eliel9012/grsimwrite-mac) - grsimwrite-mac reconstructs the Windows GRSIMWrite 4.4.10 SIM-writing workflow in Python for macOS. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/grsimwrite-mac-case/)} - [**LightCraft: a clean-room photo library and raw developer in Rust**](https://github.com/storytold/lightcraft) - The authors describe LightCraft as an open-source, clean-room non-destructive photo library and raw developer built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lightcraft-case/)} - [**Malware Analysis: a trojanized FL Studio installer and Go stealer**](https://github.com/AllobatesZaparo/malware-analysis) - This malware-analysis report investigates a trojanized FL Studio installer that bundles an Electron/NSIS wrapper and a Go information stealer. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/fl-studio-stealer-analysis-case/)} - [**MSP CSV Export Format: reconstructing My Stocks Portfolio exports**](https://github.com/Izero/msp-csv-format) - MSP CSV Export Format reconstructs the undocumented CSV export of the My Stocks Portfolio & Market app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/msp-csv-format-case/)} - [**OpenTracks: a UWP port of OpenTracks7 BETA1**](https://github.com/mediaexplorer74/OpenTracks) - OpenTracks is an early UWP port of the OpenTracks7 BETA1 Windows Phone music app informed by the author's reverse engineering. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opentracks-uwp-case/)} - [**PdfCraft: a clean-room PDF reader and editor in Rust**](https://github.com/storytold/pdfcraft) - The authors describe PdfCraft as an open-source, clean-room PDF reader and editor built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pdfcraft-case/)} - [**Picture Man: a Rust rebuild of the Windows 3.x image editor**](https://github.com/yovico-ai/pictureman) - A cross-platform Rust rebuild of Picture Man 1.55 (1991-1993), the true-color image editor for Windows 3.x, per the project README. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/pictureman-case/)} - [**RTO eChalan: investigating a BankBot Android APK**](https://github.com/Gautam-CyberSec/Android-Malware-Analysis-Report) - The RTO eChalan report investigates an Android APK impersonating an Indian government eChallan service through manifest review, JADX decompilation and sandbox analysis. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rto-echalan-android-analysis-case/)} - [**Siriously: recovering macOS Writing Tools entry points**](https://github.com/bo2themax/Siriously) - Siriously investigates how macOS 27 changed access to Writing Tools and restores its popover through a Services client. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/siriously-writing-tools-case/)} - [**SoundCraft: a clean-room digital audio workstation in Rust**](https://github.com/storytold/soundcraft) - The authors describe SoundCraft as an open-source, clean-room digital audio workstation built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/soundcraft-case/)} - [**Spark Mail: rehosting the Windows desktop app on Linux with Wine shims**](https://github.com/kyryl-bogach/spark-mail-linux) - spark-mail-linux rehosts the Windows Spark Mail desktop app on Linux with Wine, two compatibility DLL shims and launcher scripts. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/spark-mail-linux-case/)} - [**SteelSeries Overlay Hook: mapping and hooking the GameOverlay swapchain**](https://github.com/meowdiocre/ss-overlay-hook) - SteelSeries Overlay Hook documents IDA analysis of SteelSeriesGameOverlay.dll’s window, object layout and Direct3D 11 swapchain, then uses recovered offsets in a C++ DLL hook. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/steelseries-overlay-hook-case/)} - [**tuya-mobile: a Python reconstruction of Tuya app signing and API calls**](https://github.com/AboveColin/tuya-mobile) - tuya-mobile reconstructs Tuya mobile-app request signing, encrypted API calls and MQTT signaling credential derivation in Python. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/tuya-mobile-security-layer-case/)} - [**VectorCraft: a clean-room vector illustration application in Rust**](https://github.com/storytold/vectorcraft) - The authors describe VectorCraft as an open-source, clean-room vector illustration application built in pure Rust. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/vectorcraft-case/)} - [**WeChat: recovering SQLCipher keys through CommonCrypto hooks**](https://github.com/Evanyuan-builder/wechat-4.1.10-macos-key) - An investigation of WeChat 4.1.10 for macOS reports recovering per-database SQLCipher keys by breaking on CommonCrypto encryption calls in LLDB. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/wechat-4-1-10-macos-key-case/)} - [**cbyge: reconstructing the C by GE smart-bulb cloud protocol**](https://github.com/unixpickle/cbyge) - Reimplements the cloud control path of the C by GE (now Cync) smart-bulb app as a Go library and a small self-hosted web app. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/cbyge-c-by-ge-protocol-case/)} - [**NiimBlue: an independent web client for NIIMBOT label printers**](https://github.com/MultiMote/niimblue) - Replaces NIIMBOT's own label app with a browser client that designs labels and prints them over Web Bluetooth or Web Serial, with Android (Capacitor) and Windows (Tauri) builds of the same interface. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/niimblue-niimbot-printer-client-case/)} - [**open\_oura: a cloud-free Oura Ring client built on its reverse-engineered BLE protocol**](https://github.com/Th0rgal/open_oura) - Reimplements the Bluetooth Low Energy protocol of the Oura Ring Gen 3/4/5 in Rust crates and an oura command-line client that pairs with, authenticates to and syncs a ring directly, with no Oura account or cloud service. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/open-oura-ring-protocol-case/)} - [**Sony Headphones Client: a desktop client for Sony’s headset control protocol**](https://github.com/Plutoberth/SonyHeadphonesClient) - Recreates part of Sony’s mobile-only Headphones app as a Windows, Linux and macOS desktop client that changes noise-cancelling, ambient-sound and virtual-sound settings over a Bluetooth RFCOMM connection to a paired headset. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/sony-headphones-client-case/)} - [**DiskLens: a WinDirStat-derived disk usage analyzer**](https://github.com/KarlssonChristoffer/DiskLens) - A Rust/Tauri disk analyzer combines REA/Ghidra investigation of WinDirStat 2.5.0 with source-code ports of its treemap and color handling. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/disklens-windirstat-rea-case/)} - [**FastView-REA: a Rust reconstruction of Fast View 5**](https://github.com/dmytrobsp/fastview-rea) - A Rust desktop reconstruction of Mekhanotronika Fast View 5 uses REA and Ghidra research to reproduce oscillogram analysis and relay-characteristic views. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/fastview-rea-relay-analysis-rebuild-case/)} - [**rec-rs: an OBS-informed Rust recorder for macOS**](https://github.com/michaelshimeles/rec-rs) - A macOS recorder is informed by OBS architecture research using REA package inspection, platform tools and public source references. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/rec-rs-obs-rea-recorder-case/)} - [**Sketch: a Paper-shell-informed native Rust canvas**](https://github.com/michaelshimeles/sketch) - A Rust canvas models Paper-like editing behavior after REA investigation of the Paper Desktop shell. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/sketch-paper-rea-canvas-case/)} - [**Sofa TV Browser: a remote-friendly BrowseHere alternative**](https://github.com/sonalder-darlene/sofa-tv-browser) - An Android TV browser follows BrowseHere's remote-control interaction design with its own implementation. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/sofa-tv-browser-browsehere-case/)} - [**SoundConnect Desktop: a Windows client reusing a reviewed headset engine**](https://github.com/B-Howell/soundconnect-desktop) - A Windows Sony-headphone client adopts existing libmdr/libmdr-bt engine DLLs after a documented REA-assisted binary inventory and source review. _{Case study · Mixed workflow · Also: Binary · [Full entry](https://awesomerea.org/resources/soundconnect-desktop-rea-engine-case/)} - [**NOOP: an offline WHOOP strap client built from Bluetooth protocol research**](https://github.com/ryanbr/noop) - Replaces the WHOOP companion app with offline macOS, Android and iOS clients that pair with WHOOP 4.0 and 5.0/MG straps over Bluetooth, decode their vendor GATT frames, offload the strap’s history into local SQLite and compute recovery, strain, HRV and sleep on the device. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/noop-whoop-ble-client-case/)} - [**Notes CSV export: an author-reported REA check of reconstruction oracles**](https://x.com/i/article/2110962506604929025) - A Chinese article breaks three versions of a Python CSV exporter that reproduces the Notes teaching app shipped with REA. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/rea-notes-csv-oracle-mutation-case/)} - [**usque: an open reimplementation of Cloudflare WARP’s MASQUE mode**](https://github.com/Diniboy1123/usque) - Reimplements the MASQUE mode of Cloudflare’s WARP client in Go, tunnelling IP traffic over QUIC/HTTP/3 with Connect-IP (RFC 9484) and exposing it as a native TUN device, SOCKS5 or HTTP proxies, TCP-only L4 proxies or port forwarding. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/usque-warp-masque-client-case/)} - [**Webamp: a browser reimplementation of Winamp 2**](https://github.com/captbaritone/webamp) - Reimplements Winamp 2's main, equalizer and playlist windows in HTML5 and JavaScript, with Web Audio playback, volume, balance and equalizer, and renders original classic .wsz skins, which its documentation says match Winamp 2.9 pixel for pixel; Milkdrop presets run through the Butterchurn WebGL port. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/webamp-winamp-reimplementation-case/)} - [**WristBeam: reconstructing Garmin’s watch protocol for a Mac companion**](https://github.com/kongdayan/wristbeam) - Implements a Garmin watch companion as a native macOS menu-bar app that pairs over Bluetooth, receives live health notifications and original FIT files, and can upload them to Garmin Connect. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/wristbeam-garmin-watch-protocol-case/)} - [**iX500 Scan: a macOS client for the reverse-engineered ScanSnap Wi-Fi protocol**](https://github.com/jonaswagnr/ix500-scan) - Replaces ScanSnap Home for a Fujitsu/PFU ScanSnap iX500 on macOS with a SwiftUI app and Python service that scan over Wi-Fi through the community-reverse-engineered VENS protocol, or over USB through SANE, and produce searchable PDFs. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/ix500-scan-scansnap-wifi-case/)} - [**ScooterLink: reconstructing Honda RoadSync’s handlebar-button protocol**](https://github.com/gdorgian/ScooterLink) - Replaces Honda RoadSync’s Apple Music-only media control with an iOS app that pairs with a Honda PCX 2025 TFT dash over Bluetooth Low Energy and turns handlebar presses into system-wide commands for any player. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/scooterlink-honda-roadsync-case/)} - [**Claude Code background lab: an REA-informed reimplementation of a desktop animation**](https://github.com/Henry-fan88/claude-code-background) - Reimplements the glyph-wind background of the Claude desktop app’s Claude Code New session view as an offline WebGL2 page with a 38-slider control panel. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/claude-code-background-lab-case/)} - [**Elgato HDR: a userspace capture path for the Elgato 4K X’s 10-bit mode**](https://github.com/talkaboutdesign/elgato-hdr) - A native macOS app that reaches the Elgato 4K X capture card’s 10-bit P010 video mode, which the project says Apple’s built-in webcam driver does not expose to apps. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/elgato-hdr-uvc-capture-case/)} - [**Galaxy Buds Client: an unofficial manager built on Samsung’s earbud protocol**](https://github.com/timschneeb/GalaxyBudsClient) - Reimplements control of Samsung Galaxy Buds over their proprietary RFCOMM serial protocol in a cross-platform desktop and Android manager. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/galaxy-buds-client-protocol-case/)} - [**LGwebOS-menubar: a native macOS remote for LG webOS TVs**](https://github.com/gabrielgreco1/TVmenubar-MacOS) - A native macOS menu-bar app that pairs with an LG webOS TV over its local encrypted WebSocket interface to launch apps, switch inputs, adjust volume and picture settings, send pointer input and cast selected media. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lgwebos-menubar-remote-case/)} - [**RKD Telemetry Extractor: decoding Race-Keeper track-day recordings**](https://github.com/sam-dumont/rkd-telemetry-extractor) - Documents the proprietary .rkd telemetry format written by Race-Keeper “Instant Video” recorders, whose bundled player runs only on Windows, and implements matching Python and Go parsers that export GPS and IMU channels as Telemetry Overlay CSV and GPX. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rkd-telemetry-extractor-case/)} - [**Screen Studio: an author-reported REA study of auto-zoom rules**](https://x.com/i/article/2109834677343432704) - The author reports using REA to map Screen Studio’s Electron package, reading six auto-zoom and cursor rules from its obfuscated code with Claude Code’s help, and having Claude Code write an independent recorder and renderer from those rules. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/screen-studio-auto-zoom-case/)} - [**Wino Mail: recreating Windows Mail and Calendar**](https://github.com/bkaankose/Wino-Mail) - Native Windows client that aims to preserve the familiar Windows Mail and Calendar experience while rebuilding its functionality. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wino-mail-case/)} - [**Browserbase plugin: re-hosting Claude in Chrome’s browser bridge**](https://github.com/browserbase/claude-code-plugin) - Stands in for the Claude in Chrome extension side of Claude Code’s local browser bridge and runs the requested actions in Browserbase cloud browsers. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/browserbase-claude-chrome-bridge-case/)} - [**Open Scrantic: reconstructing the Johnny Castaway screensaver engine**](https://github.com/glauberlima/open-scrantic) - Reconstructs the Johnny Castaway screensaver engine in Rust, with author-disclosed REA and Claude Code use. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/open-scrantic-screensaver-case/)} - [**TCLimate: reconstructing selected TCL Home cloud controls**](https://github.com/umarz317/TCLimate) - Implements selected TCL Home air-conditioner controls and electricity reporting in a native macOS menu-bar app. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/tclimate-cloud-controls-case/)} - [**UU Remote on Linux: an unofficial protocol implementation**](https://github.com/VallierDev/uu-remote-linux) - Implements an unofficial native Linux host for NetEase UU Remote, using protocol behavior the maintainer says was recovered from official-client traffic and shipped programs. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/uu-remote-linux-protocol-case/)} - [**Visor: an independent Ray-Ban Meta glasses client**](https://github.com/macedonga/visor) - Implements an Android replacement for the Meta AI companion app that speaks the Ray-Ban Meta glasses’ own Bluetooth and Wi-Fi Direct protocol, imports media, exposes settings and answers “Hey Meta” with a model the user chooses. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/visor-ray-ban-meta-client-case/)} - [**wine-uwp: running packaged Windows Store apps on a patched Wine**](https://github.com/designgears/wine-uwp) - Extends Wine 11.17 so that signed MSIX Store apps, with Shapr3D as the main target, install and run on Linux without their source or symbols. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wine-uwp-store-apps-case/)} - [**CF632BLE: a local client from scale-protocol research**](https://github.com/guyru/cf632ble) - Reimplements the CF632BLE scale’s BLE protocol and body-composition calculations from research on the vendor’s Unique Health Android app. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/cf632ble-case/)} - [**DeckCraft: presentation workflow reconstruction and bounded PPTX interchange**](https://github.com/storytold/deckcraft) - The authors describe DeckCraft as a clean-room Rust implementation of PowerPoint-style presentation workflows. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/deckcraft-case/)} - [**Feishu: an author-reported isolated second app instance**](https://benx.ai/blog/posts/rea-reverse-engineer-feishu-dual-instance/) - The author reports using Codex and REA analysis to adapt a separate macOS Feishu copy with its own application identity, data directory and single-instance lock. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/feishu-dual-instance-case/)} - [**GridCraft: spreadsheet workflow reconstruction and XLSX round-trip limits**](https://github.com/storytold/gridcraft) - The authors describe GridCraft as a clean-room Rust implementation of Excel-style spreadsheet workflows. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/gridcraft-case/)} - [**Ledger Reborn: an independent accounting app informed by QuickBooks study**](https://github.com/lxistired/ledger-reborn) - The maintainer reports using REA and Ghidra to study selected QuickBooks Desktop for Mac behavior, then independently implements a local accounting application. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/ledger-reborn-accounting-case/)} - [**LSX II Volume Fixer: reconstructing volume behavior**](https://github.com/roberdorfer/kef-lsx-volume) - Uses measured USB-volume behavior and a macOS audio proxy to map volume keys to a KEF LSX II’s LAN control. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/kef-lsx-volume-case/)} - [**Open Claude UI: REA-informed interface reference components**](https://github.com/Caho1/open-claude-ui) - Publishes React components, motion helpers and design-system notes derived from the author’s reported REA investigation of Claude Desktop. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/open-claude-ui-case/)} - [**PhotoCraft: editor workflow reconstruction and PSD round-trip boundaries**](https://github.com/storytold/photocraft) - The authors describe this Rust image editor as a clean-room reimplementation of Photoshop-style workflows. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/photocraft-case/)} - [**PlxNative: reconstructing a native webOS media-client interface**](https://github.com/GLinnik21/plx-native) - An unofficial Plex client built after the author investigated LG webOS native media interfaces with Ghidra and coding agents. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/plx-native-case/)} - [**Pocket Tasks: reconstructing task state and persistence**](https://github.com/ShadowSwaps/REA-Reconstruction-Companion/tree/main/evals/reference/reconstruction) - A teaching case with disclosed prior source access carries a REA-assisted investigation of a small command-line app into a separate Node implementation. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/pocket-tasks-reconstruction-case/)} - [**Virtual Desktop Streamer: rehosting the platform layer on Linux**](https://github.com/cudanexus/vd-streamer-linux) - An author-reported Claude Code and REA workflow replaces the macOS streamer’s capture, encoding, audio and input layer with Linux implementations while reusing vendor protocol libraries. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/vd-streamer-linux-case/)} - [**Windows Calculator: reconstructing percentage rules**](https://github.com/morluto/rea/blob/c360cfcd6d7901514b16dd6113eba2e0b0fdf422/website/evidence/calculator-and-dino.md#windows-calculator) - REA’s case traces the installed Windows Calculator model DLL to explain different percentage behavior for multiplication/division and other operations. _{Case study · Official REA · Also: Binary · [Full entry](https://awesomerea.org/resources/rea-calculator-percent-case/)} - [**WordCraft: document workflow reconstruction and bounded DOCX compatibility**](https://github.com/storytold/wordcraft) - The authors describe WordCraft as a clean-room Rust implementation of familiar Microsoft Word workflows. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/wordcraft-case/)} - [**zee-rp: reconstructing supported Axure RP 11 document operations**](https://github.com/LilZeeCN/zee-rp) - Reads and rewrites supported native Axure RP 11 documents through a binary-record codec, reference-aware cloning and constrained interaction writers. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zee-rp-case/)} - [**Aegis: trace a login-code calculation**](https://rea.tools/showcase/aegis/) - An official APK investigation follows TOTP methods in Aegis and publishes artifact identities and selected Evidence. _{Case study · Official REA · [Full entry](https://awesomerea.org/resources/rea-aegis-case/)} - [**Notion: trace the clipboard bridge**](https://rea.tools/showcase/notion/) - Trace a packaged Electron clipboard path using REA findings and separate source inspection; the dynamic wrapper remains a stated limit. _{Case study · Official REA · [Full entry](https://awesomerea.org/resources/rea-notion-case/)} - [**PicoPrint: LX-D02 printer investigation**](https://github.com/bigtower17/picoprint) - The author describes REA-assisted Android investigation followed by separate Hermes decompilation to support a Windows BLE printer. _{Case study · Mixed workflow · Also: Protocol · [Full entry](https://awesomerea.org/resources/picoprint-rea-investigation/)} - [**ReaCut: video-editor reconstruction**](https://github.com/Xiangyu-CAS/rea-capcut) - An independent video editor whose authors document REA-assisted investigation of Jianying/CapCut behavior and project formats. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/reacut-reconstruction/)} ## Native Binary [↑ Contents](#contents) - [**CPQ IO Scheduler: reconstructing Xiaomi's block scheduler**](https://github.com/Rasenkai/CPQ_IOSched) - CPQ IO Scheduler reconstructs Xiaomi's proprietary cpq.ko Linux block scheduler from a stripped ARM64 kernel module. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cpq-iosched-case/)} - [**m0rph: tracing an obfuscated ELF flag checker**](https://github.com/UmbertoDellaMonica/m0rph-CTF-CyberChallenge.IT) - The m0rph investigation examines an obfuscated x86-64 ELF CTF flag checker with readelf, strings, Cutter and Radare2. _{Case study · [Full entry](https://awesomerea.org/resources/m0rph-ctf-analysis-case/)} - [**Malware Analysis: njRAT and Casdet behavior investigation**](https://github.com/phour44/Malware-Analysis) - A malware investigation examines njRAT and a UPX-packed Casdet executable with PEStudio static triage and ANY.RUN sandbox telemetry, alongside a malicious PDF and benign comparison files. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/malware-analysis-njrat-casdet-case/)} - [**Woxi: a Wolfram Language interpreter in Rust**](https://github.com/ad-si/Woxi) - The authors describe Woxi as a Rust interpreter for a subset of the Wolfram Language, focused on CLI scripting and Jupyter notebooks. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/woxi-case/)} - [**OpenBSD netcat: static REA and Ghidra investigation**](https://github.com/NullLabTests/OpenBSD_netcat_REA) - A REA/Ghidra report studies the Ubuntu netcat-openbsd 1.234-1 ELF binary and publishes evidence envelopes, decompiled functions and a function inventory. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/netcat-openbsd-rea-static-case/)} - [**Windows loader: static malware analysis with REA and Codex**](https://codegeeksai.github.io/en/blog/static-malware-analysis-rea-codex/) - Fedele Mantuano reports using Codex with REA in an offline Docker lab to statically analyze a public Windows malware sample without executing it. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/windows-loader-static-analysis-case/)} - [**Show Your Work: a measured dissection of REA's evidence architecture**](https://no-flag.com/2026/10/18/REA-paper/) - An unofficial field study that reads REA's source and then drives the running server through 1,012 recorded calls across 27 artifact classes, measuring its content-addressed Evidence records, revision-chained unknown ledger, typed refusals, cold starts and response limits. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/noflag-rea-evidence-architecture-study/)} - [**DownUnderCTF: masked-squares flag checker**](https://rea.tools/showcase/ctf/) - An official educational challenge investigation connects binary checks to equations and records an original-program validation. _{Case study · Official REA · [Full entry](https://awesomerea.org/resources/rea-ctf-case/)} ## Firmware and Hardware [↑ Contents](#contents) - [**Hisense AEH-W41H1: local A/C control over a reconstructed RS-485 bus**](https://github.com/AndrewDemsDS/hisense-w41h1) - Hisense AEH-W41H1 local control replaces the air conditioner's cloud-connected Wi-Fi module with ESPHome firmware for an ESP32 board or the stock RTL8710C module. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/hisense-aeh-w41h1-local-control-case/)} - [**nRF52 e-paper tag: reconstructing an undocumented display interface**](https://github.com/niazlv/nrf52-eink-price-tag) - nRF52 e-paper tag reconstructs control of an undocumented electronic shelf label with an nRF52832 board and SSD1675A-class panel. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/nrf52-eink-price-tag-case/)} - [**open-picpak: reconstructing the PicPak frame's BLE protocol and device behavior**](https://github.com/GottZ/open-PicPak) - open-picpak documents the PicPak 4.2-inch e-ink frame's stock firmware behavior, BLE GATT protocol, and image conversion pipeline. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/open-picpak-case/)} - [**OpenJooki: replacing the Jooki 2 software and recovery path**](https://github.com/Guillain-RDCDE/OpenJooki) - OpenJooki replaces the Jooki 2 music speaker's embedded Linux core and provides phone-based control, updates and SD-card recovery. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openjooki-jooki2-case/)} - [**OSIRIS: replacing Onkyo receiver firmware through MCU protocol research**](https://github.com/ubis/OSIRIS) - OSIRIS replaces the DSP-board software of Onkyo TX-NR515 and TX-NR717 receivers with its own boot loader, Linux services and DSP code. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/osiris-onkyo-receiver-case/)} - [**sony-bravia-linux: pre-Android BRAVIA platform and media behavior**](https://github.com/danielcamposramos/sony-bravia-linux) - sony-bravia-linux investigates the Linux-based, pre-Android Sony BRAVIA platform and reconstructs selected media and portal behavior for owner-run services. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/sony-bravia-linux-case/)} - [**Stickwalker: porting Pokéwalker firmware to the Stick S3**](https://github.com/lumirth/stickwalker) - Stickwalker ports a matching reconstruction of Pokéwalker firmware to the M5Stack Stick S3. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/stickwalker-case/)} - [**VanMoof BLE: a client for S5, A5 and S6 bicycle protocols**](https://github.com/Knight1/vanmoof-ble) - VanMoof BLE implements a Python client for the S5, A5 and S6 bicycle BLE protocols. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/vanmoof-ble-protocol-case/)} - [**Virtual MPC Sample: rehosting Akai MPC Sample firmware in QEMU**](https://github.com/orrpunk-art/virtual-mpc-sample) - Virtual MPC Sample rehosts Akai MPC Sample 1.3.0.12 firmware in QEMU using a custom lab kernel and a browser panel for the device controls. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/virtual-mpc-sample-case/)} - [**EchoMuse: replacement software that turns the Echo Dot 2nd gen into a Home Assistant voice satellite**](https://github.com/wilbowes/EchoMuse) - Replaces the software on an unlocked second-generation Amazon Echo Dot (2016, codename biscuit) so it works as a local Home Assistant voice satellite over the ESPHome API: EchoMuse's own Go firmware drives the microphones, speaker, LED ring and buttons, and a controller on the LAN handles wake words, devices and a dashboard. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/echomuse-echo-dot-voice-satellite-case/)} - [**iCSee LocalMod: a stock-firmware camera control extension**](https://github.com/Vittuu/icsee-localmod) - An owner-authorized XM530V200 camera case uses REA/Ghidra to investigate native Sofia command handlers, then adds local control and Home Assistant integration while preserving stock drivers and recording. _{Case study · Mixed workflow · Also: Binary, Protocol · [Full entry](https://awesomerea.org/resources/icsee-localmod-rea-camera-case/)} - [**MXQ PRO RK3229: an Android firmware investigation and Linux repurposing**](https://github.com/bigtower17/mxqpro-rk3229) - An owner documents identifying an RK3229 TV box, investigating its stock Android ROM and repurposing it with a userspace gamepad driver and Armbian. _{Case study · Mixed workflow · [Full entry](https://awesomerea.org/resources/mxqpro-rk3229-rea-repurposing-case/)} - [**Valetudo: local replacement for robot-vacuum vendor clouds**](https://github.com/Hypfer/Valetudo) - Replaces the vendor cloud of supported robot vacuums with a local service that runs on the rooted robot beside the vendor firmware and emulates the cloud endpoints that firmware expects, including a miio dummycloud and a counterpart for Midea's MSmart protocol. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/valetudo-robot-cloud-replacement-case/)} - [**TeddyCloud: a self-hosted replacement for the Toniebox cloud**](https://github.com/toniebox-reverse-engineering/teddycloud) - Reimplements the Boxine cloud services a Toniebox talks to as a self-hosted C server, so the box can fetch audio, settings and over-the-air content locally while the owner controls what reaches the manufacturer. _{Case study · Independent reconstruction · Also: Protocol · [Full entry](https://awesomerea.org/resources/teddycloud-toniebox-server-case/)} - [**OpenDMCUFirm: a reimplemented Wii U DMCU display firmware**](https://github.com/GaryOderNichts/OpenDMCUFirm) - Reimplements in C the firmware of the Wii U’s DMCU, the M68HC11-compatible display microcontroller in its AMD graphics controller, which in Wii mode reads the Video Interface state and configures display output, deinterlacing, scaling and overscan. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opendmcufirm-wii-u-dmcu-firmware-case/)} - [**reflecticon-224: running Lexicon 224 reverb firmware on emulated hardware**](https://github.com/joelanders/reflecticon-224) - Emulates the Lexicon 224, 224X and 224XL digital reverbs so that their own firmware runs in a browser page or a JUCE plugin. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/reflecticon-224-lexicon-emulation-case/)} - [**Supermodel: initial Real3D Pro-1000 image-generator emulation**](https://github.com/trzy/Supermodel) - Adds emulation of Real3D’s Pro-1000, the SCSI-attached image generator from which Sega’s Model 3 graphics hardware derives, to the Supermodel arcade emulator. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/supermodel-real3d-pro1000-emulation-case/)} - [**flipper-telink: replacement firmware for Tuya Zigbee remotes**](https://github.com/ngxson/flipper-telink) - A Flipper Zero app that bit-bangs Telink’s SWire debug interface to dump and reflash TLSR825x Zigbee devices, with static-analysis notes on the dumps and freshly written firmware for two of them. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/flipper-telink-tuya-remote-firmware-case/)} - [**ThinkPad IMX471: recovering camera tuning for Linux**](https://github.com/cschalle/mipi-fixes-x1-aura) - Recovers selected camera-tuning structures from an Intel Windows driver package and uses them to repair Linux image capture on one ThinkPad model. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/thinkpad-imx471-camera-case/)} ## Protocol [↑ Contents](#contents) - [**A.O. Smith water heater: local CTA-2045 control and protocol findings**](https://github.com/ericboehs/aosmith-water-heater) - The A.O. Smith water-heater project implements local monitoring and demand-response control of an HPS10-50H45DV over its CTA-2045 RS-485 port, publishing readings to MQTT. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/aosmith-water-heater-case/)} - [**ACiQ K18W: reconstructing a mini split's UART protocol**](https://github.com/codypendant/aciq-minisplit-protocol) - ACiQ K18W documents the UART protocol between a mini split's indoor board and TCL WBR1 Wi-Fi module. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/aciq-minisplit-protocol-case/)} - [**ak820: reconstructing AJAZZ AK820 Pro HID control on macOS**](https://github.com/gusleig/ajazz-ak820-pro-mac) - ak820 implements macOS control of the AJAZZ AK820 Pro keyboard through its vendor HID feature-report protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ajazz-ak820-pro-mac-case/)} - [**akp02: reconstructing the Ajazz AKP02 display protocol**](https://github.com/deonspengler/akp02) - akp02 reconstructs the Ajazz AKP02 secondary display's USB HID protocol as a Linux Python library. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/akp02-display-protocol-case/)} - [**aw5d-linux: driving an iBUYPOWER cooler LCD from USB-HID research**](https://github.com/claygorman/aw5d-linux) - aw5d-linux drives the round LCD on an iBUYPOWER AW5/AW5D cooler from Linux using a 64-byte USB-HID output report. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/aw5d-linux-case/)} - [**BikeStation: local Echelon Connect control over Bluetooth LE**](https://github.com/nathanbrittin/BikeStation) - BikeStation is a local Windows client for Echelon Connect exercise bikes built on community research into their proprietary Bluetooth LE protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/bikestation-case/)} - [**BMS RS485 Service Suite: reconstructing a battery-service bus protocol**](https://github.com/zonfacter/bms-rs485-service-suite) - BMS RS485 Service Suite documents an observed ASCII RS485 protocol for battery-management services and implements frame building and decoding in Node-RED. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/bms-rs485-service-suite-case/)} - [**Centerpiece Projects: decoding Finalmouse Centerpiece USB control**](https://github.com/LeiterConsulting/finalmouse_centerpiece) - Centerpiece Projects documents observed USB control messages for the Finalmouse Centerpiece keyboard and implements scripts around them. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/finalmouse-centerpiece-protocol-case/)} - [**claude-rc-api: reconstructing Claude Code Remote Control endpoints**](https://github.com/ThatCrispyToast/claude-rc-api) - claude-rc-api reconstructs the private HTTP interface used to control local Claude Code sessions from claude.ai/code. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/claude-rc-api-case/)} - [**Cooper Hunter AC: UART and infrared protocol investigation**](https://github.com/kronhait/cooper-hunter-ac-esphome) - Cooper Hunter AC documents the COM1 UART and infrared control messages of CH-IF140RK and CH-IF140RK2 units with a Gree GRZQ3-R V1 board. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cooper-hunter-ac-protocol-case/)} - [**Cosmic Byte Firestorm Controller: a USB protocol client for mouse settings**](https://github.com/electrondefuser/cbfirestorm) - Cosmic Byte Firestorm Controller implements a Linux client for the mouse's recovered USB settings protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cosmic-byte-firestorm-controller-case/)} - [**DABplay+: reconstructing USB DAB+ dongle control**](https://github.com/jvspier/dabplayplus) - DABplay+ implements an Android DAB radio using a reverse-engineered USB dongle protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dabplayplus-case/)} - [**Dell ControlVault 2 fingerprint on Linux: adapting a driver for BCM5880**](https://github.com/grosa787/dell-controlvault2-fingerprint-linux) - Dell ControlVault 2 fingerprint on Linux adapts a locally obtained Broadcom driver to the older BCM5880 fingerprint reader through five signature-matched byte patches. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/dell-controlvault2-fingerprint-linux-case/)} - [**epson-l3110-driver: investigating the printer's USB and ESC/P-R exchanges**](https://github.com/mikel-btw/epson-l3110-driver) - epson-l3110-driver investigates the Epson L3110's USB printing exchanges while developing a Linux driver in C. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/epson-l3110-driver-case/)} - [**ESPHome ↔ L&S Emotion Control: reconstructing a smart-light radio client**](https://github.com/SergeyZh/emotion-control-ha) - An ESPHome component recreates L&S Emotion Control remote commands so an ESP32 with a CC2500 radio can control furniture lights and reflect physical remote presses in Home Assistant. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/emotion-control-ha-case/)} - [**Eufy Local Light: reconstructing BLE control for E10 and E22 lights**](https://github.com/SudoSaturn/eufy-local-ha) - Eufy Local Light implements a Home Assistant client for Eufy Outdoor String Lights E10 and Permanent Outdoor Lights E22 using BLE traffic analyzed from the Eufy app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/eufy-local-ha-case/)} - [**FAAC E145 Gate Connect: reconstructing EasyBoard gate commands**](https://github.com/jens62/FAAC-E145-Gate-Connect) - FAAC E145 Gate Connect implements local control of an FAAC E145 gate through serial commands reconstructed from EasyBoard software traffic. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/faac-e145-gate-connect-case/)} - [**fitdays: reconstructing a smart-scale cloud client**](https://github.com/AboveColin/fitdays) - fitdays recreates read-only access to the Fitdays smart-scale cloud API from traffic observed in the vendor app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/fitdays-protocol-case/)} - [**GameTrak Liberation: a client for the controller's HID protocol**](https://github.com/CreativeInquiry/GameTrak-Liberation) - GameTrak Liberation implements a client for the GameTrak controller's reverse-engineered USB HID behavior. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/gametrak-liberation-case/)} - [**hardsid4u: reconstructing the HardSID 4U USB protocol**](https://github.com/pjthulin/hardsid4u) - hardsid4u reconstructs the HardSID 4U USB protocol and implements a libusb Python driver for its SID-chip sockets. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/hardsid4u-case/)} - [**hongtai-panel: reconstructing a cooler LCD's USB serial protocol**](https://github.com/GOG1071/hongtai-panel) - hongtai-panel implements Linux control of a LovingCool AIO cooler LCD using a USB CDC-ACM serial protocol reconstructed from the vendor's Electron application. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/hongtai-panel-case/)} - [**iDotMatrix: Home Assistant control through a reconstructed BLE protocol**](https://github.com/dallanwagz/idotmatrix-ha) - iDotMatrix Home Assistant integration controls the HXS-002 / NL-XSD-32 LED panel over a BLE protocol derived from analysis of the vendor Android app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/idotmatrix-ha-case/)} - [**IPI STAY FLY Driver: reconstructing mouse configuration over HID**](https://github.com/SpookyyQ/IPI-Stay-Fly-Driver) - IPI STAY FLY Driver reconstructs mouse configuration in a Windows app using reverse-engineered 16-byte HID frames. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ipi-stay-fly-driver-case/)} - [**j2208-band-tools: a direct client for the J2208 fitness-band protocol**](https://github.com/brendangooden/j2208-band-tools) - j2208-band-tools implements a direct BLE client for J2208-family fitness bands using protocol findings recovered from the FitTrack Health companion app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/j2208-band-tools-case/)} - [**K1 Pro OpenDeck Suite: a Linux driver for the Stream Dock K1 Pro**](https://github.com/leabergero/k1pro-opendeck-suite) - K1 Pro OpenDeck Suite includes a Linux OpenDeck driver for the HOTSPOTEK/Mirabox Stream Dock K1 Pro based on its reverse-engineered USB/HID CRT protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/k1-pro-opendeck-suite-case/)} - [**KeyAxis: decoding a magnetic keyboard's analog HID stream**](https://github.com/RigZeeel/KeyAxis) - KeyAxis documents the HID travel stream of keyboards using the 0416:7372 controller and turns key depth into virtual gamepad axes. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/keyaxis-keyboard-hid-case/)} - [**LED Controller: a BanlanX BLE client with audio-feed protocol findings**](https://github.com/Antrubtor/LED-controller) - LED Controller uses BanlanX BLE commands to control SP611E-family LED strips from a desktop app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/led-controller-banlanx-case/)} - [**libfprint-goodixtls: a reconstructed Goodix GXFP5187 fingerprint driver**](https://github.com/Sigfrodr/libfprint-goodixtls) - libfprint-goodixtls reconstructs communication with the Goodix GXFP5187 SPI fingerprint sensor in the Huawei MateBook X Pro as a libfprint TOD driver. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/libfprint-goodixtls-case/)} - [**LibreMP: an Epson EasyMP screen caster from packet-capture research**](https://github.com/MuazTPM-YT/libre-mp) - LibreMP casts desktop screens to Epson EasyMP projectors using a protocol reconstructed from Windows client packet captures. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/libremp-easymp-case/)} - [**LinkCam: controlling Insta360 Link 2 through UVC extension research**](https://github.com/fmontes/linkcam) - LinkCam implements macOS menu-bar and command-line controls for the Insta360 Link 2 webcam. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/linkcam-case/)} - [**lux-lat-long-log: reconstructing LUMIX S5 BLE GPS communication**](https://github.com/tobiasbrummer/lux-lat-long-log) - lux-lat-long-log reconstructs the Panasonic LUMIX S5 Bluetooth LE GPS exchange in an ESP32 camera client. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lux-lat-long-log-case/)} - [**MacroPad: reconstructing a USB macropad configuration protocol**](https://github.com/Probler-Yt/MacroPad) - MacroPad reconstructs the USB HID configuration exchange of a 12-key, two-knob macropad identified as 1189:8840 and implements it in a Linux GUI. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/macropad-usb-protocol-case/)} - [**Magene L308: reconstructing a smart taillight's BLE control protocol**](https://github.com/mchardysam/magene-l308-taillight) - Magene L308 interop tools reconstruct the smart taillight's BLE control protocol and light\_mode.bin pattern format. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/magene-l308-taillight-case/)} - [**Monix: reconstructing Audient iD USB mixer control on Linux**](https://github.com/sKuhLight/monix) - Monix implements Linux mixer control for Audient iD USB audio interfaces through a companion kernel module, protocol library and GUI. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/monix-audient-id-case/)} - [**MS5 WiFi Microscope: reconstructing the camera's UDP video protocol**](https://github.com/Fyfar/ms5-wifi-microscope) - MS5 WiFi Microscope reconstructs the MS5 camera's UDP command and video protocol and supplies a Python client that serves its reassembled JPEG stream as MJPEG. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ms5-wifi-microscope-case/)} - [**MSI Mystic Light on Linux: reconstructing B860/X870 lighting control**](https://github.com/Picachuchu69/msi-mystic-light-b860-x870-linux) - MSI Mystic Light on Linux implements lighting control for an MSI motherboard from USB traffic captured while MSI Center ran in a Windows VM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/msi-mystic-light-b860-x870-linux-case/)} - [**MyJBxHeadsetControl: JBL Quantum 950 controls over USB HID**](https://github.com/666mille/MyJBxHeadsetControl) - MyJBxHeadsetControl provides Stream Deck controls for the JBL Quantum 950 Wireless headset through its USB dongle's reverse-engineered HID exchange. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/myjbxheadsetcontrol-case/)} - [**open-rknpu: Rockchip NPU task-program reconstruction**](https://github.com/dnhkng/open-rknpu) - open-rknpu reconstructs a task-program interface for the Rockchip RV1103/RV1106 NPU from board experiments and black-box comparisons. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/open-rknpu-case/)} - [**OpenPeats: reconstructing SoundPEATS earbud controls**](https://github.com/Wasabules/OpenPeats) - OpenPeats reconstructs the SoundPEATS earbud control protocol for desktop and Android clients. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/openpeats-case/)} - [**os-xgs-npu: reconstructing Sophos XGS coprocessor interfaces**](https://github.com/AbdelmonemAwad/os-xgs-npu) - os-xgs-npu reconstructs interfaces to Sophos XGS appliance coprocessors through FreeBSD kernel modules and an OPNsense plugin. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/os-xgs-npu-case/)} - [**Parking sensor kit: reconstructing its display protocol**](https://github.com/kunkka-project/re_parking_sensor_protocol) - This parking-sensor investigation reconstructs the signal sent from a kit's controller to its display. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/parking-sensor-protocol-case/)} - [**Petkit Local: reconstructing feeder cloud and fountain BLE controls**](https://github.com/Opcodeffm/petkit-local) - Petkit Local replaces selected Petkit D4 feeder cloud exchanges with a local Home Assistant server and relays Eversweet Max 2 CTW3 fountain messages over BLE. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/petkit-local-case/)} - [**pocket-client: a BLE client for the Pocket voice recorder**](https://github.com/Enigma-Labs-Technology/pocket-client) - pocket-client implements the Pocket voice recorder's recovered BLE command protocol in a Swift library and CLI. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pocket-client-case/)} - [**PocketPrinter5890: reconstructing the Lidl 5890 printer protocol**](https://github.com/dimer47/PocketPrinter5890) - PocketPrinter5890 reconstructs the BLE printing protocol of Lidl's Tronic, SILVERCREST, and Parkside model 5890 pocket printers. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pocketprinter5890-case/)} - [**PyEilik: a client for the Eilik robot's USB protocol**](https://github.com/aklto/PyEilik) - PyEilik implements control of an Eilik desk robot over a recovered USB serial protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pyeilik-case/)} - [**pyhaseiq: reconstructing the older Hase iQ stove's WebSocket protocol**](https://github.com/bbayszczak/pyhaseiq) - pyhaseiq reconstructs the local WebSocket protocol of Hase iQ wood stoves used with the flamemonitor app and implements an asynchronous read-only Python client. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pyhaseiq-case/)} - [**QuestPad: a USB gamepad from the Quest Touch radio protocol**](https://github.com/Jakey-Jakey/questpad) - QuestPad implements the Quest Touch controllers' private 2.4 GHz radio protocol on nRF52840 firmware so a computer can use them as a USB gamepad. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/questpad-case/)} - [**RazerStream: reconstructing Stream Controller device control**](https://github.com/ShoelessTim/RazerStream) - RazerStream replaces the retired control software for the Razer Stream Controller with a macOS app, Swift protocol library and CLI. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/razerstream-case/)} - [**RK M75: reconstructing wired and wireless RGB control**](https://github.com/Lightning-13/rk-m75) - RK M75 reconstructs RGB control for the Royal Kludge RK M75 keyboard from wired USB HID captures and 2.4 GHz wireless experiments. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rk-m75-case/)} - [**RND Companion: reconstructing the RND Synth SysEx protocol**](https://github.com/Enkerli/rnd-companion) - RND Companion reconstructs the Cymaforma RND Synth's SysEx control vocabulary and implements a C++ codec and companion plugin for patch seeds. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/rnd-companion-case/)} - [**Scooter Link: a Xiaomi scooter client built from BLE protocol research**](https://github.com/desperado0044/xiaomi-scooter-link) - Scooter Link implements an Android client for Xiaomi Electric Scooter 5 Pro and 5 Max using a reconstructed BLE authentication protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/scooter-link-case/)} - [**shark-k86-mac: a client for the Attack Shark K86 HID protocol**](https://github.com/RaphaelCaputo2/shark-k86-mac) - shark-k86-mac reconstructs the Attack Shark K86 keyboard's vendor HID controls as a Python CLI and library for macOS and Linux. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/shark-k86-mac-case/)} - [**Sony CDX-A250: reconstructing the LCD panel interface**](https://github.com/emsyscode/lc75826-sony-cdx-a250) - Sony CDX-A250 LCD Panel reconstructs the serial control needed to drive the radio's detachable display independently through its LC75826W driver. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/lc75826-sony-cdx-a250-case/)} - [**Sound Blaster AE-9: reconstructing Linux control from Windows driver analysis**](https://github.com/verzic/sb-ae9) - Sound Blaster AE-9 Linux support reconstructs card and Audio Control Module behavior using static analysis of Creative's Windows drivers and hardware observations. _{Case study · Independent reconstruction · Also: Binary · [Full entry](https://awesomerea.org/resources/sb-ae9-case/)} - [**Soundcore D3200: reconstructing BLE recording transfer and decryption**](https://github.com/andrewseago/d3200-ble-note-downloader) - A Soundcore D3200 investigation reconstructs the BLE exchange used to list and transfer encrypted recordings. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/soundcore-d3200-ble-case/)} - [**Stadiacast: reconstructing the Stadia Controller's Wi-Fi service**](https://github.com/jkfran/stadiacast) - Stadiacast recreates the network service used by the Stadia Controller's Wi-Fi firmware so the controller can connect to a local computer. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/stadiacast-case/)} - [**stagg-net: investigating the Fellow Stagg EKG kettle UART**](https://github.com/linux4life798/stagg-net) - stagg-net investigates the Fellow Stagg EKG kettle's internal UART interface and documents its connector, serial settings, observed heartbeat packet, and startup message. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/stagg-net-case/)} - [**thermalmaster: a Go client for ThermalMaster camera USB commands**](https://github.com/xaionaro-go/thermalmaster) - thermalmaster implements a Go USB client for ThermalMaster P3 and P1 thermal cameras using documented VDCMD control transfers. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/thermalmaster-case/)} - [**TOZO Control: a Linux earbuds client built from the TOZO BLE protocol**](https://github.com/GabriWar/tozo-control) - TOZO Control provides a Linux GTK4 client for TOZO earbuds using a BLE GATT protocol recovered from the vendor's Android app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/tozo-control-case/)} - [**trvision: implementing Thermalright Vision USB display control**](https://github.com/0iroN/trvision) - trvision implements direct USB control of Thermalright Vision display panels using previously documented protocol research. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/trvision-case/)} - [**vanmoof-certificates: decoding VanMoof bike certificates**](https://github.com/Knight1/vanmoof-certificates) - vanmoof-certificates decodes the access certificates used with VanMoof SA5 and Series 6 bikes. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/vanmoof-certificates-case/)} - [**viture-v2: a reconstructed VITURE Gen2 glasses protocol and driver**](https://github.com/elasticjava/viture-v2) - viture-v2 documents and implements the USB HID protocol used by VITURE Gen2 XR glasses. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/viture-v2-case/)} - [**xbloom-ble: a client for the xBloom Studio BLE protocol**](https://github.com/Janczykkkko/xbloom-ble) - xbloom-ble implements a Python client for the xBloom Studio coffee machine's recovered Bluetooth LE protocol. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/xbloom-ble-case/)} - [**Zemismart Blind Controller Protocol: RF command reconstruction**](https://github.com/blark/zemismart-blind-protocol) - Zemismart Blind Controller Protocol documents the 433.92 MHz OOK PWM messages used by Zemismart motorized blind remotes. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zemismart-blind-protocol-case/)} - [**zlt: MTN ZLT T10D MAX router API reconstruction**](https://github.com/exbyte-dev/zltrouter) - zlt reconstructs the LAN JSON API of the MTN ZLT T10D MAX router from its served JavaScript and observed responses. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/zltrouter-case/)} - [**a0rfid: an open driver for A0-protocol UHF RFID readers**](https://github.com/uaih3k9x/a0rfid) - Reconstructs the A0 serial protocol of R2000-family 915 MHz UHF RFID desktop readers, which ship with only Windows software and an Android app, from the vendor app's native command encoder rather than its misleading Java SDK. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/a0rfid-uhf-reader-protocol-case/)} - [**Cat Printer BLE: reconstructing the MXW01 thermal printer protocol**](https://github.com/MaikelChan/CatPrinterBLE) - Replaces the vendor phone app for the MXW01 “cat printer”, a small Bluetooth Low Energy thermal printer, with a Windows command-line client. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/catprinterble-mxw01-printer-case/)} - [**DJI MIMO BLE artifacts: reconstructing the DJI Osmo control protocol**](https://github.com/xaionaro/reverse-engineering-dji) - Documents the Bluetooth Low Energy message format that DJI's proprietary MIMO app uses to control DJI Osmo devices, as artifacts produced while building the independent djictl CLI. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/dji-mimo-ble-reveng-case/)} - [**Ford Fiesta MK5 MS-CAN: decoding the dashboard and radio bus**](https://github.com/roncapat/Ford-Fiesta-MK5-MS-CAN-bus) - Documents the medium-speed CAN bus that links the 6000CD radio and the dashboard of a restyled (post-2006) Ford Fiesta MK5, worked out by tapping the bus at the radio's QuadLock connector with a Seeed CAN-BUS Shield on an Arduino Uno. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/ford-fiesta-mk5-ms-can-case/)} - [**opendash: reconstructing the Scanmatik SM3 J2534 adapter protocol**](https://github.com/PabloSoage/opendash) - Speaks the undocumented protocol of the Scanmatik SM3, a J2534 vehicle interface that otherwise talks only to its own Windows software, and exposes it to an Android phone as an ELM327 bridge with a diagnostics app on top. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opendash-scanmatik-sm3-protocol-case/)} - [**OWL: an open Apple Wireless Direct Link implementation**](https://github.com/seemoo-lab/owl) - Reimplements Apple Wireless Direct Link (AWDL), the proprietary Wi-Fi ad hoc protocol Apple devices use for peer-to-peer links such as AirDrop, as a user-space C daemon for Linux and macOS; the README calls it the result of reverse engineering by the Open Wireless Link project at TU Darmstadt's SEEMOO lab. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/owl-awdl-open-implementation-case/)} - [**uniden-r8-ble: reconstructing the Uniden R8 radar detector's BLE telemetry**](https://github.com/JeremyWhittaker/unidenr8_bluetooth) - Decodes the undocumented Bluetooth Low Energy output of a Uniden R8 radar detector into a receive-only collector for a Raspberry Pi, with live telemetry, alert start/update/end events, SQLite history and optional MQTT and Home Assistant publishing. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/uniden-r8-ble-telemetry-case/)} - [**Xiaomi Kettle BLE protocol: reconstructing a smart kettle's control interface**](https://github.com/anna-oake/xiaomi-kettle) - Documents the closed Bluetooth Low Energy GATT protocol of the Xiaomi Kettle, which the author reconstructed by decompiling the Mi Home Android app and disassembling its native encryption library. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/xiaomi-kettle-ble-protocol-case/)} - [**bosectl: reconstructing Bose’s BMAP headphone protocol**](https://github.com/aaronsb/bosectl) - Controls Bose headphones from Linux and macOS without the Bose app, account or cloud, through Python, Rust and C++ libraries and command-line tools that implement Bose’s BMAP protocol over Bluetooth RFCOMM. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/bosectl-bose-bmap-protocol-case/)} - [**BudsPro-Headtracking: streaming Galaxy Buds Pro head tracking over Samsung’s serial protocol**](https://github.com/timschneeb/BudsPro-Headtracking) - Reimplements the Samsung Galaxy Buds Pro’s proprietary spatial-audio messages in a small Python script so that a PC can stream the earbuds’ head-tracking data in real time. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/budspro-headtracking-case/)} - [**Even G2 protocol: reverse-engineering Even Realities G2 smart-glasses BLE traffic**](https://github.com/i-soxi/even-g2-protocol) - Documents the Bluetooth Low Energy protocol between the Even app and Even Realities G2 smart glasses, worked out from captured traffic: GATT characteristic UUIDs, an 8-byte transport header with sequence, multi-packet and two-byte service-ID fields, a CRC-16/CCITT over the payload, and protobuf payloads with draft .proto definitions. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/even-g2-ble-protocol-case/)} - [**fuji-cam-wifi-tool: reconstructing Fujifilm X-series Wi-Fi remote control**](https://github.com/hkr/fuji-cam-wifi-tool) - Reimplements the Wi-Fi remote-control protocol of Fujifilm X-series cameras as a C++ library and an interactive command-line client that joins the camera's access point. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/fuji-cam-wifi-tool-protocol-case/)} - [**garmin-ble: a Python client for Garmin's GFDI watch protocol**](https://github.com/gwerneckp/garmin-ble) - Python library that talks to Garmin watches over their proprietary GFDI V2 Bluetooth LE protocol, with no Garmin Connect, phone or cloud service. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/garmin-ble-gfdi-protocol-case/)} - [**Gymnasticon: bridging proprietary exercise-bike data to standard cycling sensors**](https://github.com/ptx2/gymnasticon) - Node.js bridge that reads power and cadence from exercise bikes whose own apps or services are gone or closed, and re-broadcasts them as standard Bluetooth LE Cycling Power and Cycling Speed and Cadence sensors and as an ANT+ bike power profile, so that Zwift, TrainerRoad, bike computers and watches can use the bike. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/gymnasticon-exercise-bike-bridge-case/)} - [**lib-osmo-ble: DJI Osmo Pocket 3 Bluetooth LE protocol library**](https://github.com/yigitkonur/lib-osmo-ble) - Reconstructs the DUML-over-BLE protocol that DJI's Mimo app uses with the Osmo Pocket 3 camera as a Node.js library and CLI for scanning, pairing, gimbal commands and roughly 20 Hz position telemetry without the vendor app. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/osmo-pocket-3-ble-protocol-case/)} - [**pyatv: a reverse-engineered client for Apple TV and AirPlay protocols**](https://github.com/postlund/pyatv) - Asyncio Python library and command-line tools that act as an independent client for Apple TV and AirPlay devices by reimplementing the DMAP/DACP, Media Remote Protocol, Companion Link, AirPlay and RAOP protocols, which its protocol documentation describes as reverse engineered. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pyatv-apple-tv-airplay-protocols-case/)} - [**bluefluff: reverse engineering Furby Connect's Bluetooth LE protocol**](https://github.com/Jeija/bluefluff) - Documents the Bluetooth Low Energy interface of Hasbro's Furby Connect toy, worked out, according to its notes, from the companion app's native library, sniffed BLE traffic and trial and error. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/bluefluff-furby-connect-ble-case/)} - [**OpenDrop: an open reimplementation of Apple AirDrop**](https://github.com/seemoo-lab/opendrop) - Python command-line reimplementation of Apple's AirDrop protocol from SEEMOO Lab's reverse-engineering research. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/opendrop-airdrop-reimplementation-case/)} - [**PixMob IR reverse engineering: controlling event wristbands at home**](https://github.com/danielweidman/pixmob-ir-reverse-engineering) - Recovers enough of the infrared protocol used by PixMob event wristbands to light them at home, starting from Flipper Zero recordings made at concerts and games and replaying them to bracelets. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pixmob-ir-protocol-case/)} - [**pypush: a Python client for Apple’s push protocol**](https://github.com/JJTech0130/pypush) - Reimplements the client side of Apple’s private Apple Push Notification service (APNs) protocol in platform-independent Python: it activates as an Apple device, connects to the APNs courier, mints app-scoped tokens and receives push notifications. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/pypush-apns-protocol-case/)} - [**Roborock Local Server: a self-hosted stand-in for Roborock’s vacuum cloud**](https://github.com/Python-roborock/local_roborock_server) - Runs a local HTTPS and MQTT stack in place of Roborock’s cloud, so supported vacuums keep live maps and controls on an isolated network without rooting or hardware changes. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/roborock-local-server-cloud-case/)} - [**cooler-lcd: a Thermalright display protocol implementation**](https://github.com/kristjaningi/cooler-lcd) - Implements a USB picture-transfer driver for Thermalright Vision cooler displays, with a Rust dashboard replacing the vendor display application. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/cooler-lcd-case/)} - [**GAMEKB-K17: reconstructing a macropad configuration protocol**](https://github.com/dvdarkin/gamekb-k17) - Implements the vendor HID configuration protocol for the GAMEKB-K17/HCY-K017 macropad. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/gamekb-k17-case/)} - [**hw-harness: scanner USB protocol investigation**](https://github.com/cschalle/hw-harness) - Documents an author-reported scanner investigation comparing vendor-driver USB control transfers with Linux-driver traces to infer initialization, timing and resolution parameters. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/hw-harness-reference-case/)} - [**NJFE: a Soulear camera protocol bridge for desktop inspection**](https://github.com/WildweaselMS/NJFE) - Reuses otoscope's reverse-engineered i4season/Soulear protocol in an ESP32-C3 bridge and Python desktop viewer. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/njfe-ear-camera-bridge-case/)} - [**open-appleremote: Siri Remote protocol reconstruction**](https://github.com/a-funk/open-appleremote) - Reconstructs first-generation Siri Remote Bluetooth reports for Linux, decoding buttons, touch and tvOS-style gestures. _{Case study · Independent reconstruction · [Full entry](https://awesomerea.org/resources/open-appleremote-case/)}