Good morning people! These days I finally got a weight off myself from a university project presentation, so not only I have been feeling in a good mood, but also I will have more time to invest in recent ideas I had, from trying to do some few videos to getting back at writing some interesting articles and having some fun interviews. And with that said, here’s where today’s topic comes in!
Recently I had caught a fascinating interest in revisiting some Super Mario 64 hacks I had played before, and soon enough the thought about the ride that must have been to get to today came into my head, with a lot of people trying their hand at it but of course being highlighted by few incredibly talented modders that have took the mission to make the most possible out of the SM64 engine and even going beyond original features (there’s several romhacks that add new powerups, and there’s one out there that even adds RPG battles)
So I ended up going to the beginning of Super Mario 64’s presence on the internet, with my research leading to the earliest videos avaliable of SM64 hacks and old hacking boards; for this occasion I managed to talk with Starxxon (previously known as VL-Tone) and Guy Perfect (previously known as BGNG), which while had long retired from this specific scene, are still on other interesting things to this day. And of course, they were very polite in recalling their stories back from more than 15 years about how they ended up making history into the future of this scene.
Now, without further ado, I hope that you enjoy this first part of this fascinating journey!
Earliest days and first progress
Our story begins as back as 2003, where Starxxon was investing time at the acmlm board in 2003, trying to figure out Star Fox model formats among other things in the ROM Hacking forum While Starxxon already seemed to have a degree of skill with hacking around this time, this experience would be a pivotal starting point for him and the following events. This would also apply to another person which ended up setting a key starting point in this entire story, arriving to the boards driven by curiosity to dive deeper into their favorite games.
Around 2003, having experimented hacking NES games that were mostly already documented, I decided to try to dig into the ROM and hope to discover how the levels and models were stored, and ways to control the camera. I barely knew anything about 3D modeling and format back then. Eventually I found a list of all objects in the ROM with pointers to polygon data. By looking at the hex data structures I figured out that objects where made of a list of vertices, and another list defining how vertices were connected to create polygons.
Starxxon
I don’t recall when or how I stumbled into the home of “Rohm Acking”. It started out called Acmlm’s Board then was at some point renamed (I think?) to Jul. For a long time that was my go-to place for modding and hacking discussion, even after Romhacking.net was a thing. […]
Guy Perfect
The date of June 27, 2004 is the date where another user named BGNG (now known as Guy Perfect) cracked and wrote the specification for the MIO0 compression format, as he happened to be working on figuring out F-Zero X models. However, these specifications would show up published in June 15, 2005 at the “Mario 64 – Amazing Stuff” topic on the aforementioned forum, as the format turned out to be the same one used in Super Mario 64 model data. In matter of days (specifically, June 19), Starxxon achieved in decoding and extracting the Peach Castle Exterior model. From here, he along with the rest of the members at the forum topic would keep documenting and eventually, find a way to decode more models.
Pictures from Starxxon’s thread with old screenshots starting from June 19, 2005
[…] I was working with F-Zero X and found a bunch of files marked with MIO0, so I figured I’d look into it. Mostly images. I actually haven’t been directly involved with Super Mario 64. VL-Tone and I were working on N64 projects at the same time, but we didn’t cross the streams. As I recall, MIO0 was also used in Super Mario 64, so it was useful to get that format sorted out.
I was researching the game data in F-Zero X with the intent of creating a level editor for the game, which I eventually did manage to release. Most of the game’s textures were compressed in the MIO0 format, so to properly generate images for the user during editing, I needed to be able to decode them. If I’m not mistaken (and let’s face it: I’ve been wrong before), the utility I produced was the first level editor for a Nintendo 64 game that was freely available to the general public.
Guy Perfect
Around that time I was in the process of reverse-engineering the polygon and level format for Star Fox and was active on a forum mostly dedicated to game “ROM hacking”. Someone (BGNG) had just cracked the compression format for Super Mario 64. Since I had some recent experience decoding Star Fox models, I started digging into the decompressed data, hoping that I could figure out the format and decode the game models. Eventually, with some help from other forum members, I started documenting the different formats and build a decoding tool. Since I had found where the vertices and colors for Mario were stored, I tried to morph the values so that it resembled Luigi, for the fun of it.
Starxxon
Starxxon also happened to be messing around with the idea of making a Luigi model, as he had got access to Mario’s model amont other things. His first experiments would end up succesful and soon enough would lead up to the first SM64 hack in Youtube ever seen.
At this time, Youtube had only some few months since it had been launched as a brand new video sharing platform, and Starxxon thought on the idea of doing something interesting with the knowledge he had recently obtained from this…which is how the very first video of Super Mario 64 ever in Youtube, “Luigi is Really Real 2005: The Movie”, was made and uploaded by Starxxon in August 27, 2005; also standing as the very first known mod of Super Mario 64 as well.
Since I had found where the vertices and colors for Mario were stored, I tried to morph the values so that it resembled Luigi, for the fun of it. Rumors of Luigi being in the game started many years before but all we had were blurry photoshoped images, or Game Genie codes that made Mario green. Self published Internet video was an emerging thing, so I decided to post a short video showing my Luigi mod to a few video sharing websites, including one called “YouTube” (which I thought was a silly name) which just had started a few months before.
Starxxon
The reaction at the time was certainly interesting! I did present the video like Luigi was really in the game, but I thought it was tongue-in-cheek enough that people would get that it was a mod. But of course I still got a few commenters yelling “Fake!” and pointing out that the HUD icon was still was showing Mario. 🙂
Starxxon
As Starxxon kept decoding models, he eventually made a tool that allowed him to view the maps in a freecam view, and at one point found a way to edit values. Here is where this level viewer would begin turning into a level editor, which would eventually become Toad’s Tool 64. The viewer would display object placements around June 27th, 2005, but the level viewer would begin turning into a level editor with a early version of the interface on July 27th, 2005, date take from the first screenshot below. One of the screenshots that was starting to resemble TT64 (but still didn’t have a name)) comes from a post in the forums dated December 23, 2005. These three dates
June 27th, 2005 
July 27th, 2005 
December 23, 2005
At first, I was content with simply decoding SM64 levels and documenting formats along the way. I was happy to be able to fly around the levels and look behind the scenery! Eventually, as the tool I was building started to decode more abstract things like level commands, I added the ability to edit values, which made it more of a level editor. Initially I didn’t want the burden of being the guy that would make the first SM64 level editor. I was hoping that someone else would use what had been documented to build a nice open source level editor. But for various reasons it didn’t happen back then. As I found new stuff in the game, the decoding/editing tool gradually evolved to the point of being a functional SM64 level editor, so I felt like I had to publish it.
Starxxon
On January 2006, Starxxon would upload a video of several objects and enemies placed at Peach Castle’s Exterior, which would be the first time this is done as well (and also showed that the level editor promise was indeed true). On July 31 2006, Starxxon would upload a teaser video of the editor interface in action, now with the iconic “Toad’s Tool 64” name and interface being shown in action. While a beta release was planned for 2006, there would be some setbacks and it wouldn’t be until almost a year later on April 9 2007, where a more matured version of TT64 would be shown interacting with objects on several maps, and in June 21, 2007, the very first public version of Toad’s Tool 64 was released.
I was researching the game data in F-Zero X with the intent of creating a level editor for the game, which I eventually did manage to release. Most of the game’s textures were compressed in the MIO0 format, so to properly generate images for the user during editing, I needed to be able to decode them. If I’m not mistaken (and let’s face it: I’ve been wrong before), the utility I produced was the first level editor for a Nintendo 64 game that was freely available to the general public.
[…] I was stoked to learn that someone else was doing Nintendo 64 hacking at the same time I was. For a time we’d arranged to release our level editors on the same day as a sort of joint event, but the Super Mario 64 stuff caught some snags and I didn’t want to unnecessarily delay F-Zero X.
Guy Perfect
The rise of custom levels and first complete hack
After this, Starxxon would upload some few more videos (two videos with placed objects, and one new Luigi video) and try something entirely new: In January 27th, 2008, Starxxon made Flatworld Battlefield, considered the very first custom level geometry in the game (instead of just placing objects over an existing map); while at a basic level it seems that only could be used to make a custom level comprised of placed objects within the flat platform, the intention was that people could figure out how to make more out of the possibilities in custom level objects.
Flatworld Battlefield was an attempt to create a minimal template for new custom level geometry. It was created manually byte by byte from the knowledge I had of the format, and would produce a simple textured square made of 4 vertices. It was documented extensively, with an explanation for each command used in its data. While the object itself could serve as a flat basis for the level, the goal was for other people to create new custom level geometry or tools based on this template.
Starxxon
After this upload, Messiaen (also known as Frauber) would enter the fray of this early modding scene, looking into how Flatworld Battlefield worked and posting about his experiments in his Youtube channel. His first mod from this, Slide Battlefield, was uploaded in April 21 2008. He would stay experimenting for a while with this, uploading the custom maps Rainbow Road (June 23), Flat Lethal Lava Land (July 18) and Platform Battlefield (August 8). The last one would show some glaring issues with this at the time, which was the draw distance of the objects, a thing that Messiaen stressed about back when he made it.
I began tinkering with Mario 64 during the first semester of 2008. I had known about the existence of Toad’s Tool 64 for a while, but it wasn’t until VL-Tone came with the “Flatworld Battlefield” that I really became interested in it. Most of my initial effort went into understanding the polygon/collision formats and how the level/geometry/behavior scripts were laid out from VL-Tone’s Mario 64 Hacking Docs. Once I had enough knowledge, I started doing some simple level hacks using a bunch of custom objects, in an extensively modified version of Flatworld which I called “Platform Battlefield”. There were a bunch of problems with this method, as objects are only drawn when you are near enough from them, resulting in a very artificial experience.
Messiaen, excerpt from readme of his SM64 Missing Stars hack (May 5, 2009)
However, another user named Celux (now known as SKELUX) happened to take on the idea of making something with the Platform Battlefield patch Messiaen provided and made the “Secret Woods” level (the source video is from 2010 but chronologically it was made a year before). Despite having the same issue as Platform Battlefield back when it was made, it convinced Messiaen about the possibility of a full hack comprised of levels like this, as he happened to be researching the draw distance issue at this time.
I was almost giving up when Celux came with the amazing “Secret Woods” level done with my Platform Battlefield patch. I was really amazed at how much he had done with my custom objects, however there were still the same problems: the level was slow as hell (pratically unplayable) and objects were only shown when Mario was very near from them. By that time I was learning some MIPS assembly in order to delve further into the game programming (scripts are only the top of the iceberg!) And thanks to the help of Cellar Dweller’s notes, who has done plenty of low-level work with Mario64, I eventually came up with a patch that solved the problem.
The key point was that whenever the collision for a specific object was not loaded (when Mario isn’t near enough), the game automatically stops displaying the object, regardless of the drawing distance setting. By patching a collision routine, I got the game to display the objects regardless of Mario distance while still keeping the collision only loaded when Mario is near enough. With that set, I knew that a full hack would be possible using only objects as level geometry.
Messiaen, readme of his SM64 Missing Stars hack (May 5, 2009)
At this point, Starxxon had made some few tools to be used as companions to Toad’s Tool 64, like the ROM Extender, and Messiaen took advantage of these and started the idea of working on a full hack. While there would be some hiccups on the development, he would also figure out how to make a music importer (mml2m64) then finally finish and release on May 5, 2009 his milestone project Super Mario 64: The Missing Stars.
I initially proposed it as a team hack, and anyone who could, like Celux, make a nice level around these custom objects would get in. That didn’t work. Many people started working on levels and after a while gave up, and I don’t blame them because it’s really hard to get a decent result. Meanwhile, I worked on a few more assembly hacks, such as the day-night system, the play as Mario or Luigi option using VL-Tone’s model and extended memory support, which will be futurely integrated into Toad’s Tool 64. When I realized I would be all by myself on such large project, I got a bit demotivated and stopped working on the hack for some months. During that period, I mostly hacked the music format and learned about C programming. I had the idea of writing a music importer, however I couldn’t deal with the complexity of MIDI.
By that time, I started hanging around the former Zelda Coalition mostly to share my findings on the music format, which is (almost) the same as used in the Zelda games plus in pretty much every Nintendo64 first party title. In some IRC sessions, ZZT32 showed me some Zelda64 hacks written directly in C using the GCC compiler targetting MIPS, and that enabled me to write many of the hacks used in “The Missing Stars”. Cendamos also suggested me to look at the mml (music macro language) format in order to write a music importer, and after some weeks mml2m64 came along. It was limited and buggy, but still very useful for this hack.
And so, on the beginning of 2009, a lot more confident in MIPS and C, I continued working on “The Missing Stars” (the name actually came much later, suggested by Darkdata). Towards the end of the hack, I got some very useful help from Celux (major work in the undergrounds area), RDX (custom music), and Darkdata (title screen background) and the hack (v1.0) was finally released on the beginning of May 2009.
Messiaen, readme of his SM64 Missing Stars hack (May 5, 2009)
Forum user Messiaen (aka. Frauber) took the bait and created its own set of custom level objects (platforms, walls etc.) after studying the Flatworld template. He then went to create the first extensive SM64 mod involving entirely new levels, called “Super Mario 64: The Missing Stars”, using TT64 and his own set of custom level objects.
Starxxon
SM64 The Missing Stars is certainly a fascinating relic of its time, not only in the primitive nature of the levels, but also in that it feels like if you are in a hub world; except that you are already looking for stars in the hub world instead of warping to a specific level for that, and seems to be filled with quirky details like a talking, friendly Piranha Plant NPC (something I found out by accident as I tried to jab the thing). On the note of time, for this research I only managed to run properly the game with Project64 1.6 (instead of the newer versions or mupen64plus) so that’s another weird detail in that older hacks may or may not like newer emulators/plugins. I might end up writing about the compatibility of these romhacks with emulators (basically what you need to run each one) but that will be a topic for later.
While it is definitely limited in scope (as you always visit flat areas with houses, searching for red coins or finding stars hidden at the place), it is also pretty creative considering the constraints, with objects being used in interesting ways, the existence of a day-night system, replaced music, the fact that you can select between Mario and Luigi (and Luigi, oddly enough, has a lower pitched voice but still a neat detail), and that there’s a handy star counter at the corner to keep track of your progress in a certain area. One star that was fun to see was a Yoshi running around quickly, but catching it has the Yoshi say “they had a star piece stuck on their back” and then grants you a star. Despite the rudimentary state, I would like to revisit this hack further one day to find everything that it does.
After spending some time with a side project of his called Metroid Cubed, Starxxon uploaded in February 10, 2009 a video where he showcased an entirely new map model, as part of showing the rudimentary OBJ importer support on Toad’s Tool 64 v0.6b. While this happened to predate Messiaen’s first known OBJ importer release video (dated October 11, 2009), this TT64 version didn’t see the light of day due to several issues. However, at that time where it still was in development, Starxxon had uploaded some few more videos with imported geometry (including a rudimentary Spiral Mountain import from Banjo Kazooie). These videos were uploaded between October 11 and 12.
Hah, the elusive version 0.6 of Toad’s Tool 64. It was supposed to be the version where I added an OBJ importer. But it never finished, was very buggy and ultimately never released, for a combination of various reasons, including data loss and some real life stuff getting in the way. Messiaen was working on his external OBJ importer around the time I abandoned development on 0.6. I was not directly involved with it, but I may have answered a couple of questions he had. But at that point he was well ahead of me, he didn’t need much help!
Starxxon
After this, while Starxxon would take a break from SM64 hacking after posting his third Luigi mod video (this time with a new and improved model instead of the previous one), Messiaen would keep making progress on his OBJ importer (later renamed to Mario 64 Level Importer), and stay experimenting with more hacks on the videos he uploaded, like a rudimentary implementation of a second player as Yoshi (long before a certain hack later fully implemented the idea), importing a Zelda OOT map, adding P-Switches (replacing coins with boxes and viceversa, like in Super Mario World), custom block/terrain types, and even made a video about earlier alpha versions of The Missing Stars. His second last video was in September 18, 2011, showcasing a 3D preview feature on his last version of his Mario 64 Level Importer (and his last video was a Super Metroid custom music test on December 26th, 2012).
However, right at the very beginning of 2010, there was another enthusiast entering the fray; only that he hadn’t really entered for the first time, but returned with a fair amount of dedication and ambition which would be only further impulsed by the arrival of new tools. This would be Celux, at this point adopting his current name, SKELUX. First uploading two videos about succesful model imports from another game, his third video would be a custom level originally intended for SM64 The Missing Stars (just like Secret Woods), called Koopa Canyon…but ended up having collision issues that weren’t possible to fix at the time. However, this level would eventually be remade and repurposed for SKELUX’s own debut hack, which was first shown in March 2010. Of course, this would be the now legendary rom-hack Super Mario Star Road.
While both Starxxon and Messiaen had retired after 5 years dedicated to SM64 hacking, they still left a quite strong foundation to be developed, with their mods showing the potential that could be given shape from here (their OBJ imports and the Missing Stars hack), and their tools standing as THE tools for SM64 hacking in the following years. Toad’s Tool 64 and SM64 Level Importer would both stay for years as the only avaliable tools for replacing models and changing objects in Super Mario 64 maps, and they spent years serving many aspiring modders. And Guy Perfect’s initial research to make a F-Zero X level editor (long before the 64DD expansion with an official editor was emulated) indeed allowed him to make F-Zero Execution Project, something I could talk about in a future article.
And of course there’s a lot to talk about Super Mario Star Road, but this is something that will be fully covered in the following part as there was much more put forward on this hack, specially for its time.
A brief look at Toad’s Tool 64
To finish this chapter, I will give a brief rundown about how Toad’s Tool 64 worked with the game, its interface and the amount of features it had. While Toad’s Tool 64 definitely had some aged details (namely the software used to build it, and the way you controll the camera), it still had enough features and power to hold up for several years until the time where alternatives to TT64 were finally made. Toad’s Tool 64 was made with Adobe Director, Starxxon’s utility of choice for making most if not all of his tools (his older ones were avaliable on his site as Shockwave files).
At the time I was using Macromedia (Adobe) Director to do most of my projects and recent versions added a nice 3D engine, which enabled me to render the objects much more easily than if I had to write native OpenGL. This served my well for Toad’s Tool 64 later.
Starxxon
In order to use Toad’s Tool 64, you needed to have an extended Super Mario 64 USA rom; Starxxon’s own SM64 ROM Extender was needed to extend the ROM and make it loadable by Toad’s Tool 64 (if you entered a wrong ROM or wasn’t extended, it would give you an error message).
If you had that ready though, you would get greeted by a suite of options, as well as a window displaying the model of the map you’re editing, with red boxes representing the objects placed around it. Interestingly it does let you resize the window and while the updating speed for the 3D view is not quite immediate (and the 2D assets don’t scale), it is fascinating that the tool allowed this back then instead of being fixed to a static resolution/sized.
On this note, most of the information and screenshots below will be provided from Version 0.5994b, the last version released by Starxxon himself back in November 2008, to give some historical context to this tool’s legacy and how even in the future updates made between Skelux and Starxxon (the first of which happened in March 2014, around 5 years after the original last release) there weren’t too many drastic changes needed to do.
The way you control the camera is…definitely arcaic: You have to hold left click over the third square panel (right below the “Right” and “Fly” buttons, showing a camera icon) to move the camera in X and Y axises, while the small rectangle at the side of it being for the Z-axis (aka zoom in or out), and to rotate the camera you have to set the “Rotate Cam” mode and hold click over the 3D view (and it does feel somewhat loose on that matter). This definitely was improved in the Skelux-assisted update, as camera rotation is absolute (doesn’t feel loose anymore) and the camera panel was cut; you can now move in X/Y axis by holding Shift and dragging over the window and use the mouse wheel to zoom in/out).
The other two panels are used for moving and rotating a selected object respectively (though an object’s X/Y/Z and rotation values can be altered by hand), and the editor allows you to change the type of object that is placed anywhere (basically replace an enemy by a coin or a Chuckya, whatever you see fit; these kind of small tests were what Starxxon started messing with back at the beginning of TT64’s development), make it get placed into the ground, and force it to stay grounded. You can also have the map itself either use a sky texture (whichever one is set for the map) or use a flat color for the sky instead. Another feature is displaying the map’s Collision Map model (which is the information for the map’s invisible collision, as it can be given different properties on triangles and helps things like fences be…well, not passable by having some geometry there).
Toad’s Tool 64 also ships with a handy texture importer/exporter, which supports PNGs and also has a option where you can alter Mario vertex colors and patch it on the ROM instead of using a color code generator.
While there’s some few extra details and options intended for experts (which means I can’t really say much about them), it is clear that Toad’s Tool 64 was huge in allowing modders to alter the object layouts, music slots used and provide enough technical insight for people that wanted to try make the most out of it. There’s also an official page/document by Starxxon dated from his own last release where the options are further detailed.
It was the end of an era of discovery and research behind the black box that used to be the game, and the following years would be rife with people’s ideas encapsulated in new worlds for Super Mario 64. While Skelux was not the first pioneer, he happened to take part of messiaen’s milestone hack and would go on to become one of the biggest names in the community of Super Mario 64 hacking, inspiring many people to take on the same challenge (and at one point, taking it to the next level, as you might know already).
Thank you for reading today’s feature, it was fascinating to not only revisit the oldest SM64 hacks and tools, but to also having got a chance to talk with two of the biggest pioneers from this time. Big thanks to Starxxon and GuyPerfect for their insight and stories through their interviews (the full interviews will be published soon). I also made a Youtube playlist with most of the videos linked here (and some that aren’t) ordered in chronological order (upload date) if you are curious to watch the hacks showcased around those years.
If you liked my content, sharing this with others helps me out; and you can lend me a hand through my Ko-fi page as well! Any feedback and ideas are appreciated, so don’t be afraid to drop a message either here or on my Twitter. On the topic of modding, I also had previously covered The History of Sonic Adventure DX Modding in a huge article (complete with interviews as well), so you can check that out as well.
Stay tuned for Part 2!
ARCADEX MACHINA 