Building on Linux

Complete guide to building and running Dolphin Emulator on Linux

System Requirements

Most modern Linux distributions are supported. Unix-like systems other than Linux are not officially supported but might work.

Hardware Requirements

• Processor: CPU with SSE2 support (modern 3 GHz Dual Core recommended, not older than 2008)
• Graphics: Graphics card supporting OpenGL 3.3 (OpenGL 4.4 recommended)

Build Requirements

Required Tools

• CMake - Build system generator
• GCC or Clang - Recent version with decent C++20 support
• Git - Version control

CMake will inform you if your compiler is too old or if you need to install any missing packages.

Installing Dependencies

Many libraries are bundled with Dolphin and used if they’re not installed on your system. For distribution-specific dependency installation instructions, refer to the Building for Linux wiki.

Building Dolphin

Clone the Repository

First, clone the Dolphin repository and initialize submodules:

git clone https://github.com/dolphin-emu/dolphin.git
cd dolphin
git submodule update --init --recursive

Make sure to pull submodules before building. Building without submodules will fail.

Build Methods

Dolphin supports three different build configurations for Linux:

Global Installation

Install Dolphin to your system (requires root access).

1. Create build directory

   mkdir build
   cd build
   
2. Configure with CMake

   cmake ..
   

   CMake will check dependencies and inform you of any missing packages.

3. Compile

   make -j $(nproc)
   

   This uses all available CPU cores for faster compilation.

4. Install to system

   sudo make install
   

   This installs Dolphin system-wide and makes it available from your application menu.

Local Development

Build for development without requiring root access.

1. Create build directory

   mkdir Build
   cd Build
   
2. Configure for local development

   cmake .. -DLINUX_LOCAL_DEV=true
   

   The LINUX_LOCAL_DEV flag enables local development mode.

3. Compile

   make -j $(nproc)
   
4. Link system data

   ln -s ../../Data/Sys Binaries/
   

   This creates a symbolic link to the system data directory.

Useful for development as root access is not required.

Portable Build

Create a portable installation that can be moved between systems.

1. Create build directory

   mkdir Build
   cd Build
   
2. Configure for local development

   cmake .. -DLINUX_LOCAL_DEV=true
   
3. Compile

   make -j $(nproc)
   
4. Copy system data

   cp -r ../Data/Sys/ Binaries/
   

   This copies (not links) the system data directory.

5. Create portable marker

   touch Binaries/portable.txt
   

   The presence of portable.txt tells Dolphin to use portable mode.

Portable builds can be stored on external storage and used on different Linux systems. Also useful for having multiple distinct Dolphin setups for testing/development/TAS.

Running Dolphin

Global Installation

After system installation, launch Dolphin from:

• Application menu
• Command line: dolphin-emu

Local/Portable Build

Run from the build directory:

cd Build/Binaries
./dolphin-emu

Command Line Usage

Dolphin supports various command-line options:

Basic Usage

# Launch a game directly
dolphin-emu -e "path/to/game.iso"

# Run in batch mode (no UI)
dolphin-emu -b -e "game.iso"

Available Video Backends

• OGL - OpenGL
• Vulkan - Vulkan API
• Null - No rendering
• Software Renderer - CPU rendering (debugging only)

Uninstalling

Global Installation

Run the following command as root from the build directory:

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

Or with sudo:

sudo sh -c "cat install_manifest.txt | xargs -d '\n' rm"

Local/Portable Build

Simply delete the build directory:

rm -rf Build

To completely remove Dolphin, also delete the global user directory (~/.dolphin-emu or ~/.local/share/dolphin-emu) if you don’t plan on reinstalling.

Troubleshooting

CMake reports compiler too old

Install a recent version of GCC or Clang with C++20 support:

# Ubuntu/Debian
sudo apt install build-essential gcc g++

# Fedora
sudo dnf install gcc gcc-c++

# Arch Linux
sudo pacman -S base-devel

Missing dependencies

CMake will inform you of missing packages. Install them using your distribution’s package manager.

For detailed dependency lists, see the Building for Linux wiki.

Build fails with submodule errors

Ensure you’ve initialized and updated all submodules:

git submodule update --init --recursive

Graphics driver issues

Ensure you have up-to-date graphics drivers:

• NVIDIA: Install proprietary drivers
• AMD: Use AMDGPU drivers (usually included in modern kernels)
• Intel: Mesa drivers (usually pre-installed)

DolphinTool Usage

Dolphin includes a command-line tool for disc image operations:

dolphin-tool COMMAND -h

Available Commands

convert

Convert disc images between formats:

dolphin-tool convert -i input.iso -o output.rvz -f rvz \
  -c zstd -l 5 -b 131072

Supported formats: ISO, GCZ, WIA, RVZ

verify

Verify disc image integrity:

dolphin-tool verify -i game.iso -a md5

Supported algorithms: crc32, md5, sha1, rchash

header

Display disc image header information:

dolphin-tool header -i game.rvz -c -l

extract

Extract files from disc images:

dolphin-tool extract -i game.iso -o output_folder