Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

Overview

Dolphin - A GameCube and Wii Emulator

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

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+).

Please read the FAQ before using Dolphin.

System Requirements

Desktop

  • OS
    • Windows (7 SP1 or higher).
    • Linux.
    • macOS (10.12 Sierra 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 (5.0 Lollipop 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.

Building for Windows

Use the solution file Source/dolphin-emu.sln to build Dolphin on Windows. Visual Studio 2019 16.3 or later is a hard requirement. Other compilers might be able to build Dolphin on Windows but have not been tested and are not recommended to be used. Git and Windows 10 SDK must be installed when building.

Make sure to pull submodules before building:

git submodule update --init

The "Release" solution configuration includes performance optimizations for the best user experience but complicates debugging Dolphin. The "Debug" solution configuration is significantly slower, more verbose and less permissive but makes debugging Dolphin easier.

An installer can be created by using the Installer.nsi script in the Installer directory. This will require the Nullsoft Scriptable Install System (NSIS) to be installed. Creating an installer is not necessary to run Dolphin since the Binary directory contains a working Dolphin distribution.

Building for Linux and macOS

Dolphin requires CMake for systems other than Windows. Many libraries are bundled with Dolphin and used if they're not installed on your system. CMake will inform you if a bundled library is used or if you need to install any missing packages yourself.

macOS Build Steps:

  1. mkdir build
  2. cd build
  3. cmake ..
  4. make

An application bundle will be created in ./Binaries.

Linux Global Build Steps:

To install to your system.

  1. mkdir build
  2. cd build
  3. cmake ..
  4. make
  5. sudo make install

Linux Local Build Steps:

Useful for development as root access is not required.

  1. mkdir Build
  2. cd Build
  3. cmake .. -DLINUX_LOCAL_DEV=true
  4. make
  5. ln -s ../../Data/Sys Binaries/

Linux Portable Build Steps:

Can be stored on external storage and used on different Linux systems. Or useful for having multiple distinct Dolphin setups for testing/development/TAS.

  1. mkdir Build
  2. cd Build
  3. cmake .. -DLINUX_LOCAL_DEV=true
  4. make
  5. cp -r ../Data/Sys/ Binaries/
  6. touch Binaries/portable.txt

Building for Android

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.

Uninstalling

When Dolphin has been installed with the NSIS installer, 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 (see below to see where it's stored) if you don't plan to reinstall Dolphin.

Command Line Usage

Usage: Dolphin [-h] [-d] [-l] [-e <str>] [-b] [-V <str>] [-A <str>]

  • -h, --help Show this help message
  • -d, --debugger Show the debugger pane and additional View menu options
  • -l, --logger Open the logger
  • -e, --exec= Load the specified file (DOL,ELF,WAD,GCM,ISO)
  • -b, --batch Exit Dolphin with emulator
  • -V, --video_backend= Specify a video backend
  • -A, --audio_emulation= Low level (LLE) or high level (HLE) audio

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.

Sys Files

  • wiitdb.txt: Wii title database from GameTDB
  • totaldb.dsy: Database of symbols (for devs only)
  • GC/font_western.bin: font dumps
  • GC/font_japanese.bin: font dumps
  • GC/dsp_coef.bin: DSP dumps
  • GC/dsp_rom.bin: DSP dumps
  • Wii/clientca.pem: Wii network certificate
  • Wii/clientcakey.pem: Wii network certificate key
  • Wii/rootca.pem: Wii network certificate issuer / CA

The DSP dumps included with Dolphin have been written from scratch and do not contain any copyrighted material. They should work for most purposes, however some games implement copy protection by checksumming the dumps. You will need to dump the DSP files from a console and replace the default dumps if you want to fix those issues.

Wii network certificates must be extracted from a Wii IOS. A guide for that can be found here.

Folder Structure

These folders are installed read-only and should not be changed:

  • GameSettings: per-game default settings database
  • GC: DSP and font dumps
  • Maps: symbol tables (dev only)
  • Shaders: post-processing shaders
  • Themes: icon themes for GUI
  • Resources: icons that are theme-agnostic
  • Wii: default Wii NAND contents

Packaging and udev

The Data folder contains a udev rule file for the official GameCube controller adapter and the Mayflash DolphinBar. Package maintainers can use that file in their packages for Dolphin. Users compiling Dolphin on Linux can also just copy the file to their udev rules folder.

User Folder Structure

A number of user writeable directories are created for caching purposes or for allowing the user to edit their contents. On macOS and Linux these folders are stored in ~/Library/Application Support/Dolphin/ and ~/.dolphin-emu respectively, but can be overwritten by setting the environment variable DOLPHIN_EMU_USERPATH. On Windows the user directory is stored in the My Documents folder by default, but there are various way to override this behavior:

  • Creating a file called portable.txt next to the Dolphin executable will store the user directory in a local directory called "User" next to the Dolphin executable.
  • If the registry string value LocalUserConfig exists in HKEY_CURRENT_USER/Software/Dolphin Emulator and has the value 1, Dolphin will always start in portable mode.
  • If the registry string value UserConfigPath exists in HKEY_CURRENT_USER/Software/Dolphin Emulator, the user folders will be stored in the directory given by that string. The other two methods will be prioritized over this setting.

List of user folders:

  • Cache: used to cache the ISO list
  • Config: configuration files
  • Dump: anything dumped from Dolphin
  • GameConfig: additional settings to be applied per-game
  • GC: memory cards and system BIOS
  • Load: custom textures
  • Logs: logs, if enabled
  • ScreenShots: screenshots taken via Dolphin
  • StateSaves: save states
  • Wii: Wii NAND contents

Custom Textures

Custom textures have to be placed in the user directory under Load/Textures/[GameID]/. You can find the Game ID by right-clicking a game in the ISO list and selecting "ISO Properties".

Issues
  • Hybrid xfb

    Hybrid xfb

    Offtopic comments not related to testing or reviews / technical questions will be moderated

    The second pr based off of @phire 's original Hybrid XFB #3880 . Leverages the AbstractTexture ( #5305 ) to treat the xfb as a texture.

    What this PR does: It allows you to play games that require "RealXFB" with higher internal resolution (the actual xfb will still be native resolution)

    What's done:

    • Initial hybrid xfb support for Vulkan, D3D, Opengl, Software
    • Make texture cache always use safe hashing for XFB copies.
    • Initial Screenshot / Video dumping for D3D, Vulkan, Opengl, Software through VideoCommon
    • GUI Options
    • Update fifoplayer to support XFB
    • Vertical scaling for PAL games
      • XFB to RAM copies need to apply the scale
      • XFB to Tex copies need to store, but not apply the scale.
      • Partial texture updates need to apply any store scaling before display.
    • Remove lots of unnecessary code!
    • GPU texture decoding works for XFBs
    • Option for 'Immediate mode' XFB which can provide better latency at the cost of graphical errors (usable on both XFB2Tex or XFB2Ram)
    • Somehow allow Swap to detect when the XFB hasn't changed since last frame
    • Update game inis
      • All games previously requiring real xfb or virtual xfb, now have immediate mode defaulting to off
      • Games that show partial/incomplete frames sets immediate mode to off
      • Added a couple of new inis that also have these restrictions
    • Strided XFB copies fully supported
      • Fixes "Sonic 3d Blast"
      • Fixes "Zelda Collector's Edition"

    What's left:

    • Nothing!

    Future Enhancements:

    • Find a new sane home for the "End of frame" stuff.
    • Fix "Super Mario Strikers" (loading screen backgrounds do not show up with XFB2Tex)
    • Screenshots do not account for post-processing
    • Partial XFB support for games like Mario Strikers or Chicken Little
      • The proper solution likely is either leverage locking so users can use XFB2Ram without a perf hit or to treat hash changes as overwrites. This means we'd upscale the 1x res xfb in memory and combine it with the texture cache xfb, treating a key color (fuchsia) as alpha
    opened by iwubcode 213
  • Vulkan: macOS support via MoltenVK

    Vulkan: macOS support via MoltenVK

    It seems MoltenVK is now mature enough to handle the shaders Dolphin generates without completely falling over. It will be interesting to see how it performs compared to OpenGL, but more importantly, it enables mac users to use features blocked by the GL version, e.g. bounding box.

    We'll also have to decide how to distribute MoltenVK. Currently, the loader searches for an environment variable named LIBMOLTENVK_PATH, and if present uses that. Otherwise, it looks in the application bundle directory, under DolphinWx.app/Contents/Frameworks/libMoltenVK.dylib.

    I'd suggest building MoltenVK externally, and copying the library in as a buildbot step. IMO, this is better than including yet another huge externals dependency, for a single platform.

    Known limitations:

    • In single core mode, enabling multithreading in graphics options can lead to lower performance. In dual core mode, it seems similar. Probably best to disable it though, due to MoltenVK doing its own threading internally.
    • Ubershaders cause the shader compiler to freak out. I haven't looked into whether this is a SPIRV-Cross (via MoltenVK) issue, or we need to update our glslang.
    opened by stenzek 180
  • Support for motion controllers like the DualShock 4

    Support for motion controllers like the DualShock 4

    The CemuHook controller input protocol

    This was done by implementing the protocol for controller input used by CemuHook in a new controller interface class (CemuHookUDPServer). The protocol is used for transmitting controller input (including motion input) to Dolphin from specific server applications written to support specific controller types. For example, the Sony Dualshock 4 is supported through the DS4Windows application. This is the only configuration I have tested. See this page on the CemuHook site for more information and instructions on testing motion input before trying to use it with Dolphin.

    Server configuration

    First make sure you have tested your controller's motion input like in the link above. Then run and quit Dolphin once to create the settings file UDPServer.ini in the Dolphin config folder. In the settings file change Enabled = False to Enabled = True. Default values for the other settings (IPAddress and Port) may need changing depending on the server application used. With DS4Windows you just need to enable the UDP Server in DS4Windows' settings.

    Emulated Wii Remote configuration

    2019-09-19 15_04_21-vs2017 (1) - Remote Viewer In the GUI for configuring an Emulated Wii Remote, a new tab called Motion Input was added. The old Motion Controls tab was renamed to Motion Simulation to differentiate them. In the Device dropdown list select a UDPServer device for motion input support. Point settings are described below. Accelerometer and Gyro settings should be left alone.

    Pointer emulation

    The Wiimote camera sensor (pointer) is emulated from motion input. There are however some inaccuracies in motion sensors making the pointer slowly drift horizontally. To help this, there are two options in the Point box on the Motion Input tab. One is Recenter, which lets you recenter the pointer on the screen with a button press. The other is Total Yaw, which horizontally limits the pointer movement like when a computer mouse pointer hits the screen edge. Try out both options to see which works best in which games. I have playtested very little, but for Skyward Sword it seems best to disable Total Yaw by setting it to 360 and mapping Recenter to Pad S just like the ingame recenter function. Then, when you need to recenter, point the controller in the direction of the screen center and tap Pad S twice without moving the controller.

    Funny story

    Initially I had troubles getting any motion input to work. Among several things I tried Wii Sports Tennis to see if I could get any reaction from the motion input. I first tried a few forehands and backhads to get the guy to serve. Then I remembered how the pros do it and took a proper swing from behind my head. The brand new DS4 controller I used first hit a ceiling lamp, knocking the controller out of my hand. The controller then, to my horror, flew towards my four months old 1100$ TV, just missing to its left and also just above a computer monitor stored temporarily on the floor. The controller hit the wall behind the computer monitor with a loud crack, prompting people on the above floor come asking what the hell was going on. Incredibly, the ceiling lamp, both displays, the controller and the wall survived with just a few scratches.

    opened by rlnilsen 171
  • Texture lookup fix

    Texture lookup fix

    Fixes Texture lookup by applying point sampling.

    Old: This adds an epsilon in the texture sampling stage to prevent rounding errors.

    An epsilon of 0.5 gave the same results (when it comes to artifacts)as point sampling without actually point sampling so there is no behavioral change. 0.5 was chosen as that is the lowest value that can always be represented when converting a 24bit signed integer to a float. The only fifolog that this doesn't fix is Just Dance 2 but the same artifacts can be found when point sampling and this depends on the hardware, so this is probably a rounding error(https://github.com/dolphin-emu/dolphin/pull/9473#issuecomment-768564342, https://github.com/dolphin-emu/dolphin/pull/9473#issuecomment-767937443). But Just Dance 2 is improved compared to master, at least on my hardware (Nvidia).

    OLD: This solution was provided by u/fortsnek47 on reddit (https://www.reddit.com/r/EmuDev/comments/l0y7sg/gc_fixing_those_vp6_videos/). I don't have any games with texture lookup issues so I can't test these changes.

    Games that can be tested: https://wiki.dolphin-emu.org/index.php?title=Template:Problems/VP6_Videos

    opened by Miksel12 132
  • Apple M1 Support for MacOS

    Apple M1 Support for MacOS

    This pull request adds support for compiling Dolphin for ARM on MacOS so that it can run natively on the M1 processors without running through Rosseta2 emulation providing a 30-50% performance speedup and less hitches from Rosseta2.

    It consists of several key changes:

    • Adding support for W^X allocation(MAP_JIT) for the ARM JIT
    • Adding the machine context and config info to identify the M1 processor
    • Additions to the build system and docs to support building universal binaries
    • Adding code signing entitlements to access the MAP_JIT functionality
    • Updating the MoltenVK libvulkan.dylib to a newer version with M1 support

    Thanks everyone on IRC for the help in making this change!

    opened by skylersaleh 122
  • Vulkan Backend

    Vulkan Backend

    This thread will be strictly moderated, any off-topic or pointless comments will be deleted.

    • Not going to implement XFB, waiting on TextureCache-based XFB first.
    • Same with screenshot/frame dumping
    • You can probably play games now.
    • Performance in my brief testing is slightly above OpenGL on nVidia
    • AMD seems roughly ~25% faster compared to OpenGL in some scenarios (apart from needing the dualsrc blend fallback)
    • Can't really test on Intel, my most recent iGPU is a Haswell and Vulkan support is buggy

    Rough overall todo:

    • [x] Basic framework
    • [x] Ability to draw stuff
    • [x] Texture/vertex uploading
    • [x] Update to new source styling
    • [x] Sort out shader compiler
    • [x] Having games render a decent amount of stuff
    • [x] Not crash regularly (somewhat improved)
    • [x] EFB to texture
    • [x] EFB to ram
    • [x] EFB format changes
    • [x] GPU texture conversion
    • [x] CPU EFB access
    • [x] Bounding box
    • [x] Perf queries
    • [x] MSAA support
    • [x] Stereoscopy support
    • [x] Anisotropic filtering support
    • [x] Logic ops for blending
    • [x] Vsync
    • [x] Texture dumping
    • [x] Support for mobile/android
    • [x] Support for drivers without coherent buffer mapping (needed?)
    • [x] Support for drivers without dual source blending (looking at you, Adreno)
    • [x] Pipeline state caching

    Now feature-complete, time for clean-ups/bug-fixing/performance work.


    This change is Reviewable

    opened by stenzek 116
  • Add ability to passthrough a Bluetooth adapter

    Add ability to passthrough a Bluetooth adapter

    This adds the ability to passthrough a whole Bluetooth adapter and skip the majority of the Bluetooth emulation code. We use libusb to send HCI commands, receive HCI events and transfer ACL data directly to the first adapter that is found, or to a specific adapter (if configured to).

    This is possible because the Wii's Bluetooth module is actually just a pretty standard Bluetooth adapter…

    …except for two vendor-specific commands and one other HCI command (for which replies are faked), and also for the sync button. On the Wii, the sync button triggers an HCI event, which emulated software interpret as a command to perform a BT inquiry. We definitely need to emulate that, so this PR also adds a hotkey and a button to trigger the "sync button" event.

    What works in this passthrough mode:

    • Pairing and reconnecting Wiimotes on button press
    • Letting the emulated software really disconnect Wiimotes
    • Reconnecting Wiimotes after e.g. an ES_Launch (depending on the adapter)
    • Wiimote audio with all Wiimotes, -TR or non -TR
    • Third-party Wiimote support just like on the Wii, even on Windows
    • Generally improved Wiimote input, especially with a Motion+

    Limitations:

    • It is difficult to connect more than 3 Wiimotes at the same time. A Wii Bluetooth module works perfectly, so this really depends on the quality of the adapter.
    • Loading a state save breaks it completely, even if the state load is reverted. Not much I can do, since we're doing hardware passthrough.

    This change is Reviewable

    opened by leoetlino 112
  • Resolution independent mipmaps (high IR Super Mario Galaxy Fix)

    Resolution independent mipmaps (high IR Super Mario Galaxy Fix)

    Super Mario Galaxy renders fog and various other effects like lava and water by tinting higher mipmap levels. This is a neat trick and all, but it means that by letting the host GPU handle mipmaps at resolutions higher than the wii could output (and especially by activating anisotropic filtering), the effect breaks down because the mipmaps get pushed much farther down from the camera than originally intended. In fact they almost disappear!

    Before (6x IR):

    00000000-3

    Note how the background star, lava and the reflections in the Starbits ice things are broken.

    With the hack enabled (still 6x IR): 00000000-2

    So to fix this I did a bunch of things:

    • Added a checkbox in Graphics/Hacks. I added it as an Hack because the downside of this fix is that with this enabled lower LODs show unnecessarily closer! In any game that doesn't use LOD tricks, this causes blurrier textures (although more accurate to the original!) This option is auto-disabled at 1x IR.
    • When the option is on, instead of using the native texture read functions, all shaders (normal and uber) go through a texture_read function. texture_read selects the LOD level by hand so that it can scale the ddx/ddy by the IR scale and get an approximation of the original values on real consoles. This is not super precise, I guess, along borders (where the gradients change quickly) but overall it seems to work pretty well! Note that the new function is also slower, because it has to compute the levels by hand! I couldn't see any real slowdown when playing on my computer, though.
    • When the option is on, it completely disables Anisotropic Filtering as well. Besides the fact that textureLod ignores it, Anisotropic is another effect that greatly pushes LODs out so you don't want to use it either.
    • Enabled that option by default in Super Mario Galaxy 1 & 2, because I think it makes no sense to play them at higher IR with broken graphics. Most textures don't seem to have more than 1 mipmaps anyway, except the ones used this way. weird.
    • Fixed a typo :D

    Let me know what you think!

    opened by Tomcc 112
  • Ubershaders 2.0

    Ubershaders 2.0

    If users want to test, use this link: https://dl.dolphin-emu.org/prs/pr-5702-dolphin-latest-x64.7z

    This pull request completes the implemention of ubershaders in the graphics backends, started by @phire. Most of the hard work was done already by them, I just had to write the vertex ubershaders, integrate it into the backends, and fix bugs.

    Last time I checked, ubershaders are fifoci regression-free on GL. Haven't tried D3D or Vulkan.

    In the graphics options under the enhancements tab, there is a new drop-down field, "Ubershader mode". The options are:

    • Disabled: "Classic" mode with normal shader generation. Stuttering will still exist, same as before. Recommended for low-end systems.
    • Hybrid: Compiles specialized shaders asynchronously, while this occurs, ubershaders will be used. Best balance of performance and stuttering. This is not the same as the Ishiiruka async shaders! Game objects will continue to render as normal while shaders are being compiled. Not guaranteed to remove stuttering completely, as drivers often defer some work to the first time a program is used, and/or GL_LINK_STATUS is checked (cough NVIDIA), which we do on the main thread.
    • Exclusive: Only use ubershaders for rendering. Largest performance hit. Don't expect to hit full speed at high resolutions, even on high-end systems. Least possible amount of compilation "stutter".

    There's also a few hidden options, which you can modify via the ini:

    • BackgroundShaderCompiling: Enables aforementioned "hybrid" mode.
    • DisableSpecializedShaders: Enables aforementioned "exclusive" mode.
    • PrecompileUberShaders: Precompiles all ubershader combinations at boot time. For drivers that support a shader cache, this will only take time on the first boot, subsequent boots should be very fast. You want to leave this enabled for the best experience, as the ubershader compile time is much longer than the specialized shader compile time.
    • ShaderCompilerThreads: Sets the number of worker threads created for asynchronous shader compilation. Most drivers have some sort of lock involved in shader creation, so this will only scale up to a certain point. It defaults to 1, as this hopefully should be sufficient for background compiling in most cases, as well as not oversubscribing those with fewer CPU cores. This can be also be set to -1, which determines the number of threads based on system it is running, or 0, which disables asynchronous compilation.
    • ForceVertexUberShaders: Replaces specialized vertex shaders with uber shaders. Only really useful for debugging issues in the uber shaders.
    • ForcePixelUberShaders: Replaces specialized pixel shaders with uber shaders. Only really useful for debugging issues in the uber shaders.

    Feel free to report bugs at this point. Please attach a fifolog where possible, and provide as much detail as you can, as this will allow me to get the issue fixed faster.

    For the best experience depending on your operating system and GPU vendor:

    • Intel on Windows
      • Use D3D for Exclusive or Hybrid modes.
      • Driver generates variants with OpenGL -> suttering.
      • The Vulkan driver only supports Skylake+, and is buggy anyway.
    • Intel on Linux
      • Use Vulkan for Exclusive or Hybrid modes.
      • anv works quite well.
      • i965 doesn't share compiled code between contexts, which means the main context will always recompile and stutter.
    • AMD on Windows
      • Use D3D for Hybrid mode.
      • Use D3D or Vulkan for Exclusive mode.
      • The AMD GL driver is just slow in general.
      • Vulkan doesn't work too badly, but the shader cache is ineffective, leading to long boot times.
    • AMD on Linux
      • Use Vulkan for Exclusive or Hybrid modes.
      • I haven't tested radeonsi, but radv likely behaves similarly to anv. If radeonsi shares GPU code between contexts, GL may be an option.
    • NVIDIA on Windows
      • Use D3D for Hybrid mode. GL isn't too bad with the latest changes, but may still have some stutter.
      • Use D3D or GL or Vulkan for Exclusive mode. D3D will get you the best performance.
    • NVIDIA on Linux
      • Use GL for Hybrid mode.
      • Use GL or Vulkan for Exclusive mode. GL performs slightly better.

    Few notes:

    • There is a large performance hit when using ubershaders. This is most noticeable in the exclusive mode. In the hybrid mode, ubershaders likely aren't used for every object being rendered, meaning the overall performance hit will be lower. There's still room for optimizations, but these can come later.
    • Per-pixel lighting is not currently compatible with ubershaders. If you enable per-pixel lighting, ubershaders won't be used, and you will still experience compilation stutter.
    • The ubershader caches are shared between games, hence the dependency on PR #5679. The compile times can be pretty long, so it makes sense to share them where possible.
    • D3D11 currently offers the best experience in regards to compilation stutter. The NV GL driver still generates variants behind our back, which sometimes creates a noticeable hitch.
    • AMD's Vulkan driver is garbage and doesn't use a pipeline cache, so every variant is expensive to create. This means when we generate ubershader variants, it'll still stutter. Not much we can do about this, unless they implement derived pipelines, which we could potentially make use of. They also fail at arrays in shader input/output interfaces, forcing an ugly workaround.
    • Progress dialogs for shader compilation at boot are implemented for D3D, and Vulkan only.
    • OpenGL asynchronous compilation is currently done via the ARB_parallel_shader_compile extension, currently only implemented by NVIDIA. We may consider a multi-context approach in the future, but for other vendors, you may wish to use one of the other backends.
    opened by stenzek 103
  • Add support for the WIA and RVZ disc image formats

    Add support for the WIA and RVZ disc image formats

    To whoever wants to merge this: Please contact me first, so that I can bump the RVZ version number to 1.0 before the merge.

    opened by JosJuice 102
  • Use MagicYUV as the lossless video codec

    Use MagicYUV as the lossless video codec

    A much faster video codec than FFV1, this enables high-resolution dumps to be performed in much more reasonable time, and even realtime recording on some lower resolutions.

    Really motivated by wanting to do 1080p/2160p recordings faster. I can achieve exactly as such now in roughly 50% realtime, versus ~3% I got with FFV1.

    opened by chungy 8
  • MoltenVK: Use an external project instead of a pre-compiled dylib

    MoltenVK: Use an external project instead of a pre-compiled dylib

    Changes the build system to build MoltenVK instead of having a dylib in the repository. This also opens up the opportunity to modify MoltenVK to our needs if needed.

    Also, the MoltenVK version has been updated to v1.1.4 (Vulkan SDK 1.2.182).

    EDIT: This PR is being blocked by the presence of the Intel macOS buildbot (pr-osx-x64). The M1 Mac Mini can build MoltenVK perfectly fine for both Intel and ARM, so the Intel buildbot needs to be shut down before can be merged.

    opened by OatmealDome 3
  • Enable anisotropic filtering when the game requests it

    Enable anisotropic filtering when the game requests it

    This PR implements the TexMode0.max_aniso field. For now this is just a test to see what games actually use it on fifoci, since I'm not sure I've actually implemented it properly.

    opened by Pokechu22 3
  • IOS HLE: Load MEM2 sections from IOS binaries into memory

    IOS HLE: Load MEM2 sections from IOS binaries into memory

    While we currently do not LLE the Starlet, we should also load the MEM2 sections into memory because some titles (notably the Homebrew Channel) require a valid IOS to be loaded.

    Untested (beyond checking that Wii games do not crash).

    opened by leoetlino 2
  • PowerPC: Implement broken masking for uncached unaligned writes

    PowerPC: Implement broken masking for uncached unaligned writes

    This implements the behavior described in https://bugs.dolphin-emu.org/issues/12565.

    The implementation requires writes to pass through slowmem in order to be affected. Since most users probably don't care about emulating this behavior and thus wouldn't want performance to get lower just for the sake of emulating it, I've added a new INI-only setting AlignmentQuirks which controls whether slowmem is forced for uncached memory.

    Thank you to eigenform, delroth, phire, marcan, segher, and Extrems for all helping in one way or another with the efforts to reverse engineer this behavior, and to Rylie for reporting the issue.

    opened by JosJuice 6
  • Handle texture wrapping more accurately; manually handle texture sampling

    Handle texture wrapping more accurately; manually handle texture sampling

    This is a continuation of #9921, also applied to hardware renderers (currently specialized shaders only). Implementing it for hardware requires manually handling texture sampling, which I have very minimally done (it doesn't handle interpolation or mipmapping currently). However, the manual implementation (currently) seems to have approximately equal performance, and and it currently doesn't have the issues with vp6 videos on some drivers (which may be because it doesn't handle interpolation at all, but hopefully the issues won't come back if interpolation is re-implemented).

    opened by Pokechu22 2
  • GameINI: Fix F1 2002 crash starting a race

    GameINI: Fix F1 2002 crash starting a race

    in F1 2002 when the game finishes loading to start the race it closes unexpectedly, this is because it requires having the JIT Follow Branch disabled.

    opened by Gamer64ytb 10
  • Netplay: Adjust text to help with controls

    Netplay: Adjust text to help with controls

    Ever since we added GBA support on netplay, there's been a lot of confusion about how controls are assigned on netplay. Pretty much everyone has a controller configured to slot 1, so this didn't come up as much. I added clarification to how Dolphin loads controller configurations to the netplay information in the connect menu.

    image

    opened by JMC47 5
  • Re-scale of buttons

    Re-scale of buttons

    opened by Gamer64ytb 4
  • DriverDetails: Add broken dual source blending bug to MoltenVK on Intel GPUs

    DriverDetails: Add broken dual source blending bug to MoltenVK on Intel GPUs

    The Metal driver on Intel GPUs appears to have a bug where if ocol1 is present in the fragment shader and dual source blending is enabled, entire primitives will not be written to the depth buffer if any fragment is discarded.

    This causes many games to exhibit odd layering issues that look similar to Z-fighting. The problem is especially pronounced in the Paper Mario games, where it affects basically every sprite-like object.

    Apparently, a similar-ish bug also involving ocol1 is also present in the OpenGL driver: see #4402, #6219.

    Fixes https://bugs.dolphin-emu.org/issues/12137 and https://bugs.dolphin-emu.org/issues/12317.

    (I'm not very experienced in graphics programming, so the comments / explanation might be wrong. Feel free to correct.)

    Depth buffer comparison

    Dual source blending enabled:

    image

    Dual source blending disabled:

    image

    opened by OatmealDome 2
An open source re-implementation of RollerCoaster Tycoon 2 🎢

OpenRCT2 An open-source re-implementation of RollerCoaster Tycoon 2. A construction and management simulation video game that simulates amusement park

OpenRCT2 9.6k Aug 2, 2021
The DOS game emulator that's fit for your Mac.

Some notes on building Boxer The Boxer XCode project is designed to be a painless one-click build. Here's a quick rundown of how it's set up: Build re

Alun Bestor 729 Jul 23, 2021
🕹 Retro video game emulation for macOS

OpenEmu OpenEmu is an open source project whose purpose is to bring macOS game emulation into the realm of first class citizenship. The project levera

null 13k Jul 29, 2021
Beautiful, powerful chess app for the Mac

Stockfish for Mac Stockfish for Mac is a powerful chess analysis app. Play two-player games on the beautiful chess board, or get instant accurate anal

Daylen Yang 418 Jul 27, 2021
An open source, turn-based strategy game with a high fantasy theme.

About The Battle for Wesnoth is an Open Source, turn-based tactical strategy game with a high fantasy theme, featuring both singleplayer and online/ho

Battle for Wesnoth 3.2k Jul 29, 2021
Turn your screen into a playable level of Mario

Screentendo Screentendo is a desktop application that allows you to to turn a selection of your screen into a playable level of Super Mario Bros. Read

Aaron Randall 1k Jul 25, 2021