Players can now play classic console games natively on Mac thanks to a growing scene of fan-made decompilations and recompilations. Here's how to get started.
If you've been around the block a time or two, you're probably familiar with emulation. It's the process in which a piece of software emulates an environment that another piece of software can run on.
But there are problems with emulation. The first is that it relies on an emulator, which can come with its own host of problems.
The first is that no matter how good an emulator is, it's not going to perfectly emulate original hardware. This can create glitching or unexpected behaviors.
It also adds an entire additional level of processing. Not only are you running a game, but you're also recreating the game's original hardware.
But emulation isn't the only way. There's always the option to play native ports, too. Read Only Memo has collated a list of such projects, and we thought they merited a closer look.
There are two main methods of reaching a native port: decompilation and recompilation. I'll explain them in more detail below, but I want to give a quick shout-out to Redditor SoulWager, who explained it in a delightful way.
We can think of both processes as baking a cake, but the path to the final product is notably different.
Recompilation is like baking a recipe you know in a new kitchen. You more or less know everything that goes into it, but you might need to change a few things to get the desired result.
Decompilation is like starting with a finished cake and reverse engineering the recipe. You might not wind up with the same ingredients, but you'll have a similar end product.
Native ports can offer better performance and tighter integration with modern hardware than emulation. They can also make features like higher resolutions, widescreen support, modern controllers, and modding significantly easier to implement.
So let's talk about the differences between the two.
Decompilation
Decompilation is, effectively, when a developer reverse engineers a game's compiled code to recreate the source code. The eventual goal is to reproduce the original game's behavior while also creating code that can be adapted to other platforms.
It confers some unique advantages over static recompilation, namely that it provides full debugging capabilities. It is also better for preservation and makes asset replacement much easier.
It is a time investment, though, and little bits of weirdness can happen. One developer noted that this seemed to happen quite a bit with audio.
Static recompilation
Static recompilation takes a different approach. Rather than recreating the game's source code, a developer will translate the existing code into something that runs on a modern platform.
This has some benefits over decompilation. The first is that it's generally much faster to do, which is a benefit if you've got a long list of projects to get through.
One developer noted that audio worked right out of the box when statically recompiling Star Fox 64. They also noted that static recompilation can preserve undefined behavior from the original game.
Of course, it's not without its drawbacks, either. The memory layout can make certain types of modding more difficult. It also means that the game must be recompiled after every code change.
There's no clear superior option here, especially for the end user. It'll probably boil down to the individual game.
So, if a game has both a decompiled and a recompiled game, you might need to play both to see which you like better.
Some assembly required
Of course, it's not just as easy as hopping on over to GitHub and downloading a port and playing Mario 64 within 20 minutes.
These projects generally don't include the original game's assets, because a platform (in this instance, Nintendo) would stomp them into the dirt with a cease-and-desist first, and a full lawsuit later.
Instead, you'll need to provide a copy of the game data. Now, how you do this is up to you, and we really can't tell you how to do that.
Projects worth checking out
All that said, we figured we'd highlight some of the more interesting, Mac-compatible projects out there. Again, we suggest that you check out Read Only Memo's write-up, too, as they've done an excellent job uncovering a plethora of playable ports.
- Legend of Zelda (NES)
- Super Mario World (SNES)
- Streets of Rage (Genesis)
- Doom (Playstation)
- Super Mario 64 (Nintendo 64)
It's also a great time to remind you of Mac Source Ports. We've mentioned them before, and they're a great way to play native app builds of old games that never got an official release on Mac.
