# Reverse-engineering case studies · Page 9

> Page 9 of 21, cases 1,601–1,800. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

- HTML: <https://awesomerea.org/cases/page/9/>
- 简体中文: <https://awesomerea.org/zh/cases/page/9/index.md>

## Games (200)

- [Souls of the Reaper: a Diablo III Xbox 360 static recompilation](https://awesomerea.org/resources/souls-of-the-reaper-case/index.md): Case study · Souls of the Reaper ports the Xbox 360 release of Diablo III to Windows by translating its PowerPC executable to native x64 C++ with ReXGlue. The project supplies a manifest, kernel overrides, generated-code patches, and a launcher that uses files from the user's disc.
- [South Park: Tenorman's Revenge: an Xbox 360 static recompilation](https://awesomerea.org/resources/south-park-tenormans-revenge-recompiled-case/index.md): Case study · South Park: Tenorman's Revenge is ported to Windows and Linux by translating its Xbox 360 executable to native PC code with ReXGlue. The project includes a package importer, launcher, and game-specific function analysis; the author reports that levels play on Windows while a full playthrough remains unconfirmed.
- [Space Channel 5 · Native: statically recompiling the Dreamcast game](https://awesomerea.org/resources/space-channel-5-native/index.md): Case study · This translates the USA Dreamcast release of Space Channel 5 ahead of time into native modules. Preview v0.1.0-preview.2 runs SpaceChannel5.exe on Windows x64, SpaceChannel5 on Linux x64 and ARM64, and SpaceChannel5.app on Apple silicon and Intel macOS. The launcher checks a USA GDI and its track files. Gameplay does not use an SH4 interpreter. Flycast supplies device, rendering, and audio components. OpenGL 3.3 is required. Original 4:3 framing is the default.
- [Space Invaders 8080 Static Recompiler: an arcade ROM to C++ translation](https://awesomerea.org/resources/space-invaders-8080-recomp-case/index.md): Case study · Space Invaders 8080 Static Recompiler translates the 1978 arcade game's Intel 8080 ROM into generated C++ before execution. Its lifter uses a linear sweep and branch-target discovery, while an SDL3 runner models I/O ports, a shift register, video output and timed interrupts. The four original ROM files are supplied by the user.
- [Space Station Silicon Valley: a static-recompilation port](https://awesomerea.org/resources/space-station-silicon-valley-recompiled-case/index.md): Case study · Space Station Silicon Valley: Recompiled turns the N64 game's code into a native port with N64Recomp. RT64 renders the game, including S2DEX sprite and background display lists through a project fork, while runtime patches add widescreen and other host features.
- [SpaceRanger: a Toy Story 2 Nintendo 64 static recompilation](https://awesomerea.org/resources/spaceranger-toy-story-2-case/index.md): Case study · SpaceRanger statically recompiles the USA Nintendo 64 release of Toy Story 2: Buzz Lightyear to the Rescue into a Windows port rendered by RT64. Its configuration and runtime adapters handle the game's overlays and generate translated code from the user's ROM during the build.
- [Sparta: a static-recompilation port of God of War: Ghost of Sparta](https://awesomerea.org/resources/sparta-ghost-of-sparta-case/index.md): Case study · Sparta builds a native port of the PSP God of War: Ghost of Sparta by translating its MIPS program to C++ ahead of time. It links game-specific configuration with PortableKit's PSP services and a GE-to-Vulkan renderer. The author reports the opening level running on Windows, Apple Silicon macOS and Android.
- [Spartan: recompiling Halo 3 Mythic multiplayer for Windows](https://awesomerea.org/resources/spartan-h3m/index.md): Case study · Spartan, formerly OpenH3M, statically recompiles the Halo 3 Mythic multiplayer disc from Halo 3: ODST to Windows x64 with ReXGlue. Beta 0.8 has the 3D menu, Custom Games, local split screen for one to four players, and Forge. Theater can be opened. Recording and saved-film playback are not fully validated. The frame cap is the original 30 fps. The release archive is OpenH3M-beta-0.8-win-x64.zip and the program is OpenH3M.exe.
- [SpeedBreaker: Carbon — statically recompiling Need for Speed: Carbon](https://awesomerea.org/resources/speedbreaker-carbon/index.md): Case study · SpeedBreaker: Carbon is a static recompilation of the Xbox 360 version of Need for Speed: Carbon (2006). The only supported disc is the USA Collector's Edition. Packages cover SteamOS, Linux, Mac, and a Windows beta. An experimental iPhone and iPad build is also described.
- [SpeedBreaker: statically recompiling Need for Speed: Most Wanted for Xbox 360](https://awesomerea.org/resources/speedbreaker-nfs-most-wanted-case/index.md): Case study · 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. Releases target SteamOS, Linux and Apple silicon Macs, with an experimental iPhone and iPad build, while all game data comes from the player’s own US disc. Rendering and frame-pacing improvements are project-reported.
- [Spider-Man (2002): a static recompilation of the Xbox game for Windows](https://awesomerea.org/resources/spider-man-2002-xbox-pc-case/index.md): Case study · The Spider-Man (2002) PC port uses xboxrecomp to translate the original Xbox game's code to C for a native Windows executable. A user-supplied default.xbe and data directory feed the build; the repository adds game-specific rendering, controls, settings and optional enhancements generated from that copy.
- [Spider-Man 2 PS2 Recomp: a static recompilation checkpoint](https://awesomerea.org/resources/spider-man-2-ps2-recomp-case/index.md): Case study · Spider-Man 2 PS2 Recomp applies static recompilation to the USA PlayStation 2 release SLUS-20776 for native PC execution. It combines a game-specific Ghidra function map with PS2Recomp source, runtime fixes and hardware comparison tests. The author reports that a native Windows build reaches the legal splash; the port is not playable.
- [Spider-Man 2: Enter Electro: a PlayStation static recompilation kit](https://awesomerea.org/resources/spider-man-2-enter-electro-recomp-case/index.md): Case study · The Spider-Man 2: Enter Electro kit configures psxrecomp to generate and compile the USA PlayStation game from the user's disc and BIOS during first-run setup. It includes title-specific symbols and function seeds, a recomp-ui launcher and a diagnostic build path.
- [Splatoon 1 PC Port: statically recompiling the Wii U game](https://awesomerea.org/resources/splatpc-splatoon-port-case/index.md): Case study · Splatoon 1 PC Port builds a Windows and Linux port of the Wii U game Splatoon by statically recompiling its RPX code to C++. Continuing RebrewU, it adds game-version manifests, a Cafe OS runtime, GX2-to-Vulkan rendering and a builder that uses the player's Wii U dump. The author describes the port as work in progress.
- [Splinter Cell: Double Agent — statically recompiling the Xbox game for Windows](https://awesomerea.org/resources/scda-xbe-recomp/index.md): Case study · This is a native Windows port of the original Xbox game Splinter Cell: Double Agent, made with Xbox XBE Recomp. The x86 game code is translated to C++ ahead of time and drawn with Direct3D 12 and XAudio2. An ISO or extracted files go in assets for play. A source build needs extracted files: default.xbe, sc4_adv.xbe, and the Default, Media, and adv folders. build.bat compiles it to out/build/release/SCDA.exe. The minimum system is Windows 10 64-bit, a CPU with SSE4.2 and POPCNT, and a Direct3D 12 GPU.
- [split2-recomp: statically recompiling TimeSplitters 2 for PC](https://awesomerea.org/resources/split2-recomp-case/index.md): Case study · split2-recomp rebuilds TimeSplitters 2 for the original Xbox as a native program for Windows, macOS, and Linux, including SteamOS and Steam Deck. The build is made on the player's computer from their own copy.
- [ssbu-recomp: static recompilation with explicit mode limits](https://awesomerea.org/resources/ssbu-recomp-case/index.md): Case study · Translates Super Smash Bros. Ultimate 13.0.4 AArch64 code ahead of time and supplies a Windows runtime with Vulkan/OpenGL rendering. It also reconstructs selected fighter scripts as editable C++ and compares translated/source behavior through differential and deterministic tests.
- [ssrecomp: a single-screen Pokémon SoulSilver static recompilation](https://awesomerea.org/resources/ssrecomp-pokemon-soulsilver-case/index.md): Case study · ssrecomp statically translates Pokémon SoulSilver's ARM9 code to C++ and runs it with a patched melonDS core supplying Nintendo DS hardware. Its frontend combines play on one screen and adds widescreen presentation and controller support. Builds generate game-specific code locally from the user's US ROM or decompilation output; the author states development has moved to another project.
- [SSX 3: statically recompiling the PS2 game to Rust](https://awesomerea.org/resources/ssx3-decomp/index.md): Case study · This is a native Rust port of SSX 3 for PlayStation 2, USA SLUS_207.72. The game code was statically recompiled to Rust and is being replaced function by function. Rendering, movies, sound, files, controllers, and the memory card are native. The README says every race, freestyle event, and Conquer the Mountain are playable, on macOS, Windows, and Linux, with an experimental browser build.
- [SSX On Tour: a PSP static recompilation for PC](https://awesomerea.org/resources/ssx-on-tour-psp-recomp-case/index.md): Case study · SSX On Tour translates the PSP game's Allegrex MIPS executable into C++ ahead of time for Linux and Windows. Its project-specific tools load PRX data, discover functions and generate code locally; the PC runtime supplies PSP kernel services, GE rendering through OpenGL and SDL audio.
- [SSX Tricky Recomp: native Linux recompilation of the Xbox game](https://awesomerea.org/resources/ssx-tricky-recomp-case/index.md): Case study · SSX Tricky Recomp generates native code from a user-supplied US retail Xbox copy of SSX Tricky and builds a Linux runtime around it. The source includes an analysis pipeline, Xbox recompilation toolkit patches and graphics, controller and audio integration; the author reports tested races and saves, with progression coverage still incomplete.
- [SSX Tricky: an Xbox static recompilation for Windows](https://awesomerea.org/resources/ssx-tricky-pc-port-case/index.md): Case study · SSX Tricky: PC Port translates the Xbox game's code to C with xboxrecomp and runs it as a native Windows program using Direct3D 11, XAudio2 and XInput. The repository contains game-specific port code and notes on gameplay systems and asset formats. Its regeneration script translates code from the user's USA disc, while additional fixes and recovered functions are needed to reproduce the tested build.
- [Star Fox: a native SNES recompilation](https://awesomerea.org/resources/starfox-snes-recomp/index.md): Case study · This statically recompiles Star Fox for the Super Nintendo into native C with snesrecomp. The required ROM is an unheadered 1 MiB dump of Star Fox (USA) version 1.2, SHA-256 82E39DFBB3E4FE5C28044E80878392070C618B298DD5A267E5EA53C8F72CC548. The README says the game boots and that attract mode, menus, route selection, training, and gameplay have passed basic testing. An optional widescreen renderer is included.
- [Star Wars Episode I: Racer: an N64 static recompilation](https://awesomerea.org/resources/star-wars-episode-i-racer-recomp-case/index.md): Case study · Racer statically recompiles the N64 release of Star Wars Episode I: Racer with N64Recomp, N64ModernRuntime and RT64. Its ROM-analysis and symbol tools support game-specific fixes for libultra calls, split functions, asset loading and controller input; the author reports driving into a tournament race.
- [Star Wars Trilogy Arcade: a native PC port from PowerPC static recompilation](https://awesomerea.org/resources/star-wars-trilogy-arcade-native-case/index.md): Case study · Star Wars Trilogy Arcade is ported to PC by statically translating its PowerPC game code to C++ and supplying new graphics, sound and control systems. The project documents Sega Model 3 Step 2.1 hardware and uses a Vulkan renderer; its build requires the player’s own Rev. A arcade ROM.
- [Star Wars: Knights of the Old Republic: a Win32 static recompilation](https://awesomerea.org/resources/kotor-static-recomp-case/index.md): Case study · Star Wars: Knights of the Old Republic is statically recompiled from a user-owned Steam swkotor.exe 1.03 into native C using pcrecomp. The repository supplies the lift driver, a 32-bit Windows host, and conformance scripts; the author reports an alpha build that reaches gameplay on the Endar Spire.
- [StarCraft 64: a native port by static recompilation](https://awesomerea.org/resources/starcraft64-recomp/index.md): Case study · This is a native port of StarCraft 64, NTSC-U. N64Recomp translates the MIPS code to C, and a software renderer draws the game's display lists. The ROM must match SHA-1 a36d91b5aac7bb95df0d7de5f9814f5270e25c2b after byte-order normalization. The README says the single-player campaign, menus, Encyclopedia, saves, and sound work. macOS on Apple Silicon and Android arm64 from Android 9 are the accepted platforms. Windows x86_64 and Linux x86_64 packages are cross-built.
- [StarCraft: Ghost — an Xbox executable statically recompiled for Windows](https://awesomerea.org/resources/starcraft-ghost-xbox-recomp-case/index.md): Case study · The StarCraft: Ghost Xbox recompilation translates the game's x86 executable into C with XboxRecomp and links it to a Windows runtime. Game-specific patches adjust generated code; the author reports tested mission loading, gameplay and transitions, with further coverage still pending.
- [Starfox 64: Recompiled — an N64Recomp static-recompilation port](https://awesomerea.org/resources/starfox64-recompiled-case/index.md): Case study · 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. Its patches and enhancements draw on headers and some functions from the separate sf64 decompilation; the port is built through static recompilation. The README reports high-frame-rate, widescreen and mod support, with assets loaded from the user's own ROM.
- [Starlit Party: porting Mario Party 6 to Windows, Android and browsers](https://awesomerea.org/resources/starlit-party/index.md): Case study · Starlit Party is a native Windows, Android, and browser port of Mario Party 6, USA, built on recovered game code, Aurora, SDL3, and Dawn/WebGPU. Release 0.5.0 runs all six Party Mode boards, Solo Mode, Mini-Game Mode, Mic Mode, the Star Bank, and the opening, ending, and credits. 49 of 81 minigames are playable. The Windows program is build\release\mp6native.exe. Rendering can be uncapped while game logic stays at 60 Hz.
- [strahlender-xnu: native recompilation of Pokémon Brilliant Diamond](https://awesomerea.org/resources/strahlender-xnu-case/index.md): Case study · strahlender-xnu builds native apps for Pokémon Brilliant Diamond by translating the game’s ARM64 code ahead of time from a user-supplied dump. Its runtime replaces Switch operating-system services and its graphics interface, rendering through Metal on Apple devices and Vulkan on Linux and Windows.
- [Street Fighter II Recompiled: a CPS1 static recompilation](https://awesomerea.org/resources/street-fighter-ii-recompiled-case/index.md): Case study · Street Fighter II Recompiled translates the CPS1 arcade game's Motorola 68000 code into C using ROM analysis, Capstone disassembly and a project-specific generator. Its native build links to a sibling CPS1 runtime for video, audio and input; the author reports reaching the character-select screen.
- [Streets of Rage: Mega Drive recompilation](https://awesomerea.org/resources/streets-of-rage-recomp/index.md): Case study · This is a recompilation of Streets of Rage for the Mega Drive, released as Streets of Rage on the Sega Genesis. The README says desktop builds cover Windows, macOS, and Linux, and that a PlayStation 5 build is documented. The player supplies the ROM.
- [Strider 2 Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/strider-2-recompiled-case/index.md): Case study · Strider 2 Recompiled uses psxrecomp to generate C from the US PlayStation release of Strider 2 and compiles a playable build locally from the user's disc. Its title-specific work includes symbol mapping and framework fixes for simulation pacing, line drawing on the stage briefing screen and interlaced menu text. The development notes describe comparisons with PlayStation reference implementations.
- [Stunt Double: Reignition — static recompilation of Stuntman: Ignition](https://awesomerea.org/resources/stuntman-ignition-recomp/index.md): Case study · This recompiles Stuntman: Ignition for the Xbox 360, 2007, to Windows with ReXGlue. The README says menus, career, and races play. The installer extracts the player's ISO and compiles the game. A hand build uses ReXGlue v0.10.0 and places default.xex in game/.
- [Stunts HD: recompiling Stunts for browser and desktop](https://awesomerea.org/resources/stunts-hd/index.md): Case study · Stunts HD recompiles Stunts 1.1, the 1990 DOS game also released as 4D Sports Driving. The player's GAME.EXE is translated to JavaScript and drawn in HD at the display resolution, with widescreen and the original physics. It runs in Chrome, Edge, or Firefox, and as a desktop app on macOS, Windows, and Linux.
- [Suikoden II: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/suikoden-ii-recomp-case/index.md): Case study · Suikoden II Recomp configures psxrecomp to generate and compile the US PlayStation game from the player's SLUS-00958 disc image and SCPH-1001 BIOS. A recomp-ui setup host collects those inputs and builds normal and diagnostic executables locally.
- [Suikoden Recompiled: a PlayStation setup candidate](https://awesomerea.org/resources/suikoden-recompiled-case/index.md): Case study · Suikoden Recompiled provides a PSXRecomp setup recipe for generating and compiling the PlayStation game from a user's SLUS-00292 disc and specified BIOS. It combines title configuration, function seeds and a recomp-ui setup wizard; package setup and gameplay acceptance remain pending.
- [SunPad: Super Mario Sunshine on Apple platforms](https://awesomerea.org/resources/sunpad-case/index.md): Case study · SunPad runs Super Mario Sunshine on iPhone, iPad, Apple silicon Mac, and experimental Apple TV through ahead-of-time recompilation, with Metal rendering, touch controls, controller support, and local game-image import.
- [Super Mario Advance 2 Recomp: statically recompiling the GBA game](https://awesomerea.org/resources/sma2-recomp/index.md): Case study · This statically recompiles Super Mario Advance 2: Super Mario World for Windows. Release v0.0.3 runs SuperMarioWorldRecomp.exe. The launcher asks for the USA/Australia ROM and a retail GBA BIOS. The game boots through the opening and attract sequence. Adaptive Widescreen is optional and can expand supported scenes up to 9:5. Shift with F1 through F9 saves a state, and F1 through F9 loads one.
- [Super Mario Advance 4 Recomp: a GBA static recompilation for Windows](https://awesomerea.org/resources/super-mario-advance-4-recomp-case/index.md): Case study · Super Mario Advance 4 Recomp builds a native Windows version of the GBA game through gbarecomp using a locally supplied ROM and BIOS. The project provides game configuration, a launcher, controls and save-state support. The author reports that the experimental build boots to the title screen and runs Super Mario Bros. 3 gameplay.
- [Super Mario All-Stars: partial static recompilation and native port](https://awesomerea.org/resources/super-mario-all-stars-recompiled-case/index.md): Case study · Builds a native Super Mario All-Stars port from the player's specified SNES ROM using snesrecomp and game-specific bank analysis inputs. Super Mario Bros. and The Lost Levels are mostly translated ahead of time; Super Mario Bros. 2 and 3 use a built-in interpreter. The port provides desktop and Android builds with a launcher and controller support.
- [Super Mario Galaxy: statically recompiling the Wii game for PS5](https://awesomerea.org/resources/ps5-mario-galaxy/index.md): Case study · Version 1.1.0 statically recompiles Super Mario Galaxy for the Wii, USA RMGE01 revision 0, into a PlayStation 5 homebrew title, PPSA99315, at 4K and 60 fps. Nebula translates that one disc. The Mac builder is SuperMarioGalaxy-PS5-Builder-1.1.0-mac.zip. The Windows builder is SuperMarioGalaxy-PS5-Builder-1.1.0-windows.zip. The result is a folder named PPSA99315, about 4.5 GB. A build takes about 4 minutes on an Apple silicon Mac and about 10 minutes on a fast PC, and needs about 12 GB free.
- [Super Mario Land 2: a Game Boy static recompilation with adaptive widescreen](https://awesomerea.org/resources/super-mario-land-2-recompiled-case/index.md): Case study · Super Mario Land 2: 6 Golden Coins — Recompiled builds native versions of the Game Boy V1.0 game and a DX color variant from one user ROM. It uses gbrecompiled for static recompilation and adds an optional widescreen view whose margins are constructed from live level data.
- [Super Smash Bros. Ultimate: static recompilation for PlayStation 4](https://awesomerea.org/resources/ssbu-ps4-recomp/index.md): Case study · This brings a static recompilation of Super Smash Bros. Ultimate version 13.0.2 to the PlayStation 4. The game's AArch64 code is translated to C ahead of time, and the runtime draws with Direct3D 11 through DXVK. The README says matches are playable with up to four controllers, and that the player builds the package from their own dump. Build steps are in docs/BUILDING.md.
- [Super Street Fighter II Turbo HD Remix: an Xbox 360 static recompilation port](https://awesomerea.org/resources/ssf2t-hd-remix-recompiled-case/index.md): Case study · This port translates the Xbox 360 code of Super Street Fighter II Turbo HD Remix into native PC code with the ReXGlue SDK. It supports the base release and Title Update #1, with a launcher for local package import, graphics settings and online play.
- [SuperMarioRPGSNESRecomp: an early 65816 static recompilation](https://awesomerea.org/resources/super-mario-rpg-snes-recomp-case/index.md): Case study · SuperMarioRPGSNESRecomp applies snesrecomp to Super Mario RPG: Legend of the Seven Stars, compiling qualified 65816 code paths to C while other paths run through an interpreter. The shared snesrecomp runner emulates the game's SA-1 coprocessor, and coverage tools collect dispatch misses to guide later regeneration. The author reports a working attract loop and early-game replay, with two qualified ahead-of-time variants.
- [SuperMarioWorldRecomp: statically recompiling Super Mario World](https://awesomerea.org/resources/smw-recomp/index.md): Case study · This recompiles Super Mario World for the SNES into C with snesrecomp. The 65816 code becomes functions in src/gen. PPU, APU, DMA, and registers stay in a C reimplementation of the SNES hardware. SuperMarioWorldSNESRecomp.exe or the Linux AppImage asks for a USA ROM in sfc or smc form and remembers the path in rom.cfg. The README says Yoshi's Island and Donut Plains were played through, and Vanilla Dome was in progress. Worlds 4 through 7 were not hand-verified.
- [SuperMetroidSNESRecomp: a selective 65816 static recompilation](https://awesomerea.org/resources/super-metroid-recomp-case/index.md): Case study · SuperMetroidSNESRecomp translates selected Super Metroid 65816 functions into native C with snesrecomp and executes other paths from the user's ROM through an interpreter. Its game-specific runtime adds optional rendering and gameplay features plus replay capture for diagnosing divergences. The author reports boot, demo, door traversal, pause and ship-save checks while broader progression testing continues.
- [SVR2011-Recomp: a ReXGlue recompilation of WWE SmackDown vs. Raw 2011](https://awesomerea.org/resources/svr2011-recomp-case/index.md): Case study · 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. A hand-maintained manifest adds function entry points the automatic pass misses, and project patches address frame pacing, a music-player delay and pipeline stalls. Exhibition play is author-tested on one AMD GPU; career mode and online remain untested.
- [SymphonyRecomp: a RecompOne static recompilation of Symphony of the Night](https://awesomerea.org/resources/symphonyrecomp-case/index.md): Case study · 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. Per-overlay function maps and patches add widescreen, quality-of-life, randomizer and cheat features. References from the SOTN decompilation help name functions in this recompilation.
- [Syphon Filter 2 Recompiled: a native Windows build of the PS1 game](https://awesomerea.org/resources/syphon-filter-2-recomp-case/index.md): Case study · Syphon Filter 2 Recompiled is an experimental Windows static recompilation of the two-disc USA release, bootstrapped from SCUS-94451 and built with PSXRecomp. Release v0.1.3-alpha runs the retail game logic as a native x64 program. The launcher can add 16:9, PGXP-assisted geometry, and mouse camera control.
- [Takedawn: statically recompiling Burnout 3: Takedown](https://awesomerea.org/resources/takedawn/index.md): Case study · Takedawn translates the original Xbox game Burnout 3: Takedown ahead of time into native x86-64 and arm64 code. One download covers the North American disc, the European disc for France, Germany, and Italy, and the Europe and Australia disc. The release is 0.3.1, with a macOS 13 arm64 dmg, a Windows x64 setup, a Linux x86-64 AppImage, and an experimental Android arm64 apk. The first start checks the disc files and copies the data. Releases include SHA256SUMS.
- [Teenage Mutant Ninja Turtles: Turtles in Time Re-Shelled — a static recompilation for PC](https://awesomerea.org/resources/tmnt-turtles-in-time-reshelled-recompiled-case/index.md): Case study · Teenage Mutant Ninja Turtles: Turtles in Time Re-Shelled Recompiled translates the Xbox 360 game's PowerPC code into C++ and builds a native PC port with the ReXGlue SDK. Its launcher extracts an exact Xbox Live Arcade package supplied by the user; the port adds PC display options and an online multiplayer service.
- [Tekken 3 Recomp: lifting PlayStation game code into Rust](https://awesomerea.org/resources/tekken-3-recomp-case/index.md): Case study · Tekken 3 Recomp statically recompiles the US PlayStation release of Tekken 3 by extracting its MIPS executable and overlays from a user-supplied disc. Ghidra exports instructions and p-code to CSV sheets, a generator translates them into Rust, and a custom PlayStation runtime hosts the result inside a Bevy app.
- [Tekken 5 Recomp: statically recompiling the PS2 game to Rust](https://awesomerea.org/resources/tekken-5-recomp-case/index.md): Case study · Tekken 5 Recomp statically translates the PlayStation 2 game's Emotion Engine programs, IOP modules, and VU microcode into native Rust. Its pipeline extracts a user's disc image, analyzes programs with Ghidra, generates instruction sheets and Rust code, and runs the result in a Bevy app with a project-specific PS2 runtime.
- [Tekken 5 × Tekken 3 Merge: Tekken 3 characters reconstructed in Tekken 5](https://awesomerea.org/resources/tekken5-t3-merge-case/index.md): Case study · Tekken 5 × Tekken 3 Merge adds five Tekken 3 characters to a statically recompiled Tekken 5. Its tools extract programs from the user’s discs, analyse them with Ghidra, generate Rust code from instruction sheets, and convert models, movesets, animations, and portraits for the expanded roster. The project documents patches and character-specific findings in its merge plan.
- [Tekken 6 Native Online: recompilation with rollback netplay](https://awesomerea.org/resources/tekken-6-native-online-case/index.md): Case study · Tekken 6 Native Online builds a PC port from the user's Xbox 360 Tekken 6 disc by translating Default.xex to C++ with ReXGlue. Its game-side code adds rollback snapshots, input handling and determinism work, while a Qt launcher manages builds and matchmaking.
- [Tekken 6 Recomp: an Xbox 360 static recompilation](https://awesomerea.org/resources/tekken-6-recomp-case/index.md): Case study · Tekken 6 Recomp generates native code from the Xbox 360 release of Tekken 6 using a patched ReXGlue SDK. It provides a game manifest, host code and runtime compatibility patches, with build paths for Windows and macOS. Its builders extract the user's own game image before code generation.
- [Tekken Tag Tournament 2 PC: Xbox 360 static recompilation](https://awesomerea.org/resources/tekken-tag-tournament-2-pc/index.md): Case study · This is a native Windows port of Tekken Tag Tournament 2 for Xbox 360, built with XenonRecomp. ttt2_setup.exe takes a USA or Europe disc image and Title Update 3, checks them, and builds the PC version. It runs on Windows 10 or 11 with a DirectX 11 GPU, up to 4K at 60 fps, with all 59 fighters available. Online matches use rollback over Steam. Ranked Match, leaderboards, teams, and replay search need a community server. The server is written in Go.
- [Tekken Tag Tournament 2: a Wii U static-recompilation port](https://awesomerea.org/resources/tekken-tag-2-wii-u-recomp-case/index.md): Case study · The Tekken Tag Tournament 2 port translates the European Wii U v16 PowerPC executable to C++ ahead of time and builds it for Linux x86-64. Its runtime implements Cafe OS services and converts GX2 graphics work to Vulkan; game-specific hooks add display, input and practice features.
- [Tenchu Z - HoloCatt Recomp Project: statically recompiling Tenchu Z](https://awesomerea.org/resources/tenchu-z-recomp/index.md): Case study · Alpha 0.1.4 statically recompiles Tenchu Z for the Xbox 360, the USA and Europe release, to Windows with ReXGlue. The archive is TenchuZ-HoloCattRecomp-0.1.4-alpha-windows.zip. Setup Tenchu Z.cmd checks the ISO and extracts it beside tenchuz.exe. Direct3D 12 and Vulkan are both available. Render scale runs from 1x to 7x. The hub and the first missions have been played. The rest of the game is untested. F6 opens the added menu.
- [Tenchu: Return from Darkness — an Xbox static recompilation for Windows](https://awesomerea.org/resources/tenchu-return-from-darkness-recomp-case/index.md): Case study · TenchuRFDRecomp builds a native Windows port of the original Xbox game Tenchu: Return from Darkness by recompiling code from the user's disc image. The repository supplies game-specific startup hooks, graphics and audio adapters, controls and mod support; the author describes the release as an alpha.
- [Tenchu: Stealth Assassins recompilation](https://awesomerea.org/resources/tenchu-sa-recomp/index.md): Case study · Version 0.1.0 recompiles Tenchu: Stealth Assassins for the PlayStation, USA SLUS-00706, into C# with a fork of RecompOne. The launcher checks the disc boot executable and refuses any other disc. The disc stays required at runtime. Release 0.1.0 boots, plays, and saves. The controller stays inactive for about the first 20 seconds of the intro. Auto-save is off until Options enables it. A PlayStation BIOS is optional because the engine services BIOS calls itself.
- [TetrisGBRecomp: a static recompilation of Game Boy Tetris](https://awesomerea.org/resources/tetris-gb-recomp-case/index.md): Case study · TetrisGBRecomp statically translates the Game Boy Tetris version 1.0 ROM into C for native PC execution. Its configuration identifies the ROM and entry points, while a dispatch manifest supplies harvested function seeds; the gb-recompiled runtime models Game Boy graphics, audio and memory. The author reports all game modes playable.
- [The Bigs 2 Recompiled: an Xbox 360 PC port](https://awesomerea.org/resources/the-bigs-2-recompiled-case/index.md): Case study · The Bigs 2 Recompiled converts the Xbox 360 game's executable to C++ with ReXGlue for native Linux and Windows builds. Its game-specific hooks and renderer changes add resolution scaling, an experimental 60 fps mode and a first-run disc import screen.
- [The Darkness Recomp: an Xbox 360 static recompilation with a native D3D11 renderer](https://awesomerea.org/resources/the-darkness-recomp-case/index.md): Case study · Builds a native Windows x64 port of The Darkness by translating its Xbox 360 executable to C++ ahead of time with a patched XenonRecomp. A D3D11 renderer draws from the engine’s original geometry, shader sources and device state instead of interpreting console GPU packets. Gameplay coverage and Linux results are project-reported, and the author discloses OpenAI Codex assistance.
- [The Legend of Zelda: The Minish Cap — GBA static recompilation](https://awesomerea.org/resources/minish-cap-recomp/index.md): Case study · This recompiles The Legend of Zelda: The Minish Cap for the Game Boy Advance with gbarecomp. The USA ROM SHA-1 is b4bd50e4131b027c334547b4524e2dbbd4227130, and the runtime refuses any other checksum. The GBA BIOS is recompiled and executed. The save chip is EEPROM. The Windows release archive is MinishCapRecomp-windows-x64. Debug port 19842.
- [The Need for Speed: static recompilation of the 3DO release](https://awesomerea.org/resources/the-need-for-speed-3do-recomp-case/index.md): Case study · pc-theneedforspeed documents a native PC run of the 1994 3DO The Need for Speed through 3dokit static recompilation of ARM60 programs. It records disc structure, Portfolio boot behavior, replay inputs and runtime additions; the author reports reaching the race and driving in a window from a user-supplied disc.
- [The Phantom Menace: a PlayStation static recompilation and matching decompilation](https://awesomerea.org/resources/phantom-menace-psx-recomp-case/index.md): Case study · The Phantom Menace project runs a static recompilation of the USA Rev 1 PlayStation game natively on desktop and M5Stack Tab5. Its recompiler translates MIPS code into C at build time and runs it with a PlayStation hardware runtime. A matching decompilation aims to replace the generated code function by function; the author reports native gameplay, while the initial handwritten C functions remain nonmatching.
- [The Simpsons Arcade Game: recompiling the PS3 arcade wrapper](https://awesomerea.org/resources/simpsons-arcade-ps3-case/index.md): Case study · The Simpsons Arcade Game PS3 project recompiles the PSN release's PowerPC EBOOT into a native PC program with ps3recomp. It lifts captured SPU jobs and documents how the EBOOT emulates the original arcade hardware while interpreting the 6809 game ROM. The author reports playable Stage 1 gameplay, saving and two-instance online co-op.
- [The Simpsons Arcade: an Xbox 360 static recompilation](https://awesomerea.org/resources/simpsons-arcade-recomp-case/index.md): Case study · The Simpsons Arcade port translates the Xbox 360 game's PowerPC executable into C++ with XenonRecomp and runs it through ReXGlue's native runtime. Its repository records XEX analysis, switch-table work, game-specific stubs and fixes for frame pacing and guest timebase scaling.
- [The Simpsons Game: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/the-simpsons-game-recomp-case/index.md): Case study · The Simpsons Game port translates the US Xbox 360 game's PowerPC code into C++ ahead of time for a native Windows x64 build. It provides handwritten platform services, audio, input, and a Direct3D 11 renderer with an optional Vulkan path; the author reports that all levels load.
- [The Simpsons Wrestling Recompiled: a psxrecomp PlayStation static recompilation](https://awesomerea.org/resources/simpsons-wrestling-recompiled-case/index.md): Case study · 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. Without patching game code, the plugin adds 16:9 matches, 60 FPS by raising the emulated CPU clock and rescaling movement, intro skipping and unlocks. The user’s own NTSC-U disc image is required, and the measurements are author-reported.
- [The Sims 2: statically recompiling the original Xbox game](https://awesomerea.org/resources/sims2-xbox-recomp/index.md): Case study · This recompiles the original Xbox release of The Sims 2, USA, with Xbox XBE Recomp. The supported default.xbe is 3,399,680 bytes, SHA-1 16f9e41ce26c315a758f25d43ba1fa9d3809d1ad. The README says Windows reaches live gameplay on a lot, and the native Linux build reaches the title screen and a 3D neighbourhood. Windows uses Direct3D 12. Linux uses Vulkan.
- [The Two Towers Recompiled: an original Xbox static-recompilation port](https://awesomerea.org/resources/two-towers-recompiled-case/index.md): Case study · 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. The recompiled sources are generated locally from the player's own default.xbe, and game data comes from their disc image or extracted folder. README reports the game as fully playable, with visual, frame-rate and mod issues listed.
- [The Urbz: Sims in the City — original Xbox static recompilation](https://awesomerea.org/resources/urbz-recomp/index.md): Case study · This static recompilation of the original Xbox game The Urbz: Sims in the City, North America, builds Urbz.exe for Windows with Direct3D 12 and XAudio2, and Urbz for Linux with Vulkan and SDL3. default.xbe is 3,035,136 bytes, SHA-1 5712b6a3e2eaaacfcae228cf6154ade499a0033c, title ID 0x45410060, linked 2004-10-07 against XDK 1.0.5849. xiso_extract.py extracts the disc, xbe_info.py checks that SHA-1, and build.bat or build.sh recompiles 15,942 functions.
- [Theme Park: a static recompilation of the DOS game](https://awesomerea.org/resources/theme-park-static-recomp-case/index.md): Case study · Theme Park statically recompiles Bullfrog's 1994 DOS game into a native Windows and Linux program using pcrecomp to translate its 32-bit code to C. The project adds a DOS/4GW host, display and sound layers, TCP support for the game's network mode, save states, and scripted conformance runs. The author reports lifting 6,517 functions and passing six conformance milestones.
- [Tiberian Sun and Firestorm: static recompilation of Game.exe](https://awesomerea.org/resources/tiberian-sun-firestorm-recomp-case/index.md): Case study · Tiberian Sun and Firestorm recompiles the games' Win32 Game.exe into native C with pcrecomp and a game-specific host. The author reports playable menus, skirmishes and early campaign missions, with high-resolution display and a native Linux build. Lifted C is generated locally from the owner's game copy.
- [Tiger Woods PGA Tour 2004 - XBE Recomp: a native PC port of the Xbox game](https://awesomerea.org/resources/tiger-woods-pga-tour-2004-xbe-recomp-case/index.md): Case study · Tiger Woods PGA Tour 2004 - XBE Recomp ports the original Xbox game to Windows by statically recompiling its XBE with Xbox XBE Recomp and building the game code from the user's copy on first launch. The port adds widescreen display, graphics settings, and PC controls, alongside an emulated Xbox audio DSP.
- [TimeSplitters: a PS2 static recompilation for PC and original Xbox](https://awesomerea.org/resources/timesplitters-ps2-recomp-case/index.md): Case study · TimeSplitters recompiles the USA PlayStation 2 game's MIPS program and VU microcode into C++ with PS2Recomp for native Windows, Linux and original Xbox builds. Its runtime models PS2 graphics, sound and IOP services. The Windows and Linux builds extract data from the player's disc dump on first launch; Xbox game files are prepared on a Windows PC.
- [tkdr-recomp: a PSP static recompilation of Tekken: Dark Resurrection](https://awesomerea.org/resources/tkdr-recomp-case/index.md): Case study · tkdr-recomp runs the PSP release of Tekken: Dark Resurrection by translating its MIPS executable ahead of time to C for native builds or WebAssembly in the browser. A custom runtime supplies PSP library calls, scheduling, graphics, audio, and input. The author reports working boot, menus, movies, saves, and full matches, with Quick Battle explored from boot.
- [TLKRecomp: a static recompilation of The Lion King for PC](https://awesomerea.org/resources/tlkrecomp-case/index.md): Case study · TLKRecomp translates the US SNES release of The Lion King's 65816 program into C with snesrecomp and builds a native program for Linux, Windows and Apple Silicon macOS. Its host uses emulated PPU and SPC components. The author reports matching frames and RAM against interpreter runs, and matching game RAM against BizHawk runs.
- [Tokyo Jungle Recompiled: a PS3 static recompilation bring-up](https://awesomerea.org/resources/tokyo-jungle-recompiled-case/index.md): Case study · Tokyo Jungle Recompiled translates the PS3 game's PowerPC executable into native PC code with ps3recomp and supplies game-specific loading, import and runtime glue. Its investigation documents PPU functions, SPU workloads, asset loading and a main-loop wait that currently blocks geometry rendering.
- [Tomba2Recomp: statically recompiling Tomba! 2](https://awesomerea.org/resources/tomba2-recomp/index.md): Case study · This statically recompiles Tomba! 2: The Evil Swine Return with psxrecomp. Windows and Linux previews accept the USA disc SCUS-94454 and the Italian PAL disc SCES-02686. Native code is prepared from all 22 original area files plus shared overlays before gameplay. Release builds include the MIT OpenBIOS from PCSX-Redux. Adaptive widescreen and 1080p internal rendering are on by default. SDL3 is the default host backend.
- [Tony Hawk's Pro Skater Recompiled: a PlayStation setup project](https://awesomerea.org/resources/tony-hawks-pro-skater-recompiled-case/index.md): Case study · Tony Hawk's Pro Skater Recompiled supplies a PSXRecomp configuration and recomp-ui flow for generating a native build from the user's PlayStation disc. The project contains title symbols, function seeds and build scripts. Its Windows, Linux and macOS setup packages are described as candidates pending package checks.
- [Top Spin 4 Recomp: a native Xbox 360 game port](https://awesomerea.org/resources/top-spin-4-recomp-case/index.md): Case study · Top Spin 4 Recomp ports the Xbox 360 game Top Spin 4 to Windows through ahead-of-time translation of its PowerPC code with ReXGlue. A game-specific renderer maps its Direct3D 9 calls to Vulkan, and a launcher prepares files from the user’s disc image and Title Update 1. The author reports working exhibition, career, academy, and local multiplayer modes.
- [TotK Recomp: statically recompiling Tears of the Kingdom](https://awesomerea.org/resources/totk-pc-recomp/index.md): Case study · TotK Recomp statically recompiles The Legend of Zelda: Tears of the Kingdom into a native x86-64 program for Windows and Linux, with a Vulkan renderer. It accepts the base game plus update 1.1.0, 1.2.1, or 1.4.3 as NSP, XCI, NSZ, or XCZ. Windows setup needs Windows 10 or later, SSE4.2, and Vulkan 1.3. Linux needs Linux 6.7 or later and glibc 2.34 or later. The toolchain steps are in docs/building.md.
- [TriAevum: statically recompiling Ocarina of Time 3D](https://awesomerea.org/resources/triaevum/index.md): Case study · TriAevum, Echoes of Time, is an ahead-of-time recompilation of The Legend of Zelda: Ocarina of Time 3D for Windows and Linux x64, with an NRI/Vulkan renderer. The documented release is v0.8.0-beta.1.2. TriAevumForge.exe accepts a decrypted EUR or USA ROM, original or revision 1, as .3ds or .cci. Japanese, Korean, and Taiwanese releases are not supported. The Windows zip contains TriAevumForge.exe, and setup writes TriAevum.exe beside it.
- [Trials HD Recompiled: static recompilation of the Xbox 360 game](https://awesomerea.org/resources/trials-hd-recomp/index.md): Case study · This statically recompiles Trials HD for the Xbox 360, title ID 5841095A, to Linux x86-64 and macOS with ReXGlue. Physics stay at 60 Hz while rendering can run at a higher refresh rate. The GPU backend is WebGPU or Vulkan. ./build.sh --game takes the game directory or the STFS package and reads default.xex from it. Later builds omit --game.
- [TribesPad: native ARM64 ports of Tribes 2 and Starsiege: Tribes](https://awesomerea.org/resources/tribespad-case/index.md): Case study · TribesPad translates the x86 code of Tribes 2 and Starsiege: Tribes ahead of time into native ARM64 for iPhone, iPad and Mac. Its runtime supplies Windows services, a Metal graphics path, audio, input and networking; mobile builds add touch and controller controls. Game-specific translation and runtime configurations accompany investigation records.
- [Trouble Makers: a Mischief Makers static-recompilation port](https://awesomerea.org/resources/trouble-makers-mischief-makers-case/index.md): Case study · Trouble Makers turns Mischief Makers' N64 MIPS code into a native PC port with N64Recomp, N64ModernRuntime and RT64. The repository includes a US 1.1 symbol map, compatibility patches and a technical reference covering the ROM and engine; optional widescreen and frame interpolation are experimental.
- [TsumuLightRecomp: static recompilation of Tsumu Light](https://awesomerea.org/resources/tsumu-light-recomp-case/index.md): Case study · TsumuLightRecomp configures PSXRecomp to translate the Japanese PlayStation game's MIPS code into native C and compile a PC executable. It supplies title-specific function seeds, build settings and a runtime English text layer; the author reports puzzle-stage play and memory-card save/load.
- [Twilight Princess HD: statically recompiling the Wii U game for macOS](https://awesomerea.org/resources/twilight-princess-hd-recomp-case/index.md): Case study · Twilight Princess HD: Recompiled translates the Wii U game's Zelda.rpx PowerPC code to C and runs it as a native Apple Silicon macOS app. It adapts a Wind Waker HD recompilation runtime with Cafe OS services and Metal graphics to Twilight Princess HD; the author reports title-screen and early Ordon Village play.
- [Twin Snakes Native Port: GameCube code analysis toward static recompilation](https://awesomerea.org/resources/twin-snakes-native-port-case/index.md): Case study · Twin Snakes Native Port analyzes the GameCube executables of Metal Gear Solid: The Twin Snakes for a planned native recompilation. Its workflow uses Ghidra, decomp-toolkit, signature matching, and DolRecomp to recover function boundaries and symbols and translate PowerPC code to C. The repository also contains runtime code for GameCube SDK services; current work centers on symbol recovery.
- [Twisted Metal: Black — a static recompilation for PC](https://awesomerea.org/resources/tmb-recomp/index.md): Case study · This statically recompiles Twisted Metal: Black for the PlayStation 2, USA SCUS-97101, to Linux and Windows with BozoEngine. The executable SCUS_971.01 has SHA-1 3ff17f4897552e355d0bb8c3abfa5125fe3ff2ef. Release v0.4.0 plays one-player, story, and four-player split-screen matches at the NTSC rate of 60 updates per second. The Windows launcher is TMB Launcher.exe, from TMB_Recomp-<version>-bozo.zip.
- [Twisted Metal: lifting the PS3 game into a native Windows build](https://awesomerea.org/resources/twisted-metal-2012-static-recompilation-case/index.md): Case study · Twisted Metal lifts the 2012 PS3 game's PowerPC EBOOT.BIN into C++ and links it with ps3recomp for a native Windows build. Its analysis notes cover imports, function boundaries, SPU images and boot behavior; the author reports reaching a match and drawing its HUD while the 3D world remains blocked.
- [TwistedMetal1234Recomp: rebuilding four PlayStation Twisted Metal games](https://awesomerea.org/resources/twisted-metal-1234-recomp-case/index.md): Case study · TwistedMetal1234Recomp builds native Windows programs for the first four PlayStation Twisted Metal games through psxrecomp, with a unified launcher. Game-specific hooks adjust frame pacing, widescreen terrain drawing and HUD placement, while framework patches expose related display settings. The generated C is produced locally from each user's disc image.
- [UltraCombo: native ports of the Killer Instinct arcade games](https://awesomerea.org/resources/ultracombo-case/index.md): Case study · UltraCombo ports the arcade games Killer Instinct and Killer Instinct 2 to Windows and Linux using users' ROM and disk files. It boots each game on an interpreter, snapshots loaded code, translates the game and sound DSP programs to C, and compiles native modules while emulating the surrounding arcade hardware.
- [UltraTears: native recompilation of Tears of the Kingdom](https://awesomerea.org/resources/ultratears/index.md): Case study · UltraTears builds a native version of The Legend of Zelda: Tears of the Kingdom 1.4.3 for Windows, Linux, and Steam Deck from plain exefs and romfs folders. The romfs tree is about 304,000 files and 16 GB. Windows 10 or 11, or Linux with kernel 6.7 or newer and glibc 2.34 or newer, plus Vulkan 1.3, are required. python tools/setup.py --dump takes the dump directory and writes the game folder under build/. About 40 GB free is listed for setup.
- [Uncharted Waters: New Horizons — a native Windows static recompilation](https://awesomerea.org/resources/uncharted-waters-new-horizons-static-recomp-case/index.md): Case study · Uncharted Waters: New Horizons is statically recompiled into a native Windows 10/11 application that uses the player's own USA/Canada NTSC ROM. The source includes generated native code, a target core and an SDL frontend, with an optional headless connector. Widescreen support remains experimental.
- [Unleashed Recompiled for Android: Sonic Unleashed port](https://awesomerea.org/resources/unleashed-recomp-android/index.md): Case study · This is an Android port of Unleashed Recompiled for the Xbox 360 version of Sonic Unleashed. It runs the statically recompiled game on ARM64 Android 10 or newer, with touch controls, gamepad support, a mod manager, and a bundled Turnip Vulkan driver. The launcher installs a zip or folder, or separate base-game, title-update, and DLC packages. The main tested GPUs are Adreno 710, 725, 732, and 750. Adreno 830 is selected automatically. Recent Mali GPUs with Vulkan 1.3 are experimental. A Windows host with Visual Studio 2022, CMake, Ninja, Android NDK r29, JDK 17, and vcpkg builds the port.
- [Unleashed Recompiled: translating Xbox 360 game code and shaders](https://awesomerea.org/resources/unleashed-recompiled-case/index.md): Case study · Builds an unofficial Sonic Unleashed PC port by statically recompiling Xbox 360 PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. The port adds modern display and modding options while documenting original-engine limits and remaining compatibility issues.
- [Unreal Championship 2: an Xbox static recompilation for Windows](https://awesomerea.org/resources/unreal-championship-2-recomp-case/index.md): Case study · Unreal Championship 2 is statically recompiled from an ISO image of the user's original Xbox game into a native Windows program with xboxrecomp. The project translates game code to C and adds game-specific runtime code, D3D11 graphics support and toolkit patches.
- [Urban Reign PC Port: a PS2 static recompilation](https://awesomerea.org/resources/urban-reign-pc-port-case/index.md): Case study · Urban Reign PC Port translates the USA PlayStation 2 game's code into C++ for native Windows and Linux builds. It uses the PCSX2 renderer through DirectX 11 or Vulkan and adds higher internal resolutions, widescreen display and multiplayer controls. Code generation reads the user's own SLUS-21209 disc image.
- [Vagrant Story Recompiled: a disc-local PSXRecomp port](https://awesomerea.org/resources/vagrant-story-recompiled-case/index.md): Case study · Vagrant Story Recompiled builds a native PC version of the USA PlayStation game through psxrecomp. It reads the user's disc for game code and supplies title-specific widescreen, input, menu and frame-rate plugins, plus patches to the recompiler runtime.
- [ValkyrieRecomp: a PlayStation static recompilation of Valkyrie Profile](https://awesomerea.org/resources/valkyrie-profile-recomp-case/index.md): Case study · ValkyrieRecomp configures PSXRecomp to generate a native PC build of the USA PlayStation release of Valkyrie Profile from a user-supplied disc. It adds a launcher for selecting the two discs, rendering options and controller support; compatibility testing remains in progress.
- [Verdite2: a RecompOne port of King's Field](https://awesomerea.org/resources/verdite2-kings-field-case/index.md): Case study · Verdite2 ports the North American PlayStation release of King's Field, SLUS-00158, to PC with RecompOne static recompilation. It contains function maps, runtime patches and documentation for the game's executable and disc handling. The project adds widescreen display, modern controls and rendering changes, and reports playability from start to finish.
- [Verdite3: a King's Field II static recompilation port](https://awesomerea.org/resources/verdite3-kings-field-ii-case/index.md): Case study · Verdite3 ports the North American PlayStation release of King's Field II, numbered King's Field III in Japan, to PC through RecompOne static recompilation. Its game-specific maps and patches cover the main executables and area modules, with changes to rendering, controls, pacing, and saves.
- [VeronicaRecomp: a PC static recompilation of Resident Evil CODE:Veronica](https://awesomerea.org/resources/veronicarecomp-case/index.md): Case study · VeronicaRecomp uses ReXGlue SDK to statically recompile Resident Evil CODE:Veronica for native PC. Its CMake project includes a code generation target and builds an executable; users extract the required assets from their own game copy. The author describes the current build as playable but unfinished.
- [Vigilante 8 Arcade: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/vig8-recomp-case/index.md): Case study · vig8 statically recompiles Vigilante 8 Arcade's Xbox 360 PowerPC executable into native Windows C++ with ReXGlue. Its manifest records game-specific function boundaries, while runtime glue handles application and networking behavior; the author reports that menus, Quest, and single-player battles run in an alpha build.
- [Virtua Cop: statically recompiling the Model 2 arcade game](https://awesomerea.org/resources/virtua-cop-static-recomp-case/index.md): Case study · Virtua Cop statically recompiles the Sega Model 2 arcade game's i960 program ROM into C for a native Windows build. A ROM loader prepares flat images from the user's ROM set, and the generated C links with model2recomp to model the board and render the game. The author reports that the game boots and plays a stage; sound is unimplemented.
- [Virtua Fighter 3 Recomp: native port of the Model 3 arcade game](https://awesomerea.org/resources/virtua-fighter-3-recomp-case/index.md): Case study · Virtua Fighter 3 Recomp runs the arcade game's PowerPC program as native ARM64 or x86-64 code translated from the user's ROM at startup. Its own runtime models the Sega Model 3 board, tile generator, and Real3D graphics, with native rendering and input on desktop systems.
- [Virtual Pro Wrestling 2: Recompiled for PC](https://awesomerea.org/resources/vpw2-recomp-case/index.md): Case study · Virtual Pro Wrestling 2: Recompiled translates the Japanese Nintendo 64 game into native PC code with N64Recomp, N64ModernRuntime and RT64. Its own disassembly metadata and runtime additions support widescreen display, controls, saves and experimental lighting effects.
- [Viva Piñata Recomp: a ReXGlue native Windows port](https://awesomerea.org/resources/viva-pinata-recomp-case/index.md): Case study · Viva Piñata Recomp translates the original Xbox 360 game's code into C++ with ReXGlue and builds a native Windows program. It includes a launcher, game-version checks and Direct3D 12 or Vulkan rendering modes; the author reports menu, garden and save functionality on the documented disc version.
- [Voldorium: SoulCalibur Dreamcast port](https://awesomerea.org/resources/voldorium/index.md): Case study · Voldorium is a native Windows and Linux port of SoulCalibur for the Dreamcast, USA release T-1401N V1.000. The README says the game's SH-4 code is statically recompiled to C and linked with a native runtime, adding 16:9 widescreen, arbitrary resolution, and an online versus mode with GGPO rollback. Only that USA release is supported.
- [VP2S_Recomp: a static recompilation of Valkyrie Profile 2: Silmeria](https://awesomerea.org/resources/vp2s-recomp-case/index.md): Case study · VP2S_Recomp builds a native Windows port of Valkyrie Profile 2: Silmeria by translating its PlayStation 2 MIPS code to C++ with PS2Recomp. Game-specific tools unpack encrypted and compressed modules, Ghidra maps functions, and the port draws models and interface elements through a native renderer with a native audio mixer.
- [War of the Monsters: statically recompiling the PS2 game for PC](https://awesomerea.org/resources/wotm-recomp/index.md): Case study · This statically recompiles War of the Monsters for the PlayStation 2 to Windows, and has a Linux x86-64 path. The Windows program is wotm.exe. PS2Recomp translates the executable, including VU0, into C++ that is generated locally. A decompilation build ends with build/SCUS_971.97.rom: OK. The Linux target needs AVX2, BMI2, POPCNT, and LZCNT. Mods go in mods next to wotm.exe.
- [WarioRecomp: a native Wario Land: Shake It! port by static recompilation](https://awesomerea.org/resources/wariorecomp-wario-land-shake-it-case/index.md): Case study · WarioRecomp builds a native PC port of the US Wii release of Wario Land: Shake It! by statically recompiling its PowerPC code to C++ with WiiCompiled. Native libraries replace Wii video, audio, controller, disc and save services, while the launcher imports the user's disc and builds the port locally.
- [WarioWare: Twisted! recomp](https://awesomerea.org/resources/warioware-twisted-recomp/index.md): Case study · This static recompilation of WarioWare: Twisted! runs on Windows x64 and Android arm64, using the phone gyroscope or a controller motion sensor for the cartridge gyro. The USA ROM and a retail GBA BIOS are selected in the launcher. Their identities are recorded in variants/warioware_twisted/game.toml. Windows builds use CMake, Ninja, MSYS2 MinGW64, and SDL2. pwsh tools/regen.ps1 regenerates the translation, and cmake --build build --target WarioWareTwistedRecomp builds the program.
- [Wave Race 64: Recompiled — an early N64 static recompilation](https://awesomerea.org/resources/chronic-wave-race-64-recomp-case/index.md): Case study · Wave Race 64: Recompiled applies N64Recomp and RT64 to a native PC port of Wave Race 64. Its build requires the player's USA Rev A ROM; the author reports that the current result boots only to two boxes of noise.
- [Wave Race 64: Recompiled: a native N64 static-recompilation port](https://awesomerea.org/resources/wave-race-64-recompiled-case/index.md): Case study · Wave Race 64: Recompiled builds a native Windows, Linux and macOS port from the player's USA Rev A ROM using N64Recomp. Its code adds widescreen, draw-distance options and an optional water renderer, while technical documents record game internals and rendering investigations.
- [Weeping of the Empire: statically recompiling Tears of the Kingdom for Windows](https://awesomerea.org/resources/weeping-of-the-empire-case/index.md): Case study · 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. It recompiles ARM64 code ahead of time to x86-64, supplies Switch services through a host runtime and renders through Vulkan. The engine documentation credits totk-recomp as the starting point and identifies the added Windows port, renderer, controls and menus.
- [WET: a ReXGlue Xbox 360 PC port](https://awesomerea.org/resources/wet-recomp-case/index.md): Case study · WET is a PC port of the Xbox 360 game built with ReXGlue from the user's disc image. Its setup script applies input patches and generates game code, while the project supplies host code, ultrawide display changes and Windows and Linux build paths.
- [WHITE ALBUM2: a shared engine migration from static recompilation](https://awesomerea.org/resources/white-album2-shared-engine-case/index.md): Case study · The WHITE ALBUM2 port shares game logic between Windows x64 and Android ARM64 while migrating from a hybrid static recompilation to a native C++ compatibility engine. Current native components handle save flags, script behavior and resource processing; the delivered shared-aot build still uses recompiled functions. Original PAK files remain external.
- [White Knight Chronicles II Recomp: PlayStation 3 recompilation](https://awesomerea.org/resources/white-knight-chronicles-2-recomp/index.md): Case study · This recompiles White Knight Chronicles II for the PlayStation 3. The disc also includes White Knight Chronicles I, and the current Windows build reaches that game's starting town and can load one local save. Vulkan is the primary renderer. DirectX 12 is experimental. The documented disc is the USA release BLUS30784. The 30 fps limit is the baseline.
- [Wii Party: a native Windows and Linux recompilation](https://awesomerea.org/resources/wii-party-recomp/index.md): Case study · This statically recompiles Wii Party to Windows and experimental Linux. The DOL and all 115 REL modules translate. 4,152 tests check every instruction kind the game uses. Graphics go from GX to Direct3D 11. The frame rate is locked at 60 fps PAL60, at up to 6 times the console resolution, using about 600 MB of RAM. Every one of the 79 Free Play minigames and a full 17-round Board Game Island session have been played. The offline Windows archive is wiipartyrecomp-offline-windows.zip, about 185 MB.
- [WiiCompiled: a Mario Kart Wii static recompilation port for Xbox UWP](https://awesomerea.org/resources/wiicompiled-xbox-uwp-case/index.md): Case study · WiiCompiled's Xbox UWP port builds the static recompilation of Mario Kart Wii as a packaged application for Xbox Series consoles. It adds fixes for MSVC compilation and AppContainer startup, Direct3D 12 rendering through aurora and Dawn, memory use, and controller mapping; the author reports play on an Xbox Series S in Developer Mode.
- [WiiCompiled: a static recompilation of Mario Kart Wii for PC](https://awesomerea.org/resources/wiicompiled-case/index.md): Case study · WiiCompiled turns a user-supplied Mario Kart Wii disc image into a native PC application through PowerPC static recompilation. Its translator parses Wii DOL files, lifts instructions through IR and SSA, emits C++, and compiles the output with a runtime; project manifests select game revisions and input layouts.
- [Wind Waker HD Recomp: a native port by static recompilation of the Wii U game](https://awesomerea.org/resources/wind-waker-hd-recomp-case/index.md): Case study · 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. All game code and data are generated locally from the user’s own dump; an experimental macOS-only build can instead run functions from the separate ZeldaWWHDDecomp/wwhd decompilation.
- [Wind Waker HD Recompiled for Android — Plus: an Android static recompilation port](https://awesomerea.org/resources/wind-waker-hd-android-plus-case/index.md): Case study · Wind Waker HD Recompiled for Android — Plus runs The Legend of Zelda: The Wind Waker HD on ARM64 Android through static recompilation of Wii U PowerPC code and Vulkan rendering. This fork adds Brazilian Portuguese translation, a HUD editor, .wua archive input and controller improvements; the app extracts and builds from a user-provided game dump.
- [Wipeout Pure: a native PSP static recompilation](https://awesomerea.org/resources/wipeout-pure-recomp-case/index.md): Case study · pure-recomp turns Wipeout Pure’s US Greatest Hits v2.00 PSP executable into a native Apple Silicon macOS or Windows program through ahead-of-time translation. It supplies host implementations of PSP services and Metal or Vulkan graphics, generating translated game code from the user’s disc image. Its checks compare frames with PPSSPP captures.
- [Wipeout XL Recompiled: a local PlayStation recompilation setup](https://awesomerea.org/resources/wipeout-xl-recomp-case/index.md): Case study · Wipeout XL Recompiled supplies a PSXRecomp recipe and recomp-ui setup host that generates and builds the PlayStation game from the user's own disc and BIOS. The repository includes title-specific identity and seed files; package setup and gameplay acceptance remain pending.
- [Wipeout XL Recompiled: PSXRecomp port of Wipeout XL](https://awesomerea.org/resources/wipeoutxl-recomp/index.md): Case study · Wipeout XL Recompiled is an unofficial PSXRecomp project for Wipeout XL (USA), SCUS-94351. Setup kits for Windows 10/11 x64, Linux x64, and macOS 15 on Intel and Apple Silicon generate the game code on the user's machine from a Redump-style CUE and all 12 BIN tracks. The runtime uses OpenBIOS and SDL3.
- [Witch Time: static recompilation of Bayonetta 3](https://awesomerea.org/resources/witch-time/index.md): Case study · Witch Time is a static recompilation of Bayonetta 3 for Nintendo Switch. It translates the AArch64 code to C from a personal dump and runs it on a reimplemented system layer, with NVN on Vulkan. The dump folder contains exefs and romfs. On Linux, cargo builds tools/wtbuild and wtbuild setup --dump takes that folder. A Windows release zip runs witch-time.exe and needs a Vulkan driver. Gameplay is 60 FPS in the tested Tokyo and Shibuya sections. The default resolution is 1600x900. The Old Picture Book uses update program 1, title ID 01004A4010FEA001, update 1.2.0, placed in program1.
- [World Driver Championship: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/world-driver-championship-recompiled-case/index.md): Case study · World Driver Championship: Recompiled builds an experimental native Windows port from the user's USA Nintendo 64 ROM. N64Recomp and RSPRecomp translate CPU code and BOSS graphics microcode, while RT64 renders low-level RDP commands. The author reports testing through menus and Hawaii practice driving.
- [Wreckless: recompiling The Yakuza Missions for Windows](https://awesomerea.org/resources/wreckless-yakuza-missions-recomp-case/index.md): Case study · Wreckless uses xboxrecomp to translate the original Xbox game's x86 code into C and compile a native Windows executable. Its analysis documents XBE sections, kernel imports, function recovery and ABI work. The author reports that initialization runs but rendering and gameplay are still blocked by an indirect call into a function body.
- [WWE '12 PC: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/wwe-12-pc-case/index.md): Case study · WWE '12 PC ports the Xbox 360 version of WWE '12 to Windows through ReXGlue static recompilation and a native Vulkan renderer. Its build uses the player's game files and includes code-generation patches, native hooks, and a script for finding function pointers omitted by the recompiler.
- [WWE '13 Recomp: an Xbox 360 static recompilation](https://awesomerea.org/resources/wwe13-recomp-case/index.md): Case study · WWE '13 Recomp translates the Xbox 360 game's PowerPC code to C++ with ReXGlue for native Windows and Linux builds. A launcher imports the user's game files and required title update, while game-specific patches address graphics, input, saves and content handling.
- [WWE 2K14 PC Recomp: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/wwe-2k14-pc-recomp-case/index.md): Case study · WWE 2K14 PC Recomp builds a Windows port of the Xbox 360 game through the ReXGlue static recompilation SDK. It reads the user's ISO or extracted game folder and includes game-specific patches and a launcher for graphics, controls, languages, DLC, and mods.
- [WWE 2K14 Recomp: a native Windows port by Xbox 360 static recompilation](https://awesomerea.org/resources/wwe-2k14-recomp-case/index.md): Case study · WWE 2K14 Recomp builds a native Windows x64 port by translating the Xbox 360 game's PowerPC code into C++ ahead of time with ReXGlue. Its game-specific work maps functions in title update 2.0.1.0 and repairs startup, cloth, texture and timing behavior. The author reports working menus, exhibition matches and saves, while several modes remain incompletely tested.
- [WWE 2K16 PC Recomp: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/wwe-2k16-pc-recomp-case/index.md): Case study · WWE 2K16 PC Recomp statically recompiles the Xbox 360 game for a PC build using the ReXGlue SDK. Its launcher accepts a user-supplied ISO or extracted folder and adds graphics settings, input mapping, DLC support and mods.
- [WWE SmackDown vs. Raw 2007: an Xbox 360 static recompilation](https://awesomerea.org/resources/wwe-svr2007-recomp-case/index.md): Case study · WWE SmackDown vs. Raw 2007 recompiles the Xbox 360 game's code with ReXGlue and renders it through game-specific native graphics code on PC. The release targets Windows directly and runs on Linux or Steam Deck through Proton. The author reports 60 FPS in entrances and matches, with resolution and controller settings exposed in game.
- [WWE SmackDown vs. Raw 2008: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/svr2008-recomp/index.md): Case study · This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2008. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.
- [WWE SmackDown vs. Raw 2009: Xbox 360 static recompilation](https://awesomerea.org/resources/svr2009-recomp/index.md): Case study · This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2009. Direct3D 12 draws on Windows, and Vulkan draws on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. Linux and Steam Deck run that Windows release through Proton.
- [WWE SmackDown vs. Raw 2010: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/svr2010-recomp/index.md): Case study · This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2010. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.
- [WWE SmackDown! Here Comes the Pain: static recompilation for Windows](https://awesomerea.org/resources/hctp-recomp-case/index.md): Case study · HCTP Recompiled is a static recompilation of WWE SmackDown! Here Comes the Pain for PlayStation 2, NTSC-U SLUS-20787, into a native Windows program. PS2Recomp translates the MIPS code to C++. A Direct3D 11 renderer draws the graphics, and the IOP runs the game's IRX modules.
- [X-Men Destiny: static recompilation for Windows](https://awesomerea.org/resources/xmd-recompiled/index.md): Case study · This recompiles X-Men Destiny for the Xbox 360 to Windows with ReXGlue. The entry executable is game/default.xex. setup.ps1 clones ReXGlue v0.10.0. The port targets Direct3D 12.
- [X-Wing Alliance: statically recompiling the 1999 PC game for Windows](https://awesomerea.org/resources/xwa-wing-alliance-case/index.md): Case study · xwa statically recompiles Star Wars: X-Wing Alliance by lifting its x86 code to C and linking it with a Win32/DirectX compatibility layer and Direct3D 11 renderer. The workflow uses the user's Steam installation and a locally obtained decrypted executable. The author reports an alpha build that reaches campaign flight and completes the first mission under autoplay; audio and much game logic remain untested.
- [Xbox 360 Native Ports: static recompilations of Xbox 360 games](https://awesomerea.org/resources/xbox360-native-ports/index.md): Case study · This repository ships Linux and Windows launchers that statically recompile Xbox 360 titles to x86-64 and draw them with Vulkan. rexmenu imports an ISO, an archive, an STFS package, an XEX, or an extracted folder, then checks the tree against content/content.sha256. The title table lists Burnout Revenge, Ridge Racer Unbounded, Midnight Club: Los Angeles Complete Edition, Split/Second, Banjo-Kazooie, Banjo-Tooie, Geometry Wars: Retro Evolved, Geometry Wars: Retro Evolved 2, Rez HD, Soulcalibur II HD Online, After Burner Climax, Hydro Thunder Hurricane, Space Giraffe, OutRun Online Arcade, Daytona USA, and Geometry Wars 3: Dimensions. Linux needs gamescope and Python 3. Windows 10 or 11 runs Launcher.bat. Saves stay in user-data.
- [Xbox 360 Quake 4 decomp: static recompilation with a native renderer](https://awesomerea.org/resources/xbox-360-quake4-decomp-case/index.md): Case study · Xbox 360 Quake 4 decomp builds a Windows port by translating a user-supplied Xbox 360 Quake 4 executable with ReXGlue and attaching game-specific hooks. Its alternate q4hle build routes the game's Direct3D calls through a native D3D11 renderer; the author reports testing the opening levels and documents remaining crashes and limited audio testing.
- [XC2 Recomp: statically recompiling Xenoblade Chronicles 2](https://awesomerea.org/resources/xc2-recomp-case/index.md): Case study · XC2 Recomp statically translates the Nintendo Switch game Xenoblade Chronicles 2 into a native x86-64 application for Windows and Linux. Its setup extracts the user's game and update files, lifts ARM64 code, and builds a runtime with Vulkan rendering. The author reports that the early build reaches the title screen and runs through the opening battle into Goldmouth.
- [XCX Recomp: statically recompiling Xenoblade Chronicles X: Definitive Edition](https://awesomerea.org/resources/xcx-recomp/index.md): Case study · XCX Recomp statically recompiles Xenoblade Chronicles X: Definitive Edition for Nintendo Switch into a Windows x86-64 executable with a Vulkan renderer. It is a fork of TotK Recomp. The project page says a new game, cutscenes, and gameplay run at 60 FPS by default, with a settings range of 30 to 360. XCX-Setup.exe builds the game from the owner's base-game files, the 2.0.0 update, and a key file. Add-on content is optional. Play starts xcx.exe. F1 opens settings and F10 opens the performance overlay.
- [Xena: Warrior Princess Recompiled: a PlayStation setup host](https://awesomerea.org/resources/xena-warrior-princess-recompiled-case/index.md): Case study · Xena: Warrior Princess Recompiled configures PSXRecomp and recomp-ui to generate a native build of the USA PlayStation game from a user's disc and BIOS. Its repository contains game configuration, symbol seeds and setup-host build files; the project report identifies gameplay, input, audio and save checks as outstanding.
- [Xena: Warrior Princess: PlayStation decompilation and static recompilation port](https://awesomerea.org/resources/xena-warrior-princess-ps1-case/index.md): Case study · Xena: Warrior Princess combines a matching decompilation of the PlayStation release SLUS-00977 with a playable Windows port. The decompilation rebuilds the game executable from C and assembly, while a separate static recompiler translates its MIPS functions to C. A project runtime supplies GPU, GTE, SPU, CD-ROM, controller, and BIOS behavior through SDL2 and other host code.
- [XenogearsRecomp: static recompilation of Xenogears](https://awesomerea.org/resources/xenogears-recomp-case/index.md): Case study · XenogearsRecomp is a static recompilation of Xenogears (USA) for the PlayStation. It uses PSXRecomp to turn MIPS R3000A code into C and then native x64, and it recompiles an OpenBIOS or retail SCPH1001.BIN backend with the game executable.
- [Xerenge: recompiling Burnout Revenge for PC](https://awesomerea.org/resources/xerenge/index.md): Case study · Xerenge recompiles the Xbox 360 retail releases of Burnout Revenge to C++ ahead of time. Europe hashes to SHA-256 34c1bd4d549c2c53f29d814fa5e5d1c04c533c5ca0c39e57b6c2538f44ff59b4. The USA release, supported since 0.4.7, hashes to 7abf689f52b70666ba92052bd157cfcae9ed6290dae298fbf639baa1d169f92b. Each build uses its own default.xex. ./scripts/bootstrap.sh takes the ISO, then rexglue/run.sh starts the game. A Vulkan machine is required. Apple silicon Macs are supported. Intel Macs are not. The renderer is the project's plume plugin.
- [XI on Anything: statically recompiling FINAL FANTASY XI clients](https://awesomerea.org/resources/xi-on-anything-case/index.md): Case study · XI on Anything recompiles FINAL FANTASY XI's 32-bit x86 FFXiMain.dll and FFXi.dll to C from the user's installation and runs them through a native game host. Its platform layer supplies graphics, audio, input and sockets across desktop and selected mobile or console targets. A LandSandBoat server provides sign-in and gameplay services.
- [Yakuza: Dead Souls Recompiled — statically recompiling the PS3 game for Windows](https://awesomerea.org/resources/yakuza-dead-souls-recomp/index.md): Case study · Yakuza: Dead Souls Recompiled translates the PlayStation 3 game's PowerPC PPU code and Cell SPU programs into a native Windows executable. It boots without PS3 firmware, plays the intro movies, reaches the title screen, and enters gameplay. Indoor scenes such as the gun tutorial were reported at the game's 30 frame cap. The crowded outdoor opening was reported at about 20 frames per second.
- [YW4 Recomp: statically recompiling Yo-kai Watch 4++ for PC](https://awesomerea.org/resources/yw4-recomp-case/index.md): Case study · YW4 Recomp translates the ARM64 code of Yo-kai Watch 4++ update 2.2.0 into a native Windows program. Its project runtime and Vulkan renderer support portions of the game from boot through early play and selected later scenes, with graphics changes including ultrawide output and revised shadows.
- [Zelda 64: Recompiled — a native Majora’s Mask port without a full source decompilation](https://awesomerea.org/resources/zelda64recomp-case/index.md): Case study · Uses N64Recomp to translate Majora’s Mask into a native application and RT64 for rendering. The project separates static recompilation from source decompilation while reusing decompilation headers and selected functions for patches and enhancements.
- [ZeldaAlttPSNESRecomp: static recompilation of A Link to the Past](https://awesomerea.org/resources/zelda-alttp-snes-recomp-case/index.md): Case study · Zelda ALttP SNES Recomp statically translates the 65816 CPU code of The Legend of Zelda: A Link to the Past into C with snesrecomp. PPU rendering, APU and SPC700 audio, DMA, and hardware registers run through an embedded snes9x core. The README says boot, the overworld, and dungeon sword combat have been checked, across those areas.
- [ZOE-Recompiled: statically recompiling Zone of the Enders for Windows](https://awesomerea.org/resources/zoe-recompiled-case/index.md): Case study · ZOE-Recompiled is a native Windows port of Zone of the Enders for the PlayStation 2, USA SLUS-201.48. PS2Recomp statically recompiles the MIPS code to C++. The runtime uses an OpenGL renderer, compiled vector-unit programs, and IOP and sound emulation.
- [2 Ship 2 Harkinian for PS4: a native Majora's Mask port](https://awesomerea.org/resources/2ship2harkinian-ps4-case/index.md): Case study · 2 Ship 2 Harkinian for PS4 adapts the decompilation-based Majora's Mask port to jailbroken PlayStation 4 consoles. It uses the OpenOrbis toolchain and Piglet rendering, with patches and technical notes covering PS4 platform integration and hardware-specific audio, memory and graphics issues.
- [2 Ship 2 Harkinian: a native Majora’s Mask port built on the decompilation](https://awesomerea.org/resources/2ship2harkinian-mm-port-case/index.md): Case study · 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. Game data comes from a user-supplied ROM and is packed into an archive that custom asset packs can override. It targets a playable PC port with enhancements.
- [358/2 Days for Android: porting Kingdom Hearts to dual-screen devices](https://awesomerea.org/resources/khdays-358-android-case/index.md): Case study · 358/2 Days for Android ports Kingdom Hearts 358/2 Days to Android using the upstream khdays-port and its decompiled C game code. It adds an Android app, ROM import, touch controls and a two-screen layout for the AYN Thor; on one-screen devices, both game screens share the display.
- [3D Pinball – Space Cadet: a PlayStation 2 port](https://awesomerea.org/resources/space-cadet-ps2/index.md): Case study · This ports the Space Cadet pinball decompilation to the PlayStation 2. It is built with the PS2SDK. Game data from 3D Pinball Space Cadet or the Full Tilt! Pinball Cadet table goes in mass:/APPS/3DPINBALL on USB storage. The README says the Full Tilt table works on PCSX2 and not on real hardware.
- [3D Pinball — Space Cadet: a Nintendo DS port of the decompilation](https://awesomerea.org/resources/3dpinball-nds-case/index.md): Case study · 3dpinball-nds adapts the Space Cadet Pinball decompilation into a Nintendo DS port built with BlocksDS. Its ARM7 and ARM9 source implements the handheld platform layer, while game data comes from the user's Windows release.
- [3SX: a native Street Fighter III: 3rd Strike port continuing the PS2 decompilation](https://awesomerea.org/resources/3sx-third-strike-native-port-case/index.md): Case study · 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. README stresses that it is neither a recompilation nor emulation. The port needs the player’s own PS2 game files and works toward arcade-accurate balance, which an optional Statcheck build tests against CPS3 RAM states recorded from Fightcade replays.
- [9mm Vita: rehosting 9mm HD Android on PS Vita](https://awesomerea.org/resources/9mm-vita-case/index.md): Case study · 9mm Vita ports 9mm HD Android to PS Vita by loading the user's ARMv7 game executable into memory. Its native compatibility layer resolves imports, patches a checked game build and maps Vita controls, while the user's APK and downloaded game data supply the original program and assets.
- [A Link to the Past 3DS: a dual-screen Zelda3 port](https://awesomerea.org/resources/a-link-to-the-past-3ds-case/index.md): Case study · A Link to the Past 3DS adapts the reverse-engineered Zelda3 engine for Nintendo 3DS with gameplay on the upper screen and maps, inventory and settings on the lower screen. It extracts assets locally from the user's USA ROM and adds 3DS rendering, controls and per-ROM settings.
- [AceCombat3-xport: an Ace Combat 3 PlayStation decompilation port](https://awesomerea.org/resources/acecombat3-xport-case/index.md): Case study · AceCombat3-xport ports reconstructed code from the Project Nemo edition of the PlayStation game Ace Combat 3: Electrosphere. Its startup code loads ACE3.BIN from DATA, while an extraction script processes the game's resource archives and XA sectors.
- [Airborne Ranger: lifting a DOS game into a C port](https://awesomerea.org/resources/airborne-ranger-port-case/index.md): Case study · Airborne Ranger ports the 1987 DOS game to C by lifting AR.EXE and its TANDYSND.EXE overlay with a masm2c-style translator, then hand-checking the output against the reference binaries. An SDL2 frontend runs with the player's original files, and the repository includes lifted code, generation scripts and tests.
- [ALTTP-DX: rebuilding A Link to the Past for native PC play](https://awesomerea.org/resources/alttp-dx-case/index.md): Case study · ALTTP-DX rebuilds The Legend of Zelda: A Link to the Past as a native PC game that extracts its assets from a user-supplied US ROM. Its Zig source adds widescreen display, menus and graphics options. A development mode runs the original machine code alongside the game and compares RAM each frame.
- [Amplitude: reconstructed PlayStation 2 game source](https://awesomerea.org/resources/wavelength-amplitude-case/index.md): Case study · Amplitude reconstructs source for the 2003 PlayStation 2 rhythm game and builds its main executable and IOP modules with ps2dev tools. A user-provided North American or European disc supplies assets for a rebuilt image. The author reports playable builds of both releases; the European DNAS2 online library remains unrecovered.
- [Angry Birds ARM64: reconstructing the Angry Birds 1.4.2 Android runtime](https://awesomerea.org/resources/angry-birds-arm64-case/index.md): Case study · Angry Birds ARM64 rebuilds the native runtime of Angry Birds 1.4.2 for AArch64 Android devices so the game's Lua logic can run with locally supplied game data. The work uses ARMv7 runtime analysis and behavioral comparisons to reconstruct rendering, input, physics bridges, audio, persistence and Android lifecycle services.
- [Animal Crossing gcNX: a native Switch port of the GameCube decompilation](https://awesomerea.org/resources/animal-crossing-gcnx-case/index.md): Case study · Animal Crossing gcNX ports the decompiled GameCube game to Nintendo Switch by compiling its code for ARM and translating GX graphics to OpenGL ES. It reads game resources from the user's USA disc image; the repository also documents an Android port built on the same decompilation.
- [Animal Crossing: a native PC port of the GameCube decompilation](https://awesomerea.org/resources/animal-crossing-pc-port-case/index.md): Case study · 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. Game assets are read at startup from the user’s own disc image instead of being shipped. It is a port built on ACreTeam’s ac-decomp.
- [Animal Crossing: an Android port of the GameCube decompilation](https://awesomerea.org/resources/acgc-android-port-case/index.md): Case study · Animal Crossing Android Port runs decompiled GameCube game code natively on Android, building on an existing PC port. It translates GX graphics to OpenGL ES 3 and adds touch controls, a launcher that imports the user’s disc image, and on-device texture conversion.
- [Animal Crossing: Wild World: a native PC port of the decompilation](https://awesomerea.org/resources/animal-crossing-wild-world-native-case/index.md): Case study · Animal Crossing: Wild World, native compiles decompiled code from the USA Rev 1 Nintendo DS game into a PC program. A host layer supplies DS hardware services, SDL input, and CPU or WebGPU renderers; this branch changes the source for portability. The byte-matching ROM build is retained at the matching tag.
- [Another World JS: a browser port interpreting the game's bytecode](https://awesomerea.org/resources/another-world-js-case/index.md): Case study · Another World JS ports Another World to an HTML5 browser runtime by implementing its 26 game bytecode opcodes in JavaScript. Extraction scripts convert original DOS and 15th anniversary data files into JavaScript input; the port adds palette switching, alternate resolutions and rewind.
- [Another World: a Commander X16 port of the original virtual machine](https://awesomerea.org/resources/another-world-commander-x16-case/index.md): Case study · Another World is ported to Commander X16 in 65C02 assembly, using data files from the user's MS-DOS game copy. The implementation adapts the original virtual-machine architecture for the X16 and builds with CC65. The author reports performance and audio limits, including missing music.
- [Ape Escape: differential C reconstruction and native port](https://awesomerea.org/resources/ape-escape-decomp-port-case/index.md): Case study · Ape Escape translates functions from the US PlayStation game's MIPS code into structured C and compares them against the original instructions on shared RAM images. A native SDL3 and OpenGL viewer runs selected game logic; the author reports about 1,500 functions differentially checked.
- [Apocalypse-xport: an Apocalypse PlayStation decompilation port](https://awesomerea.org/resources/apocalypse-xport-case/index.md): Case study · Apocalypse-xport ports reconstructed code from the PlayStation game Apocalypse. Its C++ source initializes game systems and handles CD data by resolving DATA paths, reading CD.WAD resources and mounting APOC.XA streams.
- [Arcanum Community Edition: rebuilding Arcanum for modern systems](https://awesomerea.org/resources/arcanum-community-edition-case/index.md): Case study · Arcanum Community Edition rebuilds Arcanum as a replacement executable for modern operating systems while using data from the player's game installation. Its C source covers game and engine modules, with named APIs and annotations in some areas and unresolved names in others.
- [Arcanum project: porting the game to iOS and macOS](https://awesomerea.org/resources/arcanum-ios-port-case/index.md): Case study · The project ports the game to iOS and macOS with a C++ and Metal renderer that loads tile .art files extracted from the user's original game into an Arcanum Revitalized folder. Its current build renders the crash-sector terrain and a moving player character on physical iOS devices.
- [Atlantis Native: porting the Atlantis and Atlantis II engines to Rust](https://awesomerea.org/resources/atlantis-native-case/index.md): Case study · Atlantis Native ports the reverse-engineered CryOmni3D Atlantis engine to Rust for Atlantis: The Lost Tales and Atlantis II. It reads files from the user's own game copies and runs their scripts, panoramas, cinematics and puzzles on desktop systems and in browsers, with optional display and bug fixes.
- [axis-web: a WebAssembly reconstruction of AXIS](https://awesomerea.org/resources/axis-web-case/index.md): Case study · axis-web ports the Korean action game AXIS to browsers by reconstructing client formats and simulation layers in C and compiling them to WebAssembly. WebGL renders original maps from user-supplied files, while documented packet codecs and a WebSocket relay support multiplayer state exchange.
- [BackstabRecomp: rehosting the Android BackStab HD game on Windows](https://awesomerea.org/resources/backstabrecomp-case/index.md): Case study · BackstabRecomp runs the user-supplied Android ARMv7 library from BackStab HD 1.2.8d in a Windows x64 host through AndroidRecomp. It implements the game's needed Android, JNI, graphics, audio, filesystem, input, and lifecycle behavior, with widescreen rendering changes.
- [BallPad: an iOS and iPadOS port of Super Mario Strikers](https://awesomerea.org/resources/ballpad-strikers-port-case/index.md): Case study · BallPad ports Super Mario Strikers to iOS and iPadOS by compiling a community decompilation-based source port as native ARM64 code. It adds Metal presentation, touch and physical-controller input, and an importer for the user's USA revision 0 disc image.
- [BananaPad: bringing Donkey Kong 64 Recompiled to Apple devices](https://awesomerea.org/resources/bananapad-case/index.md): Case study · BananaPad adapts the Donkey Kong 64 static-recompilation port for Apple Silicon macOS, iPhone and iPad. Its scripts generate game and RSP code from a user-supplied ROM, then combine that code with a native Apple shell, Metal rendering, touch controls and game-specific patches. The author reports playable macOS and Simulator builds and a physical iPad build that renders the game.
- [Baroque: a PlayStation 2 code translation for native Windows](https://awesomerea.org/resources/baroque-native-port-case/index.md): Case study · Baroque translates the USA PlayStation 2 game's routines into a native Windows C++ port. It reads models, game data, audio and movies from the user's disc image through its own loaders, and adds widescreen presentation, higher display frame rates and keyboard and mouse controls.
- [BarrelPad: an Apple port of the reconstructed Diddy Kong Racing engine](https://awesomerea.org/resources/barrelpad-diddy-kong-racing-case/index.md): Case study · BarrelPad adapts Golden Balloon's decompilation-based Diddy Kong Racing port for Mac, iPhone, and iPad. It adds Apple lifecycle integration, game-specific touch and controller input, and local loading of the user's ROM while the reconstructed game logic runs as native host code.
- [BattleShip: an AI-assisted Super Smash Bros. native port](https://awesomerea.org/resources/battleship-port-case/index.md): Case study · Ports the existing Super Smash Bros. N64 decompilation using libultraship and Torch. The author’s earlier README describes agent-built graphics/audio comparison tools and differential debugging against emulator behavior, rather than claiming AI recovered the game from a cartridge without prior community work.
- [bbport: a native Bloodborne runtime for Linux and Windows](https://awesomerea.org/resources/bbport-bloodborne-case/index.md): Case study · bbport runs the original Bloodborne 1.09 x86-64 game code on Linux and Windows by preparing its executable as a memory image and replacing PS4 system libraries with a game-specific runtime. Its renderer translates PS4 GPU commands and shaders to Vulkan; the author reports playable areas, sound, saving and gamepad support.
- [BearBirdPad: a Banjo-Kazooie recompilation port for iPhone and iPad](https://awesomerea.org/resources/bearbirdpad-banjo-kazooie-ios-case/index.md): Case study · BearBirdPad ports the BanjoRecomp version of Banjo-Kazooie to iPhone and iPad. Its iOS integration adds Metal rendering, movable touch controls, controller handling, local ROM import and save storage. Build scripts generate the game module from a player's supported NTSC-U 1.0 ROM.
- [Beat Hazard 2 Vita: an Android binary port for PS Vita](https://awesomerea.org/resources/beat-hazard-2-vita-case/index.md): Case study · Beat Hazard 2 Vita runs the game's Android ARMv7 executable on PS Vita by loading it into memory, resolving imports with native functions and applying runtime patches. The port also adds custom-song support for WAV, MP3, FLAC and OGG files.
- [Bejeweled LIVE + decomp: a Windows Phone game ported to MonoGame](https://awesomerea.org/resources/bejeweled-live-plus-monogame-case/index.md): Case study · Bejeweled LIVE + decomp ports decompiled C# source from the Windows Phone 7 release of Bejeweled Classic to MonoGame. Its solution contains game, graphics, audio and interface code and builds after the user supplies the original XAP assets.
- [BellPad: an Apple platform port of Animal Crossing](https://awesomerea.org/resources/bellpad-animal-crossing-port-case/index.md): Case study · BellPad ports the original US GameCube Animal Crossing to Apple Silicon macOS, iPhone and iPad using a decompiled game core. It adds Apple platform integration, Metal-backed rendering, local disc import, input handling and save support through tracked compatibility patches.
- [Birdman64: a native Pilotwings 64 port](https://awesomerea.org/resources/birdman64-case/index.md): Case study · Birdman64 ports Pilotwings 64 to native PC play by compiling decompiled game source against a user-supplied US ROM during first-time setup. Its runtime adds widescreen rendering, modern controls and two-player split-screen; the project also describes experimental Android support and iOS test builds.