[desktop, fs] main_window separation; fix Ryujinx save data link issues (#2929)

Some genius decided to put the entire MainWindow class into main.h and
main.cpp, which is not only horrific practice but also completely
destroys clangd beyond repair. Please, just don't do this.

(this will probably merge conflict to hell and back)

Also, fixes a bunch of issues with Ryujinx save data link:
- Paths with spaces would cause mklink to fail
- Add support for portable directories
- Symlink detection was incorrect sometimes(????)
- Some other stuff I'm forgetting

Furthermore, when selecting "From Eden" and attempting to save in Ryujinx, Ryujinx would destroy the link for... some reason? So to get around this we just copy the Eden data to Ryujinx then treat it like a "From Ryujinx" op

Signed-off-by: crueter <crueter@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2929
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>

CMakeLists.txt

@@ -13,6 +13,8 @@ elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
     set(PLATFORM_OPENBSD ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "NetBSD")
     set(PLATFORM_NETBSD ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "DragonFly")
+    set(PLATFORM_DRAGONFLYBSD ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
     set(PLATFORM_HAIKU ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
@@ -37,17 +39,23 @@ endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
 
+# https://gitlab.kitware.com/cmake/cmake/-/merge_requests/11112
+# This works totally fine on MinGW64, but not CLANG{,ARM}64
+if(MINGW AND CXX_CLANG)
+    set(CMAKE_SYSTEM_VERSION 10.0.0)
+endif()
+
 # NB: this does not account for SPARC
 # If you get Eden working on SPARC, please shoot crueter@crueter.xyz multiple emails
 # and you will be hailed for eternity
 if (PLATFORM_SUN)
     # Terrific Solaris pkg shenanigans
-    list(APPEND CMAKE_PREFIX_PATH "/usr/lib/qt/6.6/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH "/usr/lib/qt/6.6/lib/amd64/cmake")
+    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
 
     # Amazing - absolutely incredible
-    list(APPEND CMAKE_PREFIX_PATH "/usr/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH "/usr/lib/amd64/cmake")
+    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
 
     # For some mighty reason, doing a normal release build sometimes may not trigger
     # the proper -O3 switch to materialize
@@ -63,18 +71,18 @@ endif()
 
 # Needed for FFmpeg w/ VAAPI and DRM
 if (PLATFORM_OPENBSD)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I/usr/X11R6/include")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/X11R6/include")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/X11R6/lib")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R6/lib")
 elseif (PLATFORM_NETBSD)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I/usr/X11R7/include")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/X11R7/include")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/X11R7/lib")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R7/lib")
 endif()
 
 # NetBSD: Fun for the whole family!
 if (PLATFORM_NETBSD)
-    set(ENV{PKG_CONFIG_PATH} "${PKG_CONFIG_PATH}:/usr/pkg/lib/ffmpeg7/pkgconfig")
+    set(ENV{PKG_CONFIG_PATH} "${PKG_CONFIG_PATH}:${CMAKE_SYSROOT}/usr/pkg/lib/ffmpeg7/pkgconfig")
 endif()
 
 # Detect current compilation architecture and create standard definitions
@@ -92,12 +100,14 @@ function(detect_architecture symbol arch)
         if (ARCHITECTURE_${arch})
             set(ARCHITECTURE "${arch}" PARENT_SCOPE)
             set(ARCHITECTURE_${arch} 1 PARENT_SCOPE)
-            add_definitions(-DARCHITECTURE_${arch}=1)
+            add_definitions("-DARCHITECTURE_${arch}=1")
         endif()
     endif()
 endfunction()
 
 if (NOT ENABLE_GENERIC)
+    # https://sourceforge.net/p/predef/wiki/Architectures/
+    # TODO: THIS IS FUCKING FLAWED ONLY THE FIRST SYMBOL THAT APPEARS WILL BE CONSIDERED :(
     if (MSVC)
         detect_architecture("_M_AMD64" x86_64)
         detect_architecture("_M_IX86" x86)
@@ -109,6 +119,48 @@ if (NOT ENABLE_GENERIC)
         detect_architecture("__arm__" arm)
         detect_architecture("__aarch64__" arm64)
     endif()
+    detect_architecture("__ARM64__" arm64)
+    detect_architecture("__aarch64__" arm64)
+    detect_architecture("_M_ARM64" arm64)
+
+    detect_architecture("__arm__" arm)
+    detect_architecture("__TARGET_ARCH_ARM" arm)
+    detect_architecture("_M_ARM" arm)
+
+    detect_architecture("__x86_64" x86_64)
+    detect_architecture("__x86_64__" x86_64)
+    detect_architecture("__amd64" x86_64)
+    detect_architecture("_M_X64" x86_64)
+
+    detect_architecture("__i386" x86)
+    detect_architecture("__i386__" x86)
+    detect_architecture("_M_IX86" x86)
+
+    detect_architecture("__ia64" ia64)
+    detect_architecture("__ia64__" ia64)
+    detect_architecture("_M_IA64" ia64)
+
+    detect_architecture("__mips" mips)
+    detect_architecture("__mips__" mips)
+    detect_architecture("_M_MRX000" mips)
+
+    detect_architecture("__powerpc64__" ppc64)
+    detect_architecture("__ppc64__" ppc64)
+    detect_architecture("__PPC64__" ppc64)
+    detect_architecture("_ARCH_PPC64" ppc64)
+
+    detect_architecture("__ppc__" ppc)
+    detect_architecture("__ppc" ppc)
+    detect_architecture("__powerpc__" ppc)
+    detect_architecture("_ARCH_COM" ppc)
+    detect_architecture("_ARCH_PWR" ppc)
+    detect_architecture("_ARCH_PPC" ppc)
+    detect_architecture("_M_MPPC" ppc)
+    detect_architecture("_M_PPC" ppc)
+
+    detect_architecture("__riscv" riscv)
+
+    detect_architecture("__EMSCRIPTEN__" wasm)
 endif()
 
 if (NOT DEFINED ARCHITECTURE)
@@ -139,9 +191,9 @@ if (CXX_CLANG_CL)
         $<$<COMPILE_LANGUAGE:C,CXX>:/EHsc> # thanks microsoft
     )
 
+    # REQUIRED CPU features IN Windows-amd64
     if (ARCHITECTURE_x86_64)
         add_compile_options(
-            # Required CPU features for amd64
             $<$<COMPILE_LANGUAGE:C,CXX>:-msse4.1>
             $<$<COMPILE_LANGUAGE:C,CXX>:-mcx16>
         )
@@ -159,9 +211,8 @@ if (MSVC AND NOT CXX_CLANG)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX-")
 endif()
 
-if (PLATFORM_FREEBSD)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/local/lib")
-
+if (PLATFORM_FREEBSD OR PLATFORM_DRAGONFLYBSD)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/local/lib")
 endif()
 
 # Set bundled sdl2/qt as dependent options.
@@ -221,6 +272,7 @@ if(YUZU_ENABLE_LTO)
     set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
     set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ${COMPILER_SUPPORTS_LTO})
 endif()
+
 option(USE_CCACHE "Use ccache for compilation" OFF)
 set(CCACHE_PATH "ccache" CACHE STRING "Path to ccache binary")
 if(USE_CCACHE)
@@ -265,9 +317,11 @@ if (ANDROID OR WIN32 OR APPLE OR PLATFORM_SUN)
     # your own copy of it.
     set(DEFAULT_ENABLE_OPENSSL OFF)
 endif()
+
 if (ENABLE_WEB_SERVICE)
     set(DEFAULT_ENABLE_OPENSSL ON)
 endif()
+
 option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
 if (ENABLE_OPENSSL)
     set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL OFF)
@@ -532,7 +586,7 @@ else()
     find_package(zstd 1.5 REQUIRED MODULE)
 
     # wow
-    find_package(Boost 1.57.0 CONFIG REQUIRED OPTIONAL_COMPONENTS headers context system fiber)
+    find_package(Boost 1.57.0 CONFIG REQUIRED OPTIONAL_COMPONENTS headers context system fiber filesystem)
 
     if (CMAKE_SYSTEM_NAME STREQUAL "Linux" OR ANDROID)
         find_package(gamemode 1.7 MODULE)
@@ -894,6 +948,14 @@ if(MSVC)
     )
 endif()
 
+if (MINGW)
+    # This saves a truly ridiculous amount of time during linking
+    # In my tests, without this it takes 2 mins, with it takes 3-5 seconds
+    # or on GitHub Actions, 10 minutes -> 3 seconds
+    set(MINGW_FLAGS "-Wl,--strip-all -Wl,--gc-sections")
+    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${MINGW_FLAGS}")
+endif()
+
 add_subdirectory(src)
 
 # Set yuzu project or yuzu-cmd project as default StartUp Project in Visual Studio depending on whether QT is enabled or not

CMakeModules/CPMUtil.cmake

@@ -594,6 +594,14 @@ function(AddCIPackage)
         add_ci_package(windows-arm64)
     endif()
 
+    if ((MINGW AND ARCHITECTURE_x86_64) AND NOT "mingw-amd64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(mingw-amd64)
+    endif()
+
+    if ((MINGW AND ARCHITECTURE_arm64) AND NOT "mingw-arm64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(mingw-arm64)
+    endif()
+
     if (ANDROID AND NOT "android" IN_LIST DISABLED_PLATFORMS)
         add_ci_package(android)
     endif()

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -1,10 +0,0 @@
-# SPDX-FileCopyrightText: 2020 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-function(copy_yuzu_FFmpeg_deps target_dir)
-    include(WindowsCopyFiles)
-    set(DLL_DEST "$<TARGET_FILE_DIR:${target_dir}>/")
-    file(READ "${FFmpeg_PATH}/requirements.txt" FFmpeg_REQUIRED_DLLS)
-    string(STRIP "${FFmpeg_REQUIRED_DLLS}" FFmpeg_REQUIRED_DLLS)
-    windows_copy_files(${target_dir} ${FFmpeg_LIBRARY_DIR} ${DLL_DEST} ${FFmpeg_REQUIRED_DLLS})
-endfunction(copy_yuzu_FFmpeg_deps)

CMakeModules/CopyYuzuSDLDeps.cmake

@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2016 Citra Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-function(copy_yuzu_SDL_deps target_dir)
-    include(WindowsCopyFiles)
-    set(DLL_DEST "$<TARGET_FILE_DIR:${target_dir}>/")
-    windows_copy_files(${target_dir} ${SDL2_DLL_DIR} ${DLL_DEST} SDL2.dll)
-endfunction(copy_yuzu_SDL_deps)

CMakeModules/FindFFmpeg.cmake

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 # SPDX-FileCopyrightText: 2019 Citra Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -75,16 +78,16 @@ function(find_ffmpeg LIBNAME)
     )
   else()
     list(APPEND INCLUDE_PATHS
-      /usr/local/include/ffmpeg
-      /usr/local/include/lib${LIBNAME}
-      /usr/include/ffmpeg
-      /usr/include/lib${LIBNAME}
-      /usr/include/ffmpeg/lib${LIBNAME}
+      ${CMAKE_SYSROOT}/usr/local/include/ffmpeg
+      ${CMAKE_SYSROOT}/usr/local/include/lib${LIBNAME}
+      ${CMAKE_SYSROOT}/usr/include/ffmpeg
+      ${CMAKE_SYSROOT}/usr/include/lib${LIBNAME}
+      ${CMAKE_SYSROOT}/usr/include/ffmpeg/lib${LIBNAME}
     )
 
     list(APPEND LIB_PATHS
-      /usr/local/lib
-      /usr/lib
+      ${CMAKE_SYSROOT}/usr/local/lib
+      ${CMAKE_SYSROOT}/usr/lib
     )
   endif()
 

cpmfile.json

@@ -7,7 +7,9 @@
         "version": "3.6.0",
         "min_version": "1.1.1",
         "disabled_platforms": [
-            "macos-universal"
+            "macos-universal",
+            "mingw-amd64",
+            "mingw-arm64"
         ]
     },
     "boost": {
@@ -18,7 +20,7 @@
         "hash": "4fb7f6fde92762305aad8754d7643cd918dd1f3f67e104e9ab385b18c73178d72a17321354eb203b790b6702f2cf6d725a5d6e2dfbc63b1e35f9eb59fb42ece9",
         "git_version": "1.89.0",
         "version": "1.57",
-        "find_args": "CONFIG",
+        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
         "patches": [
             "0001-clang-cl.patch",
             "0002-use-marmasm.patch",

dist/qt_themes/qdarkstyle/style.qss

@@ -821,31 +821,6 @@ QTabBar QToolButton::left-arrow:disabled {
     image: url(:/qss_icons/rc/left_arrow_disabled.png);
 }
 
-QDockWidget {
-    background: #31363b;
-    border: 1px solid #403F3F;
-    titlebar-close-icon: url(:/qss_icons/rc/close.png);
-    titlebar-normal-icon: url(:/qss_icons/rc/undock.png);
-}
-
-QDockWidget::close-button,
-QDockWidget::float-button {
-    border: 1px solid transparent;
-    border-radius: 2px;
-    background: transparent;
-}
-
-QDockWidget::close-button:hover,
-QDockWidget::float-button:hover {
-    background: rgba(255, 255, 255, 10);
-}
-
-QDockWidget::close-button:pressed,
-QDockWidget::float-button:pressed {
-    padding: 1px -1px -1px 1px;
-    background: rgba(255, 255, 255, 10);
-}
-
 QTreeView,
 QListView {
     border: 1px solid #54575B;

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -1685,54 +1685,6 @@ QTabBar QToolButton::right-arrow:disabled {
   image: url(":/qss_icons/rc/arrow_right_disabled.png");
 }
 
-/* QDockWiget -------------------------------------------------------------
-
---------------------------------------------------------------------------- */
-QDockWidget {
-  outline: 1px solid #32414B;
-  background-color: #19232D;
-  border: 1px solid #32414B;
-  border-radius: 4px;
-  titlebar-close-icon: url(":/qss_icons/rc/window_close.png");
-  titlebar-normal-icon: url(":/qss_icons/rc/window_undock.png");
-}
-
-QDockWidget::title {
-  /* Better size for title bar */
-  padding: 6px;
-  spacing: 4px;
-  border: none;
-  background-color: #32414B;
-}
-
-QDockWidget::close-button {
-  background-color: #32414B;
-  border-radius: 4px;
-  border: none;
-}
-
-QDockWidget::close-button:hover {
-  image: url(":/qss_icons/rc/window_close_focus.png");
-}
-
-QDockWidget::close-button:pressed {
-  image: url(":/qss_icons/rc/window_close_pressed.png");
-}
-
-QDockWidget::float-button {
-  background-color: #32414B;
-  border-radius: 4px;
-  border: none;
-}
-
-QDockWidget::float-button:hover {
-  image: url(":/qss_icons/rc/window_undock_focus.png");
-}
-
-QDockWidget::float-button:pressed {
-  image: url(":/qss_icons/rc/window_undock_pressed.png");
-}
-
 /* QTreeView QListView QTableView -----------------------------------------
 
 https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qtreeview

docs/CPMUtil/AddCIPackage.md

@@ -9,6 +9,8 @@
 - `DISABLED_PLATFORMS`: List of platforms that lack artifacts for this package. Options:
   * `windows-amd64`
   * `windows-arm64`
+  * `mingw-amd64`
+  * `mingw-arm64`
   * `android`
   * `solaris-amd64`
   * `freebsd-amd64`

docs/Caveats.md

@@ -1,24 +1,28 @@
 # Caveats
 
 <!-- TOC -->
-- [Arch Linux](#arch-linux)
-- [Gentoo Linux](#gentoo-linux)
-- [macOS](#macos)
-- [Solaris](#solaris)
-- [HaikuOS](#haikuos)
-- [OpenBSD](#openbsd)
-- [FreeBSD](#freebsd)
-- [NetBSD](#netbsd)
+- [Caveats](#caveats)
+  - [Arch Linux](#arch-linux)
+  - [Gentoo Linux](#gentoo-linux)
+  - [macOS](#macos)
+  - [Solaris](#solaris)
+  - [HaikuOS](#haikuos)
+  - [OpenBSD](#openbsd)
+  - [FreeBSD](#freebsd)
+  - [NetBSD](#netbsd)
+  - [MSYS2](#msys2)
+  - [Windows 8.1 and below](#windows-81-and-below)
 <!-- /TOC -->
 
 ## Arch Linux
 
-- httplib AUR package is broken. Set `httplib_FORCE_BUNDLED=ON` if you have it installed.
-- Eden is also available as an [AUR package](https://aur.archlinux.org/packages/eden-git). If you are unable to build, either use that or compare your process to the PKGBUILD.
+Eden is also available as an [AUR package](https://aur.archlinux.org/packages/eden-git). If you are unable to build, either use that or compare your process to the PKGBUILD.
 
 ## Gentoo Linux
 
-Do not use the system sirit or xbyak packages.
+[`games-emulation/eden`](https://gitweb.gentoo.org/repo/proj/guru.git/tree/games-emulation/eden) is available in the GURU. This repository also contains some additional dependencies, such as mcl, sirit, oaknut, etc.
+
+If you're having issues with building, always consult that ebuild.
 
 ## macOS
 
@@ -26,6 +30,13 @@ macOS is largely untested. Expect crashes, significant Vulkan issues, and other
 
 ## Solaris
 
+Always consult [the OpenIndiana package list](https://pkg.openindiana.org/hipster/en/index.shtml) to cross-verify availability.
+
+Run the usual update + install of essential toolings: `sudo pkg update && sudo pkg install git cmake`.
+
+- **gcc**: `sudo pkg install developer/gcc-14`.
+- **clang**: Version 20 is broken, use `sudo pkg install developer/clang-19`.
+
 Qt Widgets appears to be broken. For now, add `-DENABLE_QT=OFF` to your configure command. In the meantime, a Qt Quick frontend is in the works--check back later!
 
 This is needed for some dependencies that call cc directly (tz):
@@ -70,7 +81,7 @@ Still will not run flawlessly until `mesa-24` is available. Modify CMakeCache.tx
 
 After configuration, you may need to modify `externals/ffmpeg/CMakeFiles/ffmpeg-build/build.make` to use `-j$(nproc)` instead of just `-j`.
 
-`-lc++-experimental` doesn't exist in OpenBSD but the LLVM driver still tries to link against it, to solve just symlink `ln -s /usr/lib/libc++.a /usr/lib/libc++experimental.a`.
+`-lc++-experimental` doesn't exist in OpenBSD but the LLVM driver still tries to link against it, to solve just symlink `ln -s /usr/lib/libc++.a /usr/lib/libc++experimental.a`. Builds are currently not working due to lack of `std::jthread` and such, either compile libc++ manually or wait for ports to catch up.
 
 If clang has errors, try using `g++-11`.
 
@@ -102,3 +113,87 @@ cmake -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build -- -j`nproc`
 cmake --install build
 ```
+
+# DragonFlyBSD
+
+If `libstdc++.so.6` is not found (`GLIBCXX_3.4.30`) then attempt:
+```sh
+rm /usr/local/lib/gcc11/libstdc++.so.6
+ln -s /usr/local/lib/gcc14/libstdc++.so /usr/local/lib/gcc11/libstdc++.so.6
+```
+This may have unforeseen consequences of which we don't need to worry about for now.
+
+Default `g++` (and the libstdc++) is too outdated - so install `gcc14` and redirect CMake to the new compiler toolchain  `-DCMAKE_CXX_COMPILER=gcc14 -DCMAKE_C_COMPILER=g++14`.
+
+There is also `llvm18` and use `-DCMAKE_CXX_COMPILER=clang++18 -DCMAKE_C_COMPILER=clang18` (note the `18` suffix at the end). NOTE: It doesn't have an updated libcxx so `<span>` will be missing, either build it manually or use gcc.
+
+If build hangs, use `hammer2 bulkfree`.
+
+## MSYS2
+
+`qt6-static` isn't supported yet.
+
+Only the `MINGW64` environment is tested; however, all of the others should work (in theory) sans `MINGW32`.
+
+Currently, only FFmpeg can be used as a system dependency; the others will result in linker errors.
+
+When packaging an MSYS2 build, you will need to copy all dependent DLLs recursively alongside the `windeployqt6`; for example:
+
+```sh
+# MSYS_TOOLCHAIN is typically just mingw64
+# since Windows is case-insensitive, you can set this to $MSYSTEM
+# or, if cross-compiling from Linux, set it to usr/x86_64-w64-mingw32
+export PATH="/${MSYS_TOOLCHAIN}/bin:$PATH"
+
+# grab deps of a dll or exe and place them in the current dir
+deps() {
+    # string parsing is fun
+    objdump -p "$1" | awk '/DLL Name:/ {print $3}' | while read -r dll; do
+        [ -z "$dll" ] && continue
+
+        # bin directory is used for DLLs, so we can do a quick "hack"
+        # and use command to find the path of the DLL
+        dllpath=$(command -v "$dll" 2>/dev/null || true)
+
+        [ -z "$dllpath" ] && continue
+
+        # explicitly exclude system32/syswow64 deps
+        # these aren't needed to be bundled, as all systems already have them
+        case "$dllpath" in
+            *System32* | *SysWOW64*) continue ;;
+        esac
+
+        # avoid copying deps multiple times
+        if [ ! -f "$dll" ]; then
+            echo "$dllpath"
+            cp "$dllpath" "$dll"
+
+            # also grab the dependencies of the dependent DLL; e.g.
+            # double-conversion is a dep of Qt6Core.dll but NOT eden.exe
+            deps "$dllpath"
+        fi
+    done
+}
+
+# NB: must be done in a directory containing eden.exe
+deps eden.exe
+
+# deploy Qt plugins and such
+windeployqt6 --no-compiler-runtime --no-opengl-sw --no-system-dxc-compiler \
+    --no-system-d3d-compiler eden.exe
+
+# grab deps for Qt plugins
+find ./*/ -name "*.dll" | while read -r dll; do deps "$dll"; done
+```
+
+## Windows 8.1 and below
+
+DirectX 12 is not available - simply copy and paste a random DLL and name it `d3d12.dll`.
+
+Install [Qt6 compatibility libraries](github.com/ANightly/qt6windows7) specifically Qt 6.9.5.
+
+## RedoxOS
+
+The package install may randomly hang at times, in which case it has to be restarted. ALWAYS do a `sudo pkg update` or the chances of it hanging will be close to 90%. If "multiple" installs fail at once, try installing 1 by 1 the packages.
+
+When CMake invokes certain file syscalls - it may sometimes cause crashes or corruptions on the (kernel?) address space - so reboot the system if there is a "hang" in CMake.

docs/Coding.md

@@ -8,6 +8,8 @@ But for new developers you may find that following these guidelines will make ev
 
 Simply put, types/classes are named as `PascalCase`, same for methods and functions like `AddElement`. Variables are named `like_this_snake_case` and constants are `IN_SCREAMING_CASE`.
 
+Except for Qt MOC where `functionName` is preferred.
+
 Template typenames prefer short names like `T`, `I`, `U`, if a longer name is required either `Iterator` or `perform_action` are fine as well.
 
 Macros must always be in `SCREAMING_CASE`. Do not use short letter macros as systems like Solaris will conflict with them; a good rule of thumb is >5 characters per macro - i.e `THIS_MACRO_IS_GOOD`, `AND_ALSO_THIS_ONE`.

docs/Deps.md

@@ -87,6 +87,53 @@ Notes for writers: Include build tools as well, assume user has NOTHING installe
 
 Click on the arrows to expand.
 
+<details>
+<summary>Gentoo Linux</summary>
+
+GURU must be enabled:
+
+```
+sudo emerge -a app-eselect/eselect-repository
+sudo eselect repository enable guru
+sudo emaint sync -r guru
+```
+
+Now, install all deps:
+
+```sh
+sudo emerge -a \
+    app-arch/lz4 app-arch/zstd app-arch/unzip \
+    dev-libs/libfmt dev-libs/libusb dev-libs/mcl dev-libs/sirit \
+    dev-libs/unordered_dense dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
+    dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
+    dev-util/vulkan-utility-libraries dev-util/glslang \
+    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
+    media-libs/VulkanMemoryAllocator media-libs/libsdl2 media-libs/cubeb \
+    net-libs/enet net-libs/mbedtls \
+    sys-libs/zlib \
+    dev-cpp/nlohmann_json dev-cpp/simpleini dev-cpp/cpp-httplib dev-cpp/cpp-jwt \
+    games-util/gamemode \
+    net-wireless/wireless-tools \
+    dev-qt/qtbase:6 dev-libs/quazip \
+    virtual/pkgconfig
+```
+
+- On `amd64`, also add `dev-libs/xbyak`
+- On `riscv64`, also add `dev-libs/biscuit` (currently unavailable)
+- On `aarch64`, also add `dev-libs/oaknut`
+- If tests are enabled, also add `dev-libs/oaknut` and `dev-cpp/catch`
+
+Required USE flags:
+- `dev-qt/qtbase network concurrent dbus gui widgets`
+- `dev-libs/quazip qt6`
+- `net-libs/mbedtls cmac`
+- `media-libs/libsdl2 haptic joystick sound video`
+- `dev-cpp/cpp-httplib ssl`
+
+[Caveats](./Caveats.md#gentoo-linux)
+
+</details>
+
 <details>
 <summary>Arch Linux</summary>
 
@@ -149,6 +196,7 @@ apk add g++ git cmake make mbedtls-dev mbedtls-static mesa-dev qt6-qtbase-dev qt
 `mbedtls-static` has to be specified otherwise `libeverest.a` and `libp256m.a` will fail to be found.
 
 </details>
+<details>
 <summary>Void Linux</summary>
 
 ```sh
@@ -158,6 +206,7 @@ xbps-install -Su git make cmake clang pkg-config patch mbedtls-devel SPIRV-Tools
 Yes, `nlohmann-json` is just named `json-c++`. Why?
 
 </details>
+
 <details>
 <summary>NixOS</summary>
 
@@ -186,7 +235,7 @@ brew install molten-vk vulkan-loader
 <details>
 <summary>FreeBSD</summary>
 
-As root run: `pkg install devel/cmake devel/sdl20 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/jwt-cpp devel/unordered-dense`
+As root run: `pkg install devel/cmake devel/sdl20 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/jwt-cpp devel/unordered-dense mbedtls3 vulkan-headers quazip-qt6`
 
 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.
 
@@ -211,18 +260,23 @@ pkg_add cmake nasm git boost unzip--iconv autoconf-2.72p0 bash ffmpeg glslang gm
 
 [Caveats](./Caveats.md#openbsd).
 
+</details>
+<details>
+<summary>DragonFlyBSD</summary>
+
+```sh
+pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmake jq nlohmann-json enet spirv-tools sdl2 vulkan-utility-libraries vulkan-headers catch2 libfmt openssl liblz4 boost-libs cpp-httplib qt6-base quazip-qt6 unordered-dense libva-vdpau-driver libva-utils libva-intel-driver
+```
+
+[Caveats](./Caveats.md#dragonflybsd).
+
 </details>
 <details>
 <summary>Solaris / OpenIndiana</summary>
 
-Always consult [the OpenIndiana package list](https://pkg.openindiana.org/hipster/en/index.shtml) to cross-verify availability.
-
-Run the usual update + install of essential toolings: `sudo pkg update && sudo pkg install git cmake`.
-
-- **gcc**: `sudo pkg install developer/gcc-14`.
-- **clang**: Version 20 is broken, use `sudo pkg install developer/clang-19`.
-
-Then install the libraries: `sudo pkg install qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt`.
+```sh
+sudo pkg install qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
+```
 
 [Caveats](./Caveats.md#solaris).
 
@@ -234,24 +288,27 @@ Then install the libraries: `sudo pkg install qt6 boost glslang libzip library/l
 * Download and install all dependencies:
 ```
 BASE="git make autoconf libtool automake-wrapper jq patch"
-MINGW="SDL2 cmake python-pip qt6-base toolchain ffmpeg boost catch fmt lz4 nlohmann-json openssl zlib zstd enet opus mbedtls vulkan-devel libusb vulkan-memory-allocator unordered_dense clang ccache"
+
+MINGW="qt6-base qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus mbedtls libusb unordered_dense"
 
 packages="$BASE"
 for pkg in $MINGW; do
     packages="$packages mingw-w64-x86_64-$pkg"
 done
 
-pacman -Syu --needed --noconfirm $packages
+pacman -Syuu --needed --noconfirm $packages
 ```
 * Notes:
   - Using `qt6-static` is possible but currently untested.
   - Other environments are entirely untested, but should theoretically work provided you install all the necessary packages.
-  - Clang is installed as it generally works better here. You can compile with GCC just fine, however.
+  - GCC is proven to work better with the MinGW environment. If you choose to use Clang, you *may* be better off using the clang64 environment.
   - Add `qt-creator` to the `MINGW` variable to install Qt Creator. You can then create a Start Menu shortcut to the MinGW Qt Creator by running `powershell "\$s=(New-Object -COM WScript.Shell).CreateShortcut('C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs\\Qt Creator.lnk');\$s.TargetPath='C:\\msys64\\mingw64\\bin\\qtcreator.exe';\$s.Save()"` in Git Bash or MSYS2.
 * Add MinGW binaries to the PATH if they aren't already:
   * `echo 'PATH=/mingw64/bin:$PATH' >> ~/.bashrc`
   * or `echo 'PATH=/mingw64/bin:$PATH' >> ~/.zshrc`
 
+[Caveats](./Caveats.md#msys2).
+
 </details>
 <details>
 <summary>HaikuOS</summary>
@@ -263,14 +320,16 @@ pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel opus_devel b
 [Caveats](./Caveats.md#haikuos).
 
 </details>
+<details>
 <summary>RedoxOS</summary>
 
-TODO: Fix syscall crashes (heavy IO stalls and hangup due to net mutexes?)
 ```sh
-sudo pkg update && sudo pkg install git cmake
-sudo pkg install ffmpeg6 sdl2 zlib llvm18
+sudo pkg update
+sudo pkg install git cmake ffmpeg6 sdl2 zlib llvm18
 ```
 
+[Caveats](./Caveats.md#redoxos).
+
 </details>
 
 ## All Done

externals/cpmfile.json

@@ -23,7 +23,11 @@
         "package": "sirit",
         "name": "sirit",
         "repo": "eden-emulator/sirit",
-        "version": "1.0.2"
+        "version": "1.0.2",
+        "disabled_platforms": [
+            "mingw-amd64",
+            "mingw-arm64"
+        ]
     },
     "httplib": {
         "repo": "yhirose/cpp-httplib",

externals/ffmpeg/CMakeLists.txt

@@ -107,9 +107,10 @@ endif()
 
 if (YUZU_USE_BUNDLED_FFMPEG)
     # MSVC conflicts with ksuser otherwise
+    # MinGW has the funny quirk of requiring avutil after avcodec
     # Android needs some deps to be compiled with PIC (TODO)
     # TODO(crueter) fix
-    if (MSVC OR ANDROID)
+    if (ANDROID)
         set(BUILD_SHARED_LIBS ON)
     else()
         set(BUILD_SHARED_LIBS OFF)

externals/ffmpeg/cpmfile.json

@@ -15,6 +15,7 @@
         "disabled_platforms": [
             "freebsd-amd64",
             "solaris-amd64",
+            "openbsd-amd64",
             "macos-universal"
         ]
     }

shell.nix

@@ -9,11 +9,15 @@ pkgs.mkShellNoCC {
     # libraries
     openssl boost fmt nlohmann_json lz4 zlib zstd
     enet libopus vulkan-headers vulkan-utility-libraries
-    spirv-tools spirv-headers simpleini vulkan-memory-allocator
-    vulkan-loader unzip mbedtls glslang python3 httplib
-    cpp-jwt ffmpeg-headless libusb1 cubeb
-    qt6.full # eden
-    SDL2 # eden-cli
-    discord-rpc gamemode # optional components
+    spirv-tools spirv-headers vulkan-loader unzip mbedtls
+    glslang python3 httplib cpp-jwt ffmpeg-headless
+    libusb1 cubeb
+    # eden
+    qt6.qtbase qt6.qtmultimedia qt6.qtwayland qt6.qttools
+    qt6.qtwebengine qt6.qt5compat
+    # eden-cli
+    SDL2
+    # optional components
+    discord-rpc gamemode
   ];
 }

src/CMakeLists.txt

@@ -178,8 +178,10 @@ else()
 
     if (MINGW)
         add_compile_definitions(MINGW_HAS_SECURE_API)
-        add_compile_options("-msse4.1")
-
+        # Only windows has this requirement, thanks windows
+        if (WIN32)
+            add_compile_options("-msse4.1")
+        endif()
         if (MINGW_STATIC_BUILD)
             add_compile_definitions(QT_STATICPLUGIN)
             add_compile_options("-static")

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -1511,7 +1511,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
             emulationState.newSurface(holder.surface)
         } else {
-            emulationState.newSurface(holder.surface)
+            // Surface changed due to rotation/config change
+            // Only update surface reference, don't trigger state changes
+            emulationState.updateSurfaceReference(holder.surface)
         }
     }
 
@@ -1842,6 +1844,14 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
         }
 
+        @Synchronized
+        fun updateSurfaceReference(surface: Surface?) {
+            this.surface = surface
+            if (this.surface != null && state == State.RUNNING) {
+                NativeLibrary.surfaceChanged(this.surface)
+            }
+        }
+
         @Synchronized
         fun clearSurface() {
             if (surface == null) {

src/audio_core/renderer/command/effect/reverb.cpp

@@ -84,6 +84,7 @@ static void UpdateReverbEffectParameter(const ReverbInfo::ParameterVersion2& par
     const auto pow_10 = [](f32 val) -> f32 {
         return (val >= 0.0f) ? 1.0f : (val <= -5.3f) ? 0.0f : std::pow(10.0f, val);
     };
+
     const auto cos = [](f32 degrees) -> f32 {
         return std::cos(degrees * std::numbers::pi_v<f32> / 180.0f);
     };
@@ -91,26 +92,39 @@ static void UpdateReverbEffectParameter(const ReverbInfo::ParameterVersion2& par
     static bool unk_initialized{false};
     static Common::FixedPoint<50, 14> unk_value{};
 
-    const auto sample_rate{Common::FixedPoint<50, 14>::from_base(params.sample_rate)};
-    const auto pre_delay_time{Common::FixedPoint<50, 14>::from_base(params.pre_delay)};
+    auto sample_rate = Common::FixedPoint<50, 14>::from_base(params.sample_rate);
+    if (sample_rate.to_float() < 1.0f) sample_rate = Common::FixedPoint<50, 14>(1.0f);
+
+    auto pre_delay_time = Common::FixedPoint<50, 14>::from_base(params.pre_delay);
+    if (pre_delay_time.to_float() < 0.0f) pre_delay_time = Common::FixedPoint<50, 14>(0.0f);
 
     for (u32 i = 0; i < ReverbInfo::MaxDelayTaps; i++) {
-        auto early_delay{
-            ((pre_delay_time + EarlyDelayTimes[params.early_mode][i]) * sample_rate).to_int()};
-        early_delay = (std::min)(early_delay, state.pre_delay_line.sample_count_max);
-        state.early_delay_times[i] = early_delay + 1;
-        state.early_gains[i] = Common::FixedPoint<50, 14>::from_base(params.early_gain) *
-                               EarlyDelayGains[params.early_mode][i];
+        int target_delay = ((pre_delay_time + EarlyDelayTimes[params.early_mode][i]) * sample_rate).to_int();
+        if (target_delay < 0) target_delay = 0;
+        if (target_delay > state.pre_delay_line.sample_count_max) target_delay = state.pre_delay_line.sample_count_max;
+
+        int old_delay = state.early_delay_times[i] - 1;
+        int smooth_delay = old_delay + (target_delay - old_delay) / 4;
+        state.early_delay_times[i] = smooth_delay + 1;
+
+        auto target_gain = Common::FixedPoint<50, 14>::from_base(params.early_gain) * EarlyDelayGains[params.early_mode][i];
+        if (target_gain.to_float() < 0.0f) target_gain = Common::FixedPoint<50, 14>(0.0f);
+        if (target_gain.to_float() > 1.0f) target_gain = Common::FixedPoint<50, 14>(1.0f);
+
+        state.early_gains[i] = state.early_gains[i] + (target_gain - state.early_gains[i]) / 4;
     }
 
     if (params.channel_count == 2) {
-        state.early_gains[4] * 0.5f;
-        state.early_gains[5] * 0.5f;
+        state.early_gains[4] *= Common::FixedPoint<50, 14>(0.5f);
+        state.early_gains[5] *= Common::FixedPoint<50, 14>(0.5f);
     }
 
-    auto pre_time{
-        ((pre_delay_time + EarlyDelayTimes[params.early_mode][10]) * sample_rate).to_int()};
-    state.pre_delay_time = (std::min)(pre_time, state.pre_delay_line.sample_count_max);
+    int target_pre_time = ((pre_delay_time + EarlyDelayTimes[params.early_mode][10]) * sample_rate).to_int();
+    if (target_pre_time < 0) target_pre_time = 0;
+    if (target_pre_time > state.pre_delay_line.sample_count_max) target_pre_time = state.pre_delay_line.sample_count_max;
+
+    int old_pre_time = state.pre_delay_time;
+    state.pre_delay_time = old_pre_time + (target_pre_time - old_pre_time) / 4;
 
     if (!unk_initialized) {
         unk_value = cos((1280.0f / sample_rate).to_float());
@@ -118,45 +132,64 @@ static void UpdateReverbEffectParameter(const ReverbInfo::ParameterVersion2& par
     }
 
     for (u32 i = 0; i < ReverbInfo::MaxDelayLines; i++) {
-        const auto fdn_delay{(FdnDelayTimes[params.late_mode][i] * sample_rate).to_int()};
-        state.fdn_delay_lines[i].sample_count =
-            (std::min)(fdn_delay, state.fdn_delay_lines[i].sample_count_max);
-        state.fdn_delay_lines[i].buffer_end =
-            &state.fdn_delay_lines[i].buffer[state.fdn_delay_lines[i].sample_count - 1];
+        int target_fdn_delay = (FdnDelayTimes[params.late_mode][i] * sample_rate).to_int();
+        if (target_fdn_delay < 0) target_fdn_delay = 0;
+        if (target_fdn_delay > state.fdn_delay_lines[i].sample_count_max) target_fdn_delay = state.fdn_delay_lines[i].sample_count_max;
 
-        const auto decay_delay{(DecayDelayTimes[params.late_mode][i] * sample_rate).to_int()};
-        state.decay_delay_lines[i].sample_count =
-            (std::min)(decay_delay, state.decay_delay_lines[i].sample_count_max);
-        state.decay_delay_lines[i].buffer_end =
-            &state.decay_delay_lines[i].buffer[state.decay_delay_lines[i].sample_count - 1];
+        int old_fdn = state.fdn_delay_lines[i].sample_count;
+        state.fdn_delay_lines[i].sample_count = old_fdn + (target_fdn_delay - old_fdn) / 4;
+        state.fdn_delay_lines[i].buffer_end = &state.fdn_delay_lines[i].buffer[state.fdn_delay_lines[i].sample_count - 1];
 
-        state.decay_delay_lines[i].decay =
-            0.5999755859375f * (1.0f - Common::FixedPoint<50, 14>::from_base(params.colouration));
+        int target_decay_delay = (DecayDelayTimes[params.late_mode][i] * sample_rate).to_int();
+        if (target_decay_delay < 0) target_decay_delay = 0;
+        if (target_decay_delay > state.decay_delay_lines[i].sample_count_max) target_decay_delay = state.decay_delay_lines[i].sample_count_max;
 
-        auto a{(Common::FixedPoint<50, 14>(state.fdn_delay_lines[i].sample_count_max) +
-                state.decay_delay_lines[i].sample_count_max) *
-               -3};
-        auto b{a / (Common::FixedPoint<50, 14>::from_base(params.decay_time) * sample_rate)};
-        Common::FixedPoint<50, 14> c{0.0f};
-        Common::FixedPoint<50, 14> d{0.0f};
-        auto hf_decay_ratio{Common::FixedPoint<50, 14>::from_base(params.high_freq_decay_ratio)};
+        int old_decay = state.decay_delay_lines[i].sample_count;
+        state.decay_delay_lines[i].sample_count = old_decay + (target_decay_delay - old_decay) / 4;
+        state.decay_delay_lines[i].buffer_end = &state.decay_delay_lines[i].buffer[state.decay_delay_lines[i].sample_count - 1];
 
-        if (hf_decay_ratio > 0.99493408203125f) {
+        auto colouration = Common::FixedPoint<50, 14>::from_base(params.colouration);
+        if (colouration.to_float() < 0.0f) colouration = Common::FixedPoint<50, 14>(0.0f);
+        if (colouration.to_float() > 1.0f) colouration = Common::FixedPoint<50, 14>(1.0f);
+
+        state.decay_delay_lines[i].decay = state.decay_delay_lines[i].decay + (0.5999755859375f * (1.0f - colouration) - state.decay_delay_lines[i].decay) / 4;
+
+        auto decay_time_fp = Common::FixedPoint<50, 14>::from_base(params.decay_time);
+        if (decay_time_fp.to_float() <= 0.0f) decay_time_fp = Common::FixedPoint<50, 14>(0.0001f);
+
+        auto a = (Common::FixedPoint<50, 14>(state.fdn_delay_lines[i].sample_count_max) + state.decay_delay_lines[i].sample_count_max) * -3;
+        auto b = a / (decay_time_fp * sample_rate);
+
+        auto hf_decay_ratio = Common::FixedPoint<50, 14>::from_base(params.high_freq_decay_ratio);
+        if (hf_decay_ratio.to_float() < 0.001f) hf_decay_ratio = Common::FixedPoint<50, 14>(0.001f);
+        if (hf_decay_ratio.to_float() > 0.999f) hf_decay_ratio = Common::FixedPoint<50, 14>(0.999f);
+
+        Common::FixedPoint<50, 14> c{0.0f}, d{0.0f};
+        if (hf_decay_ratio.to_float() > 0.9949f) {
             c = 0.0f;
             d = 1.0f;
         } else {
-            const auto e{
-                pow_10(((((1.0f / hf_decay_ratio) - 1.0f) * 2) / 100 * (b / 10)).to_float())};
-            const auto f{1.0f - e};
-            const auto g{2.0f - (unk_value * e * 2)};
-            const auto h{std::sqrt(std::pow(g.to_float(), 2.0f) - (std::pow(f, 2.0f) * 4))};
+            auto e = pow_10(((((1.0f / hf_decay_ratio.to_float()) - 1.0f) * 2) / 100 * (b / 10)).to_float());
+            if (e < 0.0001f) e = 0.0001f;
+            if (e > 1.0f) e = 1.0f;
+
+            auto f = 1.0f - e;
+            if (f < 0.0001f) f = 0.0001f;
+
+            auto g = 2.0f - (unk_value.to_float() * e * 2);
+
+            auto h_sq = g * g - f * f * 4;
+            if (h_sq < 0.0f) h_sq = 0.0f;
+
+            auto h = std::sqrt(h_sq);
 
             c = (g - h) / (f * 2.0f);
             d = 1.0f - c;
         }
 
-        state.hf_decay_prev_gain[i] = c;
-        state.hf_decay_gain[i] = pow_10((b / 1000).to_float()) * d * 0.70709228515625f;
+        state.hf_decay_prev_gain[i] = state.hf_decay_prev_gain[i] + (c - state.hf_decay_prev_gain[i]) / 4;
+        state.hf_decay_gain[i] = state.hf_decay_gain[i] + (pow_10((b / 1000).to_float()) * d * 0.70709228515625f - state.hf_decay_gain[i]) / 4;
+
         state.prev_feedback_output[i] = 0;
     }
 }
@@ -191,6 +224,8 @@ static void InitializeReverbEffect(const ReverbInfo::ParameterVersion2& params,
     const auto center_delay_time{(5 * delay).to_uint_floor()};
     state.center_delay_line.Initialize(center_delay_time, 1.0f);
 
+    UpdateReverbEffectParameter(params, state);
+
     for (u32 i = 0; i < ReverbInfo::MaxDelayLines; i++) {
         std::ranges::fill(state.fdn_delay_lines[i].buffer, 0);
         std::ranges::fill(state.decay_delay_lines[i].buffer, 0);

src/audio_core/sink/sink_stream.cpp

@@ -220,8 +220,8 @@ u64 SinkStream::GetExpectedPlayedSampleCount() {
     auto time_delta{cur_time - last_sample_count_update_time};
     auto exp_played_sample_count{min_played_sample_count + (TargetSampleRate * time_delta) / std::chrono::seconds{1}};
 
-    // Add 15ms of latency in sample reporting to allow for some leeway in scheduler timings
-    return std::min<u64>(exp_played_sample_count, max_played_sample_count) + TargetSampleCount * 3;
+    // Add 25ms of latency in sample reporting to allow for some leeway in scheduler timings
+    return std::min<u64>(exp_played_sample_count, max_played_sample_count) + TargetSampleCount * 5;
 }
 
 void SinkStream::WaitFreeSpace(std::stop_token stop_token) {
@@ -231,9 +231,9 @@ void SinkStream::WaitFreeSpace(std::stop_token stop_token) {
         return paused || queued_buffers < max_queue_size;
     };
 
-    release_cv.wait_for(lk, std::chrono::milliseconds(10), can_continue);
+    release_cv.wait_for(lk, std::chrono::milliseconds(7), can_continue);
 
-    if (queued_buffers > max_queue_size + 10) {
+    if (queued_buffers > max_queue_size + 3) {
         release_cv.wait(lk, stop_token, can_continue);
     }
 }

src/common/CMakeLists.txt

@@ -252,11 +252,13 @@ if(CXX_CLANG)
 endif()
 
 if (BOOST_NO_HEADERS)
-    target_link_libraries(common PUBLIC Boost::algorithm Boost::icl Boost::pool)
+    target_link_libraries(common PUBLIC Boost::algorithm Boost::icl Boost::pool Boost::filesystem)
 else()
     target_link_libraries(common PUBLIC Boost::headers)
 endif()
 
+target_link_libraries(common PUBLIC Boost::filesystem)
+
 if (lz4_ADDED)
     target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)
 endif()

src/common/assert.cpp

@@ -1,21 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/logging/backend.h"
-
 #include "common/settings.h"
 
-void assert_fail_impl() {
+#ifdef _MSC_VER
+extern "C" {
+__declspec(dllimport) void __stdcall DebugBreak(void);
+}
+#endif
+void AssertFailSoftImpl() {
     if (Settings::values.use_debug_asserts) {
         Common::Log::Stop();
-        Crash();
+#ifndef _MSC_VER
+#   if defined(ARCHITECTURE_x86_64)
+        __asm__ __volatile__("int $3");
+#   elif defined(ARCHITECTURE_arm64)
+        __asm__ __volatile__("brk #0");
+#   else
+        exit(1);
+#   endif
+#else // POSIX ^^^ _MSC_VER vvv
+        DebugBreak();
+#endif
     }
 }
-
-[[noreturn]] void unreachable_impl() {
+void AssertFatalImpl() {
     Common::Log::Stop();
-    Crash();
-    throw std::runtime_error("Unreachable code");
+    std::abort();
 }

src/common/assert.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -10,8 +13,8 @@
 // However touching this file yields a global recompilation as this header is included almost
 // everywhere. So let's just move the handling of the failed assert to a single cpp file.
 
-void assert_fail_impl();
-[[noreturn]] void unreachable_impl();
+void AssertFailSoftImpl();
+[[noreturn]] void AssertFatalImpl();
 
 #ifdef _MSC_VER
 #define YUZU_NO_INLINE __declspec(noinline)
@@ -22,29 +25,29 @@ void assert_fail_impl();
 #define ASSERT(_a_)                                                                                \
     ([&]() YUZU_NO_INLINE {                                                                        \
         if (!(_a_)) [[unlikely]] {                                                                 \
-            LOG_CRITICAL(Debug, "Assertion Failed!");                                              \
-            assert_fail_impl();                                                                    \
+            LOG_CRITICAL(Debug, "Assert");                                              \
+            AssertFailSoftImpl();                                                                    \
         }                                                                                          \
     }())
 
 #define ASSERT_MSG(_a_, ...)                                                                       \
     ([&]() YUZU_NO_INLINE {                                                                        \
         if (!(_a_)) [[unlikely]] {                                                                 \
-            LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__);                                \
-            assert_fail_impl();                                                                    \
+            LOG_CRITICAL(Debug, "Assert\n" __VA_ARGS__);                                \
+            AssertFailSoftImpl();                                                                    \
         }                                                                                          \
     }())
 
 #define UNREACHABLE()                                                                              \
     do {                                                                                           \
-        LOG_CRITICAL(Debug, "Unreachable code!");                                                  \
-        unreachable_impl();                                                                        \
+        LOG_CRITICAL(Debug, "Unreachable");                                                  \
+        AssertFatalImpl();                                                                        \
     } while (0)
 
 #define UNREACHABLE_MSG(...)                                                                       \
     do {                                                                                           \
-        LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__);                                    \
-        unreachable_impl();                                                                        \
+        LOG_CRITICAL(Debug, "Unreachable\n" __VA_ARGS__);                                    \
+        AssertFatalImpl();                                                                        \
     } while (0)
 
 #ifdef _DEBUG

src/common/common_funcs.h

@@ -32,27 +32,9 @@
 #define INSERT_PADDING_WORDS_NOINIT(num_words)                                                     \
     [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
-#ifndef _MSC_VER
-
-#if defined(ARCHITECTURE_x86_64)
-#define Crash() __asm__ __volatile__("int $3")
-#elif defined(ARCHITECTURE_arm64)
-#define Crash() __asm__ __volatile__("brk #0")
-#else
-#define Crash() exit(1)
-#endif
-
-#else // _MSC_VER
-
-// Locale Cross-Compatibility
-#define locale_t _locale_t
-
-extern "C" {
-__declspec(dllimport) void __stdcall DebugBreak(void);
-}
-#define Crash() DebugBreak()
-
-#endif // _MSC_VER ndef
+#ifdef _MSC_VER
+#   define locale_t _locale_t // Locale Cross-Compatibility
+#endif // _MSC_VER
 
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
     [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \

src/common/concepts.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,24 +15,4 @@ namespace Common {
 template <typename T>
 concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
 
-// TODO: Replace with std::derived_from when the <concepts> header
-//       is available on all supported platforms.
-template <typename Derived, typename Base>
-concept DerivedFrom = requires {
-                          std::is_base_of_v<Base, Derived>;
-                          std::is_convertible_v<const volatile Derived*, const volatile Base*>;
-                      };
-
-// TODO: Replace with std::convertible_to when libc++ implements it.
-template <typename From, typename To>
-concept ConvertibleTo = std::is_convertible_v<From, To>;
-
-// No equivalents in the stdlib
-
-template <typename T>
-concept IsArithmetic = std::is_arithmetic_v<T>;
-
-template <typename T>
-concept IsIntegral = std::is_integral_v<T>;
-
 } // namespace Common

src/common/fixed_point.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2015 Evan Teran
 // SPDX-License-Identifier: MIT
 
@@ -16,6 +19,10 @@
 
 namespace Common {
 
+// No equivalent for "std::arithmetic" in the stdlib
+template <typename T>
+concept IsArithmetic = std::is_arithmetic_v<T>;
+
 template <size_t I, size_t F>
 class FixedPoint;
 
@@ -392,13 +399,13 @@ public: // binary math operators, effects underlying bit pattern since these
         return *this;
     }
 
-    template <IsIntegral Integer>
+    template <std::integral Integer>
     constexpr FixedPoint& operator>>=(Integer n) {
         data_ >>= n;
         return *this;
     }
 
-    template <IsIntegral Integer>
+    template <std::integral Integer>
     constexpr FixedPoint& operator<<=(Integer n) {
         data_ <<= n;
         return *this;
@@ -587,12 +594,12 @@ constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
 }
 
 // shift operators
-template <size_t I, size_t F, IsIntegral Integer>
+template <size_t I, size_t F, std::integral Integer>
 constexpr FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
     lhs <<= rhs;
     return lhs;
 }
-template <size_t I, size_t F, IsIntegral Integer>
+template <size_t I, size_t F, std::integral Integer>
 constexpr FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
     lhs >>= rhs;
     return lhs;

src/common/fs/ryujinx_compat.cpp

@@ -14,16 +14,29 @@ namespace fs = std::filesystem;
 
 fs::path GetKvdbPath()
 {
-    return GetLegacyPath(EmuPath::RyujinxDir) / "bis" / "system" / "save" / "8000000000000000" / "0"
+    return GetKvdbPath(GetLegacyPath(EmuPath::RyujinxDir));
+}
+
+fs::path GetKvdbPath(const fs::path& path) {
+    return path / "bis" / "system" / "save" / "8000000000000000" / "0"
            / "imkvdb.arc";
 }
 
+fs::path GetRyuPathFromSavePath(const fs::path& path) {
+    // This is a horrible hack, but I cba to find something better
+    return path.parent_path().parent_path().parent_path().parent_path().parent_path();
+}
+
 fs::path GetRyuSavePath(const u64 &save_id)
 {
+    return GetRyuSavePath(GetLegacyPath(EmuPath::RyujinxDir), save_id);
+}
+
+std::filesystem::path GetRyuSavePath(const std::filesystem::path& path, const u64& save_id) {
     std::string hex = fmt::format("{:016x}", save_id);
 
-    // TODO: what's the difference between 0 and 1?
-    return GetLegacyPath(EmuPath::RyujinxDir) / "bis" / "user" / "save" / hex / "0";
+           // TODO: what's the difference between 0 and 1?
+    return path / "bis" / "user" / "save" / hex / "0";
 }
 
 IMENReadResult ReadKvdb(const fs::path &path, std::vector<IMEN> &imens)

src/common/fs/ryujinx_compat.h

@@ -7,16 +7,17 @@
 #include <filesystem>
 #include <vector>
 
-namespace fs = std::filesystem;
-
 namespace Common::FS {
 
 constexpr const char IMEN_MAGIC[4] = {0x49, 0x4d, 0x45, 0x4e};
 constexpr const char IMKV_MAGIC[4] = {0x49, 0x4d, 0x4b, 0x56};
 constexpr const u8 IMEN_SIZE = 0x8c;
 
-fs::path GetKvdbPath();
-fs::path GetRyuSavePath(const u64 &program_id);
+std::filesystem::path GetKvdbPath();
+std::filesystem::path GetKvdbPath(const std::filesystem::path &path);
+std::filesystem::path GetRyuPathFromSavePath(const std::filesystem::path &path);
+std::filesystem::path GetRyuSavePath(const u64 &save_id);
+std::filesystem::path GetRyuSavePath(const std::filesystem::path &path, const u64 &save_id);
 
 enum class IMENReadResult {
     Nonexistent,  // ryujinx not found
@@ -35,6 +36,6 @@ struct IMEN
 
 static_assert(sizeof(IMEN) == 0x10, "IMEN has incorrect size.");
 
-IMENReadResult ReadKvdb(const fs::path &path, std::vector<IMEN> &imens);
+IMENReadResult ReadKvdb(const std::filesystem::path &path, std::vector<IMEN> &imens);
 
 } // namespace Common::FS

src/common/fs/symlink.cpp

@@ -4,10 +4,12 @@
 #include "symlink.h"
 
 #ifdef _WIN32
-#include <windows.h>
 #include <fmt/format.h>
+#include <windows.h>
 #endif
 
+#include <boost/filesystem.hpp>
+
 namespace fs = std::filesystem;
 
 // The sole purpose of this file is to treat symlinks like symlinks on POSIX,
@@ -15,29 +17,40 @@ namespace fs = std::filesystem;
 // This is because, for some inexplicable reason, Microsoft has locked symbolic
 // links behind a "security policy", whereas directory junctions--functionally identical
 // for directories, by the way--are not. Why? I don't know.
+// And no, they do NOT provide a standard API for this (at least to my knowledge).
+// CreateSymbolicLink, even when EXPLICITLY TOLD to create a junction, still fails
+// because of their security policy.
+// I don't know what kind of drugs the Windows developers have been on since NT started.
+
+// Microsoft still has not implemented any of this in their std::filesystem implemenation,
+// which ALSO means that it DOES NOT FOLLOW ANY DIRECTORY JUNCTIONS... AT ALL.
+// Nor does any of their command line utilities or APIs. So you're quite literally
+// on your own.
 
 namespace Common::FS {
 
-bool CreateSymlink(const fs::path &from, const fs::path &to)
+bool CreateSymlink(fs::path from, fs::path to)
 {
-#ifdef _WIN32
-    const std::string command = fmt::format("mklink /J {} {}", to.string(), from.string());
-    return system(command.c_str()) == 0;
-#else
+    from.make_preferred();
+    to.make_preferred();
+
     std::error_code ec;
     fs::create_directory_symlink(from, to, ec);
-    return !ec;
+#ifdef _WIN32
+    if (ec) {
+        const std::string command = fmt::format("mklink /J \"{}\" \"{}\"",
+                                                to.string(),
+                                                from.string());
+        return system(command.c_str()) == 0;
+    }
 #endif
+
+    return !ec;
 }
 
 bool IsSymlink(const fs::path &path)
 {
-#ifdef _WIN32
-    auto attributes = GetFileAttributesW(path.wstring().c_str());
-    return attributes & FILE_ATTRIBUTE_REPARSE_POINT;
-#else
-    return fs::is_symlink(path);
-#endif
+    return boost::filesystem::is_symlink(boost::filesystem::path{path});
 }
 
 } // namespace Common::FS

src/common/fs/symlink.h

@@ -6,7 +6,7 @@
 #include <filesystem>
 namespace Common::FS {
 
-bool CreateSymlink(const std::filesystem::path &from, const std::filesystem::path &to);
+bool CreateSymlink(std::filesystem::path from, std::filesystem::path to);
 bool IsSymlink(const std::filesystem::path &path);
 
 } // namespace Common::FS

src/common/host_memory.cpp

@@ -521,14 +521,29 @@ public:
 #else
         fd = memfd_create("HostMemory", 0);
 #endif
-        ASSERT_MSG(fd >= 0, "memfd_create failed: {}", strerror(errno));
-
-        // Defined to extend the file with zeros
-        int ret = ftruncate(fd, backing_size);
-        ASSERT_MSG(ret == 0, "ftruncate failed with {}, are you out-of-memory?", strerror(errno));
-
-        backing_base = static_cast<u8*>(
-            mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+        bool use_anon = false;
+        if (fd <= 0) {
+            LOG_WARNING(Common_Memory, "memfd_create: {}", strerror(errno));
+            use_anon = true;
+        }
+        if (!use_anon) {
+            // Defined to extend the file with zeros
+            int ret = ftruncate(fd, backing_size);
+            if (ret != 0) {
+                LOG_WARNING(Common_Memory, "ftruncate: {} (likely out-of-emory)", strerror(errno));
+                use_anon = true;
+            }
+        }
+        if (use_anon) {
+            LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+            if (fd > 0) {
+                fd = -1;
+                close(fd);
+            }
+        } else {
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+        }
         ASSERT_MSG(backing_base != MAP_FAILED, "mmap failed: {}", strerror(errno));
 
         // Virtual memory initialization
@@ -552,22 +567,18 @@ public:
         free_manager.AllocateBlock(virtual_base + virtual_offset, length);
 
         // Deduce mapping protection flags.
-        int flags = PROT_NONE;
-        if (True(perms & MemoryPermission::Read)) {
-            flags |= PROT_READ;
-        }
-        if (True(perms & MemoryPermission::Write)) {
-            flags |= PROT_WRITE;
-        }
+        int prot_flags = PROT_NONE;
+        if (True(perms & MemoryPermission::Read))
+            prot_flags |= PROT_READ;
+        if (True(perms & MemoryPermission::Write))
+            prot_flags |= PROT_WRITE;
 #ifdef ARCHITECTURE_arm64
-        if (True(perms & MemoryPermission::Execute)) {
-            flags |= PROT_EXEC;
-        }
+        if (True(perms & MemoryPermission::Execute))
+            prot_flags |= PROT_EXEC;
 #endif
-
-        void* ret = mmap(virtual_base + virtual_offset, length, flags, MAP_SHARED | MAP_FIXED, fd,
-                         host_offset);
-        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
+        int flags = (fd > 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
+        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
+        ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
     }
 
     void Unmap(size_t virtual_offset, size_t length) {

src/common/settings.cpp

@@ -169,7 +169,7 @@ bool IsFastmemEnabled() {
     if (values.cpu_accuracy.GetValue() == CpuAccuracy::Unsafe) {
         return bool(values.cpuopt_unsafe_host_mmu);
     }
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__)
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__ANDROID__) && !defined(_WIN32)
     return false;
 #else
     return true;

src/common/settings.h

@@ -240,7 +240,7 @@ struct Values {
                                                     Category::Cpu};
     SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
                                                       "cpu_accuracy", Category::Cpu};
-
+    SwitchableSetting<bool> vtable_bouncing{linkage, true, "vtable_bouncing", Category::Cpu};
     SwitchableSetting<bool> use_fast_cpu_time{linkage,
                                               false,
                                               "use_fast_cpu_time",
@@ -296,7 +296,7 @@ struct Values {
                                               Category::CpuDebug};
 
     SwitchableSetting<bool> cpuopt_unsafe_host_mmu{linkage,
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__)
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__ANDROID__) && !defined(_WIN32)
                                         false,
 #else
                                         true,
@@ -759,7 +759,6 @@ struct Values {
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;
-    std::vector<std::string> external_dirs;
 };
 
 extern Values values;

src/common/thread.cpp

@@ -81,7 +81,10 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 
 // Sets the debugger-visible name of the current thread.
 void SetCurrentThreadName(const char* name) {
-    SetThreadDescription(GetCurrentThread(), UTF8ToUTF16W(name).data());
+    if (auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription"); pf)
+        pf(GetCurrentThread(), UTF8ToUTF16W(name).data()); // Windows 10+
+    else
+        ; // No-op
 }
 
 #else // !MSVC_VER, so must be POSIX threads
@@ -109,7 +112,7 @@ void SetCurrentThreadName(const char* name) {
         buf[len] = '\0';
         pthread_setname_np(pthread_self(), buf);
     }
-#elif !defined(_WIN32) || defined(_MSC_VER)
+#elif defined(_WIN32)
     // mingw stub
     (void)name;
 #else

src/core/CMakeLists.txt

@@ -54,8 +54,6 @@ add_library(core STATIC
     file_sys/control_metadata.cpp
     file_sys/control_metadata.h
     file_sys/errors.h
-    file_sys/external_content_index.cpp
-    file_sys/external_content_index.h
     file_sys/fs_directory.h
     file_sys/fs_file.h
     file_sys/fs_filesystem.h

src/core/arm/arm_interface.cpp

@@ -14,11 +14,33 @@ namespace Core {
 void ArmInterface::LogBacktrace(Kernel::KProcess* process) const {
     Kernel::Svc::ThreadContext ctx;
     this->GetContext(ctx);
-    LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", ctx.sp, ctx.pc);
-    LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address", "Offset", "Symbol");
+
+    std::array<u64, 32> xreg{
+        ctx.r[0], ctx.r[1], ctx.r[2], ctx.r[3],
+        ctx.r[4], ctx.r[5], ctx.r[6], ctx.r[7],
+        ctx.r[8], ctx.r[9], ctx.r[10], ctx.r[11],
+        ctx.r[12], ctx.r[13], ctx.r[14], ctx.r[15],
+        ctx.r[16], ctx.r[17], ctx.r[18], ctx.r[19],
+        ctx.r[20], ctx.r[21], ctx.r[22], ctx.r[23],
+        ctx.r[24], ctx.r[25], ctx.r[26], ctx.r[27],
+        ctx.r[28], ctx.fp, ctx.lr, ctx.sp,
+    };
+
+    std::string msg = fmt::format("Backtrace @ PC={:016X}\n", ctx.pc);
+    for (size_t i = 0; i < 32; i += 4)
+        msg += fmt::format("R{:02}={:016X} R{:02}={:016X} R{:02}={:016X} R{:02}={:016X}\n",
+            i + 0, xreg[i + 0], i + 1, xreg[i + 1],
+            i + 2, xreg[i + 2], i + 3, xreg[i + 3]);
+    for (size_t i = 0; i < 32; i += 2)
+        msg += fmt::format("V{:02}={:016X}_{:016X} V{:02}={:016X}_{:016X}\n",
+            i + 0, ctx.v[i + 0][0], ctx.v[i + 0][1],
+            i + 1, ctx.v[i + 1][0], ctx.v[i + 1][1]);
+    msg += fmt::format("PSTATE={:08X} FPCR={:08X} FPSR={:08X} TPIDR={:016X}\n", ctx.pstate, ctx.fpcr, ctx.fpsr, ctx.tpidr);
+    msg += fmt::format("{:20}{:20}{:20}{:20}{}\n", "Module", "Address", "Original Address", "Offset", "Symbol");
     auto const backtrace = GetBacktraceFromContext(process, ctx);
     for (auto const& entry : backtrace)
-        LOG_ERROR(Core_ARM, "{:20}{:016X}    {:016X}    {:016X}    {}", entry.module, entry.address, entry.original_address, entry.offset, entry.name);
+        msg += fmt::format("{:20}{:016X}    {:016X}    {:016X}    {}\n", entry.module, entry.address, entry.original_address, entry.offset, entry.name);
+    LOG_ERROR(Core_ARM, "{}", msg);
 }
 
 const Kernel::DebugWatchpoint* ArmInterface::MatchingWatchpoint(

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -292,7 +292,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
     // Curated optimizations
     case Settings::CpuAccuracy::Auto:
         config.unsafe_optimizations = true;
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__)
         config.fastmem_pointer = std::nullopt;
         config.fastmem_exclusive_access = false;
 #endif

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -351,7 +351,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
     // Safe optimisations
     case Settings::CpuAccuracy::Auto:
         config.unsafe_optimizations = true;
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__)
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__ANDROID__) && !defined(_WIN32)
         config.fastmem_pointer = std::nullopt;
         config.fastmem_exclusive_access = false;
 #endif

src/core/arm/nce/arm_nce.cpp

@@ -388,14 +388,6 @@ void ArmNce::SignalInterrupt(Kernel::KThread* thread) {
 const std::size_t CACHE_PAGE_SIZE = 4096;
 
 void ArmNce::ClearInstructionCache() {
-#if defined(__GNUC__) || defined(__clang__)
-    void* start = (void*)((uintptr_t)__builtin_return_address(0) & ~(CACHE_PAGE_SIZE - 1));
-    void* end =
-        (void*)((uintptr_t)start + CACHE_PAGE_SIZE * 2); // Clear two pages for better coverage
-    // Prefetch next likely pages
-    __builtin_prefetch((void*)((uintptr_t)end), 1, 3);
-    __builtin___clear_cache(static_cast<char*>(start), static_cast<char*>(end));
-#endif
 #ifdef __aarch64__
     // Ensure all previous memory operations complete
     asm volatile("dmb ish" ::: "memory");
@@ -405,20 +397,6 @@ void ArmNce::ClearInstructionCache() {
 }
 
 void ArmNce::InvalidateCacheRange(u64 addr, std::size_t size) {
-    #if defined(__GNUC__) || defined(__clang__)
-        // Align the start address to cache line boundary for better performance
-        const size_t CACHE_LINE_SIZE = 64;
-        addr &= ~(CACHE_LINE_SIZE - 1);
-
-        // Round up size to nearest cache line
-        size = (size + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1);
-
-        // Prefetch the range to be invalidated
-        for (size_t offset = 0; offset < size; offset += CACHE_LINE_SIZE) {
-            __builtin_prefetch((void*)(addr + offset), 1, 3);
-        }
-    #endif
-
     this->ClearInstructionCache();
 }
 

src/core/arm/nce/interpreter_visitor.cpp

@@ -181,14 +181,6 @@ bool InterpreterVisitor::Ordered(size_t size, bool L, bool o0, Reg Rn, Reg Rt) {
     const size_t dbytes = datasize / 8;
 
     u64 address = (Rn == Reg::SP) ? this->GetSp() : this->GetReg(Rn);
-
-    // Conservative prefetch for atomic ops
-    if (memop == MemOp::Load) {
-        __builtin_prefetch(reinterpret_cast<const void*>(address), 0, 1);
-    } else {
-        __builtin_prefetch(reinterpret_cast<const void*>(address), 1, 1);
-    }
-
     switch (memop) {
     case MemOp::Store: {
         std::atomic_thread_fence(std::memory_order_seq_cst);
@@ -435,21 +427,6 @@ bool InterpreterVisitor::RegisterImmediate(bool wback, bool postindex, size_t sc
     if (!postindex)
         address += offset;
 
-    // Optimized prefetch for loads
-    if (memop == MemOp::Load) {
-        const size_t access_size = datasize / 8;
-        const bool is_aligned = (address % access_size) == 0;
-
-        if (is_aligned) {
-            __builtin_prefetch(reinterpret_cast<const void*>(address), 0, 3);
-            if (access_size >= 8 && access_size <= 32) {
-                __builtin_prefetch(reinterpret_cast<const void*>(address + PREFETCH_STRIDE), 0, 3);
-            }
-        } else {
-            __builtin_prefetch(reinterpret_cast<const void*>(address), 0, 1);
-        }
-    }
-
     switch (memop) {
     case MemOp::Store: {
         u64 data = this->GetReg(Rt);
@@ -516,15 +493,6 @@ bool InterpreterVisitor::SIMDImmediate(bool wback, bool postindex, size_t scale,
     if (!postindex)
         address += offset;
 
-    // Aggressive prefetch for SIMD
-    if (memop == MemOp::Load) {
-        __builtin_prefetch(reinterpret_cast<const void*>(address), 0, 3);
-        __builtin_prefetch(reinterpret_cast<const void*>(address + CACHE_LINE_SIZE), 0, 3);
-        if (datasize >= SIMD_PREFETCH_THRESHOLD) {
-            __builtin_prefetch(reinterpret_cast<const void*>(address + PREFETCH_STRIDE), 0, 3);
-        }
-    }
-
     switch (memop) {
     case MemOp::Store: {
         u128 data = VectorGetElement(this->GetVec(Vt), datasize);

src/core/file_sys/external_content_index.cpp

@@ -1,313 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/file_sys/external_content_index.h"
-
-#include <algorithm>
-#include <cctype>
-#include <filesystem>
-#include <string>
-#include "common/fs/fs_util.h"
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "core/file_sys/common_funcs.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/submission_package.h"
-#include "core/file_sys/vfs/vfs.h"
-#include "core/loader/loader.h"
-
-namespace fs = std::filesystem;
-
-namespace FileSys {
-
-ExternalContentIndexer::ExternalContentIndexer(VirtualFilesystem vfs,
-                                               ManualContentProvider& provider,
-                                               ExternalContentPaths paths)
-    : m_vfs(std::move(vfs)), m_provider(provider), m_paths(std::move(paths)) {}
-
-void ExternalContentIndexer::Rebuild() {
-    m_provider.ClearAllEntries();
-    m_updates_by_title.clear();
-    m_all_dlc.clear();
-
-    for (const auto& dir : m_paths.update_dirs) {
-        IndexUpdatesDir(dir);
-    }
-    for (const auto& dir : m_paths.dlc_dirs) {
-        IndexDlcDir(dir);
-    }
-
-    Commit();
-}
-
-static std::string ToLowerCopy(const std::string& s) {
-    std::string out;
-    out.resize(s.size());
-    std::transform(s.begin(), s.end(), out.begin(),
-                   [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
-    return out;
-}
-
-void ExternalContentIndexer::IndexUpdatesDir(const std::string& dir) {
-    try {
-        const fs::path p = Common::FS::ToU8String(dir);
-        std::error_code ec;
-        if (!fs::exists(p, ec) || ec)
-            return;
-
-        if (fs::is_directory(p, ec) && !ec) {
-            for (const auto& entry : fs::recursive_directory_iterator(
-                     p, fs::directory_options::skip_permission_denied, ec)) {
-                if (entry.is_directory(ec))
-                    continue;
-                TryIndexFileAsContainer(Common::FS::ToUTF8String(entry.path().u8string()), true);
-            }
-            TryIndexLooseDir(Common::FS::ToUTF8String(p.u8string()), true);
-        } else {
-            TryIndexFileAsContainer(Common::FS::ToUTF8String(p.u8string()), true);
-        }
-    } catch (const std::exception& e) {
-        LOG_ERROR(Loader, "Error accessing update directory '{}': {}", dir, e.what());
-    }
-}
-
-void ExternalContentIndexer::IndexDlcDir(const std::string& dir) {
-    try {
-        const fs::path p = Common::FS::ToU8String(dir);
-        std::error_code ec;
-        if (!fs::exists(p, ec) || ec)
-            return;
-
-        if (fs::is_directory(p, ec) && !ec) {
-            for (const auto& entry : fs::recursive_directory_iterator(
-                     p, fs::directory_options::skip_permission_denied, ec)) {
-                if (entry.is_directory(ec))
-                    continue;
-                TryIndexFileAsContainer(Common::FS::ToUTF8String(entry.path().u8string()), false);
-            }
-            TryIndexLooseDir(Common::FS::ToUTF8String(p.u8string()), false);
-        } else {
-            TryIndexFileAsContainer(Common::FS::ToUTF8String(p.u8string()), false);
-        }
-    } catch (const std::exception& e) {
-        LOG_ERROR(Loader, "Error accessing DLC directory '{}': {}", dir, e.what());
-    }
-}
-
-void ExternalContentIndexer::TryIndexFileAsContainer(const std::string& path, bool is_update) {
-    const auto lower = ToLowerCopy(path);
-    if (lower.size() >= 4 && lower.rfind(".nsp") == lower.size() - 4) {
-        if (auto vf = m_vfs->OpenFile(path, OpenMode::Read)) {
-            ParseContainerNSP(vf, is_update);
-        }
-    }
-}
-
-void ExternalContentIndexer::TryIndexLooseDir(const std::string& dir, bool is_update) {
-    fs::path p = Common::FS::ToU8String(dir);
-    std::error_code ec;
-    if (!fs::is_directory(p, ec) || ec)
-        return;
-
-    for (const auto& entry :
-         fs::recursive_directory_iterator(p, fs::directory_options::skip_permission_denied, ec)) {
-        if (ec)
-            break;
-        if (!entry.is_regular_file(ec))
-            continue;
-        const auto path = Common::FS::ToUTF8String(entry.path().u8string());
-        const auto lower = ToLowerCopy(path);
-        if (lower.size() >= 9 && lower.rfind(".cnmt.nca") == lower.size() - 9) {
-            if (auto vf = m_vfs->OpenFile(path, OpenMode::Read)) {
-                ParseLooseCnmtNca(
-                    vf, Common::FS::ToUTF8String(entry.path().parent_path().u8string()), is_update);
-            }
-        }
-    }
-}
-
-void ExternalContentIndexer::ParseContainerNSP(VirtualFile file, bool is_update) {
-    if (file == nullptr)
-        return;
-    NSP nsp(file);
-    if (nsp.GetStatus() != Loader::ResultStatus::Success) {
-        LOG_WARNING(Loader, "ExternalContent: NSP parse failed");
-        return;
-    }
-
-    const auto title_map = nsp.GetNCAs();
-    if (title_map.empty())
-        return;
-
-    for (const auto& [title_id, nca_map] : title_map) {
-        std::shared_ptr<NCA> meta_nca;
-        for (const auto& [key, nca_ptr] : nca_map) {
-            if (nca_ptr && nca_ptr->GetType() == NCAContentType::Meta) {
-                meta_nca = nca_ptr;
-                break;
-            }
-        }
-        if (!meta_nca)
-            continue;
-
-        auto cnmt_opt = ExtractCnmtFromMetaNca(*meta_nca);
-        if (!cnmt_opt)
-            continue;
-        const auto& cnmt = *cnmt_opt;
-
-        const auto base_id = BaseTitleId(title_id);
-
-        if (is_update && cnmt.GetType() == TitleType::Update) {
-            ParsedUpdate candidate{};
-            // Register updates under their Update TID so PatchManager can find/apply them
-            candidate.title_id = FileSys::GetUpdateTitleID(base_id);
-            candidate.version = cnmt.GetTitleVersion();
-            for (const auto& rec : cnmt.GetContentRecords()) {
-                const auto it = nca_map.find({cnmt.GetType(), rec.type});
-                if (it != nca_map.end() && it->second) {
-                    candidate.ncas[rec.type] = it->second->GetBaseFile();
-                }
-            }
-            auto& vec = m_updates_by_title[base_id];
-            vec.emplace_back(std::move(candidate));
-        } else if (cnmt.GetType() == TitleType::AOC) {
-            const auto dlc_title_id = cnmt.GetTitleID();
-            for (const auto& rec : cnmt.GetContentRecords()) {
-                const auto it = nca_map.find({cnmt.GetType(), rec.type});
-                if (it != nca_map.end() && it->second) {
-                    m_all_dlc.push_back(
-                        ParsedDlcRecord{dlc_title_id, {}, it->second->GetBaseFile()});
-                }
-            }
-        }
-    }
-}
-
-void ExternalContentIndexer::ParseLooseCnmtNca(VirtualFile meta_nca_file, const std::string& folder,
-                                               bool is_update) {
-    if (meta_nca_file == nullptr)
-        return;
-
-    NCA meta(meta_nca_file);
-
-    if (!IsMeta(meta))
-        return;
-
-    auto cnmt_opt = ExtractCnmtFromMetaNca(meta);
-    if (!cnmt_opt)
-        return;
-    const auto& cnmt = *cnmt_opt;
-
-    const auto base_id = BaseTitleId(cnmt.GetTitleID());
-
-    if (is_update && cnmt.GetType() == TitleType::Update) {
-        ParsedUpdate candidate{};
-        // Register updates under their Update TID so PatchManager can find/apply them
-        candidate.title_id = FileSys::GetUpdateTitleID(base_id);
-        candidate.version = cnmt.GetTitleVersion();
-
-        for (const auto& rec : cnmt.GetContentRecords()) {
-            const auto file_name = Common::HexToString(rec.nca_id) + ".nca";
-            const auto full = Common::FS::ToUTF8String(
-                (fs::path(Common::FS::ToU8String(folder)) / fs::path(file_name)).u8string());
-            if (auto vf = m_vfs->OpenFile(full, OpenMode::Read)) {
-                candidate.ncas[rec.type] = vf;
-            }
-        }
-
-        auto& vec = m_updates_by_title[base_id];
-        vec.emplace_back(std::move(candidate));
-    } else if (cnmt.GetType() == TitleType::AOC) {
-        const auto dlc_title_id = cnmt.GetTitleID();
-        for (const auto& rec : cnmt.GetContentRecords()) {
-            const auto file_name = Common::HexToString(rec.nca_id) + ".nca";
-            const auto full = Common::FS::ToUTF8String(
-                (fs::path(Common::FS::ToU8String(folder)) / fs::path(file_name)).u8string());
-            if (auto vf = m_vfs->OpenFile(full, OpenMode::Read)) {
-                ParsedDlcRecord dl{dlc_title_id, {}, vf};
-                m_all_dlc.push_back(std::move(dl));
-            }
-        }
-    }
-}
-
-std::optional<CNMT> ExternalContentIndexer::ExtractCnmtFromMetaNca(const NCA& meta_nca) {
-    if (meta_nca.GetStatus() != Loader::ResultStatus::Success)
-        return std::nullopt;
-
-    const auto subs = meta_nca.GetSubdirectories();
-    if (subs.empty() || !subs[0])
-        return std::nullopt;
-
-    const auto files = subs[0]->GetFiles();
-    if (files.empty() || !files[0])
-        return std::nullopt;
-
-    CNMT cnmt(files[0]);
-    return cnmt;
-}
-
-ExternalContentIndexer::TitleID ExternalContentIndexer::BaseTitleId(TitleID id) {
-    return FileSys::GetBaseTitleID(id);
-}
-
-bool ExternalContentIndexer::IsMeta(const NCA& nca) {
-    return nca.GetType() == NCAContentType::Meta;
-}
-
-void ExternalContentIndexer::Commit() {
-    // Updates: register all discovered versions per base title under unique variant TIDs,
-    // and additionally register the highest version under the canonical update TID for default
-    // usage.
-    size_t update_variants_count = 0;
-    for (auto& [base_title, vec] : m_updates_by_title) {
-        if (vec.empty())
-            continue;
-        // sort ascending by version, dedupe identical versions (for NAND overlap, for example)
-        std::stable_sort(vec.begin(), vec.end(), [](const ParsedUpdate& a, const ParsedUpdate& b) {
-            return a.version < b.version;
-        });
-        vec.erase(std::unique(vec.begin(), vec.end(),
-                              [](const ParsedUpdate& a, const ParsedUpdate& b) {
-                                  return a.version == b.version;
-                              }),
-                  vec.end());
-
-        // highest version for canonical TID
-        const auto& latest = vec.back();
-        for (const auto& [rtype, file] : latest.ncas) {
-            if (!file)
-                continue;
-            const auto canonical_tid = FileSys::GetUpdateTitleID(base_title);
-            m_provider.AddEntry(TitleType::Update, rtype, canonical_tid, file);
-        }
-
-        // variants under update_tid + i (i starts at1 to avoid colliding with canonical)
-        for (size_t i = 0; i < vec.size(); ++i) {
-            const auto& upd = vec[i];
-            const u64 variant_tid = FileSys::GetUpdateTitleID(base_title) + static_cast<u64>(i + 1);
-            for (const auto& [rtype, file] : upd.ncas) {
-                if (!file)
-                    continue;
-                m_provider.AddEntry(TitleType::Update, rtype, variant_tid, file);
-            }
-        }
-        update_variants_count += vec.size();
-    }
-
-    // DLC: additive
-    for (const auto& dlc : m_all_dlc) {
-        if (!dlc.file)
-            continue;
-        m_provider.AddEntry(TitleType::AOC, ContentRecordType::Data, dlc.title_id, dlc.file);
-    }
-
-    LOG_INFO(Loader,
-             "ExternalContent: registered updates for {} titles ({} variants), {} DLC records",
-             m_updates_by_title.size(), update_variants_count, m_all_dlc.size());
-}
-
-} // namespace FileSys

src/core/file_sys/external_content_index.h

@@ -1,74 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include "common/common_types.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/vfs/vfs.h"
-#include "core/file_sys/nca_metadata.h"
-
-namespace FileSys {
-
-class ManualContentProvider;
-class NCA;
-
-struct ExternalContentPaths {
-    std::vector<std::string> update_dirs;
-    std::vector<std::string> dlc_dirs;
-};
-
-class ExternalContentIndexer {
-public:
-    ExternalContentIndexer(VirtualFilesystem vfs,
-                           ManualContentProvider& provider,
-                           ExternalContentPaths paths);
-
-    void Rebuild();
-
-private:
-    using TitleID = u64;
-
-    struct ParsedUpdate {
-        TitleID title_id{};
-        u32 version{};
-        std::unordered_map<ContentRecordType, VirtualFile> ncas;
-    };
-
-    struct ParsedDlcRecord {
-        TitleID title_id{};
-        NcaID nca_id{};
-        VirtualFile file{};
-    };
-
-    void IndexUpdatesDir(const std::string& dir);
-    void IndexDlcDir(const std::string& dir);
-
-    void TryIndexFileAsContainer(const std::string& path, bool is_update);
-    void TryIndexLooseDir(const std::string& dir, bool is_update);
-
-    void ParseContainerNSP(VirtualFile file, bool is_update);
-    void ParseLooseCnmtNca(VirtualFile meta_nca_file, const std::string& folder, bool is_update);
-
-    static std::optional<CNMT> ExtractCnmtFromMetaNca(const NCA& meta_nca);
-    static TitleID BaseTitleId(TitleID id);
-    static bool IsMeta(const NCA& nca);
-
-    void Commit();
-
-private:
-    VirtualFilesystem m_vfs;
-    ManualContentProvider& m_provider;
-    ExternalContentPaths m_paths;
-
-    std::unordered_map<TitleID, std::vector<ParsedUpdate>> m_updates_by_title;
-
-    std::vector<ParsedDlcRecord> m_all_dlc;
-};
-
-} // namespace FileSys

src/core/file_sys/fs_path_utility.h

@@ -63,12 +63,10 @@ constexpr bool IsInvalidCharacter(char c) {
     return impl::IsInvalidCharacterImpl<InvalidCharacters, std::size(InvalidCharacters)>(c);
 }
 constexpr bool IsInvalidCharacterForHostName(char c) {
-    return impl::IsInvalidCharacterImpl<InvalidCharactersForHostName,
-        std::size(InvalidCharactersForHostName)>(c);
+    return impl::IsInvalidCharacterImpl<InvalidCharactersForHostName, std::size(InvalidCharactersForHostName)>(c);
 }
 constexpr bool IsInvalidCharacterForMountName(char c) {
-    return impl::IsInvalidCharacterImpl<InvalidCharactersForMountName,
-        std::size(InvalidCharactersForMountName)>(c);
+    return impl::IsInvalidCharacterImpl<InvalidCharactersForMountName, std::size(InvalidCharactersForMountName)>(c);
 }
 
 } // namespace StringTraits

src/core/file_sys/patch_manager.cpp

@@ -8,9 +8,6 @@
 #include <array>
 #include <cstddef>
 #include <cstring>
-#include <set>
-#include <string>
-#include <vector>
 
 #include "common/hex_util.h"
 #include "common/logging/log.h"
@@ -67,30 +64,6 @@ std::string FormatTitleVersion(u32 version,
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-static std::array<int, 4> ParseVersionComponents(std::string_view label) {
-    std::array<int, 4> out{0, 0, 0, 0};
-    if (!label.empty() && (label.front() == 'v' || label.front() == 'V')) {
-        label.remove_prefix(1);
-    }
-    size_t part = 0;
-    size_t start = 0;
-    std::string s(label);
-    while (part < out.size() && start < s.size()) {
-        size_t dot = s.find('.', start);
-        auto token = s.substr(start, dot == std::string::npos ? std::string::npos : dot - start);
-        try {
-            out[part] = std::stoi(token);
-        } catch (...) {
-            out[part] = 0;
-        }
-        ++part;
-        if (dot == std::string::npos)
-            break;
-        start = dot + 1;
-    }
-    return out;
-}
-
 // Returns a directory with name matching name case-insensitive. Returns nullptr if directory
 // doesn't have a directory with name.
 VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name) {
@@ -144,83 +117,6 @@ void AppendCommaIfNotEmpty(std::string& to, std::string_view with) {
 bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
     return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
 }
-
-static std::vector<u64> EnumerateUpdateVariants(const ContentProvider& provider, u64 base_title_id,
-                                                ContentRecordType type) {
-    std::vector<u64> tids;
-    const auto entries = provider.ListEntriesFilter(TitleType::Update, type);
-    for (const auto& e : entries) {
-        if (GetBaseTitleID(e.title_id) == base_title_id) {
-            tids.push_back(e.title_id);
-        }
-    }
-    std::sort(tids.begin(), tids.end());
-    tids.erase(std::unique(tids.begin(), tids.end()), tids.end());
-    return tids;
-}
-
-static std::string GetUpdateVersionLabel(u64 update_tid,
-                                         const Service::FileSystem::FileSystemController& fs,
-                                         const ContentProvider& provider) {
-    PatchManager pm{update_tid, fs, provider};
-    const auto meta = pm.GetControlMetadata();
-    if (meta.first != nullptr) {
-        auto str = meta.first->GetVersionString();
-        if (!str.empty()) {
-            if (str.front() != 'v' && str.front() != 'V') {
-                str.insert(str.begin(), 'v');
-            }
-            return str;
-        }
-    }
-    const auto ver = provider.GetEntryVersion(update_tid).value_or(0);
-    return FormatTitleVersion(ver);
-}
-
-static std::optional<u64> ChooseUpdateVariant(const ContentProvider& provider, u64 base_title_id,
-                                              ContentRecordType type,
-                                              const Service::FileSystem::FileSystemController& fs) {
-    const auto& disabled = Settings::values.disabled_addons[base_title_id];
-
-    if (std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend()) {
-        return std::nullopt;
-    }
-
-    const auto candidates = EnumerateUpdateVariants(provider, base_title_id, type);
-    if (candidates.empty()) {
-        return std::nullopt;
-    }
-
-    // Sort candidates by numeric version descending, using meta version; fallback to0
-    std::vector<std::pair<u32, u64>> ordered; // (version,uTid)
-    ordered.reserve(candidates.size());
-    for (const auto tid : candidates) {
-        const u32 ver = provider.GetEntryVersion(tid).value_or(0);
-        ordered.emplace_back(ver, tid);
-    }
-    std::sort(ordered.begin(), ordered.end(), [](auto const& a, auto const& b) {
-        return a.first > b.first; // highest version first
-    });
-
-    // Pick the first candidate that is not specifically disabled via "Update vX.Y.Z"
-    for (const auto& [ver, tid] : ordered) {
-        const auto label = GetUpdateVersionLabel(tid, fs, provider);
-        const auto toggle_name = fmt::format("Update {}", label);
-        if (std::find(disabled.cbegin(), disabled.cend(), toggle_name) == disabled.cend()) {
-            return tid;
-        }
-    }
-
-    // All variants disabled, do not apply any update
-    return std::nullopt;
-}
-
-static bool HasVariantPreference(const std::vector<std::string>& disabled) {
-    return std::any_of(disabled.begin(), disabled.end(), [](const std::string& s) {
-        return s.rfind("Update v", 0) == 0;
-    });
-}
-
 } // Anonymous namespace
 
 PatchManager::PatchManager(u64 title_id_,
@@ -245,22 +141,13 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
 
     // Game Updates
-    std::optional<u64> selected_update_tid;
-    if (!update_disabled) {
-        selected_update_tid = ChooseUpdateVariant(content_provider, title_id,
-                                                  ContentRecordType::Program, fs_controller);
-        if (!selected_update_tid.has_value()) {
-            selected_update_tid = GetUpdateTitleID(title_id);
-        }
-    }
+    const auto update_tid = GetUpdateTitleID(title_id);
+    const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);
 
-    if (selected_update_tid.has_value()) {
-        const auto update =
-            content_provider.GetEntry(*selected_update_tid, ContentRecordType::Program);
-        if (update != nullptr && update->GetExeFS() != nullptr) {
-            LOG_INFO(Loader, "    ExeFS: Update applied successfully");
-            exefs = update->GetExeFS();
-        }
+    if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr) {
+        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+                 FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+        exefs = update->GetExeFS();
     }
 
     // LayeredExeFS
@@ -429,8 +316,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
-std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const BuildID& build_id_) const {
+std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildID& build_id_) const {
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
@@ -439,19 +325,16 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
-    std::sort(patch_dirs.begin(), patch_dirs.end(),
-              [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });
+    std::sort(patch_dirs.begin(), patch_dirs.end(), [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });
 
     // <mod dir> / <folder> / cheats / <build id>.txt
     std::vector<Core::Memory::CheatEntry> out;
     for (const auto& subdir : patch_dirs) {
         if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) == disabled.cend()) {
-            if (auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
-                cheats_dir != nullptr) {
+            if (auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats"); cheats_dir != nullptr) {
                 if (auto const res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, true))
                     std::copy(res->begin(), res->end(), std::back_inserter(out));
-                if (auto const res =
-                        ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, false))
+                if (auto const res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, false))
                     std::copy(res->begin(), res->end(), std::back_inserter(out));
             }
         }
@@ -461,17 +344,14 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
     auto const patch_files = load_dir->GetFiles();
     for (auto const& f : patch_files) {
         auto const name = f->GetName();
-        if (name.starts_with("cheat_") &&
-            std::find(disabled.cbegin(), disabled.cend(), name) == disabled.cend()) {
+        if (name.starts_with("cheat_") && std::find(disabled.cbegin(), disabled.cend(), name) == disabled.cend()) {
             std::vector<u8> data(f->GetSize());
             if (f->Read(data.data(), data.size()) == data.size()) {
                 const Core::Memory::TextCheatParser parser;
-                auto const res = parser.Parse(
-                    std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
+                auto const res = parser.Parse(std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
                 std::copy(res.begin(), res.end(), std::back_inserter(out));
             } else {
-                LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}",
-                         title_id);
+                LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}", title_id);
             }
         }
     }
@@ -567,12 +447,8 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
     auto romfs = base_romfs;
 
     // Game Updates
-    std::optional<u64> selected_update_tid =
-        ChooseUpdateVariant(content_provider, title_id, type, fs_controller);
-    if (!selected_update_tid.has_value()) {
-        selected_update_tid = GetUpdateTitleID(title_id);
-    }
-    const auto update_raw = content_provider.GetEntryRaw(*selected_update_tid, type);
+    const auto update_tid = GetUpdateTitleID(title_id);
+    const auto update_raw = content_provider.GetEntryRaw(update_tid, type);
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
@@ -582,45 +458,18 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
         const auto new_nca = std::make_shared<NCA>(update_raw, base_nca);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
-            const auto ver_num = content_provider.GetEntryVersion(*selected_update_tid).value_or(0);
-            LOG_DEBUG(Loader, " RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(ver_num));
+            LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
+                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
-        } else {
-            LOG_WARNING(Loader, " RomFS: Update NCA is not valid");
-        }
-    } else if (!update_disabled && base_nca != nullptr) {
-        ContentRecordType alt_type = type;
-
-        if (type == ContentRecordType::Program) {
-            alt_type = ContentRecordType::Data;
-        } else if (type == ContentRecordType::Data) {
-            alt_type = ContentRecordType::Program;
-        }
-
-        if (alt_type != type) {
-            const auto alt_update_raw =
-                content_provider.GetEntryRaw(*selected_update_tid, alt_type);
-            if (alt_update_raw != nullptr) {
-                const auto new_nca = std::make_shared<NCA>(alt_update_raw, base_nca);
-                if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
-                    new_nca->GetRomFS() != nullptr) {
-                    LOG_DEBUG(Loader, "    RomFS: Update (fallback {}) applied successfully",
-                             alt_type == ContentRecordType::Data ? "DATA" : "PROGRAM");
-                    romfs = new_nca->GetRomFS();
-                } else {
-                    LOG_WARNING(Loader, "    RomFS: Update (fallback) NCA is not valid");
-                }
-            }
+            const auto version =
+                FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0));
         }
     } else if (!update_disabled && packed_update_raw != nullptr && base_nca != nullptr) {
         const auto new_nca = std::make_shared<NCA>(packed_update_raw, base_nca);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
-            LOG_DEBUG(Loader, "    RomFS: Update (PACKED) applied successfully");
+            LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
             romfs = new_nca->GetRomFS();
-        } else {
-            LOG_WARNING(Loader, "    RomFS: Update (PACKED) NCA is not valid");
         }
     }
 
@@ -640,86 +489,36 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
     std::vector<Patch> out;
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
-    auto variant_tids =
-        EnumerateUpdateVariants(content_provider, title_id, ContentRecordType::Program);
-    {
-        auto data_tids =
-            EnumerateUpdateVariants(content_provider, title_id, ContentRecordType::Data);
-        variant_tids.insert(variant_tids.end(), data_tids.begin(), data_tids.end());
-        auto control_tids =
-            EnumerateUpdateVariants(content_provider, title_id, ContentRecordType::Control);
-        variant_tids.insert(variant_tids.end(), control_tids.begin(), control_tids.end());
-        std::sort(variant_tids.begin(), variant_tids.end());
-        variant_tids.erase(std::unique(variant_tids.begin(), variant_tids.end()),
-                           variant_tids.end());
-    }
+    // Game Updates
+    const auto update_tid = GetUpdateTitleID(title_id);
+    PatchManager update{update_tid, fs_controller, content_provider};
+    const auto metadata = update.GetControlMetadata();
+    const auto& nacp = metadata.first;
 
-    if (!variant_tids.empty()) {
-        const auto update_disabled =
-            std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+    const auto update_disabled =
+        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+    Patch update_patch = {.enabled = !update_disabled,
+                          .name = "Update",
+                          .version = "",
+                          .type = PatchType::Update,
+                          .program_id = title_id,
+                          .title_id = title_id};
 
-        out.push_back({.enabled = !update_disabled,
-                       .name = "Update",
-                       .version = "",
-                       .type = PatchType::Update,
-                       .program_id = title_id,
-                       .title_id = title_id});
-
-        std::optional<u64> selected_variant_tid;
-        if (!update_disabled) {
-            const bool has_pref = HasVariantPreference(Settings::values.disabled_addons[title_id]);
-            if (has_pref) {
-                selected_variant_tid = ChooseUpdateVariant(
-                    content_provider, title_id, ContentRecordType::Program, fs_controller);
+    if (nacp != nullptr) {
+        update_patch.version = nacp->GetVersionString();
+        out.push_back(update_patch);
+    } else {
+        if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = content_provider.GetEntryVersion(update_tid);
+            if (meta_ver.value_or(0) == 0) {
+                out.push_back(update_patch);
             } else {
-                selected_variant_tid = GetUpdateTitleID(title_id);
+                update_patch.version = FormatTitleVersion(*meta_ver);
+                out.push_back(update_patch);
             }
-        }
-
-        std::vector<std::pair<std::string, u64>> variant_labels;
-        variant_labels.reserve(variant_tids.size());
-
-        for (const auto tid : variant_tids) {
-            variant_labels.emplace_back(GetUpdateVersionLabel(tid, fs_controller, content_provider),
-                                        tid);
-        }
-
-        std::sort(variant_labels.begin(), variant_labels.end(),
-                  [this](auto const& a, auto const& b) {
-                      const auto va = content_provider.GetEntryVersion(a.second).value_or(0);
-                      const auto vb = content_provider.GetEntryVersion(b.second).value_or(0);
-
-                      if (va != vb)
-                          return va > vb;
-
-                      const auto ca = ParseVersionComponents(a.first);
-                      const auto cb = ParseVersionComponents(b.first);
-
-                      if (ca != cb)
-                          return ca > cb;
-
-                      return a.first > b.first;
-                  });
-
-        std::set<std::string> seen_versions;
-        for (const auto& [label, tid] : variant_labels) {
-            std::string version = label;
-            if (!version.empty() && (version.front() == 'v' || version.front() == 'V')) {
-                version.erase(version.begin());
-            }
-            if (seen_versions.find(version) != seen_versions.end()) {
-                continue;
-            }
-            const bool is_selected =
-                selected_variant_tid.has_value() && tid == *selected_variant_tid;
-            const bool variant_disabled = update_disabled || !is_selected;
-            out.push_back({.enabled = !variant_disabled,
-                           .name = "Update",
-                           .version = version,
-                           .type = PatchType::Update,
-                           .program_id = title_id,
-                           .title_id = tid});
-            seen_versions.insert(version);
+        } else if (update_raw != nullptr) {
+            update_patch.version = "PACKED";
+            out.push_back(update_patch);
         }
     }
 

src/core/file_sys/registered_cache.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -211,7 +208,6 @@ enum class ContentProviderUnionSlot {
     UserNAND,       ///< User NAND
     SDMC,           ///< SD Card
     FrontendManual, ///< Frontend-defined game list or similar
-    External        ///< External Updates/DLCs (not installed to NAND)
 };
 
 // Combines multiple ContentProvider(s) (i.e. SysNAND, UserNAND, SDMC) into one interface.

src/core/file_sys/vfs/vfs_real.cpp

@@ -203,7 +203,7 @@ std::unique_lock<std::mutex> RealVfsFilesystem::RefreshReference(const std::stri
                                                                  FileReference& reference) {
     std::unique_lock lk{list_lock};
 
-    // Temporarily remove from list (regardless of the current list).
+    // Temporarily remove from list.
     this->RemoveReferenceFromListLocked(reference);
 
     // Restore file if needed.
@@ -211,8 +211,7 @@ std::unique_lock<std::mutex> RealVfsFilesystem::RefreshReference(const std::stri
         this->EvictSingleReferenceLocked();
 
         reference.file =
-            FS::FileOpen(path, ModeFlagsToFileAccessMode(perms), FS::FileType::BinaryFile,
-                         FS::FileShareFlag::ShareReadWrite);
+            FS::FileOpen(path, ModeFlagsToFileAccessMode(perms), FS::FileType::BinaryFile);
         if (reference.file) {
             num_open_files++;
         }
@@ -227,7 +226,7 @@ std::unique_lock<std::mutex> RealVfsFilesystem::RefreshReference(const std::stri
 void RealVfsFilesystem::DropReference(std::unique_ptr<FileReference>&& reference) {
     std::scoped_lock lk{list_lock};
 
-    // Remove from list if present.
+    // Remove from list.
     this->RemoveReferenceFromListLocked(*reference);
 
     // Close the file.
@@ -237,19 +236,6 @@ void RealVfsFilesystem::DropReference(std::unique_ptr<FileReference>&& reference
     }
 }
 
-void RealVfsFilesystem::CloseReference(FileReference& reference) {
-    std::scoped_lock lk{list_lock};
-    if (!reference.file) {
-        return;
-    }
-    this->RemoveReferenceFromListLocked(reference);
-    reference.file.reset();
-    if (num_open_files > 0) {
-        num_open_files--;
-    }
-    this->InsertReferenceIntoListLocked(reference);
-}
-
 void RealVfsFilesystem::EvictSingleReferenceLocked() {
     if (num_open_files < MaxOpenFiles || open_references.empty()) {
         return;
@@ -270,18 +256,6 @@ void RealVfsFilesystem::EvictSingleReferenceLocked() {
 }
 
 void RealVfsFilesystem::InsertReferenceIntoListLocked(FileReference& reference) {
-    // Ensure the node is not already linked to any list before inserting.
-    if (reference.IsLinked()) {
-        // Unlink from the list it currently belongs to.
-        if (reference.file) {
-            open_references.erase(open_references.iterator_to(reference));
-        }
-
-        if (reference.IsLinked()) {
-            closed_references.erase(closed_references.iterator_to(reference));
-        }
-    }
-
     if (reference.file) {
         open_references.push_front(reference);
     } else {
@@ -290,17 +264,9 @@ void RealVfsFilesystem::InsertReferenceIntoListLocked(FileReference& reference)
 }
 
 void RealVfsFilesystem::RemoveReferenceFromListLocked(FileReference& reference) {
-    // Unlink from whichever list the node currently belongs to, if any.
-    if (!reference.IsLinked()) {
-        return;
-    }
-
-    // Erase from the correct list to avoid cross-list corruption.
     if (reference.file) {
         open_references.erase(open_references.iterator_to(reference));
-    }
-
-    if(reference.IsLinked()) {
+    } else {
         closed_references.erase(closed_references.iterator_to(reference));
     }
 }
@@ -330,19 +296,13 @@ std::size_t RealVfsFile::GetSize() const {
         return *size;
     }
     auto lk = base.RefreshReference(path, perms, *reference);
-    const auto result = reference->file ? reference->file->GetSize() : 0;
-    lk.unlock();
-    base.CloseReference(*reference);
-    return result;
+    return reference->file ? reference->file->GetSize() : 0;
 }
 
 bool RealVfsFile::Resize(std::size_t new_size) {
     size.reset();
     auto lk = base.RefreshReference(path, perms, *reference);
-    const bool ok = reference->file ? reference->file->SetSize(new_size) : false;
-    lk.unlock();
-    base.CloseReference(*reference);
-    return ok;
+    return reference->file ? reference->file->SetSize(new_size) : false;
 }
 
 VirtualDir RealVfsFile::GetContainingDirectory() const {
@@ -358,37 +318,20 @@ bool RealVfsFile::IsReadable() const {
 }
 
 std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const {
-    if (length != 0 && data == nullptr) {
-        LOG_ERROR(Common_Filesystem,
-                  "RealVfsFile::Read called with null buffer (len={}, off={}, path={})",
-                  length, offset, path);
-        return 0;
-    }
-
     auto lk = base.RefreshReference(path, perms, *reference);
     if (!reference->file || !reference->file->Seek(static_cast<s64>(offset))) {
-        lk.unlock();
-        base.CloseReference(*reference);
         return 0;
     }
-    const auto read = reference->file->ReadSpan(std::span{data, length});
-    lk.unlock();
-    base.CloseReference(*reference);
-    return read;
+    return reference->file->ReadSpan(std::span{data, length});
 }
 
 std::size_t RealVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) {
     size.reset();
     auto lk = base.RefreshReference(path, perms, *reference);
     if (!reference->file || !reference->file->Seek(static_cast<s64>(offset))) {
-        lk.unlock();
-        base.CloseReference(*reference);
         return 0;
     }
-    const auto written = reference->file->WriteSpan(std::span{data, length});
-    lk.unlock();
-    base.CloseReference(*reference);
-    return written;
+    return reference->file->WriteSpan(std::span{data, length});
 }
 
 bool RealVfsFile::Rename(std::string_view name) {

src/core/file_sys/vfs/vfs_real.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -61,7 +58,6 @@ private:
     std::unique_lock<std::mutex> RefreshReference(const std::string& path, OpenMode perms,
                                                   FileReference& reference);
     void DropReference(std::unique_ptr<FileReference>&& reference);
-    void CloseReference(FileReference& reference);
 
 private:
     friend class RealVfsDirectory;

src/core/hle/kernel/k_priority_queue.h

@@ -15,7 +15,6 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "common/concepts.h"
 
 namespace Kernel {
 
@@ -24,7 +23,7 @@ class KThread;
 template <typename T>
 concept KPriorityQueueAffinityMask = !
 std::is_reference_v<T>&& requires(T& t) {
-                             { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
+                             { t.GetAffinityMask() } -> std::convertible_to<u64>;
                              { t.SetAffinityMask(0) };
 
                              { t.GetAffinity(0) } -> std::same_as<bool>;
@@ -50,9 +49,9 @@ std::is_reference_v<T>&& requires(T& t) {
                                  std::remove_cvref_t<decltype(t.GetAffinityMask())>()
                                  } -> KPriorityQueueAffinityMask;
 
-                             { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
-                             { t.GetPriority() } -> Common::ConvertibleTo<s32>;
-                             { t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
+                             { t.GetActiveCore() } -> std::convertible_to<s32>;
+                             { t.GetPriority() } -> std::convertible_to<s32>;
+                             { t.IsDummyThread() } -> std::convertible_to<bool>;
                          };
 
 template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>

src/core/hle/kernel/k_process.cpp

@@ -28,9 +28,6 @@ namespace Kernel {
 
 namespace {
 
-// TODO: Remove this workaround when proper ASLR is implemented for all address spaces.
-constexpr u64 CodeStartOffset = 0x500000UL;
-
 Result TerminateChildren(KernelCore& kernel, KProcess* process,
                          const KThread* thread_to_not_terminate) {
     // Request that all children threads terminate.
@@ -1157,7 +1154,7 @@ KProcess::KProcess(KernelCore& kernel)
 KProcess::~KProcess() = default;
 
 Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
-                                  KProcessAddress aslr_space_start, bool is_hbl) {
+    KProcessAddress aslr_space_start, size_t aslr_space_offset, bool is_hbl) {
     // Create a resource limit for the process.
     const auto pool = static_cast<KMemoryManager::Pool>(metadata.GetPoolPartition());
     const auto physical_memory_size = m_kernel.MemoryManager().GetSize(pool);
@@ -1187,25 +1184,24 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
     // Set the address space type and code address.
     switch (metadata.GetAddressSpaceType()) {
     case FileSys::ProgramAddressSpaceType::Is39Bit:
-        flag |= Svc::CreateProcessFlag::AddressSpace64Bit;
-
         // For 39-bit processes, the ASLR region starts at 0x800'0000 and is ~512GiB large.
         // However, some (buggy) programs/libraries like skyline incorrectly depend on the
         // existence of ASLR pages before the entry point, so we will adjust the load address
         // to point to about 2GiB into the ASLR region.
-        code_address = 0x8000'0000;
+        flag |= Svc::CreateProcessFlag::AddressSpace64Bit;
+        code_address = 0x8000'0000 + aslr_space_offset;
         break;
     case FileSys::ProgramAddressSpaceType::Is36Bit:
         flag |= Svc::CreateProcessFlag::AddressSpace64BitDeprecated;
-        code_address = 0x800'0000;
+        code_address = 0x800'0000 + aslr_space_offset;
         break;
     case FileSys::ProgramAddressSpaceType::Is32Bit:
         flag |= Svc::CreateProcessFlag::AddressSpace32Bit;
-        code_address = 0x20'0000 + CodeStartOffset;
+        code_address = 0x20'0000 + aslr_space_offset;
         break;
     case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
         flag |= Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias;
-        code_address = 0x20'0000 + CodeStartOffset;
+        code_address = 0x20'0000 + aslr_space_offset;
         break;
     }
 

src/core/hle/kernel/k_process.h

@@ -511,7 +511,7 @@ public:
 
 public:
     Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
-                            KProcessAddress aslr_space_start, bool is_hbl);
+        KProcessAddress aslr_space_start, size_t aslr_space_offset, bool is_hbl);
 
     void LoadModule(CodeSet code_set, KProcessAddress base_addr);
 

src/core/hle/kernel/physical_core.cpp

@@ -103,12 +103,26 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) {
         const bool data_abort = True(hr & Core::HaltReason::DataAbort);
         const bool interrupt = True(hr & Core::HaltReason::BreakLoop);
 
+        bool may_abort = true; // Ignore aborting virtual functions (for debugging)
+        if (prefetch_abort && ::Settings::values.vtable_bouncing) {
+            auto& lock = m_kernel.GlobalSchedulerContext().SchedulerLock();
+            lock.Lock();
+            Kernel::Svc::ThreadContext ctx;
+            interface->GetContext(ctx);
+            LOG_WARNING(Core_ARM, "vtable bouncing {:016X}", ctx.lr);
+            ctx.pc = ctx.lr;
+            ctx.r[0] = 0;
+            interface->SetContext(ctx);
+            lock.Unlock();
+            may_abort = false;
+        }
+
         // Since scheduling may occur here, we cannot use any cached
         // state after returning from calls we make.
 
         // Notify the debugger and go to sleep if a breakpoint was hit,
         // or if the thread is unable to continue for any reason.
-        if (breakpoint || prefetch_abort) {
+        if (breakpoint || (prefetch_abort && may_abort)) {
             if (breakpoint) {
                 interface->RewindBreakpointInstruction();
             }

src/core/hle/kernel/svc.h

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-late
 
 // This file is automatically generated using svc_generator.py.
+// DO NOT MODIFY IT MANUALLY
 
 #pragma once
 
@@ -16,8 +19,6 @@ class System;
 #include "core/hle/result.h"
 
 namespace Kernel::Svc {
-
-// clang-format off
 Result SetHeapSize(Core::System& system, uint64_t* out_address, uint64_t size);
 Result SetMemoryPermission(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm);
 Result SetMemoryAttribute(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr);
@@ -506,8 +507,6 @@ enum class SvcId : u32 {
     MapInsecureMemory = 0x90,
     UnmapInsecureMemory = 0x91,
 };
-// clang-format on
-
 // Custom ABI.
 Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args);
 Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args);

src/core/hle/service/acc/profile_manager.cpp

@@ -7,8 +7,6 @@
 #include <algorithm>
 #include <cstring>
 #include <filesystem>
-#include <iostream>
-#include <random>
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/find.hpp>
@@ -18,11 +16,11 @@
 #include "common/fs/fs.h"
 #include "common/fs/fs_types.h"
 #include "common/fs/path_util.h"
+#include "common/fs/symlink.h"
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include <ranges>
 
 namespace Service::Account {
 
@@ -492,6 +490,32 @@ void ProfileManager::ResetUserSaveFile()
     ParseUserSaveFile();
 }
 
+std::vector<UUID> ProfileManager::FindExistingProfileUUIDs()
+{
+    std::vector<UUID> uuids;
+    for (const ProfileInfo& p : profiles) {
+        auto uuid = p.user_uuid;
+        if (!uuid.IsInvalid()) {
+            uuids.emplace_back(uuid);
+        }
+    }
+
+    return uuids;
+}
+
+std::vector<std::string> ProfileManager::FindExistingProfileStrings()
+{
+    std::vector<UUID> uuids = FindExistingProfileUUIDs();
+    std::vector<std::string> uuid_strings;
+
+    for (const UUID &uuid : uuids) {
+        auto user_id = uuid.AsU128();
+        uuid_strings.emplace_back(fmt::format("{:016X}{:016X}", user_id[1], user_id[0]));
+    }
+
+    return uuid_strings;
+}
+
 std::vector<std::string> ProfileManager::FindGoodProfiles()
 {
     namespace fs = std::filesystem;
@@ -501,31 +525,17 @@ std::vector<std::string> ProfileManager::FindGoodProfiles()
     const auto path = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir)
                       / "user/save/0000000000000000";
 
-    // some exceptions because certain games just LOVE TO CAUSE ISSUES
-    static constexpr const std::array<const char* const, 2> EXCEPTION_UUIDS
-        = {"5755CC2A545A87128500000000000000", "00000000000000000000000000000000"};
+    // some exceptions, e.g. the "system" profile
+    static constexpr const std::array<const char* const, 1> EXCEPTION_UUIDS
+        = {"00000000000000000000000000000000"};
 
     for (const char *const uuid : EXCEPTION_UUIDS) {
         if (fs::exists(path / uuid))
             good_uuids.emplace_back(uuid);
     }
 
-    for (const ProfileInfo& p : profiles) {
-        std::string uuid_string = [p]() -> std::string {
-            auto uuid = p.user_uuid;
-
-            // "ignore" invalid uuids
-            if (uuid.IsInvalid()) {
-                return "0";
-            }
-
-            auto user_id = uuid.AsU128();
-
-            return fmt::format("{:016X}{:016X}", user_id[1], user_id[0]);
-        }();
-
-        if (uuid_string != "0") good_uuids.emplace_back(uuid_string);
-    }
+    auto existing = FindExistingProfileStrings();
+    good_uuids.insert(good_uuids.end(), existing.begin(), existing.end());
 
     return good_uuids;
 }
@@ -562,7 +572,8 @@ std::vector<std::string> ProfileManager::FindOrphanedProfiles()
                             override = true;
 
                         // if there are any regular files (NOT directories) there, do NOT delete it :p
-                        if (file.is_regular_file())
+                        // Also: check for symlinks
+                        if (file.is_regular_file() || Common::FS::IsSymlink(file.path()))
                             return false;
                     }
                 } catch (const fs::filesystem_error& e) {

src/core/hle/service/acc/profile_manager.h

@@ -105,6 +105,8 @@ public:
 
     void ResetUserSaveFile();
 
+    std::vector<Common::UUID> FindExistingProfileUUIDs();
+    std::vector<std::string> FindExistingProfileStrings();
     std::vector<std::string> FindGoodProfiles();
     std::vector<std::string> FindOrphanedProfiles();
 

src/core/hle/service/am/service/common_state_getter.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -30,8 +33,8 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {8, D<&ICommonStateGetter::GetBootMode>, "GetBootMode"},
         {9, D<&ICommonStateGetter::GetCurrentFocusState>, "GetCurrentFocusState"},
         {10, D<&ICommonStateGetter::RequestToAcquireSleepLock>, "RequestToAcquireSleepLock"},
-        {11, nullptr, "ReleaseSleepLock"},
-        {12, nullptr, "ReleaseSleepLockTransiently"},
+        {11, D<&ICommonStateGetter::ReleaseSleepLock>, "ReleaseSleepLock"},
+        {12, D<&ICommonStateGetter::ReleaseSleepLockTransiently>, "ReleaseSleepLockTransiently"},
         {13, D<&ICommonStateGetter::GetAcquiredSleepLockEvent>, "GetAcquiredSleepLockEvent"},
         {14, nullptr, "GetWakeupCount"},
         {20, nullptr, "PushToGeneralChannel"},
@@ -112,6 +115,20 @@ Result ICommonStateGetter::RequestToAcquireSleepLock() {
     R_SUCCEED();
 }
 
+Result ICommonStateGetter::ReleaseSleepLock() {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    m_applet->sleep_lock_event.Clear();
+    R_SUCCEED();
+}
+
+Result ICommonStateGetter::ReleaseSleepLockTransiently() {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    m_applet->sleep_lock_event.Clear();
+    R_SUCCEED();
+}
+
 Result ICommonStateGetter::GetAcquiredSleepLockEvent(
     OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_WARNING(Service_AM, "called");

src/core/hle/service/am/service/common_state_getter.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,6 +32,8 @@ private:
     Result ReceiveMessage(Out<AppletMessage> out_applet_message);
     Result GetCurrentFocusState(Out<FocusState> out_focus_state);
     Result RequestToAcquireSleepLock();
+    Result ReleaseSleepLock();
+    Result ReleaseSleepLockTransiently();
     Result GetAcquiredSleepLockEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetReaderLockAccessorEx(Out<SharedPointer<ILockAccessor>> out_lock_accessor,
                                    u32 button_type);

src/core/hle/service/filesystem/filesystem.cpp

@@ -1,11 +1,7 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <utility>
-#include <filesystem>
 
 #include "common/assert.h"
 #include "common/fs/fs.h"
@@ -16,7 +12,6 @@
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/errors.h"
-#include "core/file_sys/external_content_index.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
@@ -718,36 +713,6 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
         system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
                                        sdmc_factory->GetSDMCContents());
     }
-
-    if (external_provider == nullptr) {
-        external_provider = std::make_unique<FileSys::ManualContentProvider>();
-        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::External,
-                                       external_provider.get());
-    }
-
-    RebuildExternalContentIndex();
-}
-
-void FileSystemController::RebuildExternalContentIndex() {
-    if (external_provider == nullptr) {
-        LOG_WARNING(Service_FS, "External provider not initialized, skipping re-index.");
-        return;
-    }
-
-    if (!Settings::values.external_dirs.empty()) {
-        FileSys::ExternalContentPaths paths{};
-        for (const auto& dir : Settings::values.external_dirs) {
-            if (dir.empty())
-                continue;
-            paths.update_dirs.push_back(dir);
-            paths.dlc_dirs.push_back(dir);
-        }
-        FileSys::ExternalContentIndexer indexer{system.GetFilesystem(), *this->external_provider,
-                                                std::move(paths)};
-        indexer.Rebuild();
-    } else {
-        external_provider->ClearAllEntries();
-    }
 }
 
 void FileSystemController::Reset() {

src/core/hle/service/filesystem/filesystem.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,7 +5,6 @@
 
 #include <memory>
 #include <mutex>
-#include <core/file_sys/registered_cache.h>
 #include "common/common_types.h"
 #include "core/file_sys/fs_directory.h"
 #include "core/file_sys/fs_filesystem.h"
@@ -125,8 +121,6 @@ public:
     // above is called.
     void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite = true);
 
-    void RebuildExternalContentIndex();
-
     void Reset();
 
 private:
@@ -147,7 +141,6 @@ private:
     std::unique_ptr<FileSys::XCI> gamecard;
     std::unique_ptr<FileSys::RegisteredCache> gamecard_registered;
     std::unique_ptr<FileSys::PlaceholderCache> gamecard_placeholder;
-    std::unique_ptr<FileSys::ManualContentProvider> external_provider;
 
     Core::System& system;
 };

src/core/hle/service/sm/sm.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,8 +11,8 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
+#include <concepts>
 
-#include "common/concepts.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/result.h"
@@ -63,7 +66,7 @@ public:
     Result UnregisterService(const std::string& name);
     Result GetServicePort(Kernel::KClientPort** out_client_port, const std::string& name);
 
-    template <Common::DerivedFrom<SessionRequestHandler> T>
+    template <std::derived_from<SessionRequestHandler> T>
     std::shared_ptr<T> GetService(const std::string& service_name, bool block = false) const {
         auto service = registered_services.find(service_name);
         if (service == registered_services.end() && !block) {

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -19,6 +19,10 @@
 #include "core/internal_network/network.h"
 #include "core/internal_network/sockets.h"
 
+#ifdef YUZU_BUNDLED_OPENSSL
+#include <openssl/cert.h>
+#endif
+
 using namespace Common::FS;
 
 namespace Service::SSL {
@@ -41,11 +45,85 @@ void OneTimeInit();
 void OneTimeInitLogFile();
 bool OneTimeInitBIO();
 
+#ifdef YUZU_BUNDLED_OPENSSL
+// This is ported from httplib
+struct scope_exit {
+  explicit scope_exit(std::function<void(void)> &&f)
+      : exit_function(std::move(f)), execute_on_destruction{true} {}
+
+  scope_exit(scope_exit &&rhs) noexcept
+      : exit_function(std::move(rhs.exit_function)),
+        execute_on_destruction{rhs.execute_on_destruction} {
+    rhs.release();
+  }
+
+  ~scope_exit() {
+    if (execute_on_destruction) { this->exit_function(); }
+  }
+
+  void release() { this->execute_on_destruction = false; }
+
+private:
+  scope_exit(const scope_exit &) = delete;
+  void operator=(const scope_exit &) = delete;
+  scope_exit &operator=(scope_exit &&) = delete;
+
+  std::function<void(void)> exit_function;
+  bool execute_on_destruction;
+};
+
+inline X509_STORE *CreateCaCertStore(const char *ca_cert,
+                                                    std::size_t size) {
+    auto mem = BIO_new_mem_buf(ca_cert, static_cast<int>(size));
+    auto se = scope_exit([&] { BIO_free_all(mem); });
+    if (!mem) { return nullptr; }
+
+    auto inf = PEM_X509_INFO_read_bio(mem, nullptr, nullptr, nullptr);
+    if (!inf) { return nullptr; }
+
+    auto cts = X509_STORE_new();
+    if (cts) {
+        for (auto i = 0; i < static_cast<int>(sk_X509_INFO_num(inf)); i++) {
+            auto itmp = sk_X509_INFO_value(inf, i);
+            if (!itmp) { continue; }
+
+            if (itmp->x509) { X509_STORE_add_cert(cts, itmp->x509); }
+            if (itmp->crl) { X509_STORE_add_crl(cts, itmp->crl); }
+        }
+    }
+
+    sk_X509_INFO_pop_free(inf, X509_INFO_free);
+    return cts;
+}
+
+inline void SetCaCertStore(SSL_CTX *ctx, X509_STORE *ca_cert_store) {
+    if (ca_cert_store) {
+        if (ctx) {
+            if (SSL_CTX_get_cert_store(ctx) != ca_cert_store) {
+                // Free memory allocated for old cert and use new store `ca_cert_store`
+                SSL_CTX_set_cert_store(ctx, ca_cert_store);
+            }
+        } else {
+            X509_STORE_free(ca_cert_store);
+        }
+    }
+}
+
+inline void LoadCaCertStore(SSL_CTX* ctx, const char* ca_cert, std::size_t size)
+{
+    SetCaCertStore(ctx, CreateCaCertStore(ca_cert, size));
+}
+#endif
+
 } // namespace
 
 class SSLConnectionBackendOpenSSL final : public SSLConnectionBackend {
 public:
     Result Init() {
+        // on bundled OpenSSL, load ca cert store
+#ifdef YUZU_BUNDLED_OPENSSL
+        LoadCaCertStore(ssl_ctx, kCert, sizeof(kCert));
+#endif
         std::call_once(one_time_init_flag, OneTimeInit);
 
         if (!one_time_init_success) {

src/core/loader/deconstructed_rom_directory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -223,8 +226,13 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     // Add patch size to the total module size
     code_size += patch_ctx.GetTotalPatchSize();
 
+    // TODO: this is bad form of ASLR, it sucks
+    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue()
+        : std::rand()) * 0x734287f27) & 0xfff000;
+
     // Setup the process code layout
-    if (process.LoadFromMetadata(metadata, code_size, fastmem_base, is_hbl).IsError()) {
+    if (process.LoadFromMetadata(metadata, code_size, fastmem_base, aslr_offset, is_hbl).IsError()) {
         return {ResultStatus::ErrorUnableToParseKernelMetadata, {}};
     }
 

src/core/loader/kip.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <cstring>
+#include "common/settings.h"
 #include "core/file_sys/kernel_executable.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
@@ -76,11 +77,10 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
     Kernel::CodeSet codeset;
     Kernel::PhysicalMemory program_image;
 
-    const auto load_segment = [&program_image](Kernel::CodeSet::Segment& segment,
-                                               const std::vector<u8>& data, u32 offset) {
+    const auto load_segment = [&program_image](Kernel::CodeSet::Segment& segment, const std::vector<u8>& data, u32 offset) {
         segment.addr = offset;
         segment.offset = offset;
-        segment.size = PageAlignSize(static_cast<u32>(data.size()));
+        segment.size = PageAlignSize(u32(data.size()));
         program_image.resize(offset + data.size());
         std::memcpy(program_image.data() + offset, data.data(), data.size());
     };
@@ -92,10 +92,14 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
     program_image.resize(PageAlignSize(kip->GetBSSOffset()) + kip->GetBSSSize());
     codeset.DataSegment().size += kip->GetBSSSize();
 
+    // TODO: this is bad form of ASLR, it sucks
+    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue()
+        : std::rand()) * 0x734287f27) & 0xfff000;
+
     // Setup the process code layout
     if (process
-            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size(), 0,
-                              false)
+            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size(), 0, aslr_offset, false)
             .IsError()) {
         return {ResultStatus::ErrorNotInitialized, {}};
     }

src/core/loader/loader.cpp

@@ -8,6 +8,7 @@
 #include <optional>
 #include <ostream>
 #include <string>
+#include <concepts>
 #include "common/concepts.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
@@ -27,7 +28,7 @@ namespace Loader {
 
 namespace {
 
-template <Common::DerivedFrom<AppLoader> T>
+template <std::derived_from<AppLoader> T>
 std::optional<FileType> IdentifyFileLoader(FileSys::VirtualFile file) {
     const auto file_type = T::IdentifyType(file);
     if (file_type != FileType::Error) {

src/core/loader/nro.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -237,10 +240,14 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
         return 0;
     }();
 
+    // TODO: this is bad form of ASLR, it sucks
+    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue()
+        : std::rand()) * 0x734287f27) & 0xfff000;
+
     // Setup the process code layout
     if (process
-            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), image_size, fastmem_base,
-                              false)
+            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), image_size, fastmem_base, aslr_offset, false)
             .IsError()) {
         return false;
     }

src/dynarmic/CMakeLists.txt

@@ -50,7 +50,6 @@ endif()
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
 
 # Arch detection
-include(DetectArchitecture)
 if (NOT DEFINED ARCHITECTURE)
     message(FATAL_ERROR "Unsupported architecture encountered. Ending CMake generation.")
 endif()

src/dynarmic/CMakeModules/DetectArchitecture.cmake

@@ -1,62 +0,0 @@
-include(CheckSymbolExists)
-
-if (CMAKE_OSX_ARCHITECTURES)
-    set(DYNARMIC_MULTIARCH_BUILD 1)
-    set(ARCHITECTURE "${CMAKE_OSX_ARCHITECTURES}")
-    return()
-endif()
-
-function(detect_architecture symbol arch)
-    if (NOT DEFINED ARCHITECTURE)
-        set(CMAKE_REQUIRED_QUIET YES)
-        check_symbol_exists("${symbol}" "" DETECT_ARCHITECTURE_${arch})
-        unset(CMAKE_REQUIRED_QUIET)
-
-        if (DETECT_ARCHITECTURE_${arch})
-            set(ARCHITECTURE "${arch}" PARENT_SCOPE)
-        endif()
-
-        unset(DETECT_ARCHITECTURE_${arch} CACHE)
-    endif()
-endfunction()
-
-detect_architecture("__ARM64__" arm64)
-detect_architecture("__aarch64__" arm64)
-detect_architecture("_M_ARM64" arm64)
-
-detect_architecture("__arm__" arm)
-detect_architecture("__TARGET_ARCH_ARM" arm)
-detect_architecture("_M_ARM" arm)
-
-detect_architecture("__x86_64" x86_64)
-detect_architecture("__x86_64__" x86_64)
-detect_architecture("__amd64" x86_64)
-detect_architecture("_M_X64" x86_64)
-
-detect_architecture("__i386" x86)
-detect_architecture("__i386__" x86)
-detect_architecture("_M_IX86" x86)
-
-detect_architecture("__ia64" ia64)
-detect_architecture("__ia64__" ia64)
-detect_architecture("_M_IA64" ia64)
-
-detect_architecture("__mips" mips)
-detect_architecture("__mips__" mips)
-detect_architecture("_M_MRX000" mips)
-
-detect_architecture("__ppc64__" ppc64)
-detect_architecture("__powerpc64__" ppc64)
-
-detect_architecture("__ppc__" ppc)
-detect_architecture("__ppc" ppc)
-detect_architecture("__powerpc__" ppc)
-detect_architecture("_ARCH_COM" ppc)
-detect_architecture("_ARCH_PWR" ppc)
-detect_architecture("_ARCH_PPC" ppc)
-detect_architecture("_M_MPPC" ppc)
-detect_architecture("_M_PPC" ppc)
-
-detect_architecture("__riscv" riscv)
-
-detect_architecture("__EMSCRIPTEN__" wasm)

src/dynarmic/src/dynarmic/backend/arm64/a32_interface.cpp

@@ -125,6 +125,10 @@ struct Jit::Impl final {
         current_state.exclusive_state = false;
     }
 
+    std::string Disassemble() const {
+        return {};
+    }
+
 private:
     void PerformRequestedCacheInvalidation(HaltReason hr) {
         if (Has(hr, HaltReason::CacheInvalidation)) {
@@ -231,4 +235,8 @@ void Jit::ClearExclusiveState() {
     impl->ClearExclusiveState();
 }
 
+std::string Jit::Disassemble() const {
+    return impl->Disassemble();
+}
+
 }  // namespace Dynarmic::A32

src/dynarmic/src/dynarmic/backend/arm64/a64_interface.cpp

@@ -152,7 +152,7 @@ struct Jit::Impl final {
     }
 
     std::string Disassemble() const {
-        UNREACHABLE();
+        return {};
     }
 
 private:

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_floating_point.cpp

@@ -468,8 +468,9 @@ void EmitIR<IR::Opcode::FPRoundInt32>(oaknut::CodeGenerator& code, EmitContext&
         case FP::RoundingMode::ToNearest_TieAwayFromZero:
             code.FRINTA(Sresult, Soperand);
             break;
+        default:
+            UNREACHABLE();
         }
-        UNREACHABLE();
     }
 }
 

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector.cpp

@@ -1668,8 +1668,9 @@ void EmitIR<IR::Opcode::VectorTableLookup64>(oaknut::CodeGenerator& code, EmitCo
             code.TBX(Dresult->B8(), oaknut::List{V0.B16(), V1.B16()}, Dindices->B8());
         }
         break;
+    default:
+        UNREACHABLE();
     }
-    UNREACHABLE();
 }
 
 template<>
@@ -1731,8 +1732,9 @@ void EmitIR<IR::Opcode::VectorTableLookup128>(oaknut::CodeGenerator& code, EmitC
             code.TBX(Qresult->B16(), oaknut::List{V0.B16(), V1.B16(), V2.B16(), V3.B16()}, Qindices->B16());
         }
         break;
+    default:
+        UNREACHABLE();
     }
-    UNREACHABLE();
 }
 
 template<>

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cpp

@@ -645,8 +645,9 @@ void EmitIR<IR::Opcode::FPVectorRoundInt32>(oaknut::CodeGenerator& code, EmitCon
             case FP::RoundingMode::ToNearest_TieAwayFromZero:
                 code.FRINTA(Qresult->S4(), Qoperand->S4());
                 break;
+            default:
+                UNREACHABLE();
             }
-            UNREACHABLE();
         }
     });
 }
@@ -684,8 +685,9 @@ void EmitIR<IR::Opcode::FPVectorRoundInt64>(oaknut::CodeGenerator& code, EmitCon
             case FP::RoundingMode::ToNearest_TieAwayFromZero:
                 code.FRINTA(Qresult->D2(), Qoperand->D2());
                 break;
+            default:
+                UNREACHABLE();
             }
-            UNREACHABLE();
         }
     });
 }

src/dynarmic/src/dynarmic/backend/arm64/reg_alloc.h

@@ -371,8 +371,9 @@ void RAReg<T>::Realize() {
     case RWType::ReadWrite:
         reg = T{reg_alloc.RealizeReadWriteImpl<kind>(read_value, write_value)};
         break;
+    default:
+        UNREACHABLE();
     }
-    UNREACHABLE();
 }
 
 }  // namespace Dynarmic::Backend::Arm64

src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp

@@ -188,15 +188,15 @@ private:
 ExceptionHandler::ExceptionHandler() = default;
 ExceptionHandler::~ExceptionHandler() = default;
 
-#if defined(MCL_ARCHITECTURE_X86_64)
+#if defined(ARCHITECTURE_x86_64)
 void ExceptionHandler::Register(X64::BlockOfCode& code) {
     impl = std::make_unique<Impl>(std::bit_cast<u64>(code.getCode()), code.GetTotalCodeSize());
 }
-#elif defined(MCL_ARCHITECTURE_ARM64)
+#elif defined(ARCHITECTURE_arm64)
 void ExceptionHandler::Register(oaknut::CodeBlock& mem, std::size_t size) {
     impl = std::make_unique<Impl>(std::bit_cast<u64>(mem.ptr()), size);
 }
-#elif defined(MCL_ARCHITECTURE_RISCV)
+#elif defined(ARCHITECTURE_riscv64)
 void ExceptionHandler::Register(RV64::CodeBlock& mem, std::size_t size) {
     impl = std::make_unique<Impl>(std::bit_cast<u64>(mem.ptr<u64>()), size);
 }

src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cpp

@@ -36,22 +36,8 @@
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/microinstruction.h"
 
-#define FCODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (fsize == 32) { \
-            code.NAME##s(args...);   \
-        } else {                     \
-            code.NAME##d(args...);   \
-        }                            \
-    }
-#define ICODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (fsize == 32) { \
-            code.NAME##d(args...);   \
-        } else {                     \
-            code.NAME##q(args...);   \
-        }                            \
-    }
+#define FCODE(NAME) [&](auto... args) { if (fsize == 32) code.NAME##s(args...); else code.NAME##d(args...); }
+#define ICODE(NAME) [&](auto... args) { if (fsize == 32) code.NAME##d(args...); else code.NAME##q(args...); }
 
 namespace Dynarmic::Backend::X64 {
 

src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp

@@ -36,22 +36,8 @@
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/microinstruction.h"
 
-#define FCODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (fsize == 32) { \
-            code.NAME##s(args...);   \
-        } else {                     \
-            code.NAME##d(args...);   \
-        }                            \
-    }
-#define ICODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (fsize == 32) { \
-            code.NAME##d(args...);   \
-        } else {                     \
-            code.NAME##q(args...);   \
-        }                            \
-    }
+#define FCODE(NAME) [&](auto... args) { if (fsize == 32) code.NAME##s(args...); else code.NAME##d(args...); }
+#define ICODE(NAME) [&](auto... args) { if (fsize == 32) code.NAME##d(args...); else code.NAME##q(args...); }
 
 namespace Dynarmic::Backend::X64 {
 

src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_saturation.cpp

@@ -14,23 +14,8 @@
 #include "dynarmic/ir/microinstruction.h"
 #include "dynarmic/ir/opcodes.h"
 
-#define FCODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (esize == 32) { \
-            code.NAME##s(args...);   \
-        } else {                     \
-            code.NAME##d(args...);   \
-        }                            \
-    }
-
-#define ICODE(NAME)                  \
-    [&code](auto... args) {          \
-        if constexpr (esize == 32) { \
-            code.NAME##d(args...);   \
-        } else {                     \
-            code.NAME##q(args...);   \
-        }                            \
-    }
+#define FCODE(NAME) [&](auto... args) { if (esize == 32) code.NAME##s(args...); else code.NAME##d(args...); }
+#define ICODE(NAME) [&](auto... args) { if (esize == 32) code.NAME##d(args...); else code.NAME##q(args...); }
 
 namespace Dynarmic::Backend::X64 {
 

src/dynarmic/src/dynarmic/common/context.h

@@ -72,6 +72,9 @@
 #    elif defined(__sun__)
 #        define CTX_RIP (mctx.gregs[REG_RIP])
 #        define CTX_RSP (mctx.gregs[REG_RSP])
+#    elif defined(__DragonFly__)
+#        define CTX_RIP (mctx.mc_rip)
+#        define CTX_RSP (mctx.mc_rsp)
 #    else
 #        error "Unknown platform"
 #    endif

src/dynarmic/src/dynarmic/ir/basic_block.cpp

@@ -44,13 +44,13 @@ Block::iterator Block::PrependNewInst(iterator insertion_point, Opcode opcode, s
     // hugely benefit from the coherency of faster allocations...
     IR::Inst* inst;
     if (inlined_inst.size() < inlined_inst.max_size()) {
-        inst = &inlined_inst[inlined_inst.size()];
         inlined_inst.emplace_back(opcode);
+        inst = &inlined_inst[inlined_inst.size() - 1];
     } else {
         if (pooled_inst.empty() || pooled_inst.back().size() == pooled_inst.back().max_size())
             pooled_inst.emplace_back();
-        inst = &pooled_inst.back()[pooled_inst.back().size()];
         pooled_inst.back().emplace_back(opcode);
+        inst = &pooled_inst.back()[pooled_inst.back().size() - 1];
     }
     DEBUG_ASSERT(args.size() == inst->NumArgs());
     std::for_each(args.begin(), args.end(), [&inst, index = size_t(0)](const auto& arg) mutable {

src/dynarmic/src/dynarmic/ir/opcodes.h

@@ -654,3 +654,11 @@ constexpr bool MayGetNZCVFromOp(const Opcode op) noexcept {
 }
 
 }  // namespace Dynarmic::IR
+
+template<>
+struct fmt::formatter<Dynarmic::IR::Opcode> : fmt::formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(Dynarmic::IR::Opcode op, FormatContext& ctx) const {
+        return formatter<std::string_view>::format(GetNameOf(op), ctx);
+    }
+};

src/dynarmic/tests/CMakeLists.txt

@@ -29,7 +29,6 @@ target_link_libraries(dynarmic_tests PRIVATE merry::oaknut)
 
 if (DYNARMIC_TESTS_USE_UNICORN)
     target_link_libraries(dynarmic_tests PRIVATE Unicorn::Unicorn)
-
     target_sources(dynarmic_tests PRIVATE
         fuzz_util.cpp
         fuzz_util.h

src/frontend_common/config.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -286,19 +283,6 @@ void Config::ReadDataStorageValues() {
 
     ReadCategory(Settings::Category::DataStorage);
 
-    Settings::values.external_dirs.clear();
-    const int num_dirs = BeginArray(std::string("external_dirs"));
-    Settings::values.external_dirs.reserve(num_dirs);
-    for (int i = 0; i < num_dirs; ++i) {
-        SetArrayIndex(i);
-        std::string dir = ReadStringSetting(std::string("path"), std::string(""));
-        if (!dir.empty()) {
-            Settings::values.external_dirs.emplace_back(std::move(dir));
-        }
-    }
-
-    EndArray();
-
     EndGroup();
 }
 
@@ -607,14 +591,6 @@ void Config::SaveDataStorageValues() {
 
     WriteCategory(Settings::Category::DataStorage);
 
-    BeginArray(std::string("external_dirs"));
-    for (std::size_t i = 0; i < Settings::values.external_dirs.size(); ++i) {
-        SetArrayIndex(static_cast<int>(i));
-        WriteStringSetting(std::string("path"), Settings::values.external_dirs[i],
-                           std::make_optional(std::string("")));
-    }
-    EndArray();
-
     EndGroup();
 }
 

src/qt_common/abstract/frontend.cpp

@@ -28,7 +28,7 @@ const QString GetOpenFileName(const QString &title,
                               Options options)
 {
 #ifdef YUZU_QT_WIDGETS
-    return QFileDialog::getOpenFileName((QWidget *) rootObject, title, dir, filter, selectedFilter, options);
+    return QFileDialog::getOpenFileName(rootObject, title, dir, filter, selectedFilter, options);
 #endif
 }
 
@@ -39,7 +39,14 @@ const QString GetSaveFileName(const QString &title,
                               Options options)
 {
 #ifdef YUZU_QT_WIDGETS
-    return QFileDialog::getSaveFileName((QWidget *) rootObject, title, dir, filter, selectedFilter, options);
+    return QFileDialog::getSaveFileName(rootObject, title, dir, filter, selectedFilter, options);
+#endif
+}
+
+const QString GetExistingDirectory(const QString& caption, const QString& dir,
+                             Options options) {
+#ifdef YUZU_QT_WIDGETS
+    return QFileDialog::getExistingDirectory(rootObject, caption, dir, options);
 #endif
 }
 

src/qt_common/abstract/frontend.h

@@ -135,5 +135,9 @@ const QString GetSaveFileName(const QString &title,
                               QString *selectedFilter = nullptr,
                               Options options = Options());
 
+const QString GetExistingDirectory(const QString &caption = QString(),
+                                    const QString &dir = QString(),
+                                    Options options = Option::ShowDirsOnly);
+
 } // namespace QtCommon::Frontend
 #endif // FRONTEND_H

src/qt_common/config/qt_config.cpp

@@ -294,6 +294,17 @@ void QtConfig::ReadUIGamelistValues() {
     }
     EndArray();
 
+    const int linked_size = BeginArray("ryujinx_linked");
+    for (int i = 0; i < linked_size; ++i) {
+        SetArrayIndex(i);
+
+        QDir ryu_dir = QString::fromStdString(ReadStringSetting("ryujinx_path"));
+        u64 program_id = ReadUnsignedIntegerSetting("program_id");
+
+        UISettings::values.ryujinx_link_paths.insert(program_id, ryu_dir);
+    }
+    EndArray();
+
     EndGroup();
 }
 
@@ -499,6 +510,21 @@ void QtConfig::SaveUIGamelistValues() {
     }
     EndArray(); // favorites
 
+    BeginArray(std::string("ryujinx_linked"));
+    int i = 0;
+    QMapIterator iter(UISettings::values.ryujinx_link_paths);
+
+    while (iter.hasNext()) {
+        iter.next();
+
+        SetArrayIndex(i);
+        WriteIntegerSetting("program_id", iter.key());
+        WriteStringSetting("ryujinx_path", iter.value().absolutePath().toStdString());
+        ++i;
+    }
+
+    EndArray(); // ryujinx
+
     EndGroup();
 }
 

src/qt_common/config/shared_translation.cpp

@@ -109,6 +109,10 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
               "cause deadlocks. A range of 77-21000 is recommended."));
     INSERT(Settings, cpu_backend, tr("Backend:"), QString());
 
+    INSERT(Settings, vtable_bouncing,
+        tr("Virtual Table Bouncing"),
+        tr("Bounces (by emulating a 0-valued return) any functions that triggers a prefetch abort"));
+
     // Cpu Debug
 
     // Cpu Unsafe

src/qt_common/config/shared_translation.h

@@ -28,54 +28,54 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject *parent);
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent);
 
 static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map = {
-    {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "None"))},
-    {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FXAA"))},
-    {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SMAA"))},
+    {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "None"))},
+    {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "FXAA"))},
+    {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "SMAA"))},
 };
 
 static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map = {
     {Settings::ScalingFilter::NearestNeighbor,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Nearest"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Nearest"))},
     {Settings::ScalingFilter::Bilinear,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
-    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
-    {Settings::ScalingFilter::ZeroTangent, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Zero-Tangent"))},
-    {Settings::ScalingFilter::BSpline, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "B-Spline"))},
-    {Settings::ScalingFilter::Mitchell, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Mitchell"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Bilinear"))},
+    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Bicubic"))},
+    {Settings::ScalingFilter::ZeroTangent, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Zero-Tangent"))},
+    {Settings::ScalingFilter::BSpline, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "B-Spline"))},
+    {Settings::ScalingFilter::Mitchell, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Mitchell"))},
      {Settings::ScalingFilter::Spline1,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Spline-1"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Spline-1"))},
     {Settings::ScalingFilter::Gaussian,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Gaussian"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Gaussian"))},
      {Settings::ScalingFilter::Lanczos,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Lanczos"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Lanczos"))},
     {Settings::ScalingFilter::ScaleForce,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
-    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
-    {Settings::ScalingFilter::Area, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Area"))},
-    {Settings::ScalingFilter::Mmpx, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "MMPX"))},
+     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "ScaleForce"))},
+    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "FSR"))},
+    {Settings::ScalingFilter::Area, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Area"))},
+    {Settings::ScalingFilter::Mmpx, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "MMPX"))},
 };
 
 static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {
-    {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Docked"))},
-    {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Handheld"))},
+    {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Docked"))},
+    {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Handheld"))},
 };
 
 static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map = {
-    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Normal"))},
-    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "High"))},
-    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Extreme"))},
+    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Normal"))},
+    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "High"))},
+    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Extreme"))},
 };
 
 static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map = {
-    {Settings::RendererBackend::Vulkan, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Vulkan"))},
-    {Settings::RendererBackend::OpenGL, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "OpenGL"))},
-    {Settings::RendererBackend::Null, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Null"))},
+    {Settings::RendererBackend::Vulkan, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Vulkan"))},
+    {Settings::RendererBackend::OpenGL, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "OpenGL"))},
+    {Settings::RendererBackend::Null, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Null"))},
 };
 
 static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map = {
-    {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},
-    {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},
-    {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},
+    {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "GLSL"))},
+    {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "GLASM"))},
+    {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "SPIRV"))},
 };
 
 } // namespace ConfigurationShared

src/qt_common/config/uisettings.h

@@ -14,6 +14,7 @@
 #include <QString>
 #include <QStringList>
 #include <QVector>
+#include <qdir.h>
 #include "common/common_types.h"
 #include "common/settings.h"
 #include "common/settings_enums.h"
@@ -201,6 +202,7 @@ struct Values {
     Setting<bool> cache_game_list{linkage, true, "cache_game_list", Category::UiGameList};
     Setting<bool> favorites_expanded{linkage, true, "favorites_expanded", Category::UiGameList};
     QVector<u64> favorited_ids;
+    QMap<u64, QDir> ryujinx_link_paths;
 
     // Compatibility List
     Setting<bool> show_compat{linkage, true, "show_compat", Category::UiGameList};

src/qt_common/qt_string_lookup.h

@@ -8,6 +8,12 @@
 #include "frozen/map.h"
 #include "frozen/string.h"
 
+/// Small helper to look up enums.
+/// res = the result code
+/// base = the base matching value in the StringKey table
+#define LOOKUP_ENUM(res, base) StringLookup::Lookup( \
+            static_cast<StringLookup::StringKey>((int) res + (int) StringLookup::base))
+
 namespace QtCommon::StringLookup {
 
 Q_NAMESPACE

src/qt_common/util/content.h

@@ -25,8 +25,7 @@ enum class FirmwareInstallResult {
 
 inline const QString GetFirmwareInstallResultString(FirmwareInstallResult result)
 {
-    return QtCommon::StringLookup::Lookup(static_cast<StringLookup::StringKey>(
-        (int) result + (int) QtCommon::StringLookup::FwInstallSuccess));
+    return LOOKUP_ENUM(result, FwInstallSuccess);
 }
 
 /**
@@ -36,9 +35,7 @@ inline const QString GetFirmwareInstallResultString(FirmwareInstallResult result
  */
 inline const QString GetKeyInstallResultString(FirmwareManager::KeyInstallResult result)
 {
-    // this can probably be made into a common function of sorts
-    return QtCommon::StringLookup::Lookup(static_cast<StringLookup::StringKey>(
-        (int) result + (int) QtCommon::StringLookup::KeyInstallSuccess));
+    return LOOKUP_ENUM(result, KeyInstallSuccess);
 }
 
 void InstallFirmware(const QString &location, bool recursive);