If anyone needs a full list of these projects (which includes this one), there's a pretty good selection here:

https://decomp.dev/projects

Though these may have a few they missed:

https://readonlymemo.com/decompilation-projects-and-n64-reco...

https://github.com/CharlotteCross1998/awesome-game-decompila...

- Moon Lights 2: https://github.com/Armonte/ml2decomp

- F-15 Strike Eagle II: https://github.com/neuviemeporte/f15se2-re

I've also been in discussion with people working on decompilation projects which are private. I won't share details, but it includes both well-known games and recent games (as in, built with link time optimizations).

The decompilation community is quite decentralized, with lots of Discord servers specific to one platform or a series of games. In the case of Windows it's also heavily fragmented, as there is no equivalent to community-standard tooling like splat or dtk-decomp for that platform, although my Ghidra extension has carved itself a niche in it.

The decomp.me Discord server invite link can be readily found on that website and in the README of its GitHub repository. It's the closest thing to a central hub of the decompilation community. You can find some invite links in its chat history by searching for "discord.gg" (including the servers listed below).

Some of these Discord servers have a #other-servers or #related-servers channel with tons of invite links to other similar Discord servers. In particular, these servers have those channels:

- PS1/PS2 Decompilation

- GC/Wii Decompilation

That way, you should be able to find dozens and dozens of Discord servers on that topic. There are still many more out there (I've joined at least six others that aren't directly reachable from the invite links inside the servers I've mentioned).

There are also other Discord servers about reverse-engineering that can contain discussions about decompilation techniques or projects.

Second, because while the biggest decompilation Discord servers have effective moderation team and processes, the vast majority are just a server for a project from one or a couple of persons with <100 members joined. Such small servers don't have round-the-clock moderation or customized settings.

Third, because I regularly see phishing crypto spam posted in the smaller servers. Spreading invite links publicly carelessly increases the odds that these scammers find them and spam them.

There are also practical concerns. An invite link that needs to be deleted (for example due to spam abuse) means that it will no longer work. Updating all the places where that old link appeared to the new one can be impractical or impossible.

Whether the broader communities will accept any of my work remains to be seek given the heavy correlation to those communities and anti AI sentiment.

I've noticed the anti-AI sentiment is starting to die down. People are slowly realising that, along with the voluminous amounts of slop, there are others who have been able to leverage AI with much success.

I've noticed the opposite. Seems that it depends on where you're looking and what you're looking for.

Reddit has a few pro-AI subreddits too, so you might find a better audience there.

The most recent noteworthy counter-example is archive.org breaching their "one purchase = one concurrent loan" limit during COVID, and they lost that court battle.

If you're equating libraries to LLMs, then every leading-model company would have purchased ~every book, newspaper, movie, and song in existence at least once. They have not.

I would make the argument that open weights models are ethically still maybe questionable, but at least it's making the output a public good

For example, when a Paper Mario decomp/port used AI, the subreddit for the series pretty much tore it to shreds for that. Mario fan communities in general tend to be really heavily against it, with Mario Fan Games Galaxy, SMW Central, and SMBX having rules which are basically "no AI allowed for submissions ever".

Meanwhile my experience on sites like ROM Hacking.net is that AI is more accepted/tolerated there.

So, it's very much a series by series thing. Best to check what the Mega Man community thinks of LLMs before you post it.

My current wishlist is to decomp Elite CGA version (tiny x86 binary) back into assembler and annotating all the method names, vars etc. That way I could swap out some of the inner loop using knowledge that has been uncovered in the last 40 years of optimizations.

I did this because those particular pieces were significant to me.

But I attracted the attention of another user who wanted to see more public-domain orchestral music on the site, and who contacted me to ask if I was planning to do the entire ballet (no; it's about 600 pages) and if I would take requests.

I responded that I was happy to take requests but wouldn't guarantee that I'd do any work on them. He requested Tchaikovsky's Italian Capriccio, which was a decent guess as to what I might be willing to transcribe (it's the same author)... but I looked into it, listened to the music, and just couldn't muster the enthusiasm to keep working on it.

So yeah, a request might work, but it's only likely to work if you happen to make an excellent guess about what the person would have wanted to do anyway. Think of it like drawing someone's attention to something.

Like OP, I've learned at lot in this process. I have versions running in the browser now with a custom WebGPU rendering engine. Still lots of jank and vibes, but it's wild to see what models are capable of with the right tooling. (I've had Claude add extensions into Ghidra for Xbox/Wii specific instruction support)

Wild times we're living in. It's great for software preservation though!

Controversial opinion: I think the FOSS movement was a setback and distraction from attaining software freedom as well as giving an undeserved negative reputation to "reverse-engineering" in some areas. RMS had the right idea, but missed the mark when it came to practical application by focusing far too much on "source code". Other industries have long been making third-party parts by merely inspecting existing ones with measuring tools, and let's not forget the whole discipline of scientific research is largely what amounts to "reverse-engineering" the natural world. You don't need the original source code if you have good decompilers, and now LLMs to assist.

Decompiling a binary, finding what you need to change, and then patching precisely that piece, seems like a far more liberating process than getting the source code, figuring out how to build it in its entirety, and possibly changing more than only the piece you wanted to. Many years ago, I remember coming across a few Java utilities that were public-domain but not open-source, and the author explicitly told users that they were to use a Java decompiler to decompile, edit, and recompile if they wanted to make any changes.

Ideas aren’t scarce. Someone who reads a book, or looks at a picture, or makes use of a copy of software is not preventing other people from doing so. The idea that an idea can be restricted are given exclusive use to one particular party for any amount of time by law, is dystopic.

> You don't need the original source code if you have good decompilers, and now LLMs to assist.

Yes, you do. Decompiling and modifying a binary can be illegal itself under the DMCA in certain circumstances. But even if it is not, distributing the decompiled source is against copyright.

> Java utilities that were public-domain but not open-source

AFAIK Java is specifically easy to decompile when it is not further obfuscated. That is not true for many other languages. And while you can technically reverse engineer any language it does make modifying software and even finding out what it does fundamentally more difficult.

> far more liberating process than getting the source code, figuring out how to build it in its entirety, and possibly changing more than only the piece you wanted to.

It's certainly more liberating because there are more restrictions you have to liberate from in the first place. RMS argues that these restrictions should not exist in the first place. As for building being difficult, no free license requires the author to use a good and easy build procedure, but the GPL requires them to provide you all the tools required to build the software unless they are already readily available: "The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities."

...and so is going over the speed limit.

Practically? Who gives a flying fuck.

PC magazines in the late 80s and early 90s told people how to patch binaries to fix bugs or enhance functionality, with lists of offsets and bytes. Without distributing the original, so no copyright issues there. I don't think anyone tried to go after them because they'd be fighting the 1st Amendment.

> I don't think anyone tried to go after them because they'd be fighting the 1st Amendment.

I have bad news for you:

https://www.eff.org/issues/coders/reverse-engineering-faq#fo...

The FSF succeeded at changing the mindset towards more collaboration.

I agree that this also allowed to divert efforts from research on reverse engineering tooling by reducing the needs.

But AI is game changer for reverse engineering, so no secrets will be hidden in binaries.

In a way, this is a merge of an alternate branch of history where RE would be more powerful.

I'm also really looking forward to trying the Dinosaur Planet decomp, because the prototype ROM from which it was derived has a tendency to crash the various libretro cores/N64 emulators I've tried.

I prefer 1080 as snowboarding games go. Though must admit some fondness for Cool Boarders and a selection of other lower quality games that few will admit to enjoying.

Decomp tools for N64 have had some breakthroughs even before AI. Now I imagine it's even better. If that facilitates folks geeking out with their favorite guilty pleasure then so be it!

More I am just confused for why the game was chosen. SM64, Zelda OoT for example I could easily understand the community motivations behind decompiling. This not so much, which makes the whole endeavor even cooler.

The other factor to consider is OoT and SM64 are Nintendo properties. Nintendo is one of the most litigious companies in the industry. That alone may shift people away from some of those big name titles owned by them.

I'm not sure "community" was always the reason, but we might be talking about different eras. Back in the late 90s and early 00s there were the pioneering scenes for modding, emulation, fan subs, remakes, etc. and it was all highly competitive.

I don't mean to shit on anyone's legacy, but it seemed more ego driven and like there was something to prove either personally or politically. It was cultural and maybe even spiritual. Anyone working on this stuff felt powerful. Nearly a century of broadcast media and being told what to do and how feel by people from far away was ending. Disassembly felt more like deconstruction. It didn't feel like love. It was hacking. There's a reason why one can still shout "hack the planet!" into a crowd of nerds and get them to instantly light up.

I'm not even saying all this as an old fart. Things just changed so fast since then. I'm in my 30s.

[1] https://github.com/cdlewis/snowboardkids2-decomp/tree/main

Useful, but complements existing tooling & falls short on the hard part

I work on Ship of Harkinian. We're sering more vibed libultraship ports. Yet to see a real success

I've made a similar point in an earlier comment, but consider the following:

Even if the original sources leaked in a human-readable format, the original game was probably written in a mixture of the device-specific dialect of the Mips R3000 assembly used by the Nintendo 64, whatever in-house assembler macro routines SGI provided for the RSP game-specific microcode, and some C89 glue code in an IDE like Metrowerks Codewarrior 4, by a team of overworked japanese developers in a hurry.

We can safely assume that the final decompiled code is way more readable/usable than the original.

> We can safely assume that the final decompiled code is way more readable/usable than the original.

Have you looked at any rediscovered repositories lately?

It's a pretty daft assumption that the original source code wouldn't carry more value than the decompiled machine-generated "source code". And much more so.

Certainly from the game historian's perspective. Just think about it. Inline comments, logs, scraps of documents/notes, variable/function naming, scrapped files and artwork, engine code, etc. These things are essentially a time capsule treasure and a peek into the history of the game, no matter their state.

If you've seen any rediscovered source code releases of old software, e.g. 86-DOS, Prince of Persia, Command & Conquer, Little Big Adventure, even Apollo or any of the "the making of"-style game releases built around it (Karateka, Ninja Turles) you'd probably think differently. These are super interesting to dive into because they capture the thoughts and decisions of the developers at the time.

Here are also some interesting articles to showcase what that means: https://gamehistory.org/category/source-code/

The source code they were given for the job was so specific to the assembler, compiler, build stack and internal company libraries and SDKs (which often they had no access to) that reverse engineering the final game was usually the quickest route.

> Certainly from the game historian's perspective.

That's a completely different topic, and I mean, sure - from an historical perspective it's absolutely essential, even simple changelogs become of enormous importance.

Define easier? There is virtually no incentive for a game studio to release their original source code. Studios are running on already tight enough margins as it is with one lackluster release being enough to doom a company to oblivion.

Unless you have a method to completely reorient capitalism away from the idea of intellectual property then painstakingly reversing the C code from MIPS assembly will always be the easier path.

Remember too, that we are on Hacker News. Only a tiny sliver of the population, in some cases just one or two people, cares about the source code. Not worthwhile for a studio to release the code just to satisfy a couple of nerds. What is the upside? Unknown. Downsides? Numerous.

Almost all instances of source code being released have come from small studios or individuals who are ideologically motivated, and are otherwise independently successful. John Carmack / Id Software comes to mind.

Completely agreed. But even if the will was there, how do we know the source code even exists? 1999 was a long time ago. Source code is company IP. Generally it's the devs who write it and care enough to want to release it to the masses or archive it properly. But they are not the decision makers. There are too many stories of source code quite literally disappearing despite the devs best efforts. A lot of the times when we do get access to source code it comes from rogue behavior aka a former dev putting their ass on the line for the community (see the recent MGS leak on 4chan).

Also like a sibling comment has stated there is no guarantee that the code would be a in a usable format. With the crazy crunch culture in game dev, I doubt most of these studios from the 90s were pumping out clean code. Like an archaeology dig, you'd have to budget a non-trivial amount of time getting what you find in a state that is useable by modern standards.

All to say, I think reversing these older games is a worthy endeavor that is not going away anytime soon. I for one, am excited by the productivity benefits that AI tools have brought with them.

https://github.com/monde-lointain/mariogolf64

Reverse engineering is (luckily) OK, but reproducing (or, well, releasing) the actual original code with the help of decompilation isn't really allowed, is it?

HEY, it was a GREAT game, but GREATEST? COME ON, this ain't no goldeneye