Compute Code

(Note: the following explanation is considerably simplified, and uses decimal numbers rather than binary for accessibility. We’re trying to get the idea across here, not teach people to count in base 16!)

It works something like this:

1. If you want a computer to remember a number, you have to tell the computer how much space it should set aside to remember it. You can think of this as a number of digits. For example, if you set aside three digits to remember a number, that number can go from 000–999; if you set aside six digits to remember a number, that number can go from 000000–999999; and so forth. The number of digits you’ve set aside to remember a number is its data type.

(In reality, there are several things about the way a number is stored in a computer’s memory that determine its data type; for our purposes, “the number of digits” is the only one that matters.)

2. There are two kinds of information that Super Mario 64 needs to remember to keep track of where everything is: the positions of all the bits of terrain, and the position of Mario. We’ll call the first kind of position world coordinates, and the second kind of position Mario’s coordinates. For whatever reason, Super Mario 64 uses a much bigger data type to store Mario’s coordinates than it does to store world coordinates. For this example, imagine that world coordinates (i.e., the positions of the terrain) can go from 000–999, but Mario’s coordinates can go from 000000–999999.

3. In order to tell whether Mario is about to bump into something, the game needs to compare Mario’s coordinates to the coordinates of various bits of terrain. Now, here’s a fun thing about computers: they can only compare numbers that have the exact same data type. To a computer, trying to compare numbers that have been stored as different data types is like asking whether the number 137 is greater or less than the word “helicopter” – it’s gibberish.

4. A lot of computers will give up and crash when asked to compare numbers with different data types – but the Nintendo 64 ain’t no quitter. If you ask it to do that, it goes “okay, you’re the boss”, converts one of the two numbers so that they both have the same data type, and does the comparison as expected.

5. Okay, so Mario’s coordinates are getting converted into the same data type as the world coordinates before comparing them. As long as Mario’s coordinates are sensible, this is no problem; position 000137 converts to position 137, and we’re off to the races. But what if Mario’s coordinates have gone shooting off to gods know where, possibly because some maniac has spent seven hours building up speed by walking into a fence?

6. Suppose for the sake of example that Mario’s current position is 222 137. If we try to convert that to a three-digit number, we have a problem: the result doesn’t fit. Again, many computers would give up and crash at this point – but the Nintendo 64 ain’t no quitter. If you ask it to convert a fuckoff huge number to a data type that’s too small to contain it, it goes “okay, you’re the boss”, and starts chopping digits off the leftmost side to make it fit. So that 222 137 becomes just 137; the comparison then proceeds as expected.

So: in summary, there aren’t really “parallel universes” lurking in the game’s code. When performing the parallel universe bug, Mario’s position is just way off in the void somewhere – but the Nintendo 64 doesn’t realise it, because when it’s comparing Mario’s position to the positions of various bits of terrain, it blithely chops off most of the ungodly huge number that represents Mario’s position, compares the little bit that’s left over to the level’s terrain map, and says “all right, that looks okay to me”.