Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Retro Reversing?
Retro Reversing is a reference site and community hub for reverse engineering retro games: how they were built, how their code and data are structured, and how to take them apart. Its focus is technical archaeology rather than playing or emulation guides — source code, development hardware, SDKs, toolchains, file formats, and decompilation.
What you'll find there
- Source code and decompilations — original sources and community decompilation projects, including material tied to the Nintendo "Gigaleak" (for example Yoshi's Island source and SNES art workspaces).
- Development hardware and SDKs — console and PC development kits, devkit hardware write-ups, and software development kits for systems such as the Game Boy and NES/Famicom.
- File formats — system-by-system breakdowns, e.g. PSX-EXE, Game Boy (DMG/GBC), and Super Famicom/SNES formats.
- Tools and techniques — decompilers, disassemblers, Ghidra material, cheat cartridges, and cracking topics.
- Foundations — maths for game developers (vectors, quaternions, matrices) and platform-specific reversing introductions.
- Industry history — company and toolchain history, magazines, and how studios actually worked.
Coverage is broad but uneven: Nintendo platforms dominate (N64, SNES, Game Boy, GBA, DS, GameCube, Wii), with solid Sega, Sony, Microsoft, and older computer coverage, plus smaller entries like Pokémon Mini and WonderSwan. Content is tagged, so browsing by tag or platform is the fastest route.
Who it's for
Homebrew developers and ROM hackers who want real toolchain and format detail; preservationists and historians tracing how games were made; students learning decompilation on well-documented targets; and curious programmers who want to see production code from the 8- and 16-bit eras.
A practical next step
Pick your target console first, then work in this order: read the platform's reversing introduction, look up its file formats, check the SDK/devkit pages to understand the original toolchain, and only then move to a decompilation or source-code article. That sequence gives you the vocabulary the deeper write-ups assume. For emulator-side context on specific systems, official project sites such as MAME are useful companions when a page references emulation of obscure hardware.
Trade-off to expect: this is enthusiast-maintained material of varying depth and completeness, and leaked or partially reconstructed sources carry legal and accuracy caveats. Treat individual pages as starting points and verify claims against the hardware or a working emulator.
How do I get started with game reverse engineering using the tutorials on Retro Reversing?
Start with the site's introductory material, pick one platform you already know well, and work through a single concrete artifact — a file format, an SDK, or a source-code listing — rather than trying to absorb the whole catalogue at once.
A practical first path
- Read the introduction to game reversing to get the vocabulary: disassembly, decompilation, symbols, toolchains, file formats.
- Choose one platform you have played or emulated before. Familiarity with the games matters more than picking the "easiest" hardware.
- Study that platform's file formats page so you understand what the data on disk or in a ROM actually represents.
- Look at a development kit or SDK page for the same console. Knowing what the original developers' tools produced explains why retail data looks the way it does.
- Move to a game-specific post — a decompilation, source-code listing, or art-workspace archive — and try to reproduce one small result, such as locating a known data table or matching a function.
What the site actually covers
The catalogue is organised around tags, which makes it easy to filter by interest:
- Platforms — Nintendo 64, SNES, Game Boy, Game Boy Advance, DS, GameCube, Wii, PlayStation, PS2, PSP, Saturn, Dreamcast, Mega Drive, Xbox and others.
- Technical topics — source code, decompilations, SDKs, development hardware, file formats, symbols, game engines, maths for game developers, and tooling such as Ghidra.
- Context — industry history, magazines, leaks, and news, useful when you want to know why a particular prototype or archive exists.
That mix suits two different readers. Someone learning reverse engineering for its own sake should stay on the format and tool pages. Someone researching how a specific game was built will get more from the source-code, art-workspace and SDK material, where the pages document real development artefacts rather than teaching technique.
Choosing a starting point
| If you want to… | Start with | Trade-off |
|---|---|---|
| Learn the general method | Introduction and decompiler explainers | Conceptual, but no single game to anchor it |
| Get a quick win | A file format page for a console you know | Narrow; little reversing theory |
| Understand original workflow | SDK and development hardware pages | Historical focus, less hands-on practice |
| Study real code | Source code and decompilation posts | Large, sometimes incomplete archives |
Equipment and habits
You will need an emulator or original hardware for the target system, a disassembler or debugger, and a hex editor. Expect to read assembly for the console's CPU, so pick a platform whose architecture is documented. Keep notes on addresses, offsets and function names — reversing is mostly bookkeeping, and revisiting a project after a week without notes is painful.
Next step: open the platform index, pick the console you know best, and read its file-format page alongside one game-specific post. That pairing gives you both the theory of the data and a real example of it in use.
Which tools and decompilers are recommended for reversing specific retro consoles like the Game Boy or SNES?
Retro Reversing is best used as a console-by-console index rather than a single tool recommendation. Its own tags show the pattern: platform pages (Game Boy, SNES, Nintendo 64, PlayStation, Sega Saturn), plus categories for SDKs, development hardware, source code, decompilations, file formats and tools such as Ghidra. So the practical answer is to start from the console page, then pick tools that match the artifact you actually have.
Match the tool to what you are reversing
| Situation | What tends to work | Trade-off |
|---|---|---|
| You have a ROM and want to trace code | Disassembler/debugger suited to that CPU, plus an emulator with debugger support | Fast to start, but you reconstruct meaning by hand |
| You have symbols or a leaked SDK | Symbol-aware disassembly and comparison against original libraries | Much faster, but only for the specific revision you have |
| You want readable C-like code | A decompiler, ideally one with an existing project for that game | Highest effort; matching the original build is the hard part |
| You care about assets and data | File-format documentation and extraction tools | Great for art/audio study, less useful for logic |
For Game Boy work, the useful entry point is the site's Game Boy pages covering reverse engineering, SDKs and file formats (DMG/GBC). For SNES, look at the SNES/Super Famicom file-format material and the source-code archives, including the Yoshi's Island and Super Mario Kart workspace posts. Decompilation-specific projects are indexed under the decompilation tag, and general tooling under tools — Ghidra appears among the tagged tools.
A concrete reader scenario
Suppose you want to understand how a Game Boy title stores its tilemaps. Start with the Game Boy file-format page to identify the data, then use an emulator debugger to find where that data is read, and only then consider a disassembler for the surrounding routine. If your goal is instead to rebuild a SNES game as compilable C, you need a decompilation project for that title, not a general-purpose tool — the site's decompilation and source-code sections are where those live.
Decision criterion
Choose the console page first, then the artifact: ROM, symbols, SDK, or source. If you have symbols or an SDK, use them before any decompiler; if you only have a ROM, expect disassembly plus manual annotation. Community help is available through the site's own community, and for emulator-side debugging the established projects are worth knowing: GitHub hosts many of these tool repositories, mGBA covers Game Boy Advance and Game Boy debugging, and ProblemKaputt hosts no$gba and related debugging documentation.
Where can I find leaked source code and development kits for classic games?
For leaked source code and development kits, Retro Reversing is a strong starting point: it is a hub for retro game reverse engineering, with a tag system that lets you jump straight to "Source Code," "SDK," "Leak," "Development Hardware," and "Tools." Its own listing shows how much of that material is concentrated on Nintendo platforms (Nintendo 64, SNES, Game Boy, GameCube, Wii) alongside Sega Saturn, Dreamcast, MegaDrive, Sony PlayStation lines, Xbox, and various handhelds.
What you actually find there
- Source code and decompilations — posts like the original Yoshi's Island source code and Mr Do! (Game Boy) source, plus a "Decompilations" section.
- Development kit material — SDK and development-hardware pages, for example NES (Famicom) Development Kit Hardware and Game Boy Software Development Kits.
- Leak documentation — the Gigaleak entries, such as the NEWS_11 workstation restore and Super Mario Kart 2D art workspace, which show what a leaked archive contains beyond raw code.
- File formats and tooling — PSX-EXE, SNES and Game Boy file formats, plus Ghidra and disassembler-related material.
How to use it
Start with the tag pages rather than the feed: pick your platform, then cross-reference "Source Code," "SDK," and "Tools" so you get the code plus the format documentation needed to build or inspect it. A realistic scenario: you want to compile a Game Boy prototype, so you read the SDK page for the toolchain, the file-format page for the ROM layout, and a source-code post for a working example — three pages that only make sense together.
Trade-offs and other places to look
Leaked SDKs and source are legally murky and often incomplete, and the site itself marks some material "Incomplete." Assume you will need to fill gaps from emulator and homebrew documentation. For the hardware and preservation side, compare with NESdev Wiki for NES/Famicom technical detail, Problem Kaputt for console hardware documentation, and GitHub for active decompilation projects where you can see build instructions and issue threads rather than a static archive.
Decision criterion: use Retro Reversing to discover and orient yourself, then move to a project-specific repository when you need something that actually compiles.
What do the leaked Gigaleak files reveal about Nintendo's development history?
The Gigaleak files matter less as a treasure chest of finished games and more as a paper trail of how Nintendo built them. Retro Reversing's coverage of the leak focuses on development hardware and workspaces rather than playable builds: a Super Famicom-era workstation restore attributed to an engineer nicknamed Hino, 2D art workspaces for Yoshi's Island, Super Mario Kart and Stunt Race FX, and related source material. Read together, they show the everyday mechanics of 1990s console development — artists working in bespoke tools, revisions accumulating in project folders, and source trees surviving on workstation disks long after the shipped cartridge.
What the material tends to contain
- Source code and partial builds for games at various stages of completion, useful for seeing how code was structured before compression, localisation and final optimisation.
- Art and level workspaces: the Yoshi's Island and Super Mario Kart items are workspace archives, so they document how graphics were authored and assembled, not just the final sprite sheets.
- Development hardware and toolchain traces: the Hino workstation restore is the clearest example — it points to the machines and setups engineers actually sat at.
- SDK and library references that recur across projects, which is where the leak is most valuable for understanding shared internal technology.
Why this is useful, and to whom
For a hobbyist decompilation project, the practical payoff is naming. Official symbol names, file layout and library boundaries can replace guessed labels, which shortens the grind of matching compiled code to C. For a historian or journalist, the interest is institutional: which teams shared tools, how long a codebase lived, and how much of a game's identity came from a small set of internal utilities. For an artist or designer studying period craft, the workspaces are the closest thing to watching the original process.
The trade-off is that leaked material is fragmentary and uneven. A workstation restore may be incomplete or missing its original environment; a source tree may be a mid-project snapshot rather than a release candidate. Treat any single file as evidence of what existed at one moment, not as the definitive version of a game.
Where to start
Pick one title you already know well and follow its thread rather than browsing the leak as a whole. If you are decompiling, begin with the symbol and SDK files, since they pay off across every function you touch; if you are researching history, the workspace archives and hardware restorations tell a clearer story than raw source dumps. Retro Reversing collects these threads alongside broader reverse-engineering material at Retro Reversing, and the decompilation community around projects such as GitHub is where symbol discoveries usually get discussed and folded back into matching work.
How can I use file format documentation to extract assets from retro games?
File format documentation tells you where the meaningful bytes live inside a game's data files, so you can pull out graphics, audio, text and level data without guessing. On Retro Reversing, format write-ups sit alongside source code, SDK and hardware material — for example the site lists dedicated pages for Game Boy File Formats (DMG, GBC) and Super Famicom / SNES File Formats. Those pages are documentation, not extractors: they describe structure, and you still supply the tooling.
A practical workflow
- Identify the container. A ROM or disc image is usually an archive of smaller files or a flat blob with an index. Documentation tells you whether there's a header, a pointer table, or a directory of offsets.
- Map the header. Note magic bytes, endianness, counts and offsets. This is what lets you split one large file into individual assets.
- Decode the payload. Formats like tile graphics, palettes, compressed blocks or sample banks need a specific decoder. Compression is the usual sticking point.
- Rebuild and verify. Assemble extracted sprites or audio back into a viewable form and compare against the running game — that's your correctness check.
Where documentation helps most
| Task | What the docs give you | What you still need |
|---|---|---|
| Splitting an archive | Offsets, table layout, file count | A script to read the table |
| Graphics | Tile size, bit depth, palette order | A viewer or converter |
| Audio | Sample rate, codec, bank structure | A decoder or tracker |
| Text | Encoding, string table, pointer format | A dumper and re-inserter |
If you're new to this, start with one platform and one asset type rather than a whole game. Pick a format with simple, uncompressed graphics, get a single sprite on screen, then move to compressed data. The site's tag list shows where the density of material is — Game Boy, SNES, Nintendo 64 and PlayStation are heavily covered, so documentation and community knowledge are easier to find there.
Two cautions. First, documentation often describes the common case; retail games frequently modify or extend a format, so treat a mismatch as information, not failure. Second, extracted assets are usually still copyrighted — this work is best suited to study, preservation, modding of games you own, and interoperability research.
User reviews (0)