Dolphin: a GameCube and Wii emulator for desktop and Android

What Dolphin emulates and who the binary is built for

Dolphin targets two Nintendo consoles: the GameCube and the Wii. The README describes it as "an emulator for running GameCube and Wii games on Windows, Linux, macOS, and recent Android devices", licensed under the GNU General Public License, version 2 or later. The practical audience is anyone holding original discs or Wii titles who wants them on a PC or phone, plus developers and researchers who need a scriptable, inspectable runtime for that hardware. The repository is written in C++, which matches what the source tree actually is: a large native emulator with platform frontends. Nothing in the README frames Dolphin as a general-purpose virtual machine or a RetroArch-style multi-system core. It emulates one vendor's two consoles, and the system requirements are written accordingly.

The two halves of the runtime: Dolphin and dolphin-tool

The project ships two executables. The GUI binary, Dolphin.exe on Windows, is the interactive emulator. The second is dolphin-tool, a command line utility whose README usage lists four commands: convert, verify, header and extract. That split matters. Disc images can be rewritten, checked or queried without ever opening the interface, which is what you want when preparing a library in bulk.

The convert subcommand takes -i for the input disc image and -o for the destination, with -f selecting the container format from iso, gcz, wia or rvz. The default is RVZ. The -s flag scrubs junk data during conversion, and -u points at a user folder used for temporary processing files, created automatically if you omit it.

On the emulation side, the command line exposes the same switches the GUI uses. -e loads a specified file, -n launches a NAND title by its 16-character ASCII title ID, and -C sets a configuration option in the form System.Section.Key=Value. Available DSP emulation engines are HLE and LLE. The README explains the trade-off plainly: HLE is faster but less accurate, LLE is slower but close to perfect, and LLE's two submodes, Interpreter and Recompiler, cannot be selected from the command line. Video backends are D3D and D3D12 on Windows only, plus OGL and Vulkan, with Null and Software Renderer available; the software renderer uses the CPU and is described as intended for debugging purposes only.

Installing Dolphin and running a first game

The README does not host binaries itself. It points to the homepage at dolphin-emu.org, and building instructions live on per-OS wiki pages for Windows, Linux, macOS, Android and OpenBSD (the last marked unsupported). If you build from source, the first step the README gives is pulling submodules:

git submodule update --init --recursive

After that, follow the wiki page for your platform. Android is the exception in structure: the README says to import the Gradle project located in ./Source/Android, and notes that while Android apps are compiled with Gradle, Dolphin's native component is compiled with CMake, with the Gradle script running the CMake build automatically.

The README's dolphin-tool usage block documents convert with -i for the input disc image, -o for the destination, -f for the container format (iso, gcz, wia or rvz, default RVZ), -s to scrub junk data and -u for the user folder.

To launch something directly, the README's own usage line is:

Usage: Dolphin.exe [options]... [FILE]...

The same block lists -e to load a specified file, -n to launch a NAND title by its 16-character ASCII title ID, and -C to set a configuration value.

Where Dolphin is the wrong tool

The system requirements are not decorative. On desktop, Dolphin wants a CPU with SSE2 support, and the README calls a modern CPU of 3 GHz and dual core, not older than 2008, highly recommended. Graphics need Direct3D 11.1 or OpenGL 3.3 at minimum, with Direct3D 11.1 or OpenGL 4.4 recommended. The README is explicit that installing on hardware below these requirements will fail and display an error message.

Android is the sharper edge. The device needs Android 7.0 Nougat or higher, a 64-bit capable processor (ARMv8 or x86-64), and a GPU supporting OpenGL ES 3.0 or higher. The README then adds that performance varies heavily with driver quality and links to a blog post on OpenGL drivers. That is a candid admission that identical hardware can behave differently depending on the vendor's driver, and it means Dolphin on Android is a poor fit if you cannot control the device or its firmware.

There is also an accuracy ceiling. Choosing HLE audio buys speed at the cost of accuracy, and LLE, the accurate path, is slower. The two LLE submodes cannot be selected from the command line, so scripted setups cannot tune that dimension. And the Software Renderer, while available, is documented as a debugging aid rather than a way to play. If you need bit-exact cycle behavior across a title library, none of this is presented as a guarantee.

How Dolphin differs from a multi-system frontend

The obvious alternative for someone consolidating a game library is a multi-system frontend such as RetroArch, which wraps many emulator cores behind one interface and one controller configuration. The difference is architectural, not cosmetic. Dolphin is a single-vendor emulator with its own GUI, its own configuration model, and a companion tool, dolphin-tool, purpose-built for GameCube and Wii disc containers (iso, gcz, wia, rvz). RetroArch does not ship that conversion pipeline; it delegates emulation to cores and leaves disc preparation to other utilities.

That cuts both ways. If your library is mostly GameCube and Wii, Dolphin's integrated convert, verify, header and extract commands save you from stitching together separate tools. If your library spans a dozen systems, you end up running Dolphin alongside a frontend anyway, and you inherit two configuration surfaces. The README's command line, with -C System.Section.Key=Value, is Dolphin's answer to scripted configuration, and it is specific to Dolphin's own settings tree rather than a frontend-wide standard.

Maintenance, licensing and upgrade cost

The repository is not archived, and the last push was on 2026-11-02, so the codebase is current. The repository has no published GitHub releases, so upgrade cost is best judged from the build instructions: the wiki pages for each OS, the submodule pull, and the CMake and Gradle build described for Android. That is the recurring cost.

Uninstalling is documented per platform. On Windows you remove the extracted directory unless you used the NSIS installer, in which case it uninstalls like any other Windows application. macOS users delete Dolphin.app. Linux users run a command from the build directory:

cat install_manifest.txt | xargs -d '\n' rm

The README says to run that as root, and adds that you should also remove the global user directory if you do not plan to reinstall. Note the asymmetry: the Linux path depends on install_manifest.txt still existing in the build directory, so a cleaned build tree removes your uninstall route.

The licence is GPLv2 or later. The repository's license field is reported as NOASSERTION, but the README states GPLv2+ explicitly, and there is a COPYING file and a LICENSES/ directory at the top level. GPLv2+ is a copyleft licence, which has implications if you intend to redistribute a modified build. This is a description of the licence, not legal advice; consult the COPYING file and a qualified professional for your own situation.

Editorial conclusion

Dolphin is for people who own GameCube or Wii software and want to run it on a desktop or a recent Android device with a Direct3D 11.1 or OpenGL 3.3 class GPU. It is not for anyone whose hardware predates SSE2, whose Android device lacks OpenGL ES 3.0, or who expects console-accurate timing on every title: the README itself points to the FAQ before use, and LLE audio trades speed for accuracy. Before adopting it, check the wiki build page for your operating system, confirm your GPU supports the required API, and read the FAQ and issue tracker for the specific games you care about.

Frequently asked questions

Official sources

1. dolphin-emu/dolphin on GitHub
2. Issues
3. Project website
4. README