Retro Games on Apple Silicon: What Runs Natively

Retro games that run natively on Apple silicon are those whose original code was written for the same ARM architecture Apple now uses, or that have been recompiled to run without emulation or translation. In practice, this means a small but growing library of classic titles from the mid-2000s onward, plus many open-source reimplementations of older games. This article explains what native means on Apple silicon, which retro games actually qualify, and how to play everything else without sacrificing performance.

What “Natively� Actually Means on Apple Silicon

Apple silicon Macs (M1, M2, M3, M4) use the ARM64 instruction set, while Intel Macs used x86_64. A game runs natively when its executable is compiled for ARM64 and uses Apple’s frameworks directly. No translation layer like Rosetta 2 is involved, and no emulator is translating the CPU instructions. For retro games, this distinction matters because most classic titles were written for x86, PowerPC, or 8/16-bit consoles.

Three situations count as native on Apple silicon:

• ARM64 ports: The developer recompiled the game for Apple silicon. Examples include many games from the mid-2010s that received Apple silicon updates, such as Baldur’s Gate II: Enhanced Edition and Planescape: Torment Enhanced Edition.
• Open-source reimplementations: Projects like ScummVM and ResidualVM compile natively for Apple silicon. They don’t emulate the original hardware; they reimplement the game engine in portable C++ that runs directly on the CPU.
• Games originally written for ARM: Some classic mobile games (e.g., early iOS titles ported to Mac) and a few older titles that had ARM versions now run without translation.

Most retro games from the 1980s and 1990s—DOS, early Windows, SNES, Genesis—do not run natively because their original code is x86 or 68k. They run through emulators like DOSBox or RetroArch, which are themselves native but translate the guest CPU.

Why Most Classic Retro Games Aren’t Native

The retro games people usually think of—Doom (1993), Final Fantasy VII (1997), Super Mario World (1990)—were written for CPUs that are now obsolete. The original Doom ran on x86 DOS; Final Fantasy VII on x86 Windows; Super Mario World on the 65c816 in the SNES. Apple silicon uses ARM64, which is a completely different instruction set. To run those exact binaries, the Mac must either emulate the old CPU or use a compatibility layer.

Emulation is not native execution. Even if the emulator itself (like DOSBox or MAME) is compiled for Apple silicon, the game code inside is still being interpreted or dynamically recompiled. That adds overhead, but on modern Apple silicon the overhead is often negligible for 2D games. Still, purists and performance-minded players prefer native ports when they exist because they use fewer resources and have lower latency.

Retro Games That Run Natively on Apple Silicon

Here are concrete examples of retro games that run natively, meaning the binary is ARM64 and no translation is needed:

• Baldur’s Gate: Enhanced Edition and Baldur’s Gate II: Enhanced Edition – Beamdog released Apple silicon native versions; they run without Rosetta.
• Planescape: Torment Enhanced Edition – Also from Beamdog, native ARM64.
• Icewind Dale: Enhanced Edition – Same engine, native.
• Star Wars: Knights of the Old Republic – Aspyr released an Apple silicon native version.
• Jedi Knight: Jedi Academy and Jedi Outcast – Aspyr updated these for Apple silicon.
• Myst (2021 remake) – Native, but it’s a remake, not the original 1993 game.
• OpenMW – A native reimplementation of The Elder Scrolls III: Morrowind (2002). It uses the original game data but runs on a modern ARM64 engine.
• ScummVM – Not a single game, but a native engine that runs many classic adventure games (Monkey Island, Day of the Tentacle, etc.) without emulating the original CPU. The games themselves are data files; the engine is native.

These are the most commonly cited native retro titles. The list is short because most game publishers haven’t recompiled 20-year-old games for a new architecture.

How to Check if a Game Is Native or Running Under Rosetta

Apple provides a simple way to see whether an app is running natively or through Rosetta 2:

1. Open Activity Monitor (in /Applications/Utilities).
2. Select the CPU tab.
3. Look at the Architecture column. If it says “Apple,� the process is native. If it says “Intel,� it’s running under Rosetta.

You can also check the app’s binary with the terminal command file /path/to/app/Contents/MacOS/executable. If it reports “arm64,â€� it’s native. If it says “x86_64,â€� it’s Intel.

For Steam games, right-click the game in your library, go to Properties, and look for a “Compatibility� tab. If it says “Use Rosetta,� it’s not native.

Emulators: The Alternative That Runs Everything Else

For the vast majority of retro games that aren’t native, emulators are the standard solution. Emulators like RetroArch, OpenEmu, DOSBox-X, and MAME all run natively on Apple silicon (the emulator itself is ARM64), but the games they run are not native. The emulator translates the old CPU instructions in real time.

Performance on Apple silicon is generally excellent. For example, SNES, Genesis, and PlayStation 1 emulation runs at full speed on even the base M1. Even PlayStation 2 emulation (via PCSX2) works well on M1 Pro and higher, though it’s not native in the strictest sense—the emulator is ARM64, but the game code is MIPS or x86.

Some emulators also use dynamic recompilation, which translates chunks of the old code into ARM64 on the fly. This is faster than pure interpretation but still not native execution. The distinction only matters for extreme accuracy or very demanding games.

Common Problems and How to Avoid Them

When trying to run retro games on Apple silicon, you might encounter these issues:

• Rosetta not installed: Some Intel-only games require Rosetta 2. Apple prompts you to install it the first time you run an Intel app. If you declined, go to Terminal and run softwareupdate --install-rosetta.
• 32-bit games won’t run at all: macOS Catalina and later dropped 32-bit support. Many retro games from the 2000s are 32-bit and will not run even under Rosetta. You need an emulator or a native reimplementation.
• Graphics glitches: Old games may not handle modern GPU APIs. Emulators often include software rendering options that fix this.
• Save files not appearing: Games that expect to write to their installation folder may fail due to macOS sandboxing. Use an emulator that supports virtual file systems or point the game to a writable folder.

If a game won’t launch, check whether it’s 32-bit (most old Windows games are) and whether it has an Apple silicon native version on GOG or Steam.

How to Choose Between Native Ports and Emulation

When a native port exists, it’s usually the better choice for stability and performance. But native ports sometimes change the game—remastered graphics, altered controls, or missing features. Emulation preserves the original experience but may have minor inaccuracies.

Consider these factors:

• Accuracy: Emulation aims for accuracy; ports may “improveâ€� the game in ways you don’t want.
• Convenience: Native ports typically have modern save systems and achievements; emulators require setting up BIOS files and controls.
• Performance: Native ports use fewer resources, which matters on lower-end Macs.
• Availability: Some games are only available via emulation because the publisher hasn’t released a native version.

For most players, the best approach is: if a native version exists, use it. If not, use a well-maintained emulator.

Costs and Legality of Retro Gaming on Apple Silicon

Native ports are sold on Steam, GOG, or the Mac App Store. Prices vary but are often low for older titles. Emulators themselves are free, but you need to own the games (ROMs) legally. Downloading ROMs for games you don’t own is copyright infringement in most jurisdictions. The safest route is to rip your own cartridges or discs, or buy digital copies from legal sources like GOG or Steam.

There’s no legal risk in using an emulator itself; it’s the ROMs that can be problematic. Many open-source reimplementations (like OpenMW) require you to own the original game data, which keeps them legal.

Frequently Asked Questions

Can I play old DOS games natively on Apple silicon?

No. DOS games are x86 binaries. They run through DOSBox, which is native but emulates the CPU. DOSBox is fast enough for nearly all DOS games on Apple silicon.

Does Rosetta 2 count as native?

No. Rosetta 2 translates x86_64 instructions to ARM64 on the fly. The game is not native; it’s translated. Performance is usually good, but it’s not the same as a true ARM64 build.

Will Apple ever drop Rosetta 2?

Apple hasn’t announced a date, but Rosetta 2 is still supported in current macOS versions. If it’s removed in the future, Intel-only games will need emulation or native ports.

Are there any retro games that run natively on Apple silicon without a port?

Only if the original game was written for ARM. Some early mobile games and a few niche titles qualify, but they’re rare. Open-source reimplementations are the closest thing to native for classic games.

Is there a performance difference between native and Rosetta for retro games?

For most 2D retro games, no noticeable difference. For demanding 3D games from the early 2000s, a native version may run smoother, but Rosetta is often sufficient on M1 Pro or better.

What’s the best way to play SNES games on Apple silicon?

Use a native emulator like OpenEmu or RetroArch with the Snes9x core. The emulator is native, but the game is not. It runs at full speed and offers save states and filters.

Related

• Ways to Use Mobile Data Before It Expires
• Signs Apple Watch Suffered Water Damage
• Pixel Features Hidden in Plain Sight