How to Build Yuzu on Windows 10 & 11 (Complete Developer Guide)

Building Yuzu from source on Windows is intended for developers, contributors, and advanced users who want debugging access, custom builds, or experimental features.
If your goal is simply to play games, compiling Yuzu yourself is unnecessary, official prebuilt installers already exist.

This guide explains every supported Windows build method, when to use each one, and common pitfalls you won’t find in shorter docs.

Building Yuzu from source on Windows using Visual Studio, Vulkan, and CMake

Before You Start (Important Notes)

  • This guide is developer-focused, not beginner-friendly installation help.
  • You’ll need basic familiarity with CMake, compilers, and command-line tools.
  • Windows 10 (64-bit) or Windows 11 is required.
  • All builds require Vulkan support.

Method 1: Building Yuzu with MSVC (Recommended)

This is the simplest and most stable way to build Yuzu on Windows.

Minimal Requirements

Install the following tools:

  • Visual Studio 2022 Community
    • Select Desktop development with C++
    • Keep Visual Studio fully updated
  • CMake
    • Either 32-bit or 64-bit works
  • Vulkan SDK
    • Always install the latest SDK
  • Git for Windows
    • Choose “Git from the command line and also from 3rd-party software”

Git is required to embed version information into the Yuzu executable.

Cloning the Repository

git clone --recursive https://github.com/yuzu-emu/yuzu

If you forgot –recursive, fix it with:

git submodule update --init --recursive

Configuring with CMake GUI

  1. Open CMake GUI
  2. Set Source directory → Yuzu repository
  3. Set Build directory → /build inside the repo
  4. Click Configure
  5. Choose:
    • Generator: Visual Studio 17 2022
    • Platform: x64
  6. Click Finish

Common Fixes

  • If dependencies fail to download:
    • Enable YUZU_USE_BUNDLED_VCPKG
  • If Catch2 errors appear:
    • Disable YUZU_TESTS

Click Configure again, then Generate.

Building in Visual Studio

  1. Open yuzu.sln from the build folder
  2. Choose one:
    • yuzu → Full GUI version
    • yuzu-cmd → Command-line only
  3. Set build type:
    • Release (recommended)
    • Debug (only for development)
  4. Press Build or F5

Your compiled executable will appear inside the build directory.

Method 2: MinGW-w64 Build Using MSYS2

This method is useful if you prefer a Linux-style toolchain on Windows.

Required Tools

  • MSYS2
  • Vulkan SDK (latest)

After installing MSYS2, update it fully:

pacman -Syu

Restart MSYS2 and repeat until no updates remain.

Installing Dependencies

Open MSYS2 MinGW 64-bit shell and run:

pacman -Syu git make \
mingw-w64-x86_64-toolchain \
mingw-w64-x86_64-cmake \
mingw-w64-x86_64-qt5 \
mingw-w64-x86_64-SDL2 \
mingw-w64-x86_64-python-pip \
autoconf libtool automake-wrapper

Add required paths:

echo 'PATH=/mingw64/bin:$PATH' >> ~/.bashrc
echo 'PATH=$(readlink -e /c/VulkanSDK/*/Bin/):$PATH' >> ~/.bashrc

Restart the shell.

Building Yuzu (Dynamic Build)

mkdir build && cd build
cmake -G "MSYS Makefiles" \
-DYUZU_USE_BUNDLED_VCPKG=ON \
-DYUZU_TESTS=OFF ..
make -j$(nproc)

Run Yuzu:

./bin/yuzu.exe

Important:
This build is not static. You must ship required DLLs alongside the executable:

cp externals/ffmpeg-*/bin/*.dll bin/

Optional: Build Without Qt (No GUI)

If you want a smaller build without the GUI:

-DENABLE_QT=no

This produces a command-line only Yuzu build.

Method 3: Building Yuzu with CLion

This option is ideal for professional C++ developers.

Requirements

  • CLion (paid)
  • Vulkan SDK (latest)

Cloning and Setup

  1. Open CLion
  2. Clone the Yuzu repository
  3. When prompted, configure:
    • Build Type: Release
    • Toolchain: Visual Studio
    • Generator: CMake default

Build directory: build

CLion will index the project, this may take several minutes.

Building & Running

  • Select yuzu from configurations
  • Click Run or press Shift + F10
  • Yuzu will launch automatically after compilation

Building Yuzu from Command Line (MSVC)

Ideal for automation or CI pipelines.

git clone --recursive https://github.com/yuzu-emu/yuzu
cd yuzu
mkdir build && cd build
cmake .. -G "Visual Studio 17 2022" -A x64
cmake --build . --config Release

Final Thoughts

For most people, MSVC is the simplest and least painful route. MinGW can work too, but it usually means dealing with DLLs by hand, which gets old fast. CLion shines if you’re doing real development and want a proper IDE-driven workflow.

When testing performance, stick to Release builds, Debug builds will skew results. Building Yuzu from source makes sense if you plan to contribute or experiment, since it gives you full control and solid debugging tools. For everyday gaming, though, it’s far more effort than it’s worth.