Six weeks ago this repo didn't exist. As of today the Super Mario 64 DS decomp is at 95.0% of functions matched (10,778 of 11,348) and 82.4% of the code by size.

This has been craaazy and the team we've assembled in the discord is incredible. This last 10% has been brutal but come reset in a few days, I think we can basically wrap this up.

The tools we've created to create a steady and autonomous decomp have come a long way and now, as long as you have access to some sort of AI, you can run our main app tangOS to start or assist any decomp.

The remaining 570 functions are the hard residue, concentrated in a handful of overlays (ov006, ov002, arm9). Basically everything I worried would be an issue has fallen within 1 to 2 days of work. The recomp is also coming along nicely...

If you want to contribute, there's still time. You just need your OWN LEGALLY acquired ROM.

BIG BIG things coming very soon!

Repo: github.com/tangosdev/sm64ds-decomp

Discord: https://discord.gg/rWrH2vVrt

GOOD AFTERNOON ALL! Everybody get off the tracks and out of the road because the Hype Train has reached maximum speed and can no longer be slowed down. The super Mario 64 DS decomp team has been hard at work since the last update and we are now at 90% FUNCTION MATCH AND 70% DATA COMPLETION!! I feel like we only started this project a month ago and here we are nearing the end… oh wait we did start a month ago.

Now the cool stuff:

Poking through the SM64DS decomp this week we found a working developer free-fly mode in Mario's movement state. The level loader also gave up a cut object category, LoadUnusedType13Objects, a no-op stub sitting in the 15-slot object dispatch table right beside the real loaders for doors, fog, teleporters and paths, so the format can still carry Type-13 records that the game just ignores. In a VS-mode overlay we hit UnknownVsEntry, a complete actor with its own Behavior, Render and vtable that nobody has identified yet, so that one is wide open if you like reversing. The retail build still ships a full developer crash handler, Crash and ShowCrashScreen, that dumps the CPU registers to the top screen and then spins forever, and it draws with the exact same font LoadDebugFont pulls in on every stage init. On coverage, the level engine itself is basically finished, with the object-load dispatch at 16 of 17 functions and collision code past 90 percent.

This project has been INSANE so far and I’ve met so many cool people and had so many good interactions with the community. Everyone has provided so much help in so many different ways and we couldn't have gotten this far without all the help.

Future plans:
Once this decomp is done I plan to release a recomp with all the features the community expects and has asked for. While that is happening, we are going to decide what game to do next. Another DS game would be cool because we have all the foundation already made and could get started at max efficiency, OR another console would be fun to expand our toolkit and availability of tooling for the community. We will be doing a poll in the Discord so come vote and chat with us or get involved! We have MANY things that would help us such as tooling work, testing, recruiting, or help with assets for tangOS (sound effects, music, art, etc.).

Thank you EVERYONE for all your support and continued support! The link to the repo and the discord will be posted below so please come visit!

GitHub: https://github.com/tangosdev/sm64ds-decomp

Discord: https://discord.gg/zVWTUS4SQq

Sorry it’s been a while everyone I usually make a Tuesday post but I’m two days behind for a few reason. Mainly because of HOW MUCH PROGRESS WE BEEN MAKING!! Everytime I’d start to make a Reddit post something new would happen and I’d get sucked into it, but now with the 80% milestone reached I figured I do a little talkin to everyone.

First things first, I need to give a MASSIVE shoutout to the tangos decomp jamboree discord for all of your encouragement and suggestions, and a super special shoutout to those of you who contributed matches to the decomp especially here in the final half where things are the toughest it’s been so far. We’ve still got a long road ahead of us but it’s downhill and the wind is to our backs AND we have motorcycles so like… oh also super duper major shoutout to Opie in the discord for being the first to join the team and contribute so much work and knowledge.

Now, onto what we’ve done. So obviously we have hit 80% which is amazing, however that 80% is functions matched. For data, we’re around 54% which is over half and honestly, is starting to fall much quicker than early %s. The smallest functions we are matching now are 12 bytes so each one adds up to a good amount of data %.

In the tooling sector, ive been hard at work cooking up something that I hope will power decomps for years to come, which is tangOS! This application is and will continue to be a suite for all the tools that get created to assist in the decomps, along with many features that allow collaborators to sync up their work, track others work, and get live views of their AI strategies stats and progress. What this app also does is allow someone who is brand new to decomping and/or AI to easily set up an agent to begin matching, with automation for the entire pipeline all the way up to sending a PR right to my doorstep to be greenlit and added to the repo.

Basically, things have never been more back. For anyone who wants to get involved or just keep track of what’s going on and chat. I’ll link the GitHub repo and the Discord below.

Have a great rest of your night and play some Mario before bed

GitHub: https://github.com/tangosdev/sm64ds-decomp

Discord: https://discord.gg/cVRtV9WXa3

Hey everyone! Yall might know me but if you don’t, I run sm64ds-decomp, a from-scratch AI assisted matching decompilation of Super Mario 64 DS.

From the start I wanted this to be an easy to contribute to community focused project, since the speed at which this project is completed is only bottle necked by how much compute power I had/could afford.

Well after meeting some people and having them ask me how to get started, or how to keep things organized, or avoid stepping on other peoples toes, and me not having a good answer for them.. I finally can proudly introduce my first tool (many more coming soon) to bring someone from brand new - to matching their first batch of functions in seconds!

And not only does it work on my project, but ANY decomp project, and all that’s required is a config file that can easily be generated by the projects author.
I really hope this can help people who want to contribute get started easily, and can help all other current and future decomps down the line!

Thank you everyone for all of your support, and if you want to join the community and get live updates on this decomp, the discord will be linked below.

Everyone have a safe holiday!

GitHub: https://github.com/bmanus2-dotcom/chaos-viewer

Chaos Viewer: https://bmanus2-dotcom.github.io/chaos-viewer/

Discord: https://discord.gg/zVWTUS4SQq

For anyone new here, welcome! and for anyone else thank you for sticking around!

A quick summary of what we are doing here:

We are using AI to assist in de compiling Super Mario 64 DS into C through matching decomp. What this means is that each line of code will be checked, then rewritten into C, then ran through an oracle to confirm each new line compiles byte for byte to the original code. At the end we wont just have similar, but a perfectly accurate recomp of the game (with improvements).

Currently we are about 66% of the way done!

The new and good news is that the boring under the hood stuff is basically done. How the console handles its memory, how the game knows when characters hit a wall or lands on a platform, how characters animate, and how everything gets drawn to the two screens and fades between scenes. All done.

Whats left is the interesting but more complicated stuff. Characters themselves, the jumping running swimming and wall kicks, that's a little past halfway. Enemies, the camera, the HUD, all partway there. This is the long haul super specific part.

The super cool part is the fun leftovers the devs left in the cartridge and never cleaned out. So far, we've mostly just found some debug stuff like a free fly mode that was used for level testing, a debug font, and an unused object slot, a type of thing the game can load that they just never used.

And we haven't even touched where the level layouts live, which will hopefully hide some cut stages or test areas. (I'm hoping we find waluigi behind the black block in the castle on the box art that I searched for for hours as a kid)

The biggest thing with this update is what I want to say about the community. Everyone who commented, DM'd, or simply upvoted or starred the repo has been such a tremendous help and encouragement to me. I've met so many people and the contributions and PR's ive gotten have gone such a long way in helping the project. My DM's are always open and ill respond to any comment I see.

With how the community is growing I decided to make a discord, where you can chat with us, assist, get our tooling, or just get live updates instead of waiting for a Tuesday post from me. If you want to contribute in any way (PR's, advice, funding, or compute power) please join, the link will be below. And to anyone that would like to help but doesn't know how to code, we also have a one prompt AI workflow that will get your agent immediately cracking on functions!

Again, thank you so much to the everyone for your support and I'm excited to share with you what's new next Tuesday! Thanks!

~Tango

Discord: https://discord.gg/zVWTUS4SQq

GitHub: https://github.com/bmanus2-dotcom/sm64ds-decomp

UPDATE TO PREVIOUS POST: https://www.reddit.com/r/decomps/s/JCiEvIuSv9

TLDR: I’m decompiling Super Mario 64 DS back into C, the matching kind where every function has to compile to the exact same bytes as the retail cart. There are over 11,000 functions, and a big chunk of the grind is automated with Claude agents that write candidate C and check it against the ROM.

For about five days I was stuck. The automated passes that used to clear functions in bulk had cratered to roughly a 7% hit rate, and I’d more or less talked myself into believing I’d hit the ceiling, that the functions left were just too gnarly for the model and the rest would be slow hand work forever. I almost posted about exactly that.
Then I sat down and reverified the whole pipeline from scratch instead of trusting it, and the wall turned out to be three things, none of them “the AI can’t do it.” One, my worklists were feeding the agents the same picked over and genuinely impossible functions on a loop (there’s a class of these where the compiler folds a memory address in a way you literally cannot reproduce from C), so the hit rate was measuring the wrong pile. Two, my register allocation brute forcer was quietly broken: it couldn’t even parse the C++ functions and was swallowing its own errors, so I never saw it fail. Three, there was a mountain of easy, untried functions I’d simply never pointed the tools at.
So I rebuilt the targeting and the tooling. The worklist now filters out the known impossible shapes and goes smallest first through fresh modules. I built a near miss database so that any attempt landing within a few instructions of a match gets saved and ranked instead of thrown away, then finished later by the brute forcer or by hand. I fixed the brute forcer, added an escape hatch for the handful of functions that were genuinely hand written assembly in the original (memset, cache ops, that sort of thing), and wrote down every codegen trick that flips a near miss into a clean match. Hit rates went from 7% back up to 50 to 86 percent.

End result: the project went from about 39% to 55% of functions matched, so it’s officially over halfway. The image is the live progress map, every rectangle is one function sized by its byte count, green is matched.

I got a genuinely great PR from someone in the community (RyanCopley) who hand matched a stack of functions and nailed every convention. There’s still a lot of unclaimed territory if anyone wants in. Repo and contributing guide: https://github.com/bmanus2-dotcom/sm64ds-decomp. If anyone else wants to jump in, the one thing I’d ask is claim a module or ping me first so we don’t both grind the same code at once. Happy to answer anything about the matching process or the tooling.

Credit also goes to webhead (webheadvr), who fixed a real bug in the tooling rather than matching functions. The part of my pipeline that figures out which function a given call points to was matching purely by address, so when two overlays happened to sit at the same address range it could resolve to a symbol from the wrong overlay and hand the matcher a bad name. He made it overlay aware and added ITCM/DTCM region support on top. That’s the kind of quiet bug that poisons everything downstream without any obvious symptom, so catching it was a big help.

I built an AI pipeline that’s auto-decompiling Super Mario 64 DS. 2 days in and it’s already chewed through a third of the functions. Still a long road on the big ones, but the speed is wild.
I’ve always been into decomps but never contributed to one since I didn’t know a programming language. Then a few months ago I picked up Claude Code, and after getting deep into it I learned more about coding in this short time than I ever did from actual lessons. So I decided to take on decomping a game, and what better one than Mario 64 DS, one of my favorite childhood games.
This actually started when I was trying to port a Mario 64 rom over to the DS and realized that if I had the source for this version like we do for the 64 version, it would be so much easier. I scraped together some other people’s work to get a baseline, and after a ton of tooling and tuning I’ve got a really tight pipeline that’s actively cracking away at the decomp right now.
The only real bottleneck is time and money. The agents still take a while to crack each function, and I’m paying for the usage out of pocket. If anyone’s willing to donate some time to the project it would mean a lot, and I’ve got a public repo that walks you through how to jump in and help.
Any questions, drop them here and I’ll answer asap. Here’s the GitHub repo: https://github.com/bmanus2-dotcom/sm64ds-decomp

26 Hour build. I used the serious editor to view and measure everything on the stage and recreated it meter by meter in Minecraft! Complimentary Unbound is the shader pack I used and distant horizons to get the full shots.

Finished all 5 using Axiom Modeling tools and reference images.

Made a custom bot to auto run through all my EZBs and it got 56 to level 30, this isn't including the 150 stones from missions I forgot to grab.