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”.

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. For many contributors, a spot on decomp.dev was the main public record of months, sometimes years, of unpaid, highly technical labour, which is part of why its freeze has been felt so sharply across the community.

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.

The freeze is a site-wide change rather than action against a single project. Rather than attempt to police every submission by hand, the decomp.dev operator opted to pause the ranking mechanism itself, removing the incentive to race for a higher position until a better way of verifying genuine progress can be worked out. That approach mirrors how other volunteer-run trackers have responded when a public score becomes easier to game than to earn.

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. On decomp.dev specifically, that percentage was the single figure most contributors and outside observers used to judge how far along a project really was, so losing confidence in it undermines the whole point of the tracker.

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.

Volunteer maintainers are usually the only people checking pull requests, often in their spare time, which makes the scene especially vulnerable to a sudden spike in low-quality submissions. A single maintainer who might normally review a handful of carefully tested changes a week can be swamped by forks that claim large jumps in match percentage overnight, with little practical way to confirm whether that jump reflects real, verified work or AI output that simply happens to compile.

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.

TermWhat it meansTypical use
DecompilationRebuilding readable source code that matches an original compiled binary, function by functionPreservation, modding, ports, documentation
RecompilationTaking a verified decompiled project and recompiling it for a new platformNative PC or modern console ports of old games
Match percentageHow closely rebuilt code reproduces the original binary’s compiled outputTracked publicly, historically on the decomp.dev leaderboard
AI slopLow-quality, high-volume AI-generated output that overwhelms review processesUsed 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.

That knock-on effect is part of why the distinction matters beyond the decompilation scene itself. A recompiled port is usually what ordinary players actually download and run, long after the original decompilation work is finished. If the underlying match percentage on decomp.dev no longer reliably signals verified accuracy, players downstream have no easy way to tell whether a given port is built on solid, human-checked foundations or on a fork that simply looked complete.

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.

There is also a quieter concern around attribution and credit. Decompilation has traditionally operated on an informal code of conduct in which forks acknowledge the original team’s groundwork rather than presenting borrowed progress as new work. AI-assisted forks that race ahead on the decomp.dev leaderboard without that acknowledgement risk eroding a norm the scene has relied on for years to keep collaboration, rather than competition, at its centre.

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.

What comes next for decomp.dev is still unclear. Some possibilities being discussed informally within decompilation communities include requiring maintainer sign-off before a project’s match percentage counts toward any future public ranking, flagging forks that build heavily on another team’s unfinished work, or simply keeping individual project pages visible while leaving the comparative leaderboard itself offline indefinitely. Whatever shape a revival takes, it will likely need some way to distinguish verified, human-checked progress from code that merely compiles, which is the exact problem the original freeze was meant to address.

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.