The decomp.dev leaderboard, a public tracker for volunteer game decompilation projects, has been frozen after its creator said AI-generated forks turned careful reverse-engineering work into a hollow numbers game. The site’s operator pointed to a wave of AI-assisted copies that raced to finish other teams’ projects and ship rough PC ports, flooding the index with what they called “AI slop”.
Key takeaways
- ✓Decomp.dev has frozen its public leaderboard ranking game decompilation projects by completion percentage.
- ✓The site's creator blames AI-driven forks that auto-complete other teams' decompilation work.
- ✓Some forks reportedly rushed rough, AI-assisted PC ports to chase leaderboard rankings.
- ✓The move highlights growing tension between AI code tools and volunteer game preservation communities.
- ✓Decompilation projects rebuild original source code from compiled game binaries, often for preservation or ports.
For years, decomp.dev has served as a central scoreboard for one of gaming’s quieter preservation movements: decompilation. Volunteers pick apart compiled game binaries, often from consoles like the N64, PS1 or PS2, and painstakingly rebuild readable source code that matches the original, instruction for instruction. The decomp.dev leaderboard turned that slow, technical grind into something visible, ranking dozens of projects by how close their rebuilt code matched the original game.
Table of Contents
What happened to the decomp.dev leaderboard
According to the project’s creator, the public index became a target rather than a useful signal. Forks of existing decompilation projects began appearing that used AI tools to rapidly fill in unfinished sections of someone else’s codebase, inflating their position on the decomp.dev leaderboard without doing the manual verification work the scene is built on.
The creator’s complaint was specific: these AI-assisted forks were not original research. They borrowed the groundwork laid by human volunteers, then used generative tools to bulk out matching percentages, before some were rushed into playable PC ports. That combination, chasing a visible ranking while skipping the careful checking that usually accompanies a decompilation release, is what prompted the decision to pull the public leaderboard rather than let it keep rewarding the behaviour.
Decompilation accuracy is normally measured as a “match” percentage, comparing the rebuilt source code’s compiled output against the original game binary. A high match score is meant to reflect genuine, verified reverse-engineering effort. When AI tools can generate code that compiles to something functionally similar without a human confirming it is correct, that percentage stops meaning what it used to.
Why AI slop became a problem for a niche community
Decompilation projects are typically slow by design. Teams work through a binary function by function, cross-checking their output against the original compiled code before merging changes. That discipline is part of why decompilation has earned trust from both game preservation advocates and, at times, the original studios whose games are being rebuilt.
AI code-generation tools disrupt that pace. Large language models can produce code that looks plausible and often compiles, but without the same verification against the original binary that human contributors apply. When that output gets folded into a fork and pushed up the decomp.dev leaderboard, it creates the appearance of progress that has not actually been checked or earned the way the rest of the scene expects.
The term “AI slop” has become shorthand across several corners of the internet for exactly this kind of output: content or code generated quickly and cheaply, with a volume that overwhelms the ability of a community to review it properly. In decompilation, where projects are hosted as open-source repositories on GitHub and rely on public trust in their match statistics, that flood has a direct cost.
Decompilation versus recompilation: why the distinction matters
Readers unfamiliar with the scene can easily confuse decompilation with recompilation, but the two serve different goals and carry different risks when AI gets involved.
| Term | What it means | Typical use |
|---|---|---|
| Decompilation | Rebuilding readable source code that matches an original compiled binary, function by function | Preservation, modding, ports, documentation |
| Recompilation | Taking a verified decompiled project and recompiling it for a new platform | Native PC or modern console ports of old games |
| Match percentage | How closely rebuilt code reproduces the original binary’s compiled output | Tracked publicly, historically on the decomp.dev leaderboard |
| AI slop | Low-quality, high-volume AI-generated output that overwhelms review processes | Used critically to describe unchecked AI code or content |
Recompilation projects, like the fan-made PC ports built from verified Zelda or Mario 64 decompilations, depend entirely on the accuracy of the underlying decompiled code. If a decompilation fork has been padded out with unverified AI output to climb the rankings, any recompiled port built on top of it inherits those errors, which is precisely the “rough PC ports” scenario the decomp.dev creator flagged as a trigger for the freeze.
What it means for game preservation and modding communities
Game decompilation sits in a legally and ethically careful space already. Projects generally avoid distributing copyrighted game assets, focus on code rather than art or audio, and lean on goodwill from both fans and, occasionally, original developers who tolerate the work because it is transparent and rigorously checked.
An influx of AI-assisted forks threatens that goodwill on two fronts. It makes it harder for outside observers, including studios watching these projects, to trust that a high match percentage reflects real, careful work. It also risks drowning out the smaller, legitimate teams who built the original decompilations, since a flashier AI-assisted fork can appear to overtake months of genuine human effort almost overnight.
The decision to freeze the decomp.dev leaderboard is a defensive move rather than a permanent shutdown of decompilation tracking itself. It reflects a broader pattern seen elsewhere as generative AI tools spread into open-source and volunteer-run spaces: when a public metric can be gamed cheaply, the people who rely on that metric for trust often have to pull it rather than let it keep rewarding the wrong behaviour. The episode adds to a wider conversation about how AI tools have already reshaped parts of game development, well beyond the big studios, and why efforts to protect digital game ownership and preservation keep running into new technical pressures. Even major publishers are not immune to the shift, as seen in Capcom’s own push to fold AI into its RE Engine, while separate efforts around AI tools that generate playable games from text prompts show how fast generative code is spreading through gaming more broadly.
Frequently asked questions
What is decomp.dev?
Decomp.dev is a community hub that tracked and ranked volunteer game decompilation projects, showing how closely each team’s rebuilt source code matched the original compiled game binary.
Why did the decomp.dev leaderboard get frozen?
Its creator said AI-generated forks were gaming the rankings by auto-completing other teams’ unfinished decompilation work and rushing the results into rough PC ports, undermining trust in the leaderboard as a genuine measure of progress.
Is game decompilation legal?
Decompilation projects generally avoid distributing copyrighted assets and focus on rebuilding code rather than sharing original game files, which is part of why many have operated with relative tolerance from rights holders, though legal risk varies by project and jurisdiction.
Does this affect existing fan-made PC ports?
It could. Recompiled PC ports rely on the accuracy of the decompilation they are built from, so forks padded with unverified AI output risk passing on errors to any port built on top of them.
