Dolphin - A GameCube and Wii Emulator

Homepage | Project Site | Buildbot | Forums | Wiki | GitHub Wiki | Issue Tracker | Coding Style | Transifex Page | Analytics

Dolphin is an emulator for running GameCube and Wii games on Windows, Linux, macOS, and recent Android devices. It's licensed under the terms of the GNU General Public License, version 2 or later (GPLv2+).

This fork adds OpenXR support to Dolphin so users can play in VR on Windows, desktop Linux, and standalone Meta Quest headsets, and was developed with the use of AI tools.

• Windows — VR runs on the Direct3D 11, Direct3D 12, Vulkan, and OpenGL backends with any OpenXR runtime (SteamVR, Oculus/Meta Link, VDXR, etc.).
• Linux — VR runs on the Vulkan backend and requires a working system OpenXR runtime such as Monado or SteamVR.
• Meta Quest — a standalone Android build (Quest 2, Quest 3, Quest 3S, and Quest Pro) renders natively in the headset on the Vulkan and OpenGL ES backends, with OpenXR controller support.

Please read the FAQ before using Dolphin.

System Requirements

Desktop

• OS
  • Windows (10 1903 or higher).
  • Linux.
  • macOS (11.0 Big Sur or higher).
  • Unix-like systems other than Linux are not officially supported but might work.
• Processor
  • A CPU with SSE2 support.
  • A modern CPU (3 GHz and Dual Core, not older than 2008) is highly recommended.
• Graphics
  • A reasonably modern graphics card (Direct3D 11.1 / OpenGL 3.3).
  • A graphics card that supports Direct3D 11.1 / OpenGL 4.4 is recommended.

Android

• OS
  • Android (7.0 Nougat or higher).
• Processor
  • A processor with support for 64-bit applications (either ARMv8 or x86-64).
• Graphics
  • A graphics processor that supports OpenGL ES 3.0 or higher. Performance varies heavily with driver quality.
  • A graphics processor that supports standard desktop OpenGL features is recommended for best performance.

Dolphin can only be installed on devices that satisfy the above requirements. Attempting to install on an unsupported device will fail and display an error message.

VR (OpenXR)

• Windows
  • An OpenXR runtime (SteamVR, Oculus/Meta Link, VDXR, etc.) and a headset it supports.
  • Direct3D 11, Direct3D 12, Vulkan, or OpenGL backend.
• Linux
  • An OpenXR runtime such as Monado or SteamVR.
  • Vulkan backend (OpenGL cannot create an OpenXR session on Linux, since Dolphin now creates EGL contexts and OpenXR has no standard EGL binding).
• Meta Quest
  • Quest 2, Quest 3, Quest 3S, or Quest Pro, running the standalone quest build.
  • Vulkan or OpenGL ES backend.
• VR is not supported on macOS.

Building

You may find building instructions on the appropriate wiki page for your operating system:

• Windows
• Linux
• macOS
• Android
• OpenBSD (unsupported)

Before building, make sure to pull all submodules:

git submodule update --init --recursive

Android-specific instructions

These instructions assume familiarity with Android development. If you do not have an Android dev environment set up, see AndroidSetup.md.

If using Android Studio, import the Gradle project located in ./Source/Android.

Android apps are compiled using a build system called Gradle. Dolphin's native component, however, is compiled using CMake. The Gradle script will attempt to run a CMake build automatically while building the Java code.

Building the OpenXR VR version

To build the VR-enabled version of this fork, OpenXR support must be enabled with -DENABLE_VR=ON. VR is supported on Windows, desktop Linux, and Android (Meta Quest). The OpenXR loader is built from the bundled Khronos SDK (Externals/OpenXR).

On Windows, configure a Visual Studio build with CMake and build Dolphin:

cmake -S . -B Build-vs2022 -G "Visual Studio 17 2022" -A x64 -DENABLE_VR=ON
cmake --build Build-vs2022 --config Release --target dolphin-emu

On desktop Linux, VR requires a working system OpenXR runtime such as Monado or SteamVR and the Vulkan backend. Configure with OpenXR and Vulkan enabled:

cmake -S . -B Build -DENABLE_VR=ON -DENABLE_VULKAN=ON
cmake --build Build --target dolphin-emu -j $(nproc)

Building with Docker

A Dockerfile is provided for a reproducible Linux build environment. Build the image from the repository root:

docker build -t dolphinxr:latest .

To produce an installable .deb package from the built image and extract it to the host:

mkdir -p dist
docker run --rm -v "$(pwd)/dist:/out" -w /app/dolphinxr/Build dolphinxr:latest   bash -c "cpack -G DEB && cp -v *.deb /out/"

Then install it:

sudo apt install ./dist/dolphin-emu-*.deb

Building the Meta Quest VR version

The Android project has two product flavors on the device dimension: standard (phones and tablets, built with -DENABLE_VR=OFF) and quest (standalone headsets, built with -DENABLE_VR=ON). The quest flavor is arm64-only, installs under the application ID org.dolphinemu.dolphinemu.quest so it can live alongside a standard install, and declares the OpenXR manifest entries required by Quest 2, Quest 3, Quest 3S, and Quest Pro.

Build it with Gradle from Source/Android:

./gradlew assembleQuestDebug     # or assembleQuestRelease

Helper scripts are also provided for Windows:

.\Source\Android\build-quest.ps1          # debug APK
.\Source\Android\build-quest-release.ps1  # release APK (needs signing properties)

Install the resulting APK on a headset with adb:

adb install -r Source/Android/app/build/outputs/apk/quest/debug/app-quest-debug.apk

VR settings for the headset (launch in VR, resolution scale, reference space, controller bindings, and so on) live under the OpenXR section of the in-app settings.

Uninstalling

On Windows, simply remove the extracted directory, unless it was installed with the NSIS installer, in which case you can uninstall Dolphin like any other Windows application.

Linux users can run cat install_manifest.txt | xargs -d '\n' rm as root from the build directory to uninstall Dolphin from their system.

macOS users can simply delete Dolphin.app to uninstall it.

Additionally, you'll want to remove the global user directory if you don't plan on reinstalling Dolphin.

Command Line Usage

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

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -u USER, --user=USER  User folder path
  -m MOVIE, --movie=MOVIE
                        Play a movie file
  -e <file>, --exec=<file>
                        Load the specified file
  -n <16-character ASCII title ID>, --nand_title=<16-character ASCII title ID>
                        Launch a NAND title
  -C <System>.<Section>.<Key>=<Value>, --config=<System>.<Section>.<Key>=<Value>
                        Set a configuration option
  -s <file>, --save_state=<file>
                        Load the initial save state
  -d, --debugger        Show the debugger pane and additional View menu options
  -l, --logger          Open the logger
  -b, --batch           Run Dolphin without the user interface (Requires
                        --exec or --nand-title)
  -c, --confirm         Set Confirm on Stop
  -v VIDEO_BACKEND, --video_backend=VIDEO_BACKEND
                        Specify a video backend
  -a AUDIO_EMULATION, --audio_emulation=AUDIO_EMULATION
                        Choose audio emulation from [HLE|LLE]

Available DSP emulation engines are HLE (High Level Emulation) and LLE (Low Level Emulation). HLE is faster but less accurate whereas LLE is slower but close to perfect. Note that LLE has two submodes (Interpreter and Recompiler) but they cannot be selected from the command line.

Available video backends are "D3D" and "D3D12" (they are only available on Windows), "OGL", and "Vulkan". There's also "Null", which will not render anything, and "Software Renderer", which uses the CPU for rendering and is intended for debugging purposes only.

DolphinTool Usage

usage: dolphin-tool COMMAND -h

commands supported: [convert, verify, header, extract]

Usage: convert [options]... [FILE]...

Options:
  -h, --help            show this help message and exit
  -u USER, --user=USER  User folder path, required for temporary processing
                        files. Will be automatically created if this option is
                        not set.
  -i FILE, --input=FILE
                        Path to disc image FILE.
  -o FILE, --output=FILE
                        Path to the destination FILE.
  -f rvz|iso|gcz|wia, --format=rvz|iso|gcz|wia
                        Container format to use. Default is RVZ.
  -s, --scrub           Scrub junk data as part of conversion.
  -b BLOCK_SIZE, --block_size=BLOCK_SIZE
                        Block size for GCZ/WIA/RVZ formats, as an integer.
                        Suggested value for RVZ: 131072 (128 KiB)
  -c none|zstd|bzip2|lzma|lzma2, --compression=none|zstd|bzip2|lzma|lzma2
                        Compression method to use when converting to WIA/RVZ.
                        Suggested value for RVZ: zstd
  -l COMPRESSION_LEVEL, --compression_level=COMPRESSION_LEVEL
                        Level of compression for the selected method. Ignored
                        if 'none'. Suggested value for zstd: 5

Usage: verify [options]...

Options:
  -h, --help            show this help message and exit
  -u USER, --user=USER  User folder path, required for temporary processing
                        files. Will be automatically created if this option is
                        not set.
  -i FILE, --input=FILE
                        Path to input file.
  -a crc32|md5|sha1|rchash, --algorithm=crc32|md5|sha1|rchash
                        Optional. Compute and print the digest using the
                        selected algorithm, then exit.

Usage: header [options]...

Options:
  -h, --help            show this help message and exit
  -i FILE, --input=FILE
                        Path to disc image FILE.
  -b, --block_size      Optional. Print the block size of GCZ/WIA/RVZ formats,
then exit.
  -c, --compression     Optional. Print the compression method of GCZ/WIA/RVZ
                        formats, then exit.
  -l, --compression_level
                        Optional. Print the level of compression for WIA/RVZ
                        formats, then exit.

Usage: extract [options]...

Options:
  -h, --help            show this help message and exit
  -i FILE, --input=FILE
                        Path to disc image FILE.
  -o FOLDER, --output=FOLDER
                        Path to the destination FOLDER.
  -p PARTITION, --partition=PARTITION
                        Which specific partition you want to extract.
  -s SINGLE, --single=SINGLE
                        Which specific file/directory you want to extract.
  -l, --list            List all files in volume/partition. Will print the
                        directory/file specified with --single if defined.
  -q, --quiet           Mute all messages except for errors.
  -g, --gameonly        Only extracts the DATA partition.