What happens when three programs that look almost identical behave in completely different ways? That is the puzzle facing anyone who opens Dolphin, Slippi, or PrimeHack for the first time. All three run GameCube and Wii games on a PC. All three share the same visual layout, the same menu structure, and much of the same underlying code. Yet they exist for different reasons, and those reasons shape everything from which games boot properly to where your save files end up.
This guide breaks down how the three relate, where compatibility diverges, how controls differ in practice, and how save data travels between them. It also flags the practical mistakes people make most often, because most frustration with these tools comes from treating them as interchangeable when they are not. (Service mesh architecture explained control plane data plane)
The family tree: one codebase, three branches
Dolphin is the original open-source emulator for the GameCube and Wii. It is a community project with years of development behind it, and it serves as the base for the other two programs. When people say “the emulator,” they usually mean this mainline version.
Slippi is a fork, meaning a separate copy of Dolphin’s source code modified for a specific purpose. It was built for competitive Super Smash Bros. Melee. Its headline feature is rollback netcode, a networking technique that predicts inputs so online matches feel closer to local play, plus automatic replay saving for match review. It is not a general-purpose emulator in the way mainline Dolphin is.
PrimeHack is a second fork, this one aimed at the Metroid Prime trilogy. It adds mouse-and-keyboard aiming and a control scheme built around first-person shooting, which the original GameCube controller layout never handled elegantly.
A useful mental model: think of mainline Dolphin as the trunk of a tree, with Slippi and PrimeHack as branches that grew in specific directions. A branch inherits whatever the trunk looked like at the moment it split off. Anything the trunk grows afterward does not automatically appear on the branch.
That single fact explains most compatibility confusion. If a game runs in mainline Dolphin but stutters in Slippi, the cause is usually that Slippi tracks an older base version and has not inherited a later fix. The same logic applies to PrimeHack. This pattern is not unique to emulation. The same dynamic appears in infrastructure tooling, where a fork of a control plane can drift from upstream over time, a theme explored in this explanation of how gitops made git the control plane for modern deployments.
Compatibility: what each build actually runs
Mainline Dolphin has the broadest compatibility by design. It targets the entire GameCube and Wii libraries, and its community maintains detailed per-game reports covering graphical glitches, audio problems, and performance quirks.
Slippi narrows that scope sharply. It exists to run Melee well, and specifically to run the competitive version of it well. Other games may boot, but nothing about the fork is tested or tuned for them. Treating Slippi as a general emulator is the single most common beginner mistake.
PrimeHack sits in the middle. It targets the Metroid Prime trilogy and the control rework those games need. Other titles generally behave like they would on the Dolphin version PrimeHack was based on, but the fork’s own development focuses elsewhere.
| Feature | Dolphin (mainline) | Slippi | PrimeHack |
|---|---|---|---|
| Primary purpose | General GameCube/Wii emulation | Competitive Melee with rollback netcode | Metroid Prime trilogy with mouse and keyboard |
| Game coverage | Full library, community-tested | Melee-focused | Prime trilogy-focused |
| Online play | Basic netplay | Rollback netcode plus replays | Not the focus |
| Input emphasis | GameCube controllers, general pads | GameCube controller, competitive timing | Keyboard and mouse aiming |
| Update cadence | Regular, broad | Tied to fork maintenance | Tied to fork maintenance |
| Save data location | User-configured directory | Fork-specific config paths | Fork-specific config paths |
The practical takeaway: pick the tool for the job. If you want to play Twilight Princess or Mario Galaxy, use mainline Dolphin. If you want lag-resistant Melee against a friend across the country, use Slippi. If you want to aim a beam weapon with a mouse, use PrimeHack. Overlap exists, but it is incidental rather than supported.
Controls: three different ideas of input
Controls are where the three programs feel most distinct, and where configuration files are least likely to transfer cleanly.
Dolphin offers a flexible input system. You map GameCube buttons to whatever controller or keyboard keys you like, and you can save profiles for different setups. It supports real GameCube controllers through USB adapters, which remains the gold standard for authenticity.
Slippi inherits that system but optimizes around a specific use case: a GameCube controller, polled precisely, with input timing that matters for competitive play. Players care about things like analog stick sensitivity and trigger travel because those details affect wavedashes and shield drops. Slippi’s configuration assumes you are chasing that precision.
PrimeHack inverts the priority entirely. Its reason for existing is mouse look and keyboard movement mapped to a first-person shooter. The GameCube original used lock-on targeting because precise aiming with a stick was awkward. PrimeHack removes that limitation, and its control configuration reflects a desktop shooter rather than a console pad.
Here is the mistake to avoid: copying a controller configuration file from one fork into another and expecting identical behavior. The file formats may look similar because the forks share ancestry, but the forks can diverge in how they interpret mappings. Rebuild your bindings inside each program rather than migrating them. It takes five minutes and saves an evening of debugging.
Save files: where your progress actually lives
Save data is the topic that generates the most panicked forum posts, and the confusion is understandable. Two separate things get called “saves,” and they behave differently.
The first is the memory card file. This is the emulated GameCube memory card, a single file holding save data for multiple games, just like the physical card it imitates. Mainline Dolphin lets you create and manage these files, and you choose where they live in your configuration.
The second is the save state. This is a snapshot of the emulator’s entire memory at a chosen instant, letting you resume exactly where you stopped, mid-jump if you like. Save states are convenient and fragile. They are tied to the emulator build that created them, and loading a state from a different version can fail or corrupt the session. (Dolphin (emulator)))
Slippi and PrimeHack inherit both systems, but each maintains its own configuration paths. That means a memory card created in mainline Dolphin is not automatically visible to Slippi, and vice versa. The fix is straightforward: locate the memory card file in one program’s settings, then point the other program at the same file, or copy it into the second program’s directory. The format is shared because the emulated hardware is shared, so the file itself travels fine. Only the default location differs.
Save states are stricter. Do not assume a state made in one fork loads in another. Create fresh states inside whichever program you are using.
One more habit worth building: back up your memory card file before experimenting. Copy it somewhere safe, then tinker. Emulated memory cards are small, backups cost nothing, and a corrupted card with dozens of hours of progress is a genuinely bad afternoon.
Performance and the settings that actually matter
All three programs expose a similar settings panel, and all three reward the same basic tuning. Internal resolution scales the rendered image; raising it sharpens visuals and costs GPU time. Anisotropic filtering improves textures viewed at angles. Backend choice, whether Vulkan, OpenGL, or Direct3D, affects stability differently depending on your graphics card, so test rather than assume.
The fork-specific wrinkle is version lag. Because Slippi and PrimeHack track particular base versions, they may lack optimizations added to mainline Dolphin afterward. If a game runs smoothly in mainline but not in a fork, the fork’s older base is the likely culprit, and no amount of settings tweaking fully closes that gap.
There is a broader lesson here about where work gets done. Modern systems increasingly push specialized tasks onto dedicated hardware so the main processor is not doing everything, a division of labor worth understanding through this breakdown of router hardware offloading and why your CPU is not doing all the work. Emulators make the same trade: the GPU renders, the CPU emulates, and the split determines your frame rate.
Networking: why Slippi feels different
Slippi’s rollback netcode deserves separate mention because it is the fork’s entire reason for existing. Older netplay approaches wait for the other player’s input before advancing, which introduces delay proportional to distance. Rollback predicts the opponent’s next input, advances immediately, and corrects if the prediction was wrong. The result is responsiveness that feels local even over long distances.
That engineering choice has a cost: rollback is complex, and it is tuned for one game. It is not a general feature you can expect from mainline Dolphin’s netplay or from PrimeHack. If online Melee is your goal, Slippi is not merely the better option, it is effectively the only one. (Web application firewall explained beginners it blocks it)
Common mistakes worth avoiding
A short list, drawn from the questions that come up again and again:
- Installing all three into the same folder. Keep separate directories so configuration files do not overwrite each other.
- Assuming a game that runs in Dolphin runs identically in a fork. Test before committing to a playthrough.
- Migrating controller profiles between programs instead of rebuilding them.
- Forgetting where the memory card file lives, then concluding progress was lost when it was simply in another program’s default directory.
- Relying on save states as primary backups. Use memory cards for durability and states for convenience.
- Skipping updates on the fork you actually use. Fork maintenance matters more than mainline version numbers.
Conclusion
Dolphin, Slippi, and PrimeHack are not rivals competing for the same job. They are one codebase split three ways, each branch optimized for a different player. Mainline Dolphin is the generalist, the one to install first and keep updated. Slippi is the specialist for competitive Melee, and its rollback netcode justifies its existence entirely. PrimeHack is the specialist for Metroid Prime, turning a lock-on shooter into a mouse-and-keyboard experience.
Compatibility follows from that structure: broadest on the trunk, narrowest on the branches. Controls follow the same pattern, with each fork tuned to its audience. Save files are more forgiving than they first appear, since memory cards travel between programs once you point each one at the right location, while save states stay loyal to the build that made them. Understand the family tree, keep your directories separate, back up your memory card, and the three programs stop feeling like a confusing tangle and start feeling like a well-stocked toolbox.
Frequently Asked Questions
Can I use Slippi to play games other than Super Smash Bros. Melee?
Technically some titles may boot, but Slippi is not built or tested for them. It tracks a specific Dolphin base version and focuses entirely on Melee’s competitive needs. For anything else, use mainline Dolphin, which targets the full GameCube and Wii libraries.
Will my save file from Dolphin work in PrimeHack?
The memory card file itself should work, because all three programs emulate the same hardware. The catch is location: each fork uses its own default configuration paths. Find the memory card file in one program’s settings and point the other program at it, or copy it across. Save states, by contrast, are tied to the build that created them and should not be moved between programs.
Why does a game run worse in a fork than in mainline Dolphin?
Forks inherit the state of the code at the moment they split from the main project. Improvements added to mainline Dolphin afterward do not automatically reach Slippi or PrimeHack. If performance differs, the fork’s older base version is usually the explanation, and settings changes will only partly compensate.
Can I copy my controller configuration between the three programs?
You can try, but do not count on it working. The configuration formats share ancestry, so they look similar, yet the forks can interpret mappings differently. Rebuilding your bindings inside each program is faster and far less frustrating than debugging a migrated profile that half-works.
Do I need to install all three?
No. Install mainline Dolphin first, since it covers the widest range of games and gives you a baseline. Add Slippi only if you play competitive Melee online, and add PrimeHack only if you want mouse-and-keyboard controls for the Metroid Prime trilogy. Keep each in its own folder so their settings never collide.
Is rollback netcode available in mainline Dolphin or PrimeHack?
Rollback netcode is Slippi’s signature feature and is tuned specifically for Melee. Mainline Dolphin offers netplay with a different approach, and PrimeHack does not focus on online play at all. If low-latency online Melee is your goal, Slippi is effectively the only option among the three.
