Remove saving the layout as it's no longer needed

Correct light theme loading
2021-06-03 21:47:00 +01:00 · 2021-06-03 18:37:22 +01:00
855 changed files with 40994 additions and 66361 deletions
--- a/.ci/scripts/common/post-upload.sh
+++ b/.ci/scripts/common/post-upload.sh
@@ -9,5 +9,11 @@ cp "${REV_NAME}-source.tar.xz" "$DIR_NAME"

 tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"

+mv "$DIR_NAME" $RELEASE_NAME
+mv "${REV_NAME}-source.tar.xz" $RELEASE_NAME
+
+7z a "$REV_NAME.7z" $RELEASE_NAME
+
 # move the compiled archive into the artifacts directory to be uploaded by travis releases
 mv "$ARCHIVE_NAME" "${ARTIFACTS_DIR}/"
+mv "$REV_NAME.7z" "${ARTIFACTS_DIR}/"
--- a/.ci/scripts/format/script.sh
+++ b/.ci/scripts/format/script.sh
@@ -7,7 +7,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi

 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-12
+CLANG_FORMAT=clang-format-10
 $CLANG_FORMAT --version

 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
--- a/.ci/scripts/linux/docker.sh
+++ b/.ci/scripts/linux/docker.sh
@@ -18,8 +18,7 @@ cmake .. \
      -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
      -DENABLE_QT_TRANSLATION=ON \
      -DUSE_DISCORD_PRESENCE=ON \
-      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
-      -DYUZU_USE_BUNDLED_FFMPEG=ON
+      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"}

 make -j$(nproc)

--- a/.ci/scripts/windows/docker.sh
+++ b/.ci/scripts/windows/docker.sh
@@ -18,20 +18,19 @@ cd ..
 mkdir package

 if [ -d "/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/" ]; then
-  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins'
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
 else
  #fallback to qt
-  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins'
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins/platforms/'
 fi

 find build/ -name "yuzu*.exe" -exec cp {} 'package' \;

 # copy Qt plugins
 mkdir package/platforms
-cp -v "${QT_PLUGINS_PATH}/platforms/qwindows.dll" package/platforms/
-cp -rv "${QT_PLUGINS_PATH}/mediaservice/" package/
-cp -rv "${QT_PLUGINS_PATH}/imageformats/" package/
-cp -rv "${QT_PLUGINS_PATH}/styles/" package/
+cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
 rm -f package/mediaservice/*d.dll

 for i in package/*.exe; do
--- a/.ci/scripts/windows/upload.sh
+++ b/.ci/scripts/windows/upload.sh
@@ -3,8 +3,8 @@
 . .ci/scripts/common/pre-upload.sh

 REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.xz"
-COMPRESSION_FLAGS="-cJvf"
+ARCHIVE_NAME="${REV_NAME}.tar.gz"
+COMPRESSION_FLAGS="-czvf"

 if [ "${RELEASE_NAME}" = "mainline" ]; then
    DIR_NAME="${REV_NAME}"
--- a/.ci/yuzu-mainline-step2.yml
+++ b/.ci/yuzu-mainline-step2.yml
@@ -19,7 +19,6 @@ stages:
  displayName: 'build'
  jobs:
  - job: build
-    timeoutInMinutes: 120
    displayName: 'standard'
    pool:
      vmImage: ubuntu-latest
@@ -44,7 +43,6 @@ stages:
  displayName: 'build-windows'
  jobs:
  - job: build
-    timeoutInMinutes: 120
    displayName: 'msvc'
    pool:
      vmImage: windows-2019
@@ -67,4 +65,4 @@ stages:
  - job: github
    displayName: 'github'
    steps:
-    - template: ./templates/release-github.yml
+    - template: ./templates/release-github.yml
--- a/.gitmodules
+++ b/.gitmodules
@@ -18,7 +18,7 @@
 	url = https://github.com/libusb/libusb.git
 [submodule "discord-rpc"]
    path = externals/discord-rpc
-    url = https://github.com/discord/discord-rpc.git
+    url = https://github.com/discordapp/discord-rpc.git
 [submodule "Vulkan-Headers"]
    path = externals/Vulkan-Headers
    url = https://github.com/KhronosGroup/Vulkan-Headers.git
@@ -43,6 +43,3 @@
 [submodule "SDL"]
 	path = externals/SDL
 	url = https://github.com/libsdl-org/SDL.git
-[submodule "externals/cpp-httplib"]
-	path = externals/cpp-httplib
-	url = https://github.com/yhirose/cpp-httplib.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ project(yuzu)
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
-CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
+option(YUZU_ALLOW_SYSTEM_SDL2 "Try using system SDL2 before fallling back to one from externals" OFF)

 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
@@ -23,9 +23,7 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

 option(YUZU_USE_BUNDLED_BOOST "Download bundled Boost" OFF)

-option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
-
-option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON "WIN32" OFF)

 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

@@ -47,10 +45,9 @@ if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
 endif()

 if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
-    if (EXISTS ${PROJECT_SOURCE_DIR}/.git/)
-        message(STATUS "Copying pre-commit hook")
-        file(COPY hooks/pre-commit DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
-    endif()
+    message(STATUS "Copying pre-commit hook")
+    file(COPY hooks/pre-commit
+        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
 endif()

 # Sanity check : Check that all submodules are present
@@ -135,7 +132,7 @@ endif()
 # boost asio's concept usage doesn't play nicely with some compilers yet.
 add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
-    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
+    add_compile_options(/std:c++latest)

    # cubeb and boost still make use of deprecated result_of.
    add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
@@ -173,7 +170,7 @@ macro(yuzu_find_packages)
    set(REQUIRED_LIBS
    #    Cmake Pkg Prefix  Version     Conan Pkg
        "Catch2            2.13        catch2/2.13.0"
-        "fmt               8.0         fmt/8.0.0"
+        "fmt               7.1         fmt/7.1.2"
        "lz4               1.8         lz4/1.9.2"
        "nlohmann_json     3.8         nlohmann_json/3.8.0"
        "ZLIB              1.2         zlib/1.2.11"
@@ -255,83 +252,10 @@ if(ENABLE_QT)
    # Check for system Qt on Linux, fallback to bundled Qt
    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets)
-        endif()
-        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
-            # Check for dependencies, then enable bundled Qt download
-
-            # Check that the system GLIBCXX version is compatible
-            find_program(OBJDUMP objdump)
-            if ("${OBJDUMP}" STREQUAL "OBJDUMP-NOTFOUND")
-                message(FATAL_ERROR "Required program `objdump` not found.")
+            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets QUIET)
+            if (NOT Qt5_FOUND)
+                set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
            endif()
-            find_library(LIBSTDCXX libstdc++.so.6)
-            execute_process(
-                COMMAND
-                    ${OBJDUMP} -T ${LIBSTDCXX}
-                COMMAND
-                    grep GLIBCXX_3.4.28
-                COMMAND
-                    sed "s/[0-9a-f]*.*  //"
-                COMMAND
-                    sed "s/ .*//"
-                COMMAND
-                    sort -u
-                OUTPUT_VARIABLE
-                    GLIBCXX_MET
-            )
-            if (NOT GLIBCXX_MET)
-                message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
-                    compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
-                    to Qt by setting the variable Qt5_ROOT.")
-            endif()
-
-            # Check for headers
-            Include(FindPkgConfig REQUIRED)
-            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
-            if (NOT QT_DEP_GLU_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
-                    Perhaps `libglu1-mesa-dev` needs to be installed?")
-            endif()
-            pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
-            if (NOT QT_DEP_MESA_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
-                    Perhaps `mesa-common-dev` needs to be installed?")
-            endif()
-
-            # Check for X libraries
-            set(BUNDLED_QT_REQUIREMENTS
-                libxcb-icccm.so.4
-                libxcb-image.so.0
-                libxcb-keysyms.so.1
-                libxcb-randr.so.0
-                libxcb-render-util.so.0
-                libxcb-render.so.0
-                libxcb-shape.so.0
-                libxcb-shm.so.0
-                libxcb-sync.so.1
-                libxcb-xfixes.so.0
-                libxcb-xinerama.so.0
-                libxcb-xkb.so.1
-                libxcb.so.1
-                libxkbcommon-x11.so.0
-                libxkbcommon.so.0
-            )
-            set(UNRESOLVED_QT_DEPS "")
-            foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
-                find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
-                if ("${BUNDLED_QT_${REQUIREMENT}}" STREQUAL "BUNDLED_QT_${REQUIREMENT}-NOTFOUND")
-                    set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
-                endif()
-                unset(BUNDLED_QT_${REQUIREMENT})
-            endforeach()
-            unset(BUNDLED_QT_REQUIREMENTS)
-
-            if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
-                message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
-            endif()
-
-            set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
        endif()
        if (YUZU_USE_BUNDLED_QT)
            # Binary package currently does not support Qt webengine, so make sure it's disabled
@@ -339,8 +263,6 @@ if(ENABLE_QT)
        endif()
    endif()

-    set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
-
    # Workaround for an issue where conan tries to build Qt from scratch instead of download prebuilt binaries
    set(QT_PREFIX_HINT)

@@ -358,10 +280,8 @@ if(ENABLE_QT)
        endif()

        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-
-        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
    endif()
-    find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+    find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets ${QT_PREFIX_HINT} NO_CMAKE_SYSTEM_PATH)
    if (YUZU_USE_QT_WEB_ENGINE)
        find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
    endif()
@@ -376,7 +296,7 @@ if (ENABLE_SDL2)
    if (YUZU_USE_BUNDLED_SDL2)
        # Detect toolchain and platform
        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.16")
+            set(SDL2_VER "SDL2-2.0.15-prerelease")
        else()
            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
        endif()
@@ -393,20 +313,26 @@ if (ENABLE_SDL2)
        add_library(SDL2 INTERFACE)
        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
        target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
-    elseif (YUZU_USE_EXTERNAL_SDL2)
-        message(STATUS "Using SDL2 from externals.")
    else()
-        find_package(SDL2 2.0.16 REQUIRED)
+        if (YUZU_ALLOW_SYSTEM_SDL2)
+            find_package(SDL2 2.0.15 QUIET)

-        # Some installations don't set SDL2_LIBRARIES
-        if("${SDL2_LIBRARIES}" STREQUAL "")
-            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-            set(SDL2_LIBRARIES "SDL2::SDL2")
+            if (SDL2_FOUND)
+                # Some installations don't set SDL2_LIBRARIES
+                if("${SDL2_LIBRARIES}" STREQUAL "")
+                    message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
+                    set(SDL2_LIBRARIES "SDL2::SDL2")
+                endif()
+
+                include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
+                add_library(SDL2 INTERFACE)
+                target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
+            else()
+                message(STATUS "SDL2 2.0.15 or newer not found, falling back to externals.")
+            endif()
+        else()
+            message(STATUS "Using SDL2 from externals.")
        endif()
-
-        include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
    endif()
 endif()

@@ -494,22 +420,14 @@ elseif (TARGET Boost::boost)
 endif()

 # Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
+if(NOT APPLE)
    include(FindPkgConfig)
-    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
-        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
-    else()
-        find_package(LibUSB)
-    endif()
-
-    if (LIBUSB_FOUND)
-        add_library(usb INTERFACE)
-        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
-        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    else()
-        message(WARNING "libusb not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_LIBUSB ON)
-    endif()
+    find_package(LibUSB)
+endif()
+if (NOT LIBUSB_FOUND)
+    add_subdirectory(externals/libusb)
+    set(LIBUSB_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/externals/libusb/libusb/libusb")
+    set(LIBUSB_LIBRARIES usb)
 endif()

 # List of all FFmpeg components required
@@ -518,10 +436,6 @@ set(FFmpeg_COMPONENTS
    avutil
    swscale)

-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    Include(FindPkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
    # Use system installed FFmpeg
    find_package(FFmpeg QUIET COMPONENTS ${FFmpeg_COMPONENTS})
@@ -544,23 +458,12 @@ endif()

 if (YUZU_USE_BUNDLED_FFMPEG)
    if (NOT WIN32)
-        # TODO(lat9nq): Move this to externals/ffmpeg/CMakeLists.txt (and move externals/ffmpeg to
-        # externals/ffmpeg/ffmpeg)
-
        # Build FFmpeg from externals
        message(STATUS "Using FFmpeg from externals")

        # FFmpeg has source that requires one of nasm or yasm to assemble it.
        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm)
-        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
-            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
-        endif()
-
-        find_program(AUTOCONF autoconf)
-        if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-            message(FATAL_ERROR "Required program `autoconf` not found.")
-        endif()
+        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)

        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
@@ -586,84 +489,12 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                CACHE PATH "Paths to FFmpeg libraries" FORCE)
        endforeach()

-        Include(FindPkgConfig REQUIRED)
-        pkg_check_modules(LIBVA libva)
-        pkg_check_modules(CUDA cuda)
-        pkg_check_modules(FFNVCODEC ffnvcodec)
-        pkg_check_modules(VDPAU vdpau)
-
-        set(FFmpeg_HWACCEL_LIBRARIES)
-        set(FFmpeg_HWACCEL_FLAGS)
-        set(FFmpeg_HWACCEL_INCLUDE_DIRS)
-        set(FFmpeg_HWACCEL_LDFLAGS)
-
-        if(LIBVA_FOUND)
-            pkg_check_modules(LIBDRM libdrm REQUIRED)
-            find_package(X11 REQUIRED)
-            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${LIBDRM_LIBRARIES}
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
-            set(FFmpeg_HWACCEL_FLAGS
-                --enable-hwaccel=h264_vaapi
-                --enable-hwaccel=vp9_vaapi
-                --enable-libdrm)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${LIBDRM_INCLUDE_DIRS}
-                ${X11_INCLUDE_DIRS}
-                ${LIBVA-DRM_INCLUDE_DIRS}
-                ${LIBVA-X11_INCLUDE_DIRS}
-                ${LIBVA_INCLUDE_DIRS}
-            )
-            message(STATUS "VA-API found")
-        else()
-            set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        endif()
-
-        if (FFNVCODEC_FOUND AND CUDA_FOUND)
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-cuvid
-                --enable-ffnvcodec
-                --enable-nvdec
-                --enable-hwaccel=h264_nvdec
-                --enable-hwaccel=vp9_nvdec
-                --extra-cflags=-I${CUDA_INCLUDE_DIRS}
-            )
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${FFNVCODEC_LIBRARIES}
-                ${CUDA_LIBRARIES}
-            )
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${FFNVCODEC_INCLUDE_DIRS}
-                ${CUDA_INCLUDE_DIRS}
-            )
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS
-                ${FFNVCODEC_LDFLAGS}
-                ${CUDA_LDFLAGS}
-            )
-            message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
-        endif()
-
-        if (VDPAU_FOUND)
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-vdpau
-                --enable-hwaccel=h264_vdpau
-                --enable-hwaccel=vp9_vdpau
-            )
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-            message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
-        else()
-            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
-        endif()
+        set(FFmpeg_INCLUDE_DIR
+            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR}"
+            CACHE PATH "Path to FFmpeg headers" FORCE)

        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
-        # `--disable-vdpau` is needed to avoid linking issues
+        # `--disable-{vaapi,vdpau}` is needed to avoid linking issues
        add_custom_command(
            OUTPUT
                ${FFmpeg_MAKEFILE}
@@ -679,15 +510,13 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                    --disable-network
                    --disable-postproc
                    --disable-swresample
+                    --disable-vaapi
+                    --disable-vdpau
                    --enable-decoder=h264
                    --enable-decoder=vp9
-                    --cc="${CMAKE_C_COMPILER}"
-                    --cxx="${CMAKE_CXX_COMPILER}"
-                    ${FFmpeg_HWACCEL_FLAGS}
            WORKING_DIRECTORY
                ${FFmpeg_BUILD_DIR}
        )
-        unset(FFmpeg_HWACCEL_FLAGS)

        # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
        # with context of the jobserver. Also helps ninja users.
@@ -697,36 +526,19 @@ if (YUZU_USE_BUNDLED_FFMPEG)
            OUTPUT_VARIABLE
                SYSTEM_THREADS)

-        set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
        add_custom_command(
            OUTPUT
-                ${FFmpeg_BUILD_LIBRARIES}
+                ${FFmpeg_LIBRARIES}
            COMMAND
                make -j${SYSTEM_THREADS}
            WORKING_DIRECTORY
                ${FFmpeg_BUILD_DIR}
        )

-        set(FFmpeg_INCLUDE_DIR
-            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
-            CACHE PATH "Path to FFmpeg headers" FORCE)
-
-        set(FFmpeg_LDFLAGS
-            "${FFmpeg_HWACCEL_LDFLAGS}"
-            CACHE STRING "FFmpeg linker flags" FORCE)
-
        # ALL makes this custom target build every time
        # but it won't actually build if the DEPENDS parameter is up to date
        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
-        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
-        link_libraries(${FFmpeg_LIBVA_LIBRARIES})
-        set(FFmpeg_LIBRARIES ${FFmpeg_BUILD_LIBRARIES} ${FFmpeg_HWACCEL_LIBRARIES}
-            CACHE PATH "Paths to FFmpeg libraries" FORCE)
-        unset(FFmpeg_BUILD_LIBRARIES)
-        unset(FFmpeg_HWACCEL_FLAGS)
-        unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
-        unset(FFmpeg_HWACCEL_LDFLAGS)
-        unset(FFmpeg_HWACCEL_LIBRARIES)
+        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_LIBRARIES} ffmpeg-configure)

        if (FFmpeg_FOUND)
            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
@@ -735,13 +547,12 @@ if (YUZU_USE_BUNDLED_FFMPEG)
        endif()
    else() # WIN32
        # Use yuzu FFmpeg binaries
-        set(FFmpeg_EXT_NAME "ffmpeg-4.4")
+        set(FFmpeg_EXT_NAME "ffmpeg-4.3.1")
        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
        set(FFmpeg_FOUND YES)
        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
-        set(FFmpeg_LDFLAGS "" CACHE STRING "FFmpeg linker flags" FORCE)
        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
        set(FFmpeg_LIBRARIES
            ${FFmpeg_LIBRARY_DIR}/swscale.lib
@@ -767,7 +578,7 @@ if (APPLE)
 elseif (WIN32)
    # WSAPoll and SHGetKnownFolderPath (AppData/Roaming) didn't exist before WinNT 6.x (Vista)
    add_definitions(-D_WIN32_WINNT=0x0600 -DWINVER=0x0600)
-    set(PLATFORM_LIBRARIES winmm ws2_32 iphlpapi)
+    set(PLATFORM_LIBRARIES winmm ws2_32)
    if (MINGW)
        # PSAPI is the Process Status API
        set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version)
@@ -780,7 +591,7 @@ endif()
 # against all the src files. This should be used before making a pull request.
 # =======================================================================

-set(CLANG_FORMAT_POSTFIX "-12")
+set(CLANG_FORMAT_POSTFIX "-10")
 find_program(CLANG_FORMAT
    NAMES clang-format${CLANG_FORMAT_POSTFIX}
          clang-format
--- a/CMakeModules/GenerateSCMRev.cmake
+++ b/CMakeModules/GenerateSCMRev.cmake
@@ -48,6 +48,69 @@ if (BUILD_REPOSITORY)
  endif()
 endif()

-# The variable SRC_DIR must be passed into the script
-# (since it uses the current build directory for all values of CMAKE_*_DIR)
+# The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
+set(VIDEO_CORE "${SRC_DIR}/src/video_core")
+set(HASH_FILES
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/bfe.cpp"
+    "${VIDEO_CORE}/shader/decode/bfi.cpp"
+    "${VIDEO_CORE}/shader/decode/conversion.cpp"
+    "${VIDEO_CORE}/shader/decode/ffma.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+    "${VIDEO_CORE}/shader/decode/image.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/memory.cpp"
+    "${VIDEO_CORE}/shader/decode/texture.cpp"
+    "${VIDEO_CORE}/shader/decode/other.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/shift.cpp"
+    "${VIDEO_CORE}/shader/decode/video.cpp"
+    "${VIDEO_CORE}/shader/decode/warp.cpp"
+    "${VIDEO_CORE}/shader/decode/xmad.cpp"
+    "${VIDEO_CORE}/shader/ast.cpp"
+    "${VIDEO_CORE}/shader/ast.h"
+    "${VIDEO_CORE}/shader/compiler_settings.cpp"
+    "${VIDEO_CORE}/shader/compiler_settings.h"
+    "${VIDEO_CORE}/shader/control_flow.cpp"
+    "${VIDEO_CORE}/shader/control_flow.h"
+    "${VIDEO_CORE}/shader/decode.cpp"
+    "${VIDEO_CORE}/shader/expr.cpp"
+    "${VIDEO_CORE}/shader/expr.h"
+    "${VIDEO_CORE}/shader/node.h"
+    "${VIDEO_CORE}/shader/node_helper.cpp"
+    "${VIDEO_CORE}/shader/node_helper.h"
+    "${VIDEO_CORE}/shader/registry.cpp"
+    "${VIDEO_CORE}/shader/registry.h"
+    "${VIDEO_CORE}/shader/shader_ir.cpp"
+    "${VIDEO_CORE}/shader/shader_ir.h"
+    "${VIDEO_CORE}/shader/track.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.h"
+)
+set(COMBINED "")
+foreach (F IN LISTS HASH_FILES)
+    file(READ ${F} TMP)
+    set(COMBINED "${COMBINED}${TMP}")
+endforeach()
+string(MD5 SHADER_CACHE_VERSION "${COMBINED}")
 configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY)
--- a/README.md
+++ b/README.md
@@ -1,82 +1,43 @@
-<h1 align="center">
-  <br>
-  <a href="https://yuzu-emu.org/"><img src="https://raw.githubusercontent.com/yuzu-emu/yuzu-assets/master/icons/icon.png" alt="yuzu" width="200"></a>
-  <br>
-  <b>yuzu</b>
-  <br>
-</h1>
+yuzu emulator
+=============
+[![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
+[![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
+[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.com/invite/u77vRWY)

-<h4 align="center"><b>yuzu</b> is the world's most popular, open-source, Nintendo Switch emulator — started by the creators of <a href="https://citra-emu.org" target="_blank">Citra</a>.
-<br>
-It is written in C++ with portability in mind, and we actively maintain builds for Windows and Linux.
-</h4>
+yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).

-<p align="center">
-    <a href="https://dev.azure.com/yuzu-emu/yuzu/">
-        <img src="https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master"
-            alt="Azure Mainline CI Build Status">
-    </a>
-    <a href="https://discord.com/invite/u77vRWY">
-        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
-            alt="Discord">
-    </a>
-</p>
+It is written in C++ with portability in mind, with builds actively maintained for Windows and Linux. The emulator is capable of running several commercial games.

-<p align="center">
-  <a href="#compatibility">Compatibility</a> |
-  <a href="#development">Development</a> |
-  <a href="#building">Building</a> |
-  <a href="#download">Download</a> |
-  <a href="#support">Support</a> |
-  <a href="#license">License</a>
-</p>
+yuzu only emulates a subset of Switch hardware and therefore most commercial games **do not** run at full speed or are not fully functional.

-## Compatibility
+Do you want to check which games are compatible and which ones are not? Please visit our [Compatibility page](https://yuzu-emu.org/game/)!

-The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).
+yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.

-For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/)
+Check out our [website](https://yuzu-emu.org/)!

-Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!
+For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).

-## Development
+### Development

-Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted. For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
+Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.

-If you want to contribute, please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information).
-You can also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.

-If you want to contribute to the user interface translation project, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
+If you want to contribute to the user interface translation, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.

-## Building
+### Building

 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)
 * __Linux__: [Linux Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Linux)

-## Download

-You can download the latest releases automatically via the installer on our [downloads](https://yuzu-emu.org/downloads/) page.
-
-
-## Support
-
-If you enjoy the project and want to support us financially, check out our Patreon!
-
-<a href="https://www.patreon.com/yuzuteam">
-    <img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
-</a>
-
-Any donations received will go towards things like:
+### Support
+We happily accept monetary donations, or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:
 * Switch consoles to explore and reverse-engineer the hardware
 * Switch games for testing, reverse-engineering, and implementing new features
 * Web hosting and infrastructure setup
 * Software licenses (e.g. Visual Studio, IDA Pro, etc.)
 * Additional hardware (e.g. GPUs as-needed to improve rendering support, other peripherals to add support for, etc.)

-If you wish to support us a different way, please join our [Discord](https://discord.gg/u77vRWY) and talk to bunnei. You may also contact: donations@yuzu-emu.org.
-
-## License
-
-yuzu is licensed under the GPLv2 (or any later version). Refer to the [license.txt](https://github.com/yuzu-emu/yuzu/blob/master/license.txt) file.
-
-The [Skyline-Emulator Team](https://github.com/skyline-emu/skyline) is exempt from GPLv2 for the contributions from all these contributors [FernandoS27](https://github.com/FernandoS27), [lioncash](https://github.com/lioncash), [bunnei](https://github.com/bunnei), [ReinUsesLisp](https://github.com/ReinUsesLisp), [Morph1984](https://github.com/Morph1984), [ogniK5377](https://github.com/ogniK5377), [german77](https://github.com/german77), [ameerj](https://github.com/ameerj), [Kelebek1](https://github.com/Kelebek1) and [lat9nq](https://github.com/lat9nq). They may only use the code from these contributors under Mozilla Public License, version 2.0.
+We also more than gladly accept used Switch consoles, preferably ones with firmware 3.0.0 or lower! If you would like to give yours away, don't hesitate to join our [Discord](https://discord.gg/VXqngT3) and talk to bunnei. You may also contact: donations@yuzu-emu.org.
--- a/dist/qt_themes/default/style.qss
+++ b/dist/qt_themes/default/style.qss
@@ -38,26 +38,6 @@ QPushButton#RendererStatusBarButton:!checked {
    color: #0066ff;
 }

-QPushButton#GPUStatusBarButton {
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #b06020;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #109010;
-}
-
 QPushButton#buttonRefreshDevices {
    min-width: 21px;
    min-height: 21px;
--- a/dist/qt_themes/qdarkstyle/style.qss
+++ b/dist/qt_themes/qdarkstyle/style.qss
@@ -1283,27 +1283,6 @@ QPushButton#RendererStatusBarButton:!checked {
    color: #00ccdd;
 }

-QPushButton#GPUStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
    min-width: 23px;
    min-height: 23px;
--- a/dist/qt_themes/qdarkstyle_midnight_blue/style.qss
+++ b/dist/qt_themes/qdarkstyle_midnight_blue/style.qss
@@ -2186,27 +2186,6 @@ QPushButton#RendererStatusBarButton:!checked {
  color: #00ccdd;
 }

-QPushButton#GPUStatusBarButton {
-  min-width: 0px;
-  color: #656565;
-  border: 1px solid transparent;
-  background-color: transparent;
-  padding: 0px 3px 0px 3px;
-  text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-  border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-  color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-  color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
  min-width: 19px;
  min-height: 19px;
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -7,9 +7,7 @@ include(DownloadExternals)
 # xbyak
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
    add_library(xbyak INTERFACE)
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/xbyak/xbyak DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_include_directories(xbyak SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
+    target_include_directories(xbyak SYSTEM INTERFACE ./xbyak/xbyak)
    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
 endif()

@@ -21,7 +19,6 @@ target_include_directories(catch-single-include INTERFACE catch/single_include)
 if (ARCHITECTURE_x86_64)
    set(DYNARMIC_TESTS OFF)
    set(DYNARMIC_NO_BUNDLED_FMT ON)
-    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
    add_subdirectory(dynarmic)
 endif()

@@ -48,18 +45,13 @@ target_include_directories(microprofile INTERFACE ./microprofile)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)

-# libusb
-if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
-    add_subdirectory(libusb)
-endif()
-
 # SDL2
-if (YUZU_USE_EXTERNAL_SDL2)
+if (NOT SDL2_FOUND AND ENABLE_SDL2)
    if (NOT WIN32)
-        # Yuzu itself needs: Events Joystick Haptic Sensor Timers Audio
+        # Yuzu itself needs: Events Joystick Haptic Sensor Timers
        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
        set(SDL_UNUSED_SUBSYSTEMS
-            Atomic Render Power Threads
+            Atomic Audio Render Power Threads
            File CPUinfo Filesystem Locale)
        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
          string(TOUPPER ${_SUB} _OPT)
@@ -118,7 +110,7 @@ if (ENABLE_WEB_SERVICE)

    # httplib
    add_library(httplib INTERFACE)
-    target_include_directories(httplib INTERFACE ./cpp-httplib)
+    target_include_directories(httplib INTERFACE ./httplib)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
    if (WIN32)
--- a/externals/SDL
+++ b/externals/SDL
--- a/externals/Vulkan-Headers
+++ b/externals/Vulkan-Headers
--- a/externals/cpp-httplib
+++ b/externals/cpp-httplib
--- a/externals/discord-rpc
+++ b/externals/discord-rpc
--- a/externals/dynarmic
+++ b/externals/dynarmic
--- a/externals/httplib/README.md
+++ b/externals/httplib/README.md
@@ -0,0 +1,15 @@
+From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
+
+MIT License
+
+===
+
+cpp-httplib
+
+A C++11 header-only HTTP library.
+
+It's extremely easy to setup. Just include httplib.h file in your code!
+
+Inspired by Sinatra and express.
+
+© 2017 Yuji Hirose
--- a/externals/httplib/httplib.h
+++ b/externals/httplib/httplib.h
--- a/externals/libusb/CMakeLists.txt
+++ b/externals/libusb/CMakeLists.txt
@@ -1,24 +1,10 @@
-if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
-    set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
-    set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)
-
-    # GNU toolchains for some reason doesn't work with the later half of this CMakeLists after
-    # updating to 1.0.24, so we do it the old-fashioned way for now.
-
-    # Require autoconf and libtoolize here, rather than crash during compilation
-    find_program(AUTOCONF autoconf)
-    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-        message(FATAL_ERROR "Required program `autoconf` not found.")
-    endif()
-
-    find_program(LIBTOOLIZE libtoolize)
-    if ("${LIBTOOLIZE}" STREQUAL "LIBTOOLIZE-NOTFOUND")
-        message(FATAL_ERROR "Required program `libtoolize` not found.")
-    endif()
+if (MINGW)
+    # The MinGW toolchain for some reason doesn't work with this CMakeLists file after updating to
+    # 1.0.24, so we do it the old-fashioned way for now. We may want to move native Linux toolchains
+    # to here, too (TODO lat9nq?).

    set(LIBUSB_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libusb")
    set(LIBUSB_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libusb")
-
    # Workarounds for MSYS/MinGW
    if (MSYS)
        # CMake on Windows passes `C:/`, but we need `/C/` or `/c/` to use `configure`
@@ -33,44 +19,36 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)

    set(LIBUSB_CONFIGURE "${LIBUSB_SRC_DIR}/configure")
    set(LIBUSB_MAKEFILE "${LIBUSB_PREFIX}/Makefile")
+    set(LIBUSB_LIBRARY "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll.a")
+    set(LIBUSB_SHARED_LIBRARY "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll")
+    set(LIBUSB_SHARED_LIBRARY_DEST "${CMAKE_BINARY_DIR}/bin/libusb-1.0.dll")

-    if (MINGW)
-        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll.a" CACHE PATH "libusb library path" FORCE)
-        set(LIBUSB_SHARED_LIBRARY "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll")
-        set(LIBUSB_SHARED_LIBRARY_DEST "${CMAKE_BINARY_DIR}/bin/libusb-1.0.dll")
-
-        set(LIBUSB_CONFIGURE_ARGS --host=x86_64-w64-mingw32 --build=x86_64-windows)
-    else()
-        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.a" CACHE PATH "libusb library path" FORCE)
-    endif()
-
-    set(LIBUSB_INCLUDE_DIRS "${LIBUSB_SRC_DIR}/libusb" CACHE PATH "libusb headers path" FORCE)
-
-    # MINGW: causes "externals/libusb/libusb/libusb/os/windows_winusb.c:1427:2: error: conversion to non-scalar type requested", so cannot statically link it for now.
-    if (NOT MINGW)
-        set(LIBUSB_CFLAGS "-DGUID_DEVINTERFACE_USB_DEVICE=\\(GUID\\){0xA5DCBF10,0x6530,0x11D2,{0x90,0x1F,0x00,0xC0,0x4F,0xB9,0x51,0xED}}")
-    endif()
+    # Causes "externals/libusb/libusb/libusb/os/windows_winusb.c:1427:2: error: conversion to non-scalar type requested", so cannot statically link it for now.
+    # set(LIBUSB_CFLAGS "-DGUID_DEVINTERFACE_USB_DEVICE=\\(GUID\\){0xA5DCBF10,0x6530,0x11D2,{0x90,0x1F,0x00,0xC0,0x4F,0xB9,0x51,0xED}}")

    make_directory("${LIBUSB_PREFIX}")

    add_custom_command(
        OUTPUT
-            "${LIBUSB_LIBRARIES}"
+            "${LIBUSB_LIBRARY}"
        COMMAND
            make
        WORKING_DIRECTORY
            "${LIBUSB_PREFIX}"
    )

+    # We may use this path for other GNU toolchains, so put all of the MinGW-specific stuff here
+    if (MINGW)
+        set(LIBUSB_CONFIGURE_ARGS --host=x86_64-w64-mingw32 --build=x86_64-windows)
+    endif()
+
    add_custom_command(
        OUTPUT
            "${LIBUSB_MAKEFILE}"
        COMMAND
-            env
-                CC="${CMAKE_C_COMPILER}"
-                CXX="${CMAKE_CXX_COMPILER}"
-                CFLAGS="${LIBUSB_CFLAGS}"
-            sh "${LIBUSB_CONFIGURE}"
+            # /bin/env
+            #     CFLAGS="${LIBUSB_CFLAGS}"
+            /bin/sh "${LIBUSB_CONFIGURE}"
                ${LIBUSB_CONFIGURE_ARGS}
                --srcdir="${LIBUSB_SRC_DIR}"
        WORKING_DIRECTORY
@@ -81,7 +59,7 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
        OUTPUT
            "${LIBUSB_CONFIGURE}"
        COMMAND
-            sh "${LIBUSB_SRC_DIR}/bootstrap.sh"
+            /bin/sh "${LIBUSB_SRC_DIR}/bootstrap.sh"
        WORKING_DIRECTORY
            "${LIBUSB_SRC_DIR}"
    )
@@ -90,30 +68,19 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
        OUTPUT
            "${LIBUSB_SHARED_LIBRARY_DEST}"
        COMMAND
-            cp "${LIBUSB_SHARED_LIBRARY}" "${LIBUSB_SHARED_LIBRARY_DEST}"
+            /bin/cp "${LIBUSB_SHARED_LIBRARY}" "${LIBUSB_SHARED_LIBRARY_DEST}"
    )

-    add_custom_target(usb-bootstrap DEPENDS "${LIBUSB_CONFIGURE}")
-    add_custom_target(usb-configure DEPENDS "${LIBUSB_MAKEFILE}" usb-bootstrap)
-    add_custom_target(usb-build ALL DEPENDS "${LIBUSB_LIBRARIES}" usb-configure)
+    add_custom_target(usb-bootstrap ALL DEPENDS "${LIBUSB_CONFIGURE}")
+    add_custom_target(usb-configure ALL DEPENDS "${LIBUSB_MAKEFILE}" usb-bootstrap)
+    add_custom_target(usb-build ALL DEPENDS "${LIBUSB_LIBRARY}" usb-configure)
    # Workaround since static linking didn't work out -- We need to copy the DLL to the bin directory
    add_custom_target(usb-copy ALL DEPENDS "${LIBUSB_SHARED_LIBRARY_DEST}" usb-build)

+    # Make `usb` alias to LIBUSB_LIBRARY
    add_library(usb INTERFACE)
-    add_dependencies(usb usb-copy)
-    target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
-
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-        Include(FindPkgConfig)
-        pkg_check_modules(LIBUDEV REQUIRED libudev)
-
-        if (LIBUDEV_FOUND)
-            target_include_directories(usb INTERFACE "${LIBUDEV_INCLUDE_DIRS}")
-            target_link_libraries(usb INTERFACE "${LIBUDEV_STATIC_LIBRARIES}")
-        endif()
-    endif()
-else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARY}")
+else() # MINGW
    # Ensure libusb compiles with UTF-8 encoding on MSVC
    if(MSVC)
        add_compile_options(/utf-8)
@@ -269,4 +236,4 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")


    configure_file(config.h.in config.h)
-endif() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+endif() # MINGW
--- a/externals/sirit
+++ b/externals/sirit
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -45,23 +45,13 @@ if (MSVC)
        /Zc:inline
        /Zc:throwingNew

-        # External headers diagnostics
-        /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
-        /external:anglebrackets # Treats all headers included by #include <header>, where the header file is enclosed in angle brackets (< >), as external headers
-        /external:W0            # Sets the default warning level to 0 for external headers, effectively turning off warnings for external headers
-
        # Warnings
        /W3
-        /we4018 # 'expression': signed/unsigned mismatch
-        /we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
+        /we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
        /we4101 # 'identifier': unreferenced local variable
-        /we4189 # 'identifier': local variable is initialized but not referenced
        /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
-        /we4305 # 'context': truncation from 'type1' to 'type2'
-        /we4388 # 'expression': signed/unsigned mismatch
-        /we4389 # 'operator': signed/unsigned mismatch
-        /we4547 # 'operator': operator before comma has no effect; expected operator with side-effect
+        /we4388 # signed/unsigned mismatch
+        /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
        /we4555 # Expression has no effect; expected expression with side-effect
        /we4715 # 'function': not all control paths return a value
@@ -82,7 +72,6 @@ else()
        -Werror=missing-declarations
        -Werror=missing-field-initializers
        -Werror=reorder
-        -Werror=sign-compare
        -Werror=switch
        -Werror=uninitialized
        -Werror=unused-function
@@ -142,7 +131,6 @@ add_subdirectory(core)
 add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(input_common)
-add_subdirectory(shader_recompiler)
 add_subdirectory(tests)

 if (ENABLE_SDL2)
--- a/src/audio_core/CMakeLists.txt
+++ b/src/audio_core/CMakeLists.txt
@@ -42,7 +42,6 @@ add_library(audio_core STATIC
    voice_context.h

    $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
-    $<$<BOOL:${ENABLE_SDL2}>:sdl2_sink.cpp sdl2_sink.h>
 )

 create_target_directory_groups(audio_core)
@@ -51,6 +50,9 @@ if (NOT MSVC)
    target_compile_options(audio_core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
+        -Werror=implicit-fallthrough
+        -Werror=reorder
+        -Werror=sign-compare
        -Werror=shadow
        -Werror=unused-parameter
        -Werror=unused-variable
@@ -69,7 +71,3 @@ if(ENABLE_CUBEB)
    target_link_libraries(audio_core PRIVATE cubeb)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
-    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
-endif()
--- a/src/audio_core/audio_out.cpp
+++ b/src/audio_core/audio_out.cpp
@@ -30,8 +30,7 @@ StreamPtr AudioOut::OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample
                               u32 num_channels, std::string&& name,
                               Stream::ReleaseCallback&& release_callback) {
    if (!sink) {
-        sink = CreateSinkFromID(Settings::values.sink_id.GetValue(),
-                                Settings::values.audio_device_id.GetValue());
+        sink = CreateSinkFromID(Settings::values.sink_id, Settings::values.audio_device_id);
    }

    return std::make_shared<Stream>(
--- a/src/audio_core/audio_renderer.cpp
+++ b/src/audio_core/audio_renderer.cpp
@@ -12,7 +12,6 @@
 #include "audio_core/voice_context.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
-#include "core/core_timing.h"
 #include "core/memory.h"

 namespace {
@@ -29,9 +28,10 @@ namespace {
                                       (static_cast<float>(r_channel) * r_mix_amount)));
 }

-[[maybe_unused, nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(
-    s16 fl_channel, s16 fr_channel, s16 fc_channel, [[maybe_unused]] s16 lf_channel, s16 bl_channel,
-    s16 br_channel) {
+[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
+                                                            s16 fc_channel,
+                                                            [[maybe_unused]] s16 lf_channel,
+                                                            s16 bl_channel, s16 br_channel) {
    // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
    // are mixed to be 36.94%

@@ -56,11 +56,11 @@ namespace {
    const std::array<float_le, 4>& coeff) {
    const auto left =
        static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[3];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];

    const auto right =
        static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[3];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];

    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
 }
@@ -68,9 +68,7 @@ namespace {
 } // namespace

 namespace AudioCore {
-constexpr s32 NUM_BUFFERS = 2;
-
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_,
+AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                             AudioCommon::AudioRendererParameter params,
                             Stream::ReleaseCallback&& release_callback,
                             std::size_t instance_number)
@@ -79,8 +77,7 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
      sink_context(params.sink_count), splitter_context(),
      voices(params.voice_count), memory{memory_},
      command_generator(worker_params, voice_context, mix_context, splitter_context, effect_context,
-                        memory),
-      core_timing{core_timing_} {
+                        memory) {
    behavior_info.SetUserRevision(params.revision);
    splitter_context.Initialize(behavior_info, params.splitter_count,
                                params.num_splitter_send_channels);
@@ -89,27 +86,16 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
    stream = audio_out->OpenStream(
        core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
        fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
-    process_event = Core::Timing::CreateEvent(
-        fmt::format("AudioRenderer-Instance{}-Process", instance_number),
-        [this](std::uintptr_t, std::chrono::nanoseconds) { ReleaseAndQueueBuffers(); });
-    for (s32 i = 0; i < NUM_BUFFERS; ++i) {
-        QueueMixedBuffer(i);
-    }
+    audio_out->StartStream(stream);
+
+    QueueMixedBuffer(0);
+    QueueMixedBuffer(1);
+    QueueMixedBuffer(2);
+    QueueMixedBuffer(3);
 }

 AudioRenderer::~AudioRenderer() = default;

-ResultCode AudioRenderer::Start() {
-    audio_out->StartStream(stream);
-    ReleaseAndQueueBuffers();
-    return ResultSuccess;
-}
-
-ResultCode AudioRenderer::Stop() {
-    audio_out->StopStream(stream);
-    return ResultSuccess;
-}
-
 u32 AudioRenderer::GetSampleRate() const {
    return worker_params.sample_rate;
 }
@@ -128,7 +114,7 @@ Stream::State AudioRenderer::GetStreamState() const {

 ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
                                              std::vector<u8>& output_params) {
-    std::scoped_lock lock{mutex};
+
    InfoUpdater info_updater{input_params, output_params, behavior_info};

    if (!info_updater.UpdateBehaviorInfo(behavior_info)) {
@@ -208,6 +194,9 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
        LOG_ERROR(Audio, "Audio buffers were not consumed!");
        return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
    }
+
+    ReleaseAndQueueBuffers();
+
    return ResultSuccess;
 }

@@ -231,8 +220,10 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
    command_generator.PostCommand();
    // Base sample size
    std::size_t BUFFER_SIZE{worker_params.sample_count};
-    // Samples, making sure to clear
-    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels(), 0);
+    // Samples
+    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels());
+    // Make sure to clear our samples
+    std::memset(buffer.data(), 0, buffer.size() * sizeof(s16));

    if (sink_context.InUse()) {
        const auto stream_channel_count = stream->GetNumChannels();
@@ -240,7 +231,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
        const auto channel_count = buffer_offsets.size();
        const auto& final_mix = mix_context.GetFinalMixInfo();
        const auto& in_params = final_mix.GetInParams();
-        std::vector<std::span<s32>> mix_buffers(channel_count);
+        std::vector<s32*> mix_buffers(channel_count);
        for (std::size_t i = 0; i < channel_count; i++) {
            mix_buffers[i] =
                command_generator.GetMixBuffer(in_params.buffer_offset + buffer_offsets[i]);
@@ -293,11 +284,18 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                    buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
                } else if (stream_channel_count == 2) {
                    // Mix all channels into 2 channels
-                    const auto [left, right] = Mix6To2WithCoefficients(
-                        fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
-                        sink_context.GetDownmixCoefficients());
-                    buffer[i * stream_channel_count + 0] = left;
-                    buffer[i * stream_channel_count + 1] = right;
+                    if (sink_context.HasDownMixingCoefficients()) {
+                        const auto [left, right] = Mix6To2WithCoefficients(
+                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
+                            sink_context.GetDownmixCoefficients());
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    } else {
+                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
+                                                           lf_sample, bl_sample, br_sample);
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    }
                } else if (stream_channel_count == 6) {
                    // Pass through
                    buffer[i * stream_channel_count + 0] = fl_sample;
@@ -317,24 +315,10 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }

 void AudioRenderer::ReleaseAndQueueBuffers() {
-    if (!stream->IsPlaying()) {
-        return;
+    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
+    for (const auto& tag : released_buffers) {
+        QueueMixedBuffer(tag);
    }
-
-    {
-        std::scoped_lock lock{mutex};
-        const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
-        for (const auto& tag : released_buffers) {
-            QueueMixedBuffer(tag);
-        }
-    }
-
-    const f32 sample_rate = static_cast<f32>(GetSampleRate());
-    const f32 sample_count = static_cast<f32>(GetSampleCount());
-    const f32 consume_rate = sample_rate / (sample_count * (sample_count / 240));
-    const s32 ms = (1000 / static_cast<s32>(consume_rate)) - 1;
-    const std::chrono::milliseconds next_event_time(std::max(ms / NUM_BUFFERS, 1));
-    core_timing.ScheduleEvent(next_event_time, process_event, {});
 }

 } // namespace AudioCore
--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -6,7 +6,6 @@

 #include <array>
 #include <memory>
-#include <mutex>
 #include <vector>

 #include "audio_core/behavior_info.h"
@@ -46,8 +45,6 @@ public:

    [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
                                                 std::vector<u8>& output_params);
-    [[nodiscard]] ResultCode Start();
-    [[nodiscard]] ResultCode Stop();
    void QueueMixedBuffer(Buffer::Tag tag);
    void ReleaseAndQueueBuffers();
    [[nodiscard]] u32 GetSampleRate() const;
@@ -71,9 +68,6 @@ private:
    Core::Memory::Memory& memory;
    CommandGenerator command_generator;
    std::size_t elapsed_frame_count{};
-    Core::Timing::CoreTiming& core_timing;
-    std::shared_ptr<Core::Timing::EventType> process_event;
-    std::mutex mutex;
 };

 } // namespace AudioCore
--- a/src/audio_core/command_generator.cpp
+++ b/src/audio_core/command_generator.cpp
@@ -31,7 +31,7 @@ constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
    0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};

 template <std::size_t N>
-void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 sample_count) {
+void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
    for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
        for (std::size_t j = 0; j < N; j++) {
            output[i + j] +=
@@ -40,17 +40,7 @@ void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 s
    }
 }

-s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain, float delta,
-                 s32 sample_count) {
-    // XC2 passes in NaN mix volumes, causing further issues as we handle everything as s32 rather
-    // than float, so the NaN propogation is lost. As the samples get further modified for
-    // volume etc, they can get out of NaN range, so a later heuristic for catching this is
-    // more difficult. Handle it here by setting these samples to silence.
-    if (std::isnan(gain)) {
-        gain = 0.0f;
-        delta = 0.0f;
-    }
-
+s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sample_count) {
    s32 x = 0;
    for (s32 i = 0; i < sample_count; i++) {
        x = static_cast<s32>(static_cast<float>(input[i]) * gain);
@@ -60,22 +50,20 @@ s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain,
    return x;
 }

-void ApplyGain(std::span<s32> output, std::span<const s32> input, s32 gain, s32 delta,
-               s32 sample_count) {
+void ApplyGain(s32* output, const s32* input, s32 gain, s32 delta, s32 sample_count) {
    for (s32 i = 0; i < sample_count; i++) {
        output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
        gain += delta;
    }
 }

-void ApplyGainWithoutDelta(std::span<s32> output, std::span<const s32> input, s32 gain,
-                           s32 sample_count) {
+void ApplyGainWithoutDelta(s32* output, const s32* input, s32 gain, s32 sample_count) {
    for (s32 i = 0; i < sample_count; i++) {
        output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
    }
 }

-s32 ApplyMixDepop(std::span<s32> output, s32 first_sample, s32 delta, s32 sample_count) {
+s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
    const bool positive = first_sample > 0;
    auto final_sample = std::abs(first_sample);
    for (s32 i = 0; i < sample_count; i++) {
@@ -140,10 +128,10 @@ constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1,
                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};

 template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(
-    I3dl2ReverbState& state,
-    const std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT>& input,
-    const std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT>& output, s32 sample_count) {
+void ApplyReverbGeneric(I3dl2ReverbState& state,
+                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
+                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
+                        s32 sample_count) {

    auto GetTapLookup = []() {
        if constexpr (CHANNEL_COUNT == 1) {
@@ -412,10 +400,7 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
        }
    } else {
        switch (in_params.sample_format) {
-        case SampleFormat::Pcm8:
        case SampleFormat::Pcm16:
-        case SampleFormat::Pcm32:
-        case SampleFormat::PcmFloat:
            DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
                                  worker_params.sample_rate, worker_params.sample_count,
                                  in_params.node_id);
@@ -469,8 +454,8 @@ void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buff
                  "input_mix_buffer={}, output_mix_buffer={}",
                  node_id, input_offset, output_offset);
    }
-    std::span<const s32> input = GetMixBuffer(input_offset);
-    std::span<s32> output = GetMixBuffer(output_offset);
+    const auto* input = GetMixBuffer(input_offset);
+    auto* output = GetMixBuffer(output_offset);

    // Biquad filter parameters
    const auto [n0, n1, n2] = params.numerator;
@@ -563,8 +548,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
        return;
    }

-    std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT> input{};
-    std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT> output{};
+    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
+    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};

    const auto status = params.status;
    for (s32 i = 0; i < channel_count; i++) {
@@ -599,8 +584,7 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
        for (s32 i = 0; i < channel_count; i++) {
            // Only copy if the buffer input and output do not match!
            if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
-                std::memcpy(output[i].data(), input[i].data(),
-                            worker_params.sample_count * sizeof(s32));
+                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
            }
        }
    }
@@ -616,8 +600,8 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
    for (s32 i = 0; i < channel_count; i++) {
        // TODO(ogniK): Actually implement biquad filter
        if (params.input[i] != params.output[i]) {
-            std::span<const s32> input = GetMixBuffer(mix_buffer_offset + params.input[i]);
-            std::span<s32> output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
        }
    }
@@ -656,15 +640,14 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf

                if (samples_read != static_cast<int>(worker_params.sample_count) &&
                    samples_read <= params.sample_count) {
-                    std::memset(GetMixBuffer(output_index).data(), 0,
-                                params.sample_count - samples_read);
+                    std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
                }
            } else {
                AuxInfoDSP empty{};
                memory.WriteBlock(aux->GetSendInfo(), &empty, sizeof(AuxInfoDSP));
                memory.WriteBlock(aux->GetRecvInfo(), &empty, sizeof(AuxInfoDSP));
                if (output_index != input_index) {
-                    std::memcpy(GetMixBuffer(output_index).data(), GetMixBuffer(input_index).data(),
+                    std::memcpy(GetMixBuffer(output_index), GetMixBuffer(input_index),
                                worker_params.sample_count * sizeof(s32));
                }
            }
@@ -682,7 +665,7 @@ ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter
 }

 s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                                     std::span<const s32> data, u32 sample_count, u32 write_offset,
+                                     const s32* data, u32 sample_count, u32 write_offset,
                                     u32 write_count) {
    if (max_samples == 0) {
        return 0;
@@ -692,14 +675,14 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
        return 0;
    }

-    s32 data_offset{};
+    std::size_t data_offset{};
    u32 remaining = sample_count;
    while (remaining > 0) {
        // Get position in buffer
        const auto base = send_buffer + (offset * sizeof(u32));
        const auto samples_to_grab = std::min(max_samples - offset, remaining);
        // Write to output
-        memory.WriteBlock(base, (data.data() + data_offset), samples_to_grab * sizeof(u32));
+        memory.WriteBlock(base, (data + data_offset), samples_to_grab * sizeof(u32));
        offset = (offset + samples_to_grab) % max_samples;
        remaining -= samples_to_grab;
        data_offset += samples_to_grab;
@@ -712,7 +695,7 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
 }

 s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                                    std::span<s32> out_data, u32 sample_count, u32 read_offset,
+                                    s32* out_data, u32 sample_count, u32 read_offset,
                                    u32 read_count) {
    if (max_samples == 0) {
        return 0;
@@ -724,16 +707,15 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
    }

    u32 remaining = sample_count;
-    s32 data_offset{};
    while (remaining > 0) {
        const auto base = recv_buffer + (offset * sizeof(u32));
        const auto samples_to_grab = std::min(max_samples - offset, remaining);
        std::vector<s32> buffer(samples_to_grab);
        memory.ReadBlock(base, buffer.data(), buffer.size() * sizeof(u32));
-        std::memcpy(out_data.data() + data_offset, buffer.data(), buffer.size() * sizeof(u32));
+        std::memcpy(out_data, buffer.data(), buffer.size() * sizeof(u32));
+        out_data += samples_to_grab;
        offset = (offset + samples_to_grab) % max_samples;
        remaining -= samples_to_grab;
-        data_offset += samples_to_grab;
    }

    if (read_count != 0) {
@@ -813,7 +795,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
        state.lowpass_1 = 0.0f;
    } else {
        const auto a = 1.0f - hf_gain;
-        const auto b = 2.0f * (2.0f - hf_gain * CosD(256.0f * info.hf_reference /
+        const auto b = 2.0f * (1.0f - hf_gain * CosD(256.0f * info.hf_reference /
                                                     static_cast<f32>(info.sample_rate)));
        const auto c = std::sqrt(b * b - 4.0f * a * a);

@@ -861,7 +843,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
    }

    const auto max_early_delay = state.early_delay_line.GetMaxDelay();
-    const auto reflection_time = 1000.0f * (0.9998f * info.reverb_delay + 0.02f);
+    const auto reflection_time = 1000.0f * (0.0098f * info.reverb_delay + 0.02f);
    for (std::size_t tap = 0; tap < AudioCommon::I3DL2REVERB_TAPS; tap++) {
        const auto length = AudioCommon::CalculateDelaySamples(
            sample_rate, 1000.0f * info.reflection_delay + reflection_time * EARLY_TAP_TIMES[tap]);
@@ -980,8 +962,8 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
                  node_id, input_offset, output_offset, volume);
    }

-    std::span<s32> output = GetMixBuffer(output_offset);
-    std::span<const s32> input = GetMixBuffer(input_offset);
+    auto* output = GetMixBuffer(output_offset);
+    const auto* input = GetMixBuffer(input_offset);

    const s32 gain = static_cast<s32>(volume * 32768.0f);
    // Mix with loop unrolling
@@ -1021,10 +1003,8 @@ void CommandGenerator::GenerateFinalMixCommand() {
    }
 }

-template <typename T>
-s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
-                                s32 channel, std::size_t mix_offset) {
+s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
+                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
@@ -1033,41 +1013,30 @@ s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_sta
    if (wave_buffer.buffer_size == 0) {
        return 0;
    }
-    if (sample_end_offset < sample_start_offset) {
+    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
        return 0;
    }
-    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
+    const auto samples_remaining =
+        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
    const auto start_offset =
-        ((dsp_state.offset + sample_start_offset) * in_params.channel_count) * sizeof(T);
+        ((wave_buffer.start_sample_offset + dsp_state.offset) * in_params.channel_count) *
+        sizeof(s16);
    const auto buffer_pos = wave_buffer.buffer_address + start_offset;
    const auto samples_processed = std::min(sample_count, samples_remaining);

-    const auto channel_count = in_params.channel_count;
-    std::vector<T> buffer(samples_processed * channel_count);
-    memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(T));
-
-    if constexpr (std::is_floating_point_v<T>) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] = static_cast<s32>(buffer[i * channel_count + channel] *
-                                                             std::numeric_limits<s16>::max());
-        }
-    } else if constexpr (sizeof(T) == 1) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] =
-                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
-                                                  std::numeric_limits<s8>::max()) *
-                                 std::numeric_limits<s16>::max());
-        }
-    } else if constexpr (sizeof(T) == 2) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
+    if (in_params.channel_count == 1) {
+        std::vector<s16> buffer(samples_processed);
+        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
+        for (std::size_t i = 0; i < buffer.size(); i++) {
+            sample_buffer[mix_offset + i] = buffer[i];
        }
    } else {
+        const auto channel_count = in_params.channel_count;
+        std::vector<s16> buffer(samples_processed * channel_count);
+        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
+
        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] =
-                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
-                                                  std::numeric_limits<s32>::max()) *
-                                 std::numeric_limits<s16>::max());
+            sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
        }
    }

@@ -1075,8 +1044,8 @@ s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_sta
 }

 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
-                                  [[maybe_unused]] s32 channel, std::size_t mix_offset) {
+                                  s32 sample_count, [[maybe_unused]] s32 channel,
+                                  std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
@@ -1085,7 +1054,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    if (wave_buffer.buffer_size == 0) {
        return 0;
    }
-    if (sample_end_offset < sample_start_offset) {
+    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
        return 0;
    }

@@ -1110,9 +1079,10 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    s32 coef1 = coeffs[idx * 2];
    s32 coef2 = coeffs[idx * 2 + 1];

-    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
+    const auto samples_remaining =
+        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
    const auto samples_processed = std::min(sample_count, samples_remaining);
-    const auto sample_pos = dsp_state.offset + sample_start_offset;
+    const auto sample_pos = wave_buffer.start_sample_offset + dsp_state.offset;

    const auto samples_remaining_in_frame = sample_pos % SAMPLES_PER_FRAME;
    auto position_in_frame = ((sample_pos / SAMPLES_PER_FRAME) * NIBBLES_PER_SAMPLE) +
@@ -1187,14 +1157,12 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    return samples_processed;
 }

-std::span<s32> CommandGenerator::GetMixBuffer(std::size_t index) {
-    return std::span<s32>(mix_buffer.data() + (index * worker_params.sample_count),
-                          worker_params.sample_count);
+s32* CommandGenerator::GetMixBuffer(std::size_t index) {
+    return mix_buffer.data() + (index * worker_params.sample_count);
 }

-std::span<const s32> CommandGenerator::GetMixBuffer(std::size_t index) const {
-    return std::span<const s32>(mix_buffer.data() + (index * worker_params.sample_count),
-                                worker_params.sample_count);
+const s32* CommandGenerator::GetMixBuffer(std::size_t index) const {
+    return mix_buffer.data() + (index * worker_params.sample_count);
 }

 std::size_t CommandGenerator::GetMixChannelBufferOffset(s32 channel) const {
@@ -1205,15 +1173,15 @@ std::size_t CommandGenerator::GetTotalMixBufferCount() const {
    return worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT;
 }

-std::span<s32> CommandGenerator::GetChannelMixBuffer(s32 channel) {
+s32* CommandGenerator::GetChannelMixBuffer(s32 channel) {
    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

-std::span<const s32> CommandGenerator::GetChannelMixBuffer(s32 channel) const {
+const s32* CommandGenerator::GetChannelMixBuffer(s32 channel) const {
    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

-void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
+void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output,
                                             VoiceState& dsp_state, s32 channel,
                                             s32 target_sample_rate, s32 sample_count,
                                             s32 node_id) {
@@ -1225,7 +1193,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
                  node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
                  in_params.mix_id, in_params.splitter_info_id);
    }
-    ASSERT_OR_EXECUTE(output.data() != nullptr, { return; });
+    ASSERT_OR_EXECUTE(output != nullptr, { return; });

    const auto resample_rate = static_cast<s32>(
        static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
@@ -1242,9 +1210,9 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
    }

    std::size_t temp_mix_offset{};
-    s32 samples_output{};
+    bool is_buffer_completed{false};
    auto samples_remaining = sample_count;
-    while (samples_remaining > 0) {
+    while (samples_remaining > 0 && !is_buffer_completed) {
        const auto samples_to_output = std::min(samples_remaining, min_required_samples);
        const auto samples_to_read = (samples_to_output * resample_rate + dsp_state.fraction) >> 15;

@@ -1261,53 +1229,24 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
            const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
            // No more data can be read
            if (!dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index]) {
+                is_buffer_completed = true;
                break;
            }

            if (in_params.sample_format == SampleFormat::Adpcm && dsp_state.offset == 0 &&
                wave_buffer.context_address != 0 && wave_buffer.context_size != 0) {
-                memory.ReadBlock(wave_buffer.context_address, &dsp_state.context,
-                                 sizeof(ADPCMContext));
-            }
-
-            s32 samples_offset_start;
-            s32 samples_offset_end;
-            if (dsp_state.loop_count > 0 && wave_buffer.loop_start_sample != 0 &&
-                wave_buffer.loop_end_sample != 0 &&
-                wave_buffer.loop_start_sample <= wave_buffer.loop_end_sample) {
-                samples_offset_start = wave_buffer.loop_start_sample;
-                samples_offset_end = wave_buffer.loop_end_sample;
-            } else {
-                samples_offset_start = wave_buffer.start_sample_offset;
-                samples_offset_end = wave_buffer.end_sample_offset;
+                // TODO(ogniK): ADPCM loop context
            }

            s32 samples_decoded{0};
            switch (in_params.sample_format) {
-            case SampleFormat::Pcm8:
-                samples_decoded =
-                    DecodePcm<s8>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                  samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
            case SampleFormat::Pcm16:
-                samples_decoded =
-                    DecodePcm<s16>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
-            case SampleFormat::Pcm32:
-                samples_decoded =
-                    DecodePcm<s32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
-            case SampleFormat::PcmFloat:
-                samples_decoded =
-                    DecodePcm<f32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
+                samples_decoded = DecodePcm16(voice_info, dsp_state, samples_to_read - samples_read,
+                                              channel, temp_mix_offset);
                break;
            case SampleFormat::Adpcm:
-                samples_decoded =
-                    DecodeAdpcm(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                samples_to_read - samples_read, channel, temp_mix_offset);
+                samples_decoded = DecodeAdpcm(voice_info, dsp_state, samples_to_read - samples_read,
+                                              channel, temp_mix_offset);
                break;
            default:
                UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
@@ -1318,19 +1257,15 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
            dsp_state.offset += samples_decoded;
            dsp_state.played_sample_count += samples_decoded;

-            if (dsp_state.offset >= (samples_offset_end - samples_offset_start) ||
+            if (dsp_state.offset >=
+                    (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) ||
                samples_decoded == 0) {
                // Reset our sample offset
                dsp_state.offset = 0;
                if (wave_buffer.is_looping) {
-                    dsp_state.loop_count++;
-                    if (wave_buffer.loop_count > 0 &&
-                        (dsp_state.loop_count > wave_buffer.loop_count || samples_decoded == 0)) {
-                        // End of our buffer
-                        voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
-                    }
-
                    if (samples_decoded == 0) {
+                        // End of our buffer
+                        is_buffer_completed = true;
                        break;
                    }

@@ -1338,29 +1273,35 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
                        dsp_state.played_sample_count = 0;
                    }
                } else {
+
                    // Update our wave buffer states
-                    voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
+                    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
+                    dsp_state.wave_buffer_consumed++;
+                    dsp_state.wave_buffer_index =
+                        (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
+                    if (wave_buffer.end_of_stream) {
+                        dsp_state.played_sample_count = 0;
+                    }
                }
            }
        }

        if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
            // No need to resample
-            std::memcpy(output.data() + samples_output, sample_buffer.data(),
-                        samples_read * sizeof(s32));
+            std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
        } else {
            std::fill(sample_buffer.begin() + temp_mix_offset,
                      sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
                      0);
-            AudioCore::Resample(output.data() + samples_output, sample_buffer.data(), resample_rate,
-                                dsp_state.fraction, samples_to_output);
+            AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
+                                samples_to_output);
            // Resample
            for (std::size_t i = 0; i < AudioCommon::MAX_SAMPLE_HISTORY; i++) {
                dsp_state.sample_history[i] = sample_buffer[samples_to_read + i];
            }
        }
+        output += samples_to_output;
        samples_remaining -= samples_to_output;
-        samples_output += samples_to_output;
    }
 }

--- a/src/audio_core/command_generator.h
+++ b/src/audio_core/command_generator.h
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <span>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
 #include "common/common_types.h"
@@ -42,10 +41,10 @@ public:
    void PreCommand();
    void PostCommand();

-    [[nodiscard]] std::span<s32> GetChannelMixBuffer(s32 channel);
-    [[nodiscard]] std::span<const s32> GetChannelMixBuffer(s32 channel) const;
-    [[nodiscard]] std::span<s32> GetMixBuffer(std::size_t index);
-    [[nodiscard]] std::span<const s32> GetMixBuffer(std::size_t index) const;
+    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
+    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
+    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
+    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
    [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;

    [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
@@ -78,24 +77,21 @@ private:
    void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
    [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);

-    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                       std::span<const s32> data, u32 sample_count, u32 write_offset,
-                       u32 write_count);
-    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                      std::span<s32> out_data, u32 sample_count, u32 read_offset, u32 read_count);
+    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
+                       u32 sample_count, u32 write_offset, u32 write_count);
+    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
+                      u32 sample_count, u32 read_offset, u32 read_count);

    void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
                               std::vector<u8>& work_buffer);
    void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
    // DSP Code
-    template <typename T>
-    s32 DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
-                  s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
-    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
-                    s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
-    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
-                               VoiceState& dsp_state, s32 channel, s32 target_sample_rate,
-                               s32 sample_count, s32 node_id);
+    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
+                    s32 channel, std::size_t mix_offset);
+    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
+                    s32 channel, std::size_t mix_offset);
+    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output, VoiceState& dsp_state,
+                               s32 channel, s32 target_sample_rate, s32 sample_count, s32 node_id);

    AudioCommon::AudioRendererParameter& worker_params;
    VoiceContext& voice_context;
--- a/src/audio_core/common.h
+++ b/src/audio_core/common.h
@@ -15,7 +15,7 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren

-constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '9');
+constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
 constexpr std::size_t MAX_MIX_BUFFERS = 24;
 constexpr std::size_t MAX_BIQUAD_FILTERS = 2;
 constexpr std::size_t MAX_CHANNEL_COUNT = 6;
--- a/src/audio_core/info_updater.cpp
+++ b/src/audio_core/info_updater.cpp
@@ -189,6 +189,9 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
        if (voice_in_params.is_new) {
            // Default our values for our voice
            voice_info.Initialize();
+            if (channel_count == 0 || channel_count > AudioCommon::MAX_CHANNEL_COUNT) {
+                continue;
+            }

            // Zero out our voice states
            for (std::size_t channel = 0; channel < channel_count; channel++) {
--- a/src/audio_core/sdl2_sink.cpp
+++ b/src/audio_core/sdl2_sink.cpp
@@ -1,163 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <atomic>
-#include <cstring>
-#include "audio_core/sdl2_sink.h"
-#include "audio_core/stream.h"
-#include "audio_core/time_stretch.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-//#include "common/settings.h"
-
-// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
-#endif
-#include <SDL.h>
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace AudioCore {
-
-class SDLSinkStream final : public SinkStream {
-public:
-    SDLSinkStream(u32 sample_rate, u32 num_channels_, const std::string& output_device)
-        : num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate, num_channels} {
-
-        SDL_AudioSpec spec;
-        spec.freq = sample_rate;
-        spec.channels = static_cast<u8>(num_channels);
-        spec.format = AUDIO_S16SYS;
-        spec.samples = 4096;
-        spec.callback = nullptr;
-
-        SDL_AudioSpec obtained;
-        if (output_device.empty()) {
-            dev = SDL_OpenAudioDevice(nullptr, 0, &spec, &obtained, 0);
-        } else {
-            dev = SDL_OpenAudioDevice(output_device.c_str(), 0, &spec, &obtained, 0);
-        }
-
-        if (dev == 0) {
-            LOG_CRITICAL(Audio_Sink, "Error opening sdl audio device: {}", SDL_GetError());
-            return;
-        }
-
-        SDL_PauseAudioDevice(dev, 0);
-    }
-
-    ~SDLSinkStream() override {
-        if (dev == 0) {
-            return;
-        }
-
-        SDL_CloseAudioDevice(dev);
-    }
-
-    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
-        if (source_num_channels > num_channels) {
-            // Downsample 6 channels to 2
-            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
-
-            std::vector<s16> buf;
-            buf.reserve(samples.size() * num_channels / source_num_channels);
-            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                // Downmixing implementation taken from the ATSC standard
-                const s16 left{samples[i + 0]};
-                const s16 right{samples[i + 1]};
-                const s16 center{samples[i + 2]};
-                const s16 surround_left{samples[i + 4]};
-                const s16 surround_right{samples[i + 5]};
-                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects{samples[i + 3]};
-
-                constexpr s32 clev{707}; // center mixing level coefficient
-                constexpr s32 slev{707}; // surround mixing level coefficient
-
-                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
-                                               (slev * surround_left / 1000)));
-                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
-                                               (slev * surround_right / 1000)));
-            }
-            int ret = SDL_QueueAudio(dev, static_cast<const void*>(buf.data()),
-                                     static_cast<u32>(buf.size() * sizeof(s16)));
-            if (ret < 0)
-                LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-            return;
-        }
-
-        int ret = SDL_QueueAudio(dev, static_cast<const void*>(samples.data()),
-                                 static_cast<u32>(samples.size() * sizeof(s16)));
-        if (ret < 0)
-            LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-    }
-
-    std::size_t SamplesInQueue(u32 channel_count) const override {
-        if (dev == 0)
-            return 0;
-
-        return SDL_GetQueuedAudioSize(dev) / (channel_count * sizeof(s16));
-    }
-
-    void Flush() override {
-        should_flush = true;
-    }
-
-    u32 GetNumChannels() const {
-        return num_channels;
-    }
-
-private:
-    SDL_AudioDeviceID dev = 0;
-    u32 num_channels{};
-    std::atomic<bool> should_flush{};
-    TimeStretcher time_stretch;
-};
-
-SDLSink::SDLSink(std::string_view target_device_name) {
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return;
-        }
-    }
-
-    if (target_device_name != auto_device_name && !target_device_name.empty()) {
-        output_device = target_device_name;
-    } else {
-        output_device.clear();
-    }
-}
-
-SDLSink::~SDLSink() = default;
-
-SinkStream& SDLSink::AcquireSinkStream(u32 sample_rate, u32 num_channels, const std::string&) {
-    sink_streams.push_back(
-        std::make_unique<SDLSinkStream>(sample_rate, num_channels, output_device));
-    return *sink_streams.back();
-}
-
-std::vector<std::string> ListSDLSinkDevices() {
-    std::vector<std::string> device_list;
-
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return {};
-        }
-    }
-
-    const int device_count = SDL_GetNumAudioDevices(0);
-    for (int i = 0; i < device_count; ++i) {
-        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
-    }
-
-    return device_list;
-}
-
-} // namespace AudioCore
--- a/src/audio_core/sdl2_sink.h
+++ b/src/audio_core/sdl2_sink.h
@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "audio_core/sink.h"
-
-namespace AudioCore {
-
-class SDLSink final : public Sink {
-public:
-    explicit SDLSink(std::string_view device_id);
-    ~SDLSink() override;
-
-    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
-                                  const std::string& name) override;
-
-private:
-    std::string output_device;
-    std::vector<SinkStreamPtr> sink_streams;
-};
-
-std::vector<std::string> ListSDLSinkDevices();
-
-} // namespace AudioCore
--- a/src/audio_core/sink_context.cpp
+++ b/src/audio_core/sink_context.cpp
@@ -15,17 +15,10 @@ std::size_t SinkContext::GetCount() const {
 void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
    ASSERT(in.type == SinkTypes::Device);

-    if (in.device.down_matrix_enabled) {
+    has_downmix_coefs = in.device.down_matrix_enabled;
+    if (has_downmix_coefs) {
        downmix_coefficients = in.device.down_matrix_coef;
-    } else {
-        downmix_coefficients = {
-            1.0f,   // front
-            0.707f, // center
-            0.0f,   // lfe
-            0.707f, // back
-        };
    }
-
    in_use = in.in_use;
    use_count = in.device.input_count;
    buffers = in.device.input;
@@ -41,6 +34,10 @@ std::vector<u8> SinkContext::OutputBuffers() const {
    return buffer_ret;
 }

+bool SinkContext::HasDownMixingCoefficients() const {
+    return has_downmix_coefs;
+}
+
 const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
    return downmix_coefficients;
 }
--- a/src/audio_core/sink_context.h
+++ b/src/audio_core/sink_context.h
@@ -4,8 +4,6 @@

 #pragma once

-#include <array>
-#include <vector>
 #include "audio_core/common.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -84,6 +82,7 @@ public:
    [[nodiscard]] bool InUse() const;
    [[nodiscard]] std::vector<u8> OutputBuffers() const;

+    [[nodiscard]] bool HasDownMixingCoefficients() const;
    [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;

 private:
@@ -91,6 +90,7 @@ private:
    s32 use_count{};
    std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
    std::size_t sink_count{};
+    bool has_downmix_coefs{false};
    DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore
--- a/src/audio_core/sink_details.cpp
+++ b/src/audio_core/sink_details.cpp
@@ -11,9 +11,6 @@
 #ifdef HAVE_CUBEB
 #include "audio_core/cubeb_sink.h"
 #endif
-#ifdef HAVE_SDL2
-#include "audio_core/sdl2_sink.h"
-#endif
 #include "common/logging/log.h"

 namespace AudioCore {
@@ -38,13 +35,6 @@ constexpr SinkDetails sink_details[] = {
                    return std::make_unique<CubebSink>(device_id);
                },
                &ListCubebSinkDevices},
-#endif
-#ifdef HAVE_SDL2
-    SinkDetails{"sdl2",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<SDLSink>(device_id);
-                },
-                &ListSDLSinkDevices},
 #endif
    SinkDetails{"null",
                [](std::string_view device_id) -> std::unique_ptr<Sink> {
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -107,12 +107,9 @@ void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {
    active_buffer = queued_buffers.front();
    queued_buffers.pop();

-    auto& samples = active_buffer->GetSamples();
+    VolumeAdjustSamples(active_buffer->GetSamples(), game_volume);

-    VolumeAdjustSamples(samples, game_volume);
-
-    sink_stream.EnqueueSamples(GetNumChannels(), samples);
-    played_samples += samples.size();
+    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());

    const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);

--- a/src/audio_core/stream.h
+++ b/src/audio_core/stream.h
@@ -89,11 +89,6 @@ public:
        return sample_rate;
    }

-    /// Gets the number of samples played so far
-    [[nodiscard]] u64 GetPlayedSampleCount() const {
-        return played_samples;
-    }
-
    /// Gets the number of channels
    [[nodiscard]] u32 GetNumChannels() const;

@@ -111,7 +106,6 @@ private:
    [[nodiscard]] std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;

    u32 sample_rate;                  ///< Sample rate of the stream
-    u64 played_samples{};             ///< The current played sample count
    Format format;                    ///< Format of the stream
    float game_volume = 1.0f;         ///< The volume the game currently has set
    ReleaseCallback release_callback; ///< Buffer release callback for the stream
--- a/src/audio_core/voice_context.cpp
+++ b/src/audio_core/voice_context.cpp
@@ -66,7 +66,7 @@ void ServerVoiceInfo::Initialize() {
    in_params.last_volume = 0.0f;
    in_params.biquad_filter.fill({});
    in_params.wave_buffer_count = 0;
-    in_params.wave_buffer_head = 0;
+    in_params.wave_bufffer_head = 0;
    in_params.mix_id = AudioCommon::NO_MIX;
    in_params.splitter_info_id = AudioCommon::NO_SPLITTER;
    in_params.additional_params_address = 0;
@@ -75,7 +75,7 @@ void ServerVoiceInfo::Initialize() {
    out_params.played_sample_count = 0;
    out_params.wave_buffer_consumed = 0;
    in_params.voice_drop_flag = false;
-    in_params.buffer_mapped = true;
+    in_params.buffer_mapped = false;
    in_params.wave_buffer_flush_request_count = 0;
    in_params.was_biquad_filter_enabled.fill(false);

@@ -126,7 +126,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
    in_params.volume = voice_in.volume;
    in_params.biquad_filter = voice_in.biquad_filter;
    in_params.wave_buffer_count = voice_in.wave_buffer_count;
-    in_params.wave_buffer_head = voice_in.wave_buffer_head;
+    in_params.wave_bufffer_head = voice_in.wave_buffer_head;
    if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
        const auto in_request_count = in_params.wave_buffer_flush_request_count;
        const auto voice_request_count = voice_in.wave_buffer_flush_request_count;
@@ -185,16 +185,14 @@ void ServerVoiceInfo::UpdateWaveBuffers(
            wave_buffer.buffer_size = 0;
            wave_buffer.context_address = 0;
            wave_buffer.context_size = 0;
-            wave_buffer.loop_start_sample = 0;
-            wave_buffer.loop_end_sample = 0;
            wave_buffer.sent_to_dsp = true;
        }

        // Mark all our wave buffers as invalid
        for (std::size_t channel = 0; channel < static_cast<std::size_t>(in_params.channel_count);
             channel++) {
-            for (std::size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; ++i) {
-                voice_states[channel]->is_wave_buffer_valid[i] = false;
+            for (auto& is_valid : voice_states[channel]->is_wave_buffer_valid) {
+                is_valid = false;
            }
        }
    }
@@ -213,7 +211,7 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
                                       const WaveBuffer& in_wave_buffer, SampleFormat sample_format,
                                       bool is_buffer_valid,
                                       [[maybe_unused]] BehaviorInfo& behavior_info) {
-    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp && out_wavebuffer.buffer_address != 0) {
+    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp) {
        out_wavebuffer.buffer_address = 0;
        out_wavebuffer.buffer_size = 0;
    }
@@ -221,40 +219,11 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
    if (!in_wave_buffer.sent_to_server || !in_params.buffer_mapped) {
        // Validate sample offset sizings
        if (sample_format == SampleFormat::Pcm16) {
-            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
-            const s64 start = sizeof(s16) * in_wave_buffer.start_sample_offset;
-            const s64 end = sizeof(s16) * in_wave_buffer.end_sample_offset;
-            if (0 > start || start > buffer_size || 0 > end || end > buffer_size) {
+            const auto buffer_size = in_wave_buffer.buffer_size;
+            if (in_wave_buffer.start_sample_offset < 0 || in_wave_buffer.end_sample_offset < 0 ||
+                (buffer_size < (sizeof(s16) * in_wave_buffer.start_sample_offset)) ||
+                (buffer_size < (sizeof(s16) * in_wave_buffer.end_sample_offset))) {
                // TODO(ogniK): Write error info
-                LOG_ERROR(Audio,
-                          "PCM16 wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
-                          "offsets were "
-                          "{:08X} - 0x{:08X}",
-                          buffer_size, sizeof(s16) * in_wave_buffer.start_sample_offset,
-                          sizeof(s16) * in_wave_buffer.end_sample_offset);
-                return;
-            }
-        } else if (sample_format == SampleFormat::Adpcm) {
-            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
-            const s64 start_frames = in_wave_buffer.start_sample_offset / 14;
-            const s64 start_extra = in_wave_buffer.start_sample_offset % 14 == 0
-                                        ? 0
-                                        : (in_wave_buffer.start_sample_offset % 14) / 2 + 1 +
-                                              (in_wave_buffer.start_sample_offset % 2);
-            const s64 start = start_frames * 8 + start_extra;
-            const s64 end_frames = in_wave_buffer.end_sample_offset / 14;
-            const s64 end_extra = in_wave_buffer.end_sample_offset % 14 == 0
-                                      ? 0
-                                      : (in_wave_buffer.end_sample_offset % 14) / 2 + 1 +
-                                            (in_wave_buffer.end_sample_offset % 2);
-            const s64 end = end_frames * 8 + end_extra;
-            if (in_wave_buffer.start_sample_offset < 0 || start > buffer_size ||
-                in_wave_buffer.end_sample_offset < 0 || end > buffer_size) {
-                LOG_ERROR(Audio,
-                          "ADPMC wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
-                          "offsets were "
-                          "{:08X} - 0x{:08X}",
-                          in_wave_buffer.buffer_size, start, end);
                return;
            }
        }
@@ -270,34 +239,29 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
        out_wavebuffer.buffer_size = in_wave_buffer.buffer_size;
        out_wavebuffer.context_address = in_wave_buffer.context_address;
        out_wavebuffer.context_size = in_wave_buffer.context_size;
-        out_wavebuffer.loop_start_sample = in_wave_buffer.loop_start_sample;
-        out_wavebuffer.loop_end_sample = in_wave_buffer.loop_end_sample;
        in_params.buffer_mapped =
            in_wave_buffer.buffer_address != 0 && in_wave_buffer.buffer_size != 0;
        // TODO(ogniK): Pool mapper attachment
        // TODO(ogniK): IsAdpcmLoopContextBugFixed
-        if (sample_format == SampleFormat::Adpcm && in_wave_buffer.context_address != 0 &&
-            in_wave_buffer.context_size != 0 && behavior_info.IsAdpcmLoopContextBugFixed()) {
-        } else {
-            out_wavebuffer.context_address = 0;
-            out_wavebuffer.context_size = 0;
-        }
    }
 }

 void ServerVoiceInfo::WriteOutStatus(
    VoiceInfo::OutParams& voice_out, VoiceInfo::InParams& voice_in,
    std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& voice_states) {
-    if (voice_in.is_new || in_params.is_new) {
+    if (voice_in.is_new) {
        in_params.is_new = true;
        voice_out.wave_buffer_consumed = 0;
        voice_out.played_sample_count = 0;
        voice_out.voice_dropped = false;
+    } else if (!in_params.is_new) {
+        voice_out.wave_buffer_consumed = voice_states[0]->wave_buffer_consumed;
+        voice_out.played_sample_count = voice_states[0]->played_sample_count;
+        voice_out.voice_dropped = in_params.voice_drop_flag;
    } else {
-        const auto& state = voice_states[0];
-        voice_out.wave_buffer_consumed = state->wave_buffer_consumed;
-        voice_out.played_sample_count = state->played_sample_count;
-        voice_out.voice_dropped = state->voice_dropped;
+        voice_out.wave_buffer_consumed = 0;
+        voice_out.played_sample_count = 0;
+        voice_out.voice_dropped = false;
    }
 }

@@ -319,8 +283,7 @@ ServerVoiceInfo::OutParams& ServerVoiceInfo::GetOutParams() {

 bool ServerVoiceInfo::ShouldSkip() const {
    // TODO(ogniK): Handle unmapped wave buffers or parameters
-    return !in_params.in_use || in_params.wave_buffer_count == 0 || !in_params.buffer_mapped ||
-           in_params.voice_drop_flag;
+    return !in_params.in_use || (in_params.wave_buffer_count == 0) || in_params.voice_drop_flag;
 }

 bool ServerVoiceInfo::UpdateForCommandGeneration(VoiceContext& voice_context) {
@@ -418,7 +381,7 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
 void ServerVoiceInfo::FlushWaveBuffers(
    u8 flush_count, std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
    s32 channel_count) {
-    auto wave_head = in_params.wave_buffer_head;
+    auto wave_head = in_params.wave_bufffer_head;

    for (u8 i = 0; i < flush_count; i++) {
        in_params.wave_buffer[wave_head].sent_to_dsp = true;
@@ -438,17 +401,6 @@ bool ServerVoiceInfo::HasValidWaveBuffer(const VoiceState* state) const {
    return std::find(valid_wb.begin(), valid_wb.end(), true) != valid_wb.end();
 }

-void ServerVoiceInfo::SetWaveBufferCompleted(VoiceState& dsp_state,
-                                             const ServerWaveBuffer& wave_buffer) {
-    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
-    dsp_state.wave_buffer_consumed++;
-    dsp_state.wave_buffer_index = (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
-    dsp_state.loop_count = 0;
-    if (wave_buffer.end_of_stream) {
-        dsp_state.played_sample_count = 0;
-    }
-}
-
 VoiceContext::VoiceContext(std::size_t voice_count_) : voice_count{voice_count_} {
    for (std::size_t i = 0; i < voice_count; i++) {
        voice_channel_resources.emplace_back(static_cast<s32>(i));
--- a/src/audio_core/voice_context.h
+++ b/src/audio_core/voice_context.h
@@ -60,12 +60,10 @@ struct WaveBuffer {
    u8 is_looping{};
    u8 end_of_stream{};
    u8 sent_to_server{};
-    INSERT_PADDING_BYTES(1);
-    s32 loop_count{};
+    INSERT_PADDING_BYTES(5);
    u64 context_address{};
    u64 context_size{};
-    u32 loop_start_sample{};
-    u32 loop_end_sample{};
+    INSERT_PADDING_BYTES(8);
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer is an invalid size");

@@ -78,9 +76,6 @@ struct ServerWaveBuffer {
    bool end_of_stream{};
    VAddr context_address{};
    std::size_t context_size{};
-    s32 loop_count{};
-    u32 loop_start_sample{};
-    u32 loop_end_sample{};
    bool sent_to_dsp{true};
 };

@@ -113,7 +108,6 @@ struct VoiceState {
    u32 external_context_size;
    bool is_external_context_used;
    bool voice_dropped;
-    s32 loop_count;
 };

 class VoiceChannelResource {
@@ -212,7 +206,7 @@ public:
        float last_volume{};
        std::array<BiquadFilterParameter, AudioCommon::MAX_BIQUAD_FILTERS> biquad_filter{};
        s32 wave_buffer_count{};
-        s16 wave_buffer_head{};
+        s16 wave_bufffer_head{};
        INSERT_PADDING_BYTES(2);
        BehaviorFlags behavior_flags{};
        VAddr additional_params_address{};
@@ -258,7 +252,6 @@ public:
    void FlushWaveBuffers(u8 flush_count,
                          std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
                          s32 channel_count);
-    void SetWaveBufferCompleted(VoiceState& dsp_state, const ServerWaveBuffer& wave_buffer);

 private:
    std::vector<s16> stored_samples;
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -1,3 +1,8 @@
+# Add a custom command to generate a new shader_cache_version hash when any of the following files change
+# NOTE: This is an approximation of what files affect shader generation, its possible something else
+# could affect the result, but much more unlikely than the following files. Keeping a list of files
+# like this allows for much better caching since it doesn't force the user to recompile binary shaders every update
+set(VIDEO_CORE "${CMAKE_SOURCE_DIR}/src/video_core")
 if (DEFINED ENV{AZURECIREPO})
  set(BUILD_REPOSITORY $ENV{AZURECIREPO})
 endif()
@@ -16,21 +21,77 @@ find_package(Git QUIET)

 add_custom_command(OUTPUT scm_rev.cpp
    COMMAND ${CMAKE_COMMAND}
-      -DSRC_DIR=${CMAKE_SOURCE_DIR}
-      -DBUILD_REPOSITORY=${BUILD_REPOSITORY}
-      -DTITLE_BAR_FORMAT_IDLE=${TITLE_BAR_FORMAT_IDLE}
-      -DTITLE_BAR_FORMAT_RUNNING=${TITLE_BAR_FORMAT_RUNNING}
-      -DBUILD_TAG=${BUILD_TAG}
-      -DBUILD_ID=${DISPLAY_VERSION}
-      -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
-      -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
+      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
+      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
+      -DTITLE_BAR_FORMAT_IDLE="${TITLE_BAR_FORMAT_IDLE}"
+      -DTITLE_BAR_FORMAT_RUNNING="${TITLE_BAR_FORMAT_RUNNING}"
+      -DBUILD_TAG="${BUILD_TAG}"
+      -DBUILD_ID="${DISPLAY_VERSION}"
+      -DGIT_EXECUTABLE="${GIT_EXECUTABLE}"
+      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
    DEPENDS
-      # Check that the scm_rev files haven't changed
+      # WARNING! It was too much work to try and make a common location for this list,
+      # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/bfe.cpp"
+      "${VIDEO_CORE}/shader/decode/bfi.cpp"
+      "${VIDEO_CORE}/shader/decode/conversion.cpp"
+      "${VIDEO_CORE}/shader/decode/ffma.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+      "${VIDEO_CORE}/shader/decode/image.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/memory.cpp"
+      "${VIDEO_CORE}/shader/decode/texture.cpp"
+      "${VIDEO_CORE}/shader/decode/other.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/shift.cpp"
+      "${VIDEO_CORE}/shader/decode/video.cpp"
+      "${VIDEO_CORE}/shader/decode/warp.cpp"
+      "${VIDEO_CORE}/shader/decode/xmad.cpp"
+      "${VIDEO_CORE}/shader/ast.cpp"
+      "${VIDEO_CORE}/shader/ast.h"
+      "${VIDEO_CORE}/shader/compiler_settings.cpp"
+      "${VIDEO_CORE}/shader/compiler_settings.h"
+      "${VIDEO_CORE}/shader/control_flow.cpp"
+      "${VIDEO_CORE}/shader/control_flow.h"
+      "${VIDEO_CORE}/shader/decode.cpp"
+      "${VIDEO_CORE}/shader/expr.cpp"
+      "${VIDEO_CORE}/shader/expr.h"
+      "${VIDEO_CORE}/shader/node.h"
+      "${VIDEO_CORE}/shader/node_helper.cpp"
+      "${VIDEO_CORE}/shader/node_helper.h"
+      "${VIDEO_CORE}/shader/registry.cpp"
+      "${VIDEO_CORE}/shader/registry.h"
+      "${VIDEO_CORE}/shader/shader_ir.cpp"
+      "${VIDEO_CORE}/shader/shader_ir.h"
+      "${VIDEO_CORE}/shader/track.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.h"
+      # and also check that the scm_rev files haven't changed
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
      # technically we should regenerate if the git version changed, but its not worth the effort imo
      "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
-    VERBATIM
 )

 add_library(common STATIC
@@ -48,13 +109,12 @@ add_library(common STATIC
    cityhash.cpp
    cityhash.h
    common_funcs.h
+    common_sizes.h
    common_types.h
    concepts.h
    div_ceil.h
    dynamic_library.cpp
    dynamic_library.h
-    error.cpp
-    error.h
    fiber.cpp
    fiber.h
    fs/file.cpp
@@ -70,10 +130,7 @@ add_library(common STATIC
    hash.h
    hex_util.cpp
    hex_util.h
-    host_memory.cpp
-    host_memory.h
    intrusive_red_black_tree.h
-    literals.h
    logging/backend.cpp
    logging/backend.h
    logging/filter.cpp
@@ -81,7 +138,6 @@ add_library(common STATIC
    logging/log.h
    logging/text_formatter.cpp
    logging/text_formatter.h
-    logging/types.h
    lz4_compression.cpp
    lz4_compression.h
    math_util.h
@@ -90,6 +146,7 @@ add_library(common STATIC
    microprofile.cpp
    microprofile.h
    microprofileui.h
+    misc.cpp
    nvidia_flags.cpp
    nvidia_flags.h
    page_table.cpp
@@ -119,6 +176,7 @@ add_library(common STATIC
    thread.cpp
    thread.h
    thread_queue_list.h
+    thread_worker.cpp
    thread_worker.h
    threadsafe_queue.h
    time_zone.cpp
@@ -126,7 +184,6 @@ add_library(common STATIC
    tiny_mt.h
    tree.h
    uint128.h
-    unique_function.h
    uuid.cpp
    uuid.h
    vector_math.h
@@ -170,7 +227,7 @@ endif()

 create_target_directory_groups(common)

-target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
+target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 xbyak)
 if (MSVC)
  target_link_libraries(common PRIVATE zstd::zstd)
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -9,48 +9,41 @@
 namespace Common {

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
    auto mod{static_cast<T>(value % size)};
    value -= mod;
    return static_cast<T>(mod == T{0} ? value : value + size);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
    return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
    return static_cast<T>(value - value % size);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
    return (value & 0xFFF) == 0;
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr bool IsWordAligned(T value) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

 template <typename T>
-requires std::is_integral_v<T>
-[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
+requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
    using U = typename std::make_unsigned_t<T>;
    const U mask = static_cast<U>(alignment - 1);
    return (value & mask) == 0;
 }

 template <typename T, typename U>
-requires std::is_integral_v<T>
-[[nodiscard]] constexpr T DivideUp(T x, U y) {
+requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
    return (x + (y - 1)) / y;
 }

--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -52,12 +52,8 @@ assert_noinline_call(const Fn& fn) {
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
 #define DEBUG_ASSERT_MSG(_a_, ...) ASSERT_MSG(_a_, __VA_ARGS__)
 #else // not debug
-#define DEBUG_ASSERT(_a_)                                                                          \
-    do {                                                                                           \
-    } while (0)
-#define DEBUG_ASSERT_MSG(_a_, _desc_, ...)                                                         \
-    do {                                                                                           \
-    } while (0)
+#define DEBUG_ASSERT(_a_)
+#define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif

 #define UNIMPLEMENTED() ASSERT_MSG(false, "Unimplemented code!")
--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -4,8 +4,9 @@

 #pragma once

+#include <algorithm>
 #include <array>
-#include <iterator>
+#include <string>

 #if !defined(ARCHITECTURE_x86_64)
 #include <cstdlib> // for exit
@@ -48,6 +49,16 @@ __declspec(dllimport) void __stdcall DebugBreak(void);

 #endif // _MSC_VER ndef

+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+// Defined in misc.cpp.
+[[nodiscard]] std::string GetLastErrorMsg();
+
+// Like GetLastErrorMsg(), but passing an explicit error code.
+// Defined in misc.cpp.
+[[nodiscard]] std::string NativeErrorToString(int e);
+
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
    [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
        using T = std::underlying_type_t<type>;                                                    \
@@ -61,14 +72,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
        using T = std::underlying_type_t<type>;                                                    \
        return static_cast<type>(static_cast<T>(a) ^ static_cast<T>(b));                           \
    }                                                                                              \
-    [[nodiscard]] constexpr type operator<<(type a, type b) noexcept {                             \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) << static_cast<T>(b));                          \
-    }                                                                                              \
-    [[nodiscard]] constexpr type operator>>(type a, type b) noexcept {                             \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) >> static_cast<T>(b));                          \
-    }                                                                                              \
    constexpr type& operator|=(type& a, type b) noexcept {                                         \
        a = a | b;                                                                                 \
        return a;                                                                                  \
@@ -81,14 +84,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
        a = a ^ b;                                                                                 \
        return a;                                                                                  \
    }                                                                                              \
-    constexpr type& operator<<=(type& a, type b) noexcept {                                        \
-        a = a << b;                                                                                \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type& operator>>=(type& a, type b) noexcept {                                        \
-        a = a >> b;                                                                                \
-        return a;                                                                                  \
-    }                                                                                              \
    [[nodiscard]] constexpr type operator~(type key) noexcept {                                    \
        using T = std::underlying_type_t<type>;                                                    \
        return static_cast<type>(~static_cast<T>(key));                                            \
--- a/src/common/common_sizes.h
+++ b/src/common/common_sizes.h
@@ -0,0 +1,43 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <limits>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+enum : u64 {
+    Size_1_KB = 0x400ULL,
+    Size_64_KB = 64ULL * Size_1_KB,
+    Size_128_KB = 128ULL * Size_1_KB,
+    Size_1_MB = 0x100000ULL,
+    Size_2_MB = 2ULL * Size_1_MB,
+    Size_4_MB = 4ULL * Size_1_MB,
+    Size_5_MB = 5ULL * Size_1_MB,
+    Size_14_MB = 14ULL * Size_1_MB,
+    Size_32_MB = 32ULL * Size_1_MB,
+    Size_33_MB = 33ULL * Size_1_MB,
+    Size_128_MB = 128ULL * Size_1_MB,
+    Size_448_MB = 448ULL * Size_1_MB,
+    Size_507_MB = 507ULL * Size_1_MB,
+    Size_562_MB = 562ULL * Size_1_MB,
+    Size_1554_MB = 1554ULL * Size_1_MB,
+    Size_2048_MB = 2048ULL * Size_1_MB,
+    Size_2193_MB = 2193ULL * Size_1_MB,
+    Size_3285_MB = 3285ULL * Size_1_MB,
+    Size_4916_MB = 4916ULL * Size_1_MB,
+    Size_1_GB = 0x40000000ULL,
+    Size_2_GB = 2ULL * Size_1_GB,
+    Size_4_GB = 4ULL * Size_1_GB,
+    Size_6_GB = 6ULL * Size_1_GB,
+    Size_8_GB = 8ULL * Size_1_GB,
+    Size_64_GB = 64ULL * Size_1_GB,
+    Size_512_GB = 512ULL * Size_1_GB,
+    Size_Invalid = std::numeric_limits<u64>::max(),
+};
+
+} // namespace Common
--- a/src/common/detached_tasks.cpp
+++ b/src/common/detached_tasks.cpp
@@ -21,8 +21,6 @@ void DetachedTasks::WaitForAllTasks() {
 }

 DetachedTasks::~DetachedTasks() {
-    WaitForAllTasks();
-
    std::unique_lock lock{mutex};
    ASSERT(count == 0);
    instance = nullptr;
--- a/src/common/div_ceil.h
+++ b/src/common/div_ceil.h
@@ -11,15 +11,15 @@ namespace Common {

 /// Ceiled integer division.
 template <typename N, typename D>
-requires std::is_integral_v<N> && std::is_unsigned_v<D>
-[[nodiscard]] constexpr N DivCeil(N number, D divisor) {
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
+                                                                                        D divisor) {
    return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }

 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
-requires std::is_integral_v<N> && std::is_unsigned_v<D>
-[[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
+    N value, D alignment_log2) {
    return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }

--- a/src/common/error.h
+++ b/src/common/error.h
@@ -1,21 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-namespace Common {
-
-// Generic function to get last error message.
-// Call directly after the command or use the error num.
-// This function might change the error code.
-// Defined in error.cpp.
-[[nodiscard]] std::string GetLastErrorMsg();
-
-// Like GetLastErrorMsg(), but passing an explicit error code.
-// Defined in error.cpp.
-[[nodiscard]] std::string NativeErrorToString(int e);
-
-} // namespace Common
--- a/src/common/fs/file.cpp
+++ b/src/common/fs/file.cpp
@@ -172,7 +172,7 @@ std::string ReadStringFromFile(const std::filesystem::path& path, FileType type)

 size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
                         std::string_view string) {
-    if (Exists(path) && !IsFile(path)) {
+    if (!IsFile(path)) {
        return 0;
    }

@@ -183,7 +183,11 @@ size_t WriteStringToFile(const std::filesystem::path& path, FileType type,

 size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
                          std::string_view string) {
-    if (Exists(path) && !IsFile(path)) {
+    if (!Exists(path)) {
+        return WriteStringToFile(path, type, string);
+    }
+
+    if (!IsFile(path)) {
        return 0;
    }

@@ -305,11 +309,7 @@ bool IOFile::Flush() const {

    errno = 0;

-#ifdef _WIN32
    const auto flush_result = std::fflush(file) == 0;
-#else
-    const auto flush_result = std::fflush(file) == 0;
-#endif

    if (!flush_result) {
        const auto ec = std::error_code{errno, std::generic_category()};
@@ -320,28 +320,6 @@ bool IOFile::Flush() const {
    return flush_result;
 }

-bool IOFile::Commit() const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
-#ifdef _WIN32
-    const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
-#else
-    const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
-#endif
-
-    if (!commit_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    return commit_result;
-}
-
 bool IOFile::SetSize(u64 size) const {
    if (!IsOpen()) {
        return false;
@@ -369,9 +347,6 @@ u64 IOFile::GetSize() const {
        return 0;
    }

-    // Flush any unwritten buffered data into the file prior to retrieving the file size.
-    std::fflush(file);
-
    std::error_code ec;

    const auto file_size = fs::file_size(file_path, ec);
--- a/src/common/fs/file.h
+++ b/src/common/fs/file.h
@@ -49,7 +49,7 @@ void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::op

 /**
 * Reads an entire file at path and returns a string of the contents read from the file.
- * If the filesystem object at path is not a regular file, this function returns an empty string.
+ * If the filesystem object at path is not a file, this function returns an empty string.
 *
 * @param path Filesystem path
 * @param type File type
@@ -71,9 +71,8 @@ template <typename Path>

 /**
 * Writes a string to a file at path and returns the number of characters successfully written.
- * If a file already exists at path, its contents will be erased.
- * If a file does not exist at path, it creates and opens a new empty file for writing.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
+ * If an file already exists at path, its contents will be erased.
+ * If the filesystem object at path is not a file, this function returns 0.
 *
 * @param path Filesystem path
 * @param type File type
@@ -96,8 +95,8 @@ template <typename Path>

 /**
 * Appends a string to a file at path and returns the number of characters successfully written.
- * If a file does not exist at path, it creates and opens a new empty file for appending.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
+ * If a file does not exist at path, WriteStringToFile is called instead.
+ * If the filesystem object at path is not a file, this function returns 0.
 *
 * @param path Filesystem path
 * @param type File type
@@ -396,20 +395,11 @@ public:
    [[nodiscard]] size_t WriteString(std::span<const char> string) const;

    /**
-     * Attempts to flush any unwritten buffered data into the file.
+     * Flushes any unwritten buffered data into the file.
     *
     * @returns True if the flush was successful, false otherwise.
     */
-    bool Flush() const;
-
-    /**
-     * Attempts to commit the file into the disk.
-     * Note that this is an expensive operation as this forces the operating system to write
-     * the contents of the file associated with the file descriptor into the disk.
-     *
-     * @returns True if the commit was successful, false otherwise.
-     */
-    bool Commit() const;
+    [[nodiscard]] bool Flush() const;

    /**
     * Resizes the file to a given size.
--- a/src/common/fs/fs.cpp
+++ b/src/common/fs/fs.cpp
@@ -135,9 +135,8 @@ std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, File
        return nullptr;
    }

-    if (Exists(path) && !IsFile(path)) {
-        LOG_ERROR(Common_Filesystem,
-                  "Filesystem object at path={} exists and is not a regular file",
+    if (!IsFile(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
                  PathToUTF8String(path));
        return nullptr;
    }
@@ -322,8 +321,7 @@ bool RemoveDirContentsRecursively(const fs::path& path) {

    std::error_code ec;

-    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
+    for (const auto& entry : fs::recursive_directory_iterator(path, ec)) {
        if (ec) {
            LOG_ERROR(Common_Filesystem,
                      "Failed to completely enumerate the directory at path={}, ec_message={}",
@@ -339,12 +337,6 @@ bool RemoveDirContentsRecursively(const fs::path& path) {
                      PathToUTF8String(entry.path()), ec.message());
            break;
        }
-
-        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
-        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
-        if (entry.status().type() == fs::file_type::directory) {
-            return RemoveDirContentsRecursively(entry.path());
-        }
    }

    if (ec) {
@@ -483,8 +475,7 @@ void IterateDirEntriesRecursively(const std::filesystem::path& path,

    std::error_code ec;

-    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
+    for (const auto& entry : fs::recursive_directory_iterator(path, ec)) {
        if (ec) {
            break;
        }
@@ -504,12 +495,6 @@ void IterateDirEntriesRecursively(const std::filesystem::path& path,
                break;
            }
        }
-
-        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
-        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
-        if (entry.status().type() == fs::file_type::directory) {
-            IterateDirEntriesRecursively(entry.path(), callback, filter);
-        }
    }

    if (callback_error || ec) {
--- a/src/common/fs/fs.h
+++ b/src/common/fs/fs.h
@@ -48,18 +48,18 @@ template <typename Path>
 *
 * Failures occur when:
 * - Input path is not valid
- * - Filesystem object at path is not a regular file
+ * - Filesystem object at path is not a file
 * - Filesystem at path is read only
 *
 * @param path Filesystem path
 *
 * @returns True if file removal succeeds or file does not exist, false otherwise.
 */
-bool RemoveFile(const std::filesystem::path& path);
+[[nodiscard]] bool RemoveFile(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-bool RemoveFile(const Path& path) {
+[[nodiscard]] bool RemoveFile(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveFile(ToU8String(path));
    } else {
@@ -74,7 +74,7 @@ bool RemoveFile(const Path& path) {
 * Failures occur when:
 * - One or both input path(s) is not valid
 * - Filesystem object at old_path does not exist
- * - Filesystem object at old_path is not a regular file
+ * - Filesystem object at old_path is not a file
 * - Filesystem object at new_path exists
 * - Filesystem at either path is read only
 *
@@ -110,8 +110,8 @@ template <typename Path1, typename Path2>
 *
 * Failures occur when:
 * - Input path is not valid
- * - Filesystem object at path exists and is not a regular file
- * - The file is not open
+ * - Filesystem object at path is not a file
+ * - The file is not opened
 *
 * @param path Filesystem path
 * @param mode File access mode
@@ -251,11 +251,11 @@ template <typename Path>
 *
 * @returns True if directory removal succeeds or directory does not exist, false otherwise.
 */
-bool RemoveDir(const std::filesystem::path& path);
+[[nodiscard]] bool RemoveDir(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-bool RemoveDir(const Path& path) {
+[[nodiscard]] bool RemoveDir(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDir(ToU8String(path));
    } else {
@@ -276,11 +276,11 @@ bool RemoveDir(const Path& path) {
 *
 * @returns True if the directory and all of its contents are removed successfully, false otherwise.
 */
-bool RemoveDirRecursively(const std::filesystem::path& path);
+[[nodiscard]] bool RemoveDirRecursively(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-bool RemoveDirRecursively(const Path& path) {
+[[nodiscard]] bool RemoveDirRecursively(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDirRecursively(ToU8String(path));
    } else {
@@ -301,11 +301,11 @@ bool RemoveDirRecursively(const Path& path) {
 *
 * @returns True if all of the directory's contents are removed successfully, false otherwise.
 */
-bool RemoveDirContentsRecursively(const std::filesystem::path& path);
+[[nodiscard]] bool RemoveDirContentsRecursively(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-bool RemoveDirContentsRecursively(const Path& path) {
+[[nodiscard]] bool RemoveDirContentsRecursively(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDirContentsRecursively(ToU8String(path));
    } else {
@@ -435,13 +435,11 @@ template <typename Path>
 #endif

 /**
- * Returns whether a filesystem object at path is a regular file.
- * A regular file is a file that stores text or binary data.
- * It is not a directory, symlink, FIFO, socket, block device, or character device.
+ * Returns whether a filesystem object at path is a file.
 *
 * @param path Filesystem path
 *
- * @returns True if a filesystem object at path is a regular file, false otherwise.
+ * @returns True if a filesystem object at path is a file, false otherwise.
 */
 [[nodiscard]] bool IsFile(const std::filesystem::path& path);

--- a/src/common/fs/fs_paths.h
+++ b/src/common/fs/fs_paths.h
@@ -21,7 +21,6 @@
 #define SCREENSHOTS_DIR "screenshots"
 #define SDMC_DIR "sdmc"
 #define SHADER_DIR "shader"
-#define TAS_DIR "tas"

 // yuzu-specific files

--- a/src/common/fs/fs_util.cpp
+++ b/src/common/fs/fs_util.cpp
@@ -20,10 +20,6 @@ std::string ToUTF8String(std::u8string_view u8_string) {
    return std::string{u8_string.begin(), u8_string.end()};
 }

-std::string BufferToUTF8String(std::span<const u8> buffer) {
-    return std::string{buffer.begin(), std::ranges::find(buffer, u8{0})};
-}
-
 std::string PathToUTF8String(const std::filesystem::path& path) {
    return ToUTF8String(path.u8string());
 }
--- a/src/common/fs/fs_util.h
+++ b/src/common/fs/fs_util.h
@@ -46,17 +46,6 @@ concept IsChar = std::same_as<T, char>;
 */
 [[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);

-/**
- * Converts a buffer of bytes to a UTF8-encoded std::string.
- * This converts from the start of the buffer until the first encountered null-terminator.
- * If no null-terminator is found, this converts the entire buffer instead.
- *
- * @param buffer Buffer of bytes
- *
- * @returns UTF-8 encoded std::string.
- */
-[[nodiscard]] std::string BufferToUTF8String(std::span<const u8> buffer);
-
 /**
 * Converts a filesystem path to a UTF-8 encoded std::string.
 *
--- a/src/common/fs/path_util.cpp
+++ b/src/common/fs/path_util.cpp
@@ -116,7 +116,6 @@ private:
        GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
        GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
        GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
-        GenerateYuzuPath(YuzuPath::TASDir, yuzu_path / TAS_DIR);
    }

    ~PathManagerImpl() = default;
--- a/src/common/fs/path_util.h
+++ b/src/common/fs/path_util.h
@@ -23,7 +23,6 @@ enum class YuzuPath {
    ScreenshotsDir, // Where yuzu screenshots are stored.
    SDMCDir,        // Where the emulated SDMC is stored.
    ShaderDir,      // Where shaders are stored.
-    TASDir,         // Where TAS scripts are stored.
 };

 /**
@@ -210,7 +209,7 @@ void SetYuzuPath(YuzuPath yuzu_path, const std::filesystem::path& new_path);

 #ifdef _WIN32
 template <typename Path>
-void SetYuzuPath(YuzuPath yuzu_path, const Path& new_path) {
+[[nodiscard]] void SetYuzuPath(YuzuPath yuzu_path, const Path& new_path) {
    if constexpr (IsChar<typename Path::value_type>) {
        SetYuzuPath(yuzu_path, ToU8String(new_path));
    } else {
--- a/src/common/hex_util.h
+++ b/src/common/hex_util.h
@@ -53,15 +53,14 @@ template <typename ContiguousContainer>
    std::string out;
    out.reserve(std::size(data) * pad_width);

-    const auto format_str = fmt::runtime(upper ? "{:02X}" : "{:02x}");
    for (const u8 c : data) {
-        out += fmt::format(format_str, c);
+        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
    }

    return out;
 }

-[[nodiscard]] constexpr std::array<u8, 16> AsArray(const char (&data)[33]) {
+[[nodiscard]] constexpr std::array<u8, 16> AsArray(const char (&data)[17]) {
    return HexStringToArray<16>(data);
 }

--- a/src/common/host_memory.cpp
+++ b/src/common/host_memory.cpp
@@ -1,543 +0,0 @@
-#ifdef _WIN32
-
-#include <iterator>
-#include <unordered_map>
-#include <boost/icl/separate_interval_set.hpp>
-#include <windows.h>
-#include "common/dynamic_library.h"
-
-#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#endif // ^^^ Linux ^^^
-
-#include <mutex>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/host_memory.h"
-#include "common/logging/log.h"
-#include "common/scope_exit.h"
-
-namespace Common {
-
-constexpr size_t PageAlignment = 0x1000;
-constexpr size_t HugePageSize = 0x200000;
-
-#ifdef _WIN32
-
-// Manually imported for MinGW compatibility
-#ifndef MEM_RESERVE_PLACEHOLDER
-#define MEM_RESERVE_PLACEHOLDER 0x00040000
-#endif
-#ifndef MEM_REPLACE_PLACEHOLDER
-#define MEM_REPLACE_PLACEHOLDER 0x00004000
-#endif
-#ifndef MEM_COALESCE_PLACEHOLDERS
-#define MEM_COALESCE_PLACEHOLDERS 0x00000001
-#endif
-#ifndef MEM_PRESERVE_PLACEHOLDER
-#define MEM_PRESERVE_PLACEHOLDER 0x00000002
-#endif
-
-using PFN_CreateFileMapping2 = _Ret_maybenull_ HANDLE(WINAPI*)(
-    _In_ HANDLE File, _In_opt_ SECURITY_ATTRIBUTES* SecurityAttributes, _In_ ULONG DesiredAccess,
-    _In_ ULONG PageProtection, _In_ ULONG AllocationAttributes, _In_ ULONG64 MaximumSize,
-    _In_opt_ PCWSTR Name,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_VirtualAlloc2 = _Ret_maybenull_ PVOID(WINAPI*)(
-    _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress, _In_ SIZE_T Size,
-    _In_ ULONG AllocationType, _In_ ULONG PageProtection,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_MapViewOfFile3 = _Ret_maybenull_ PVOID(WINAPI*)(
-    _In_ HANDLE FileMapping, _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress,
-    _In_ ULONG64 Offset, _In_ SIZE_T ViewSize, _In_ ULONG AllocationType, _In_ ULONG PageProtection,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_UnmapViewOfFile2 = BOOL(WINAPI*)(_In_ HANDLE Process, _In_ PVOID BaseAddress,
-                                           _In_ ULONG UnmapFlags);
-
-template <typename T>
-static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn) {
-    if (!dll.GetSymbol(name, &pfn)) {
-        LOG_CRITICAL(HW_Memory, "Failed to load {}", name);
-        throw std::bad_alloc{};
-    }
-}
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
-        : backing_size{backing_size_}, virtual_size{virtual_size_}, process{GetCurrentProcess()},
-          kernelbase_dll("Kernelbase") {
-        if (!kernelbase_dll.IsOpen()) {
-            LOG_CRITICAL(HW_Memory, "Failed to load Kernelbase.dll");
-            throw std::bad_alloc{};
-        }
-        GetFuncAddress(kernelbase_dll, "CreateFileMapping2", pfn_CreateFileMapping2);
-        GetFuncAddress(kernelbase_dll, "VirtualAlloc2", pfn_VirtualAlloc2);
-        GetFuncAddress(kernelbase_dll, "MapViewOfFile3", pfn_MapViewOfFile3);
-        GetFuncAddress(kernelbase_dll, "UnmapViewOfFile2", pfn_UnmapViewOfFile2);
-
-        // Allocate backing file map
-        backing_handle =
-            pfn_CreateFileMapping2(INVALID_HANDLE_VALUE, nullptr, FILE_MAP_WRITE | FILE_MAP_READ,
-                                   PAGE_READWRITE, SEC_COMMIT, backing_size, nullptr, nullptr, 0);
-        if (!backing_handle) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate {} MiB of backing memory",
-                         backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Allocate a virtual memory for the backing file map as placeholder
-        backing_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, backing_size,
-                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
-                                                          PAGE_NOACCESS, nullptr, 0));
-        if (!backing_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to reserve {} MiB of virtual memory",
-                         backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Map backing placeholder
-        void* const ret = pfn_MapViewOfFile3(backing_handle, process, backing_base, 0, backing_size,
-                                             MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0);
-        if (ret != backing_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to map {} MiB of virtual memory", backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Allocate virtual address placeholder
-        virtual_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, virtual_size,
-                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
-                                                          PAGE_NOACCESS, nullptr, 0));
-        if (!virtual_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to reserve {} GiB of virtual memory",
-                         virtual_size >> 30);
-            throw std::bad_alloc{};
-        }
-    }
-
-    ~Impl() {
-        Release();
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
-        std::unique_lock lock{placeholder_mutex};
-        if (!IsNiechePlaceholder(virtual_offset, length)) {
-            Split(virtual_offset, length);
-        }
-        ASSERT(placeholders.find({virtual_offset, virtual_offset + length}) == placeholders.end());
-        TrackPlaceholder(virtual_offset, host_offset, length);
-
-        MapView(virtual_offset, host_offset, length);
-    }
-
-    void Unmap(size_t virtual_offset, size_t length) {
-        std::lock_guard lock{placeholder_mutex};
-
-        // Unmap until there are no more placeholders
-        while (UnmapOnePlaceholder(virtual_offset, length)) {
-        }
-    }
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-        DWORD new_flags{};
-        if (read && write) {
-            new_flags = PAGE_READWRITE;
-        } else if (read && !write) {
-            new_flags = PAGE_READONLY;
-        } else if (!read && !write) {
-            new_flags = PAGE_NOACCESS;
-        } else {
-            UNIMPLEMENTED_MSG("Protection flag combination read={} write={}", read, write);
-        }
-        const size_t virtual_end = virtual_offset + length;
-
-        std::lock_guard lock{placeholder_mutex};
-        auto [it, end] = placeholders.equal_range({virtual_offset, virtual_end});
-        while (it != end) {
-            const size_t offset = std::max(it->lower(), virtual_offset);
-            const size_t protect_length = std::min(it->upper(), virtual_end) - offset;
-            DWORD old_flags{};
-            if (!VirtualProtect(virtual_base + offset, protect_length, new_flags, &old_flags)) {
-                LOG_CRITICAL(HW_Memory, "Failed to change virtual memory protect rules");
-            }
-            ++it;
-        }
-    }
-
-    const size_t backing_size; ///< Size of the backing memory in bytes
-    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-
-    u8* backing_base{};
-    u8* virtual_base{};
-
-private:
-    /// Release all resources in the object
-    void Release() {
-        if (!placeholders.empty()) {
-            for (const auto& placeholder : placeholders) {
-                if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder.lower(),
-                                          MEM_PRESERVE_PLACEHOLDER)) {
-                    LOG_CRITICAL(HW_Memory, "Failed to unmap virtual memory placeholder");
-                }
-            }
-            Coalesce(0, virtual_size);
-        }
-        if (virtual_base) {
-            if (!VirtualFree(virtual_base, 0, MEM_RELEASE)) {
-                LOG_CRITICAL(HW_Memory, "Failed to free virtual memory");
-            }
-        }
-        if (backing_base) {
-            if (!pfn_UnmapViewOfFile2(process, backing_base, MEM_PRESERVE_PLACEHOLDER)) {
-                LOG_CRITICAL(HW_Memory, "Failed to unmap backing memory placeholder");
-            }
-            if (!VirtualFreeEx(process, backing_base, 0, MEM_RELEASE)) {
-                LOG_CRITICAL(HW_Memory, "Failed to free backing memory");
-            }
-        }
-        if (!CloseHandle(backing_handle)) {
-            LOG_CRITICAL(HW_Memory, "Failed to free backing memory file handle");
-        }
-    }
-
-    /// Unmap one placeholder in the given range (partial unmaps are supported)
-    /// Return true when there are no more placeholders to unmap
-    bool UnmapOnePlaceholder(size_t virtual_offset, size_t length) {
-        const auto it = placeholders.find({virtual_offset, virtual_offset + length});
-        const auto begin = placeholders.begin();
-        const auto end = placeholders.end();
-        if (it == end) {
-            return false;
-        }
-        const size_t placeholder_begin = it->lower();
-        const size_t placeholder_end = it->upper();
-        const size_t unmap_begin = std::max(virtual_offset, placeholder_begin);
-        const size_t unmap_end = std::min(virtual_offset + length, placeholder_end);
-        ASSERT(unmap_begin >= placeholder_begin && unmap_begin < placeholder_end);
-        ASSERT(unmap_end <= placeholder_end && unmap_end > placeholder_begin);
-
-        const auto host_pointer_it = placeholder_host_pointers.find(placeholder_begin);
-        ASSERT(host_pointer_it != placeholder_host_pointers.end());
-        const size_t host_offset = host_pointer_it->second;
-
-        const bool split_left = unmap_begin > placeholder_begin;
-        const bool split_right = unmap_end < placeholder_end;
-
-        if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder_begin,
-                                  MEM_PRESERVE_PLACEHOLDER)) {
-            LOG_CRITICAL(HW_Memory, "Failed to unmap placeholder");
-        }
-        // If we have to remap memory regions due to partial unmaps, we are in a data race as
-        // Windows doesn't support remapping memory without unmapping first. Avoid adding any extra
-        // logic within the panic region described below.
-
-        // Panic region, we are in a data race right now
-        if (split_left || split_right) {
-            Split(unmap_begin, unmap_end - unmap_begin);
-        }
-        if (split_left) {
-            MapView(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
-        }
-        if (split_right) {
-            MapView(unmap_end, host_offset + unmap_end - placeholder_begin,
-                    placeholder_end - unmap_end);
-        }
-        // End panic region
-
-        size_t coalesce_begin = unmap_begin;
-        if (!split_left) {
-            // Try to coalesce pages to the left
-            coalesce_begin = it == begin ? 0 : std::prev(it)->upper();
-            if (coalesce_begin != placeholder_begin) {
-                Coalesce(coalesce_begin, unmap_end - coalesce_begin);
-            }
-        }
-        if (!split_right) {
-            // Try to coalesce pages to the right
-            const auto next = std::next(it);
-            const size_t next_begin = next == end ? virtual_size : next->lower();
-            if (placeholder_end != next_begin) {
-                // We can coalesce to the right
-                Coalesce(coalesce_begin, next_begin - coalesce_begin);
-            }
-        }
-        // Remove and reinsert placeholder trackers
-        UntrackPlaceholder(it);
-        if (split_left) {
-            TrackPlaceholder(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
-        }
-        if (split_right) {
-            TrackPlaceholder(unmap_end, host_offset + unmap_end - placeholder_begin,
-                             placeholder_end - unmap_end);
-        }
-        return true;
-    }
-
-    void MapView(size_t virtual_offset, size_t host_offset, size_t length) {
-        if (!pfn_MapViewOfFile3(backing_handle, process, virtual_base + virtual_offset, host_offset,
-                                length, MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0)) {
-            LOG_CRITICAL(HW_Memory, "Failed to map placeholder");
-        }
-    }
-
-    void Split(size_t virtual_offset, size_t length) {
-        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
-                           MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER)) {
-            LOG_CRITICAL(HW_Memory, "Failed to split placeholder");
-        }
-    }
-
-    void Coalesce(size_t virtual_offset, size_t length) {
-        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
-                           MEM_RELEASE | MEM_COALESCE_PLACEHOLDERS)) {
-            LOG_CRITICAL(HW_Memory, "Failed to coalesce placeholders");
-        }
-    }
-
-    void TrackPlaceholder(size_t virtual_offset, size_t host_offset, size_t length) {
-        placeholders.insert({virtual_offset, virtual_offset + length});
-        placeholder_host_pointers.emplace(virtual_offset, host_offset);
-    }
-
-    void UntrackPlaceholder(boost::icl::separate_interval_set<size_t>::iterator it) {
-        placeholders.erase(it);
-        placeholder_host_pointers.erase(it->lower());
-    }
-
-    /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
-    /// splitted.
-    bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
-        const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
-        if (it != placeholders.end() && it->lower() == virtual_offset + length) {
-            const bool is_root = it == placeholders.begin() && virtual_offset == 0;
-            return is_root || std::prev(it)->upper() == virtual_offset;
-        }
-        return false;
-    }
-
-    HANDLE process{};        ///< Current process handle
-    HANDLE backing_handle{}; ///< File based backing memory
-
-    DynamicLibrary kernelbase_dll;
-    PFN_CreateFileMapping2 pfn_CreateFileMapping2{};
-    PFN_VirtualAlloc2 pfn_VirtualAlloc2{};
-    PFN_MapViewOfFile3 pfn_MapViewOfFile3{};
-    PFN_UnmapViewOfFile2 pfn_UnmapViewOfFile2{};
-
-    std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
-    boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
-};
-
-#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
-        : backing_size{backing_size_}, virtual_size{virtual_size_} {
-        bool good = false;
-        SCOPE_EXIT({
-            if (!good) {
-                Release();
-            }
-        });
-
-        // Backing memory initialization
-#if defined(__FreeBSD__) && __FreeBSD__ < 13
-        // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
-        fd = shm_open(SHM_ANON, O_RDWR, 0600);
-#else
-        fd = memfd_create("HostMemory", 0);
-#endif
-        if (fd == -1) {
-            LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        // Defined to extend the file with zeros
-        int ret = ftruncate(fd, backing_size);
-        if (ret != 0) {
-            LOG_CRITICAL(HW_Memory, "ftruncate failed with {}, are you out-of-memory?",
-                         strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        backing_base = static_cast<u8*>(
-            mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
-        if (backing_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        // Virtual memory initialization
-        virtual_base = static_cast<u8*>(
-            mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
-        if (virtual_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        good = true;
-    }
-
-    ~Impl() {
-        Release();
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
-
-        void* ret = mmap(virtual_base + virtual_offset, length, PROT_READ | PROT_WRITE,
-                         MAP_SHARED | MAP_FIXED, fd, host_offset);
-        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
-    }
-
-    void Unmap(size_t virtual_offset, size_t length) {
-        // The method name is wrong. We're still talking about the virtual range.
-        // We don't want to unmap, we want to reserve this memory.
-
-        void* ret = mmap(virtual_base + virtual_offset, length, PROT_NONE,
-                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
-        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
-    }
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-        int flags = 0;
-        if (read) {
-            flags |= PROT_READ;
-        }
-        if (write) {
-            flags |= PROT_WRITE;
-        }
-        int ret = mprotect(virtual_base + virtual_offset, length, flags);
-        ASSERT_MSG(ret == 0, "mprotect failed: {}", strerror(errno));
-    }
-
-    const size_t backing_size; ///< Size of the backing memory in bytes
-    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-
-    u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
-    u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
-
-private:
-    /// Release all resources in the object
-    void Release() {
-        if (virtual_base != MAP_FAILED) {
-            int ret = munmap(virtual_base, virtual_size);
-            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
-        }
-
-        if (backing_base != MAP_FAILED) {
-            int ret = munmap(backing_base, backing_size);
-            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
-        }
-
-        if (fd != -1) {
-            int ret = close(fd);
-            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
-        }
-    }
-
-    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
-};
-
-#else // ^^^ Linux ^^^ vvv Generic vvv
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
-        // This is just a place holder.
-        // Please implement fastmem in a propper way on your platform.
-        throw std::bad_alloc{};
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {}
-
-    void Unmap(size_t virtual_offset, size_t length) {}
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {}
-
-    u8* backing_base{nullptr};
-    u8* virtual_base{nullptr};
-};
-
-#endif // ^^^ Generic ^^^
-
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
-    : backing_size(backing_size_), virtual_size(virtual_size_) {
-    try {
-        // Try to allocate a fastmem arena.
-        // The implementation will fail with std::bad_alloc on errors.
-        impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment),
-                                                  AlignUp(virtual_size, PageAlignment) +
-                                                      3 * HugePageSize);
-        backing_base = impl->backing_base;
-        virtual_base = impl->virtual_base;
-
-        if (virtual_base) {
-            virtual_base += 2 * HugePageSize - 1;
-            virtual_base -= reinterpret_cast<size_t>(virtual_base) & (HugePageSize - 1);
-            virtual_base_offset = virtual_base - impl->virtual_base;
-        }
-
-    } catch (const std::bad_alloc&) {
-        LOG_CRITICAL(HW_Memory,
-                     "Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
-        fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
-        backing_base = fallback_buffer->data();
-        virtual_base = nullptr;
-    }
-}
-
-HostMemory::~HostMemory() = default;
-
-HostMemory::HostMemory(HostMemory&&) noexcept = default;
-
-HostMemory& HostMemory::operator=(HostMemory&&) noexcept = default;
-
-void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(host_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    ASSERT(host_offset + length <= backing_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Map(virtual_offset + virtual_base_offset, host_offset, length);
-}
-
-void HostMemory::Unmap(size_t virtual_offset, size_t length) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Unmap(virtual_offset + virtual_base_offset, length);
-}
-
-void HostMemory::Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Protect(virtual_offset + virtual_base_offset, length, read, write);
-}
-
-} // namespace Common
--- a/src/common/host_memory.h
+++ b/src/common/host_memory.h
@@ -1,70 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "common/common_types.h"
-#include "common/virtual_buffer.h"
-
-namespace Common {
-
-/**
- * A low level linear memory buffer, which supports multiple mappings
- * Its purpose is to rebuild a given sparse memory layout, including mirrors.
- */
-class HostMemory {
-public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
-    ~HostMemory();
-
-    /**
-     * Copy constructors. They shall return a copy of the buffer without the mappings.
-     * TODO: Implement them with COW if needed.
-     */
-    HostMemory(const HostMemory& other) = delete;
-    HostMemory& operator=(const HostMemory& other) = delete;
-
-    /**
-     * Move constructors. They will move the buffer and the mappings to the new object.
-     */
-    HostMemory(HostMemory&& other) noexcept;
-    HostMemory& operator=(HostMemory&& other) noexcept;
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length);
-
-    void Unmap(size_t virtual_offset, size_t length);
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write);
-
-    [[nodiscard]] u8* BackingBasePointer() noexcept {
-        return backing_base;
-    }
-    [[nodiscard]] const u8* BackingBasePointer() const noexcept {
-        return backing_base;
-    }
-
-    [[nodiscard]] u8* VirtualBasePointer() noexcept {
-        return virtual_base;
-    }
-    [[nodiscard]] const u8* VirtualBasePointer() const noexcept {
-        return virtual_base;
-    }
-
-private:
-    size_t backing_size{};
-    size_t virtual_size{};
-
-    // Low level handler for the platform dependent memory routines
-    class Impl;
-    std::unique_ptr<Impl> impl;
-    u8* backing_base{};
-    u8* virtual_base{};
-    size_t virtual_base_offset{};
-
-    // Fallback if fastmem is not supported on this platform
-    std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
-};
-
-} // namespace Common
--- a/src/common/intrusive_red_black_tree.h
+++ b/src/common/intrusive_red_black_tree.h
@@ -235,19 +235,20 @@ public:

 template <typename T>
 concept HasLightCompareType = requires {
-    { std::is_same<typename T::LightCompareType, void>::value } -> std::convertible_to<bool>;
+    { std::is_same<typename T::LightCompareType, void>::value }
+    ->std::convertible_to<bool>;
 };

 namespace impl {

-    template <typename T, typename Default>
-    consteval auto* GetLightCompareType() {
-        if constexpr (HasLightCompareType<T>) {
-            return static_cast<typename T::LightCompareType*>(nullptr);
-        } else {
-            return static_cast<Default*>(nullptr);
-        }
+template <typename T, typename Default>
+consteval auto* GetLightCompareType() {
+    if constexpr (HasLightCompareType<T>) {
+        return static_cast<typename T::LightCompareType*>(nullptr);
+    } else {
+        return static_cast<Default*>(nullptr);
    }
+}

 } // namespace impl

--- a/src/common/literals.h
+++ b/src/common/literals.h
@@ -1,31 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Common::Literals {
-
-constexpr u64 operator""_KiB(unsigned long long int x) {
-    return 1024ULL * x;
-}
-
-constexpr u64 operator""_MiB(unsigned long long int x) {
-    return 1024_KiB * x;
-}
-
-constexpr u64 operator""_GiB(unsigned long long int x) {
-    return 1024_MiB * x;
-}
-
-constexpr u64 operator""_TiB(unsigned long long int x) {
-    return 1024_GiB * x;
-}
-
-constexpr u64 operator""_PiB(unsigned long long int x) {
-    return 1024_TiB * x;
-}
-
-} // namespace Common::Literals
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -2,10 +2,13 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <climits>
-#include <exception>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
 #include <thread>
 #include <vector>

@@ -13,174 +16,25 @@
 #include <windows.h> // For OutputDebugStringW
 #endif

-#include "common/fs/file.h"
+#include "common/assert.h"
 #include "common/fs/fs.h"
-#include "common/fs/fs_paths.h"
-#include "common/fs/path_util.h"
-#include "common/literals.h"
-#include "common/thread.h"
-
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/settings.h"
-#ifdef _WIN32
 #include "common/string_util.h"
-#endif
 #include "common/threadsafe_queue.h"

 namespace Common::Log {

-namespace {
-
-/**
- * Interface for logging backends.
- */
-class Backend {
-public:
-    virtual ~Backend() = default;
-
-    virtual void Write(const Entry& entry) = 0;
-
-    virtual void EnableForStacktrace() = 0;
-
-    virtual void Flush() = 0;
-};
-
-/**
- * Backend that writes to stderr and with color
- */
-class ColorConsoleBackend final : public Backend {
-public:
-    explicit ColorConsoleBackend() = default;
-
-    ~ColorConsoleBackend() override = default;
-
-    void Write(const Entry& entry) override {
-        if (enabled.load(std::memory_order_relaxed)) {
-            PrintColoredMessage(entry);
-        }
-    }
-
-    void Flush() override {
-        // stderr shouldn't be buffered
-    }
-
-    void EnableForStacktrace() override {
-        enabled = true;
-    }
-
-    void SetEnabled(bool enabled_) {
-        enabled = enabled_;
-    }
-
-private:
-    std::atomic_bool enabled{false};
-};
-
-/**
- * Backend that writes to a file passed into the constructor
- */
-class FileBackend final : public Backend {
-public:
-    explicit FileBackend(const std::filesystem::path& filename) {
-        auto old_filename = filename;
-        old_filename += ".old.txt";
-
-        // Existence checks are done within the functions themselves.
-        // We don't particularly care if these succeed or not.
-        static_cast<void>(FS::RemoveFile(old_filename));
-        static_cast<void>(FS::RenameFile(filename, old_filename));
-
-        file = std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write,
-                                            FS::FileType::TextFile);
-    }
-
-    ~FileBackend() override = default;
-
-    void Write(const Entry& entry) override {
-        if (!enabled) {
-            return;
-        }
-
-        bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
-
-        using namespace Common::Literals;
-        // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
-        const auto write_limit = Settings::values.extended_logging ? 1_GiB : 100_MiB;
-        const bool write_limit_exceeded = bytes_written > write_limit;
-        if (entry.log_level >= Level::Error || write_limit_exceeded) {
-            if (write_limit_exceeded) {
-                // Stop writing after the write limit is exceeded.
-                // Don't close the file so we can print a stacktrace if necessary
-                enabled = false;
-            }
-            file->Flush();
-        }
-    }
-
-    void Flush() override {
-        file->Flush();
-    }
-
-    void EnableForStacktrace() override {
-        enabled = true;
-        bytes_written = 0;
-    }
-
-private:
-    std::unique_ptr<FS::IOFile> file;
-    bool enabled = true;
-    std::size_t bytes_written = 0;
-};
-
-/**
- * Backend that writes to Visual Studio's output window
- */
-class DebuggerBackend final : public Backend {
-public:
-    explicit DebuggerBackend() = default;
-
-    ~DebuggerBackend() override = default;
-
-    void Write(const Entry& entry) override {
-#ifdef _WIN32
-        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
-#endif
-    }
-
-    void Flush() override {}
-
-    void EnableForStacktrace() override {}
-};
-
-bool initialization_in_progress_suppress_logging = true;
-
 /**
 * Static state as a singleton.
 */
 class Impl {
 public:
    static Impl& Instance() {
-        if (!instance) {
-            throw std::runtime_error("Using Logging instance before its initialization");
-        }
-        return *instance;
-    }
-
-    static void Initialize() {
-        if (instance) {
-            LOG_WARNING(Log, "Reinitializing logging backend");
-            return;
-        }
-        using namespace Common::FS;
-        const auto& log_dir = GetYuzuPath(YuzuPath::LogDir);
-        void(CreateDir(log_dir));
-        Filter filter;
-        filter.ParseFilterString(Settings::values.log_filter.GetValue());
-        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter),
-                                                             Deleter);
-        initialization_in_progress_suppress_logging = false;
+        static Impl backend;
+        return backend;
    }

    Impl(const Impl&) = delete;
@@ -189,54 +43,74 @@ public:
    Impl(Impl&&) = delete;
    Impl& operator=(Impl&&) = delete;

+    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, std::string message) {
+        message_queue.Push(
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
+    }
+
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard lock{writing_mutex};
+        backends.push_back(std::move(backend));
+    }
+
+    void RemoveBackend(std::string_view backend_name) {
+        std::lock_guard lock{writing_mutex};
+
+        std::erase_if(backends, [&backend_name](const auto& backend) {
+            return backend_name == backend->GetName();
+        });
+    }
+
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+
    void SetGlobalFilter(const Filter& f) {
        filter = f;
    }

-    void SetColorConsoleBackendEnabled(bool enabled) {
-        color_console_backend.SetEnabled(enabled);
-    }
-
-    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
-        if (!filter.CheckMessage(log_class, log_level))
-            return;
-        const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
-        message_queue.Push(entry);
+    Backend* GetBackend(std::string_view backend_name) {
+        const auto it =
+            std::find_if(backends.begin(), backends.end(),
+                         [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
    }

 private:
-    Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
-              Common::SetCurrentThreadName("yuzu:Log");
-              Entry entry;
-              const auto write_logs = [this, &entry]() {
-                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-              };
-              while (true) {
-                  entry = message_queue.PopWait();
-                  if (entry.final_entry) {
-                      break;
-                  }
-                  write_logs();
-              }
-              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-              // case where a system is repeatedly spamming logs even on close.
-              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-              while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                  write_logs();
-              }
-          })} {}
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard lock{writing_mutex};
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                entry = message_queue.PopWait();
+                if (entry.final_entry) {
+                    break;
+                }
+                write_logs(entry);
+            }

-    ~Impl() {
-        StopBackendThread();
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
    }

-    void StopBackendThread() {
-        Entry stop_entry{};
-        stop_entry.final_entry = true;
-        message_queue.Push(stop_entry);
+    ~Impl() {
+        Entry entry;
+        entry.final_entry = true;
+        message_queue.Push(entry);
        backend_thread.join();
    }

@@ -258,51 +132,216 @@ private:
        };
    }

-    void ForEachBackend(auto lambda) {
-        lambda(static_cast<Backend&>(debugger_backend));
-        lambda(static_cast<Backend&>(color_console_backend));
-        lambda(static_cast<Backend&>(file_backend));
-    }
-
-    static void Deleter(Impl* ptr) {
-        delete ptr;
-    }
-
-    static inline std::unique_ptr<Impl, decltype(&Deleter)> instance{nullptr, Deleter};
-
-    Filter filter;
-    DebuggerBackend debugger_backend{};
-    ColorConsoleBackend color_console_backend{};
-    FileBackend file_backend;
-
+    std::mutex writing_mutex;
    std::thread backend_thread;
-    MPSCQueue<Entry> message_queue{};
+    std::vector<std::unique_ptr<Backend>> backends;
+    MPSCQueue<Entry> message_queue;
+    Filter filter;
    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
-} // namespace

-void Initialize() {
-    Impl::Initialize();
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
 }

-void DisableLoggingInTests() {
-    initialization_in_progress_suppress_logging = true;
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+
+FileBackend::FileBackend(const std::filesystem::path& filename) {
+    auto old_filename = filename;
+    old_filename += ".old.txt";
+
+    // Existence checks are done within the functions themselves.
+    // We don't particularly care if these succeed or not.
+    void(FS::RemoveFile(old_filename));
+    void(FS::RenameFile(filename, old_filename));
+
+    file = FS::IOFile(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
+}
+
+void FileBackend::Write(const Entry& entry) {
+    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
+    // know)
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
+
+    if (!file.IsOpen()) {
+        return;
+    }
+
+    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
+        return;
+    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+
+    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+    if (entry.log_level >= Level::Error) {
+        void(file.Flush());
+    }
+}
+
+void DebuggerBackend::Write(const Entry& entry) {
+#ifdef _WIN32
+    ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+#endif
+}
+
+/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
+#define ALL_LOG_CLASSES()                                                                          \
+    CLS(Log)                                                                                       \
+    CLS(Common)                                                                                    \
+    SUB(Common, Filesystem)                                                                        \
+    SUB(Common, Memory)                                                                            \
+    CLS(Core)                                                                                      \
+    SUB(Core, ARM)                                                                                 \
+    SUB(Core, Timing)                                                                              \
+    CLS(Config)                                                                                    \
+    CLS(Debug)                                                                                     \
+    SUB(Debug, Emulated)                                                                           \
+    SUB(Debug, GPU)                                                                                \
+    SUB(Debug, Breakpoint)                                                                         \
+    SUB(Debug, GDBStub)                                                                            \
+    CLS(Kernel)                                                                                    \
+    SUB(Kernel, SVC)                                                                               \
+    CLS(Service)                                                                                   \
+    SUB(Service, ACC)                                                                              \
+    SUB(Service, Audio)                                                                            \
+    SUB(Service, AM)                                                                               \
+    SUB(Service, AOC)                                                                              \
+    SUB(Service, APM)                                                                              \
+    SUB(Service, ARP)                                                                              \
+    SUB(Service, BCAT)                                                                             \
+    SUB(Service, BPC)                                                                              \
+    SUB(Service, BGTC)                                                                             \
+    SUB(Service, BTDRV)                                                                            \
+    SUB(Service, BTM)                                                                              \
+    SUB(Service, Capture)                                                                          \
+    SUB(Service, ERPT)                                                                             \
+    SUB(Service, ETicket)                                                                          \
+    SUB(Service, EUPLD)                                                                            \
+    SUB(Service, Fatal)                                                                            \
+    SUB(Service, FGM)                                                                              \
+    SUB(Service, Friend)                                                                           \
+    SUB(Service, FS)                                                                               \
+    SUB(Service, GRC)                                                                              \
+    SUB(Service, HID)                                                                              \
+    SUB(Service, IRS)                                                                              \
+    SUB(Service, LBL)                                                                              \
+    SUB(Service, LDN)                                                                              \
+    SUB(Service, LDR)                                                                              \
+    SUB(Service, LM)                                                                               \
+    SUB(Service, Migration)                                                                        \
+    SUB(Service, Mii)                                                                              \
+    SUB(Service, MM)                                                                               \
+    SUB(Service, NCM)                                                                              \
+    SUB(Service, NFC)                                                                              \
+    SUB(Service, NFP)                                                                              \
+    SUB(Service, NIFM)                                                                             \
+    SUB(Service, NIM)                                                                              \
+    SUB(Service, NPNS)                                                                             \
+    SUB(Service, NS)                                                                               \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, OLSC)                                                                             \
+    SUB(Service, PCIE)                                                                             \
+    SUB(Service, PCTL)                                                                             \
+    SUB(Service, PCV)                                                                              \
+    SUB(Service, PM)                                                                               \
+    SUB(Service, PREPO)                                                                            \
+    SUB(Service, PSC)                                                                              \
+    SUB(Service, PSM)                                                                              \
+    SUB(Service, SET)                                                                              \
+    SUB(Service, SM)                                                                               \
+    SUB(Service, SPL)                                                                              \
+    SUB(Service, SSL)                                                                              \
+    SUB(Service, TCAP)                                                                             \
+    SUB(Service, Time)                                                                             \
+    SUB(Service, USB)                                                                              \
+    SUB(Service, VI)                                                                               \
+    SUB(Service, WLAN)                                                                             \
+    CLS(HW)                                                                                        \
+    SUB(HW, Memory)                                                                                \
+    SUB(HW, LCD)                                                                                   \
+    SUB(HW, GPU)                                                                                   \
+    SUB(HW, AES)                                                                                   \
+    CLS(IPC)                                                                                       \
+    CLS(Frontend)                                                                                  \
+    CLS(Render)                                                                                    \
+    SUB(Render, Software)                                                                          \
+    SUB(Render, OpenGL)                                                                            \
+    SUB(Render, Vulkan)                                                                            \
+    CLS(Audio)                                                                                     \
+    SUB(Audio, DSP)                                                                                \
+    SUB(Audio, Sink)                                                                               \
+    CLS(Input)                                                                                     \
+    CLS(Network)                                                                                   \
+    CLS(Loader)                                                                                    \
+    CLS(CheatEngine)                                                                               \
+    CLS(Crypto)                                                                                    \
+    CLS(WebService)
+
+// GetClassName is a macro defined by Windows.h, grrr...
+const char* GetLogClassName(Class log_class) {
+    switch (log_class) {
+#define CLS(x)                                                                                     \
+    case Class::x:                                                                                 \
+        return #x;
+#define SUB(x, y)                                                                                  \
+    case Class::x##_##y:                                                                           \
+        return #x "." #y;
+        ALL_LOG_CLASSES()
+#undef CLS
+#undef SUB
+    case Class::Count:
+        break;
+    }
+    return "Invalid";
+}
+
+const char* GetLevelName(Level log_level) {
+#define LVL(x)                                                                                     \
+    case Level::x:                                                                                 \
+        return #x
+    switch (log_level) {
+        LVL(Trace);
+        LVL(Debug);
+        LVL(Info);
+        LVL(Warning);
+        LVL(Error);
+        LVL(Critical);
+    case Level::Count:
+        break;
+    }
+#undef LVL
+    return "Invalid";
 }

 void SetGlobalFilter(const Filter& filter) {
    Impl::Instance().SetGlobalFilter(filter);
 }

-void SetColorConsoleBackendEnabled(bool enabled) {
-    Impl::Instance().SetColorConsoleBackendEnabled(enabled);
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
+
+void RemoveBackend(std::string_view backend_name) {
+    Impl::Instance().RemoveBackend(backend_name);
+}
+
+Backend* GetBackend(std::string_view backend_name) {
+    return Impl::Instance().GetBackend(backend_name);
 }

 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                       unsigned int line_num, const char* function, const char* format,
                       const fmt::format_args& args) {
-    if (!initialization_in_progress_suppress_logging) {
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
-                                   fmt::vformat(format, args));
-    }
+    auto& instance = Impl::Instance();
+    const auto& filter = instance.GetGlobalFilter();
+    if (!filter.CheckMessage(log_class, log_level))
+        return;
+
+    instance.PushEntry(log_class, log_level, filename, line_num, function,
+                       fmt::vformat(format, args));
 }
 } // namespace Common::Log
--- a/src/common/logging/backend.h
+++ b/src/common/logging/backend.h
@@ -1,25 +1,139 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-
 #pragma once

+#include <chrono>
 #include <filesystem>
+#include <memory>
+#include <string>
+#include <string_view>
+#include "common/fs/file.h"
 #include "common/logging/filter.h"
+#include "common/logging/log.h"

 namespace Common::Log {

 class Filter;

-/// Initializes the logging system. This should be the first thing called in main.
-void Initialize();
-
-void DisableLoggingInTests();
+/**
+ * A log entry. Log entries are store in a structured format to permit more varied output
+ * formatting on different frontends, as well as facilitating filtering and aggregation.
+ */
+struct Entry {
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    unsigned int line_num = 0;
+    std::string function;
+    std::string message;
+    bool final_entry = false;
+};

 /**
- * The global filter will prevent any messages from even being processed if they are filtered.
+ * Interface for logging backends. As loggers can be created and removed at runtime, this can be
+ * used by a frontend for adding a custom logging backend as needed
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+
+private:
+    Filter filter;
+};
+
+/**
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "color_console";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::filesystem::path& filename);
+
+    static const char* Name() {
+        return "file";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+
+private:
+    FS::IOFile file;
+    std::size_t bytes_written = 0;
+};
+
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend : public Backend {
+public:
+    static const char* Name() {
+        return "debugger";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+void AddBackend(std::unique_ptr<Backend> backend);
+
+void RemoveBackend(std::string_view backend_name);
+
+Backend* GetBackend(std::string_view backend_name);
+
+/**
+ * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+ * instead of underscores as in the enumeration.
+ */
+const char* GetLogClassName(Class log_class);
+
+/**
+ * Returns the name of the passed log level as a C-string.
+ */
+const char* GetLevelName(Level log_level);
+
+/**
+ * The global filter will prevent any messages from even being processed if they are filtered. Each
+ * backend can have a filter, but if the level is lower than the global filter, the backend will
+ * never get the message
 */
 void SetGlobalFilter(const Filter& filter);
-
-void SetColorConsoleBackendEnabled(bool enabled);
-} // namespace Common::Log
+} // namespace Common::Log
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.

 #include <algorithm>
+#include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/string_util.h"

@@ -21,7 +22,7 @@ Level GetLevelByName(const It begin, const It end) {

 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    for (u8 i = 0; i < static_cast<u8>(Class::Count); ++i) {
+    for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
        const char* level_name = GetLogClassName(static_cast<Class>(i));
        if (Common::ComparePartialString(begin, end, level_name)) {
            return static_cast<Class>(i);
@@ -61,140 +62,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
 }
 } // Anonymous namespace

-/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
-#define ALL_LOG_CLASSES()                                                                          \
-    CLS(Log)                                                                                       \
-    CLS(Common)                                                                                    \
-    SUB(Common, Filesystem)                                                                        \
-    SUB(Common, Memory)                                                                            \
-    CLS(Core)                                                                                      \
-    SUB(Core, ARM)                                                                                 \
-    SUB(Core, Timing)                                                                              \
-    CLS(Config)                                                                                    \
-    CLS(Debug)                                                                                     \
-    SUB(Debug, Emulated)                                                                           \
-    SUB(Debug, GPU)                                                                                \
-    SUB(Debug, Breakpoint)                                                                         \
-    SUB(Debug, GDBStub)                                                                            \
-    CLS(Kernel)                                                                                    \
-    SUB(Kernel, SVC)                                                                               \
-    CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    SUB(Service, AM)                                                                               \
-    SUB(Service, AOC)                                                                              \
-    SUB(Service, APM)                                                                              \
-    SUB(Service, ARP)                                                                              \
-    SUB(Service, BCAT)                                                                             \
-    SUB(Service, BPC)                                                                              \
-    SUB(Service, BGTC)                                                                             \
-    SUB(Service, BTDRV)                                                                            \
-    SUB(Service, BTM)                                                                              \
-    SUB(Service, Capture)                                                                          \
-    SUB(Service, ERPT)                                                                             \
-    SUB(Service, ETicket)                                                                          \
-    SUB(Service, EUPLD)                                                                            \
-    SUB(Service, Fatal)                                                                            \
-    SUB(Service, FGM)                                                                              \
-    SUB(Service, Friend)                                                                           \
-    SUB(Service, FS)                                                                               \
-    SUB(Service, GRC)                                                                              \
-    SUB(Service, HID)                                                                              \
-    SUB(Service, IRS)                                                                              \
-    SUB(Service, LBL)                                                                              \
-    SUB(Service, LDN)                                                                              \
-    SUB(Service, LDR)                                                                              \
-    SUB(Service, LM)                                                                               \
-    SUB(Service, Migration)                                                                        \
-    SUB(Service, Mii)                                                                              \
-    SUB(Service, MM)                                                                               \
-    SUB(Service, NCM)                                                                              \
-    SUB(Service, NFC)                                                                              \
-    SUB(Service, NFP)                                                                              \
-    SUB(Service, NGCT)                                                                             \
-    SUB(Service, NIFM)                                                                             \
-    SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
-    SUB(Service, NS)                                                                               \
-    SUB(Service, NVDRV)                                                                            \
-    SUB(Service, OLSC)                                                                             \
-    SUB(Service, PCIE)                                                                             \
-    SUB(Service, PCTL)                                                                             \
-    SUB(Service, PCV)                                                                              \
-    SUB(Service, PM)                                                                               \
-    SUB(Service, PREPO)                                                                            \
-    SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
-    SUB(Service, SET)                                                                              \
-    SUB(Service, SM)                                                                               \
-    SUB(Service, SPL)                                                                              \
-    SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
-    SUB(Service, Time)                                                                             \
-    SUB(Service, USB)                                                                              \
-    SUB(Service, VI)                                                                               \
-    SUB(Service, WLAN)                                                                             \
-    CLS(HW)                                                                                        \
-    SUB(HW, Memory)                                                                                \
-    SUB(HW, LCD)                                                                                   \
-    SUB(HW, GPU)                                                                                   \
-    SUB(HW, AES)                                                                                   \
-    CLS(IPC)                                                                                       \
-    CLS(Frontend)                                                                                  \
-    CLS(Render)                                                                                    \
-    SUB(Render, Software)                                                                          \
-    SUB(Render, OpenGL)                                                                            \
-    SUB(Render, Vulkan)                                                                            \
-    CLS(Shader)                                                                                    \
-    SUB(Shader, SPIRV)                                                                             \
-    SUB(Shader, GLASM)                                                                             \
-    SUB(Shader, GLSL)                                                                              \
-    CLS(Audio)                                                                                     \
-    SUB(Audio, DSP)                                                                                \
-    SUB(Audio, Sink)                                                                               \
-    CLS(Input)                                                                                     \
-    CLS(Network)                                                                                   \
-    CLS(Loader)                                                                                    \
-    CLS(CheatEngine)                                                                               \
-    CLS(Crypto)                                                                                    \
-    CLS(WebService)
-
-// GetClassName is a macro defined by Windows.h, grrr...
-const char* GetLogClassName(Class log_class) {
-    switch (log_class) {
-#define CLS(x)                                                                                     \
-    case Class::x:                                                                                 \
-        return #x;
-#define SUB(x, y)                                                                                  \
-    case Class::x##_##y:                                                                           \
-        return #x "." #y;
-        ALL_LOG_CLASSES()
-#undef CLS
-#undef SUB
-    case Class::Count:
-        break;
-    }
-    return "Invalid";
-}
-
-const char* GetLevelName(Level log_level) {
-#define LVL(x)                                                                                     \
-    case Level::x:                                                                                 \
-        return #x
-    switch (log_level) {
-        LVL(Trace);
-        LVL(Debug);
-        LVL(Info);
-        LVL(Warning);
-        LVL(Error);
-        LVL(Critical);
-    case Level::Count:
-        break;
-    }
-#undef LVL
-    return "Invalid";
-}
-
 Filter::Filter(Level default_level) {
    ResetAll(default_level);
 }
--- a/src/common/logging/filter.h
+++ b/src/common/logging/filter.h
@@ -5,24 +5,12 @@
 #pragma once

 #include <array>
-#include <chrono>
 #include <cstddef>
 #include <string_view>
 #include "common/logging/log.h"

 namespace Common::Log {

-/**
- * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
- * instead of underscores as in the enumeration.
- */
-const char* GetLogClassName(Class log_class);
-
-/**
- * Returns the name of the passed log level as a C-string.
- */
-const char* GetLevelName(Level log_level);
-
 /**
 * Implements a log message filter which allows different log classes to have different minimum
 * severity levels. The filter can be changed at runtime and can be parsed from a string to allow
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -5,7 +5,7 @@
 #pragma once

 #include <fmt/format.h>
-#include "common/logging/types.h"
+#include "common/common_types.h"

 namespace Common::Log {

@@ -18,6 +18,124 @@ constexpr const char* TrimSourcePath(std::string_view source) {
    return source.data() + idx;
 }

+/// Specifies the severity or level of detail of the log message.
+enum class Level : u8 {
+    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
+              ///< pollute logs.
+    Debug,    ///< Less detailed debugging information.
+    Info,     ///< Status information from important points during execution.
+    Warning,  ///< Minor or potential problems found during execution of a task.
+    Error,    ///< Major problems found during execution of a task that prevent it from being
+              ///< completed.
+    Critical, ///< Major problems during execution that threaten the stability of the entire
+              ///< application.
+
+    Count ///< Total number of logging levels
+};
+
+typedef u8 ClassType;
+
+/**
+ * Specifies the sub-system that generated the log message.
+ *
+ * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
+ * backend.cpp.
+ */
+enum class Class : ClassType {
+    Log,               ///< Messages about the log system itself
+    Common,            ///< Library routines
+    Common_Filesystem, ///< Filesystem interface library
+    Common_Memory,     ///< Memory mapping and management functions
+    Core,              ///< LLE emulation core
+    Core_ARM,          ///< ARM CPU core
+    Core_Timing,       ///< CoreTiming functions
+    Config,            ///< Emulator configuration (including commandline)
+    Debug,             ///< Debugging tools
+    Debug_Emulated,    ///< Debug messages from the emulated programs
+    Debug_GPU,         ///< GPU debugging tools
+    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
+    Debug_GDBStub,     ///< GDB Stub
+    Kernel,            ///< The HLE implementation of the CTR kernel
+    Kernel_SVC,        ///< Kernel system calls
+    Service,           ///< HLE implementation of system services. Each major service
+                       ///< should have its own subclass.
+    Service_ACC,       ///< The ACC (Accounts) service
+    Service_AM,        ///< The AM (Applet manager) service
+    Service_AOC,       ///< The AOC (AddOn Content) service
+    Service_APM,       ///< The APM (Performance) service
+    Service_ARP,       ///< The ARP service
+    Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
+    Service_BGTC,      ///< The BGTC (Background Task Controller) service
+    Service_BPC,       ///< The BPC service
+    Service_BTDRV,     ///< The Bluetooth driver service
+    Service_BTM,       ///< The BTM service
+    Service_Capture,   ///< The capture service
+    Service_ERPT,      ///< The error reporting service
+    Service_ETicket,   ///< The ETicket service
+    Service_EUPLD,     ///< The error upload service
+    Service_Fatal,     ///< The Fatal service
+    Service_FGM,       ///< The FGM service
+    Service_Friend,    ///< The friend service
+    Service_FS,        ///< The FS (Filesystem) service
+    Service_GRC,       ///< The game recording service
+    Service_HID,       ///< The HID (Human interface device) service
+    Service_IRS,       ///< The IRS service
+    Service_LBL,       ///< The LBL (LCD backlight) service
+    Service_LDN,       ///< The LDN (Local domain network) service
+    Service_LDR,       ///< The loader service
+    Service_LM,        ///< The LM (Logger) service
+    Service_Migration, ///< The migration service
+    Service_Mii,       ///< The Mii service
+    Service_MM,        ///< The MM (Multimedia) service
+    Service_NCM,       ///< The NCM service
+    Service_NFC,       ///< The NFC (Near-field communication) service
+    Service_NFP,       ///< The NFP service
+    Service_NIFM,      ///< The NIFM (Network interface) service
+    Service_NIM,       ///< The NIM service
+    Service_NPNS,      ///< The NPNS service
+    Service_NS,        ///< The NS services
+    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_OLSC,      ///< The OLSC service
+    Service_PCIE,      ///< The PCIe service
+    Service_PCTL,      ///< The PCTL (Parental control) service
+    Service_PCV,       ///< The PCV service
+    Service_PM,        ///< The PM service
+    Service_PREPO,     ///< The PREPO (Play report) service
+    Service_PSC,       ///< The PSC service
+    Service_PSM,       ///< The PSM service
+    Service_SET,       ///< The SET (Settings) service
+    Service_SM,        ///< The SM (Service manager) service
+    Service_SPL,       ///< The SPL service
+    Service_SSL,       ///< The SSL service
+    Service_TCAP,      ///< The TCAP service.
+    Service_Time,      ///< The time service
+    Service_USB,       ///< The USB (Universal Serial Bus) service
+    Service_VI,        ///< The VI (Video interface) service
+    Service_WLAN,      ///< The WLAN (Wireless local area network) service
+    HW,                ///< Low-level hardware emulation
+    HW_Memory,         ///< Memory-map and address translation
+    HW_LCD,            ///< LCD register emulation
+    HW_GPU,            ///< GPU control emulation
+    HW_AES,            ///< AES engine emulation
+    IPC,               ///< IPC interface
+    Frontend,          ///< Emulator UI
+    Render,            ///< Emulator video output and hardware acceleration
+    Render_Software,   ///< Software renderer backend
+    Render_OpenGL,     ///< OpenGL backend
+    Render_Vulkan,     ///< Vulkan backend
+    Audio,             ///< Audio emulation
+    Audio_DSP,         ///< The HLE implementation of the DSP
+    Audio_Sink,        ///< Emulator audio output backend
+    Loader,            ///< ROM loader
+    CheatEngine,       ///< Memory manipulation and engine VM functions
+    Crypto,            ///< Cryptographic engine/functions
+    Input,             ///< Input emulation
+    Network,           ///< Network emulation
+    WebService,        ///< Interface to yuzu Web Services
+    Count              ///< Total number of logging classes
+};
+
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                       unsigned int line_num, const char* function, const char* format,
--- a/src/common/logging/text_formatter.cpp
+++ b/src/common/logging/text_formatter.cpp
@@ -11,7 +11,7 @@

 #include "common/assert.h"
 #include "common/common_funcs.h"
-#include "common/logging/filter.h"
+#include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"
--- a/src/common/logging/types.h
+++ b/src/common/logging/types.h
@@ -1,149 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-
-#include "common/common_types.h"
-
-namespace Common::Log {
-
-/// Specifies the severity or level of detail of the log message.
-enum class Level : u8 {
-    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
-    Debug,    ///< Less detailed debugging information.
-    Info,     ///< Status information from important points during execution.
-    Warning,  ///< Minor or potential problems found during execution of a task.
-    Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
-
-    Count ///< Total number of logging levels
-};
-
-/**
- * Specifies the sub-system that generated the log message.
- *
- * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
- * filter.cpp.
- */
-enum class Class : u8 {
-    Log,               ///< Messages about the log system itself
-    Common,            ///< Library routines
-    Common_Filesystem, ///< Filesystem interface library
-    Common_Memory,     ///< Memory mapping and management functions
-    Core,              ///< LLE emulation core
-    Core_ARM,          ///< ARM CPU core
-    Core_Timing,       ///< CoreTiming functions
-    Config,            ///< Emulator configuration (including commandline)
-    Debug,             ///< Debugging tools
-    Debug_Emulated,    ///< Debug messages from the emulated programs
-    Debug_GPU,         ///< GPU debugging tools
-    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,     ///< GDB Stub
-    Kernel,            ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,        ///< Kernel system calls
-    Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    Service_AOC,       ///< The AOC (AddOn Content) service
-    Service_APM,       ///< The APM (Performance) service
-    Service_ARP,       ///< The ARP service
-    Service_Audio,     ///< The Audio (Audio control) service
-    Service_BCAT,      ///< The BCAT service
-    Service_BGTC,      ///< The BGTC (Background Task Controller) service
-    Service_BPC,       ///< The BPC service
-    Service_BTDRV,     ///< The Bluetooth driver service
-    Service_BTM,       ///< The BTM service
-    Service_Capture,   ///< The capture service
-    Service_ERPT,      ///< The error reporting service
-    Service_ETicket,   ///< The ETicket service
-    Service_EUPLD,     ///< The error upload service
-    Service_Fatal,     ///< The Fatal service
-    Service_FGM,       ///< The FGM service
-    Service_Friend,    ///< The friend service
-    Service_FS,        ///< The FS (Filesystem) service
-    Service_GRC,       ///< The game recording service
-    Service_HID,       ///< The HID (Human interface device) service
-    Service_IRS,       ///< The IRS service
-    Service_LBL,       ///< The LBL (LCD backlight) service
-    Service_LDN,       ///< The LDN (Local domain network) service
-    Service_LDR,       ///< The loader service
-    Service_LM,        ///< The LM (Logger) service
-    Service_Migration, ///< The migration service
-    Service_Mii,       ///< The Mii service
-    Service_MM,        ///< The MM (Multimedia) service
-    Service_NCM,       ///< The NCM service
-    Service_NFC,       ///< The NFC (Near-field communication) service
-    Service_NFP,       ///< The NFP service
-    Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
-    Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
-    Service_NS,        ///< The NS services
-    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
-    Service_OLSC,      ///< The OLSC service
-    Service_PCIE,      ///< The PCIe service
-    Service_PCTL,      ///< The PCTL (Parental control) service
-    Service_PCV,       ///< The PCV service
-    Service_PM,        ///< The PM service
-    Service_PREPO,     ///< The PREPO (Play report) service
-    Service_PSC,       ///< The PSC service
-    Service_PSM,       ///< The PSM service
-    Service_SET,       ///< The SET (Settings) service
-    Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
-    Service_Time,      ///< The time service
-    Service_USB,       ///< The USB (Universal Serial Bus) service
-    Service_VI,        ///< The VI (Video interface) service
-    Service_WLAN,      ///< The WLAN (Wireless local area network) service
-    HW,                ///< Low-level hardware emulation
-    HW_Memory,         ///< Memory-map and address translation
-    HW_LCD,            ///< LCD register emulation
-    HW_GPU,            ///< GPU control emulation
-    HW_AES,            ///< AES engine emulation
-    IPC,               ///< IPC interface
-    Frontend,          ///< Emulator UI
-    Render,            ///< Emulator video output and hardware acceleration
-    Render_Software,   ///< Software renderer backend
-    Render_OpenGL,     ///< OpenGL backend
-    Render_Vulkan,     ///< Vulkan backend
-    Shader,            ///< Shader recompiler
-    Shader_SPIRV,      ///< Shader SPIR-V code generation
-    Shader_GLASM,      ///< Shader GLASM code generation
-    Shader_GLSL,       ///< Shader GLSL code generation
-    Audio,             ///< Audio emulation
-    Audio_DSP,         ///< The HLE implementation of the DSP
-    Audio_Sink,        ///< Emulator audio output backend
-    Loader,            ///< ROM loader
-    CheatEngine,       ///< Memory manipulation and engine VM functions
-    Crypto,            ///< Cryptographic engine/functions
-    Input,             ///< Input emulation
-    Network,           ///< Network emulation
-    WebService,        ///< Interface to yuzu Web Services
-    Count              ///< Total number of logging classes
-};
-
-/**
- * A log entry. Log entries are store in a structured format to permit more varied output
- * formatting on different frontends, as well as facilitating filtering and aggregation.
- */
-struct Entry {
-    std::chrono::microseconds timestamp;
-    Class log_class{};
-    Level log_level{};
-    const char* filename = nullptr;
-    unsigned int line_num = 0;
-    std::string function;
-    std::string message;
-    bool final_entry = false;
-};
-
-} // namespace Common::Log
--- a/src/common/lru_cache.h
+++ b/src/common/lru_cache.h
@@ -1,140 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2+ or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <deque>
-#include <memory>
-#include <type_traits>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-template <class Traits>
-class LeastRecentlyUsedCache {
-    using ObjectType = typename Traits::ObjectType;
-    using TickType = typename Traits::TickType;
-
-    struct Item {
-        ObjectType obj;
-        TickType tick;
-        Item* next{};
-        Item* prev{};
-    };
-
-public:
-    LeastRecentlyUsedCache() : first_item{}, last_item{} {}
-    ~LeastRecentlyUsedCache() = default;
-
-    size_t Insert(ObjectType obj, TickType tick) {
-        const auto new_id = Build();
-        auto& item = item_pool[new_id];
-        item.obj = obj;
-        item.tick = tick;
-        Attach(item);
-        return new_id;
-    }
-
-    void Touch(size_t id, TickType tick) {
-        auto& item = item_pool[id];
-        if (item.tick >= tick) {
-            return;
-        }
-        item.tick = tick;
-        if (&item == last_item) {
-            return;
-        }
-        Detach(item);
-        Attach(item);
-    }
-
-    void Free(size_t id) {
-        auto& item = item_pool[id];
-        Detach(item);
-        item.prev = nullptr;
-        item.next = nullptr;
-        free_items.push_back(id);
-    }
-
-    template <typename Func>
-    void ForEachItemBelow(TickType tick, Func&& func) {
-        static constexpr bool RETURNS_BOOL =
-            std::is_same_v<std::invoke_result<Func, ObjectType>, bool>;
-        Item* iterator = first_item;
-        while (iterator) {
-            if (static_cast<s64>(tick) - static_cast<s64>(iterator->tick) < 0) {
-                return;
-            }
-            Item* next = iterator->next;
-            if constexpr (RETURNS_BOOL) {
-                if (func(iterator->obj)) {
-                    return;
-                }
-            } else {
-                func(iterator->obj);
-            }
-            iterator = next;
-        }
-    }
-
-private:
-    size_t Build() {
-        if (free_items.empty()) {
-            const size_t item_id = item_pool.size();
-            auto& item = item_pool.emplace_back();
-            item.next = nullptr;
-            item.prev = nullptr;
-            return item_id;
-        }
-        const size_t item_id = free_items.front();
-        free_items.pop_front();
-        auto& item = item_pool[item_id];
-        item.next = nullptr;
-        item.prev = nullptr;
-        return item_id;
-    }
-
-    void Attach(Item& item) {
-        if (!first_item) {
-            first_item = &item;
-        }
-        if (!last_item) {
-            last_item = &item;
-        } else {
-            item.prev = last_item;
-            last_item->next = &item;
-            item.next = nullptr;
-            last_item = &item;
-        }
-    }
-
-    void Detach(Item& item) {
-        if (item.prev) {
-            item.prev->next = item.next;
-        }
-        if (item.next) {
-            item.next->prev = item.prev;
-        }
-        if (&item == first_item) {
-            first_item = item.next;
-            if (first_item) {
-                first_item->prev = nullptr;
-            }
-        }
-        if (&item == last_item) {
-            last_item = item.prev;
-            if (last_item) {
-                last_item->next = nullptr;
-            }
-        }
-    }
-
-    std::deque<Item> item_pool;
-    std::deque<size_t> free_items;
-    Item* first_item{};
-    Item* last_item{};
-};
-
-} // namespace Common
--- a/src/common/error.cpp
+++ b/src/common/error.cpp
@@ -10,9 +10,7 @@
 #include <cstring>
 #endif

-#include "common/error.h"
-
-namespace Common {
+#include "common/common_funcs.h"

 std::string NativeErrorToString(int e) {
 #ifdef _WIN32
@@ -52,5 +50,3 @@ std::string GetLastErrorMsg() {
    return NativeErrorToString(errno);
 #endif
 }
-
-} // namespace Common
--- a/src/common/page_table.h
+++ b/src/common/page_table.h
@@ -111,8 +111,6 @@ struct PageTable {
    VirtualBuffer<u64> backing_addr;

    size_t current_address_space_width_in_bits;
-
-    u8* fastmem_arena;
 };

 } // namespace Common
--- a/src/common/scm_rev.cpp.in
+++ b/src/common/scm_rev.cpp.in
@@ -14,6 +14,7 @@
 #define BUILD_ID "@BUILD_ID@"
 #define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
 #define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
+#define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"

 namespace Common {

@@ -27,6 +28,7 @@ const char g_build_version[]  = BUILD_VERSION;
 const char g_build_id[] = BUILD_ID;
 const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
 const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
+const char g_shader_cache_version[] = SHADER_CACHE_VERSION;

 } // namespace

--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -41,39 +41,36 @@ void LogSettings() {
    LOG_INFO(Config, "yuzu Configuration:");
    log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
    log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
-    log_setting("System_CurrentUser", values.current_user.GetValue());
+    log_setting("System_CurrentUser", values.current_user);
    log_setting("System_LanguageIndex", values.language_index.GetValue());
    log_setting("System_RegionIndex", values.region_index.GetValue());
    log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
    log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
    log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
-    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
-    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
+    log_setting("Renderer_UseFrameLimit", values.use_frame_limit.GetValue());
+    log_setting("Renderer_FrameLimit", values.frame_limit.GetValue());
    log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
    log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
    log_setting("Renderer_UseAsynchronousGpuEmulation",
                values.use_asynchronous_gpu_emulation.GetValue());
-    log_setting("Renderer_NvdecEmulation", values.nvdec_emulation.GetValue());
-    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
+    log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
    log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
-    log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
+    log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
    log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
    log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
-    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
-    log_setting("Audio_OutputDevice", values.audio_device_id.GetValue());
-    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
+    log_setting("Audio_OutputEngine", values.sink_id);
+    log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
+    log_setting("Audio_OutputDevice", values.audio_device_id);
+    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd);
    log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
    log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
    log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
    log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
    log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
-    log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
-    log_setting("Services_BCATBackend", values.bcat_backend.GetValue());
-    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local.GetValue());
-    log_setting("Input_EnableMotion", values.motion_enabled.GetValue());
-    log_setting("Input_EnableVibration", values.vibration_enabled.GetValue());
-    log_setting("Input_EnableRawInput", values.enable_raw_input.GetValue());
+    log_setting("Debugging_ProgramArgs", values.program_args);
+    log_setting("Services_BCATBackend", values.bcat_backend);
+    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local);
 }

 bool IsConfiguringGlobal() {
@@ -93,18 +90,11 @@ bool IsGPULevelHigh() {
           values.gpu_accuracy.GetValue() == GPUAccuracy::High;
 }

-bool IsFastmemEnabled() {
-    if (values.cpu_debug_mode) {
-        return static_cast<bool>(values.cpuopt_fastmem);
-    }
-    return true;
-}
-
 float Volume() {
    if (values.audio_muted) {
        return 0.0f;
    }
-    return values.volume.GetValue() / 100.0f;
+    return values.volume.GetValue();
 }

 void RestoreGlobalState(bool is_powered_on) {
@@ -114,6 +104,7 @@ void RestoreGlobalState(bool is_powered_on) {
    }

    // Audio
+    values.enable_audio_stretching.SetGlobal(true);
    values.volume.SetGlobal(true);

    // Core
@@ -123,24 +114,21 @@ void RestoreGlobalState(bool is_powered_on) {
    values.cpu_accuracy.SetGlobal(true);
    values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
    values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
-    values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
    values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
-    values.cpuopt_unsafe_fastmem_check.SetGlobal(true);

    // Renderer
    values.renderer_backend.SetGlobal(true);
    values.vulkan_device.SetGlobal(true);
    values.aspect_ratio.SetGlobal(true);
    values.max_anisotropy.SetGlobal(true);
-    values.use_speed_limit.SetGlobal(true);
-    values.speed_limit.SetGlobal(true);
+    values.use_frame_limit.SetGlobal(true);
+    values.frame_limit.SetGlobal(true);
    values.use_disk_shader_cache.SetGlobal(true);
    values.gpu_accuracy.SetGlobal(true);
    values.use_asynchronous_gpu_emulation.SetGlobal(true);
-    values.nvdec_emulation.SetGlobal(true);
-    values.accelerate_astc.SetGlobal(true);
+    values.use_nvdec_emulation.SetGlobal(true);
    values.use_vsync.SetGlobal(true);
-    values.shader_backend.SetGlobal(true);
+    values.use_assembly_shaders.SetGlobal(true);
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
    values.bg_red.SetGlobal(true);
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -4,14 +4,12 @@

 #pragma once

-#include <algorithm>
 #include <array>
 #include <atomic>
 #include <chrono>
 #include <map>
 #include <optional>
 #include <string>
-#include <utility>
 #include <vector>

 #include "common/common_types.h"
@@ -24,12 +22,6 @@ enum class RendererBackend : u32 {
    Vulkan = 1,
 };

-enum class ShaderBackend : u32 {
-    GLSL = 0,
-    GLASM = 1,
-    SPIRV = 2,
-};
-
 enum class GPUAccuracy : u32 {
    Normal = 0,
    High = 1,
@@ -37,371 +29,73 @@ enum class GPUAccuracy : u32 {
 };

 enum class CPUAccuracy : u32 {
-    Auto = 0,
-    Accurate = 1,
-    Unsafe = 2,
+    Accurate = 0,
+    Unsafe = 1,
+    DebugMode = 2,
 };

-enum class FullscreenMode : u32 {
-    Borderless = 0,
-    Exclusive = 1,
-};
-
-enum class NvdecEmulation : u32 {
-    Off = 0,
-    CPU = 1,
-    GPU = 2,
-};
-
-/** The BasicSetting class is a simple resource manager. It defines a label and default value
- * alongside the actual value of the setting for simpler and less-error prone use with frontend
- * configurations. Setting a default value and label is required, though subclasses may deviate from
- * this requirement.
- */
 template <typename Type>
-class BasicSetting {
-protected:
-    BasicSetting() = default;
-
-    /**
-     * Only sets the setting to the given initializer, leaving the other members to their default
-     * initializers.
-     *
-     * @param global_val Initial value of the setting
-     */
-    explicit BasicSetting(const Type& global_val) : global{global_val} {}
-
+class Setting final {
 public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     */
-    explicit BasicSetting(const Type& default_val, const std::string& name)
-        : default_value{default_val}, global{default_val}, label{name} {}
-    virtual ~BasicSetting() = default;
-
-    /**
-     *  Returns a reference to the setting's value.
-     *
-     * @returns A reference to the setting
-     */
-    [[nodiscard]] virtual const Type& GetValue() const {
-        return global;
-    }
-
-    /**
-     * Sets the setting to the given value.
-     *
-     * @param value The desired value
-     */
-    virtual void SetValue(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
-    }
-
-    /**
-     * Returns the value that this setting was created with.
-     *
-     * @returns A reference to the default value
-     */
-    [[nodiscard]] const Type& GetDefault() const {
-        return default_value;
-    }
-
-    /**
-     * Returns the label this setting was created with.
-     *
-     * @returns A reference to the label
-     */
-    [[nodiscard]] const std::string& GetLabel() const {
-        return label;
-    }
-
-    /**
-     * Assigns a value to the setting.
-     *
-     * @param value The desired setting value
-     *
-     * @returns A reference to the setting
-     */
-    virtual const Type& operator=(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
-        return global;
-    }
-
-    /**
-     * Returns a reference to the setting.
-     *
-     * @returns A reference to the setting
-     */
-    explicit virtual operator const Type&() const {
-        return global;
-    }
-
-protected:
-    const Type default_value{}; ///< The default value
-    Type global{};              ///< The setting
-    const std::string label{};  ///< The setting's label
-};
-
-/**
- * BasicRangedSetting class is intended for use with quantifiable settings that need a more
- * restrictive range than implicitly defined by its type. Implements a minimum and maximum that is
- * simply used to sanitize SetValue and the assignment overload.
- */
-template <typename Type>
-class BasicRangedSetting : virtual public BasicSetting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit BasicRangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                                const std::string& name)
-        : BasicSetting<Type>{default_val, name}, minimum{min_val}, maximum{max_val} {}
-    virtual ~BasicRangedSetting() = default;
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-        return this->global;
-    }
-
-    const Type minimum; ///< Minimum allowed value of the setting
-    const Type maximum; ///< Maximum allowed value of the setting
-};
-
-/**
- * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
- * custom setting to switch to when a guest application specifically requires it. The effect is that
- * other components of the emulator can access the setting's intended value without any need for the
- * component to ask whether the custom or global setting is needed at the moment.
- *
- * By default, the global setting is used.
- *
- * Like the BasicSetting, this requires setting a default value and label to use.
- */
-template <typename Type>
-class Setting : virtual public BasicSetting<Type> {
-public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     */
-    explicit Setting(const Type& default_val, const std::string& name)
-        : BasicSetting<Type>(default_val, name) {}
-    virtual ~Setting() = default;
-
-    /**
-     * Tells this setting to represent either the global or custom setting when other member
-     * functions are used.
-     *
-     * @param to_global Whether to use the global or custom setting.
-     */
+    Setting() = default;
+    explicit Setting(Type val) : global{val} {}
+    ~Setting() = default;
    void SetGlobal(bool to_global) {
        use_global = to_global;
    }
-
-    /**
-     * Returns whether this setting is using the global setting or not.
-     *
-     * @returns The global state
-     */
-    [[nodiscard]] bool UsingGlobal() const {
+    bool UsingGlobal() const {
        return use_global;
    }
-
-    /**
-     * Returns either the global or custom setting depending on the values of this setting's global
-     * state or if the global value was specifically requested.
-     *
-     * @param need_global Request global value regardless of setting's state; defaults to false
-     *
-     * @returns The required value of the setting
-     */
-    [[nodiscard]] virtual const Type& GetValue() const override {
-        if (use_global) {
-            return this->global;
-        }
-        return custom;
-    }
-    [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
+    Type GetValue(bool need_global = false) const {
        if (use_global || need_global) {
-            return this->global;
+            return global;
        }
-        return custom;
+        return local;
    }
-
-    /**
-     * Sets the current setting value depending on the global state.
-     *
-     * @param value The new value
-     */
-    void SetValue(const Type& value) override {
-        Type temp{value};
+    void SetValue(const Type& value) {
        if (use_global) {
-            std::swap(this->global, temp);
+            global = value;
        } else {
-            std::swap(custom, temp);
+            local = value;
        }
    }

-    /**
-     * Assigns the current setting value depending on the global state.
-     *
-     * @param value The new value
-     *
-     * @returns A reference to the current setting value
-     */
-    const Type& operator=(const Type& value) override {
-        Type temp{value};
-        if (use_global) {
-            std::swap(this->global, temp);
-            return this->global;
-        }
-        std::swap(custom, temp);
-        return custom;
-    }
-
-    /**
-     * Returns the current setting value depending on the global state.
-     *
-     * @returns A reference to the current setting value
-     */
-    virtual explicit operator const Type&() const override {
-        if (use_global) {
-            return this->global;
-        }
-        return custom;
-    }
-
-protected:
-    bool use_global{true}; ///< The setting's global state
-    Type custom{};         ///< The custom value of the setting
+private:
+    bool use_global = true;
+    Type global{};
+    Type local{};
 };

 /**
- * RangedSetting is a Setting that implements a maximum and minimum value for its setting. Intended
- * for use with quantifiable settings.
- */
-template <typename Type>
-class RangedSetting final : public BasicRangedSetting<Type>, public Setting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit RangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                           const std::string& name)
-        : BasicSetting<Type>{default_val, name},
-          BasicRangedSetting<Type>{default_val, min_val, max_val, name}, Setting<Type>{default_val,
-                                                                                       name} {}
-    virtual ~RangedSetting() = default;
-
-    // The following are needed to avoid a MSVC bug
-    // (source: https://stackoverflow.com/questions/469508)
-    [[nodiscard]] const Type& GetValue() const override {
-        return Setting<Type>::GetValue();
-    }
-    [[nodiscard]] const Type& GetValue(bool need_global) const override {
-        return Setting<Type>::GetValue(need_global);
-    }
-    explicit operator const Type&() const override {
-        if (this->use_global) {
-            return this->global;
-        }
-        return this->custom;
-    }
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting. Sets the
-     * appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-        }
-        this->custom = temp;
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     * Uses the appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-            return this->global;
-        }
-        this->custom = temp;
-        return this->custom;
-    }
-};
-
-/**
- * The InputSetting class allows for getting a reference to either the global or custom members.
+ * The InputSetting class allows for getting a reference to either the global or local members.
 * This is required as we cannot easily modify the values of user-defined types within containers
 * using the SetValue() member function found in the Setting class. The primary purpose of this
- * class is to store an array of 10 PlayerInput structs for both the global and custom setting and
- * allows for easily accessing and modifying both settings.
+ * class is to store an array of 10 PlayerInput structs for both the global and local (per-game)
+ * setting and allows for easily accessing and modifying both settings.
 */
 template <typename Type>
 class InputSetting final {
 public:
    InputSetting() = default;
-    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
+    explicit InputSetting(Type val) : global{val} {}
    ~InputSetting() = default;
    void SetGlobal(bool to_global) {
        use_global = to_global;
    }
-    [[nodiscard]] bool UsingGlobal() const {
+    bool UsingGlobal() const {
        return use_global;
    }
-    [[nodiscard]] Type& GetValue(bool need_global = false) {
+    Type& GetValue(bool need_global = false) {
        if (use_global || need_global) {
            return global;
        }
-        return custom;
+        return local;
    }

 private:
-    bool use_global{true}; ///< The setting's global state
-    Type global{};         ///< The setting
-    Type custom{};         ///< The custom setting value
+    bool use_global = true;
+    Type global{};
+    Type local{};
 };

 struct TouchFromButtonMap {
@@ -411,172 +105,137 @@ struct TouchFromButtonMap {

 struct Values {
    // Audio
-    BasicSetting<std::string> audio_device_id{"auto", "output_device"};
-    BasicSetting<std::string> sink_id{"auto", "output_engine"};
-    BasicSetting<bool> audio_muted{false, "audio_muted"};
-    RangedSetting<u8> volume{100, 0, 100, "volume"};
+    std::string audio_device_id;
+    std::string sink_id;
+    bool audio_muted;
+    Setting<bool> enable_audio_stretching;
+    Setting<float> volume;

    // Core
-    Setting<bool> use_multi_core{true, "use_multi_core"};
+    Setting<bool> use_multi_core;

    // Cpu
-    RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                            CPUAccuracy::Unsafe, "cpu_accuracy"};
-    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
-    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
-    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
+    Setting<CPUAccuracy> cpu_accuracy;

-    BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
-    BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
-    BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
-    BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
-    BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
-    BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
-    BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
-    BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
-    BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
+    bool cpuopt_page_tables;
+    bool cpuopt_block_linking;
+    bool cpuopt_return_stack_buffer;
+    bool cpuopt_fast_dispatcher;
+    bool cpuopt_context_elimination;
+    bool cpuopt_const_prop;
+    bool cpuopt_misc_ir;
+    bool cpuopt_reduce_misalign_checks;

-    Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
-    Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
-    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
-    Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
-    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
+    Setting<bool> cpuopt_unsafe_unfuse_fma;
+    Setting<bool> cpuopt_unsafe_reduce_fp_error;
+    Setting<bool> cpuopt_unsafe_inaccurate_nan;

    // Renderer
-    RangedSetting<RendererBackend> renderer_backend{
-        RendererBackend::OpenGL, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
-    BasicSetting<bool> renderer_debug{false, "debug"};
-    BasicSetting<bool> renderer_shader_feedback{false, "shader_feedback"};
-    BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
-    BasicSetting<bool> disable_shader_loop_safety_checks{false,
-                                                         "disable_shader_loop_safety_checks"};
-    Setting<int> vulkan_device{0, "vulkan_device"};
+    Setting<RendererBackend> renderer_backend;
+    bool renderer_debug;
+    Setting<int> vulkan_device;

-    Setting<u16> resolution_factor{1, "resolution_factor"};
-    // *nix platforms may have issues with the borderless windowed fullscreen mode.
-    // Default to exclusive fullscreen on these platforms for now.
-    RangedSetting<FullscreenMode> fullscreen_mode{
-#ifdef _WIN32
-        FullscreenMode::Borderless,
-#else
-        FullscreenMode::Exclusive,
-#endif
-        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    RangedSetting<int> max_anisotropy{0, 0, 4, "max_anisotropy"};
-    Setting<bool> use_speed_limit{true, "use_speed_limit"};
-    RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
-    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
-    RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
-                                            GPUAccuracy::Extreme, "gpu_accuracy"};
-    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
-    Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
-    Setting<bool> accelerate_astc{true, "accelerate_astc"};
-    Setting<bool> use_vsync{true, "use_vsync"};
-    BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
-    BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
-                                                ShaderBackend::SPIRV, "shader_backend"};
-    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
-    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    Setting<u16> resolution_factor{1};
+    Setting<int> fullscreen_mode;
+    Setting<int> aspect_ratio;
+    Setting<int> max_anisotropy;
+    Setting<bool> use_frame_limit;
+    Setting<u16> frame_limit;
+    Setting<bool> use_disk_shader_cache;
+    Setting<GPUAccuracy> gpu_accuracy;
+    Setting<bool> use_asynchronous_gpu_emulation;
+    Setting<bool> use_nvdec_emulation;
+    Setting<bool> use_vsync;
+    Setting<bool> use_assembly_shaders;
+    Setting<bool> use_asynchronous_shaders;
+    Setting<bool> use_fast_gpu_time;

-    Setting<u8> bg_red{0, "bg_red"};
-    Setting<u8> bg_green{0, "bg_green"};
-    Setting<u8> bg_blue{0, "bg_blue"};
+    Setting<float> bg_red;
+    Setting<float> bg_green;
+    Setting<float> bg_blue;

    // System
-    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::optional<u32>> rng_seed;
    // Measured in seconds since epoch
    std::optional<std::chrono::seconds> custom_rtc;
    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
    std::chrono::seconds custom_rtc_differential;

-    BasicSetting<s32> current_user{0, "current_user"};
-    RangedSetting<s32> language_index{1, 0, 17, "language_index"};
-    RangedSetting<s32> region_index{1, 0, 6, "region_index"};
-    RangedSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
-    RangedSetting<s32> sound_index{1, 0, 2, "sound_index"};
+    s32 current_user;
+    Setting<s32> language_index;
+    Setting<s32> region_index;
+    Setting<s32> time_zone_index;
+    Setting<s32> sound_index;

    // Controls
    InputSetting<std::array<PlayerInput, 10>> players;

-    Setting<bool> use_docked_mode{true, "use_docked_mode"};
+    Setting<bool> use_docked_mode;

-    BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
+    Setting<bool> vibration_enabled;
+    Setting<bool> enable_accurate_vibrations;

-    Setting<bool> vibration_enabled{true, "vibration_enabled"};
-    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
+    Setting<bool> motion_enabled;
+    std::string motion_device;
+    std::string udp_input_servers;

-    Setting<bool> motion_enabled{true, "motion_enabled"};
-    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
-                                            "motion_device"};
-    BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
-
-    BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
-    BasicSetting<bool> tas_enable{false, "tas_enable"};
-    BasicSetting<bool> tas_loop{false, "tas_loop"};
-    BasicSetting<bool> tas_swap_controllers{true, "tas_swap_controllers"};
-
-    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
-    BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
-    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
+    bool mouse_panning;
+    float mouse_panning_sensitivity;
+    bool mouse_enabled;
    std::string mouse_device;
    MouseButtonsRaw mouse_buttons;

-    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
-    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
+    bool emulate_analog_keyboard;
+    bool keyboard_enabled;
    KeyboardKeysRaw keyboard_keys;
    KeyboardModsRaw keyboard_mods;

-    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
+    bool debug_pad_enabled;
    ButtonsRaw debug_pad_buttons;
    AnalogsRaw debug_pad_analogs;

    TouchscreenInput touchscreen;

-    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
-    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
-                                           "touch_device"};
-    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
+    bool use_touch_from_button;
+    std::string touch_device;
+    int touch_from_button_map_index;
    std::vector<TouchFromButtonMap> touch_from_button_maps;

    std::atomic_bool is_device_reload_pending{true};

    // Data Storage
-    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
-    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
-    BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
-    BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};
+    bool use_virtual_sd;
+    bool gamecard_inserted;
+    bool gamecard_current_game;
+    std::string gamecard_path;

    // Debugging
    bool record_frame_times;
-    BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
-    BasicSetting<u16> gdbstub_port{0, "gdbstub_port"};
-    BasicSetting<std::string> program_args{std::string(), "program_args"};
-    BasicSetting<bool> dump_exefs{false, "dump_exefs"};
-    BasicSetting<bool> dump_nso{false, "dump_nso"};
-    BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
-    BasicSetting<bool> reporting_services{false, "reporting_services"};
-    BasicSetting<bool> quest_flag{false, "quest_flag"};
-    BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
-    BasicSetting<bool> extended_logging{false, "extended_logging"};
-    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
-    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
+    bool use_gdbstub;
+    u16 gdbstub_port;
+    std::string program_args;
+    bool dump_exefs;
+    bool dump_nso;
+    bool reporting_services;
+    bool quest_flag;
+    bool disable_macro_jit;
+    bool extended_logging;
+    bool use_debug_asserts;
+    bool use_auto_stub;

    // Miscellaneous
-    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
-    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
+    std::string log_filter;
+    bool use_dev_keys;

-    // Network
-    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
-    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
-    BasicSetting<std::string> network_interface{std::string(), "network_interface"};
+    // Services
+    std::string bcat_backend;
+    bool bcat_boxcat_local;

    // WebService
-    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
-    BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
-    BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
-    BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};
+    bool enable_telemetry;
+    std::string web_api_url;
+    std::string yuzu_username;
+    std::string yuzu_token;

    // Add-Ons
    std::map<u64, std::vector<std::string>> disabled_addons;
@@ -590,8 +249,6 @@ void SetConfiguringGlobal(bool is_global);
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();

-bool IsFastmemEnabled();
-
 float Volume();

 std::string GetTimeZoneString();
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -2,9 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <string>
-
-#include "common/error.h"
+#include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "common/thread.h"
 #ifdef __APPLE__
@@ -23,6 +21,8 @@
 #include <unistd.h>
 #endif

+#include <string>
+
 #ifdef __FreeBSD__
 #define cpu_set_t cpuset_t
 #endif
--- a/src/common/thread_worker.cpp
+++ b/src/common/thread_worker.cpp
@@ -0,0 +1,58 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/thread.h"
+#include "common/thread_worker.h"
+
+namespace Common {
+
+ThreadWorker::ThreadWorker(std::size_t num_workers, const std::string& name) {
+    for (std::size_t i = 0; i < num_workers; ++i)
+        threads.emplace_back([this, thread_name{std::string{name}}] {
+            Common::SetCurrentThreadName(thread_name.c_str());
+
+            // Wait for first request
+            {
+                std::unique_lock lock{queue_mutex};
+                condition.wait(lock, [this] { return stop || !requests.empty(); });
+            }
+
+            while (true) {
+                std::function<void()> task;
+
+                {
+                    std::unique_lock lock{queue_mutex};
+                    condition.wait(lock, [this] { return stop || !requests.empty(); });
+                    if (stop || requests.empty()) {
+                        return;
+                    }
+                    task = std::move(requests.front());
+                    requests.pop();
+                }
+
+                task();
+            }
+        });
+}
+
+ThreadWorker::~ThreadWorker() {
+    {
+        std::unique_lock lock{queue_mutex};
+        stop = true;
+    }
+    condition.notify_all();
+    for (std::thread& thread : threads) {
+        thread.join();
+    }
+}
+
+void ThreadWorker::QueueWork(std::function<void()>&& work) {
+    {
+        std::unique_lock lock{queue_mutex};
+        requests.emplace(work);
+    }
+    condition.notify_one();
+}
+
+} // namespace Common
--- a/src/common/thread_worker.h
+++ b/src/common/thread_worker.h
@@ -5,113 +5,26 @@
 #pragma once

 #include <atomic>
-#include <condition_variable>
 #include <functional>
 #include <mutex>
-#include <stop_token>
 #include <string>
-#include <thread>
-#include <type_traits>
 #include <vector>
 #include <queue>

-#include "common/thread.h"
-#include "common/unique_function.h"
-
 namespace Common {

-template <class StateType = void>
-class StatefulThreadWorker {
-    static constexpr bool with_state = !std::is_same_v<StateType, void>;
-
-    struct DummyCallable {
-        int operator()() const noexcept {
-            return 0;
-        }
-    };
-
-    using Task =
-        std::conditional_t<with_state, UniqueFunction<void, StateType*>, UniqueFunction<void>>;
-    using StateMaker = std::conditional_t<with_state, std::function<StateType()>, DummyCallable>;
-
+class ThreadWorker final {
 public:
-    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})
-        : workers_queued{num_workers}, thread_name{std::move(name)} {
-        const auto lambda = [this, func](std::stop_token stop_token) {
-            Common::SetCurrentThreadName(thread_name.c_str());
-            {
-                [[maybe_unused]] std::conditional_t<with_state, StateType, int> state{func()};
-                while (!stop_token.stop_requested()) {
-                    Task task;
-                    {
-                        std::unique_lock lock{queue_mutex};
-                        if (requests.empty()) {
-                            wait_condition.notify_all();
-                        }
-                        condition.wait(lock, stop_token, [this] { return !requests.empty(); });
-                        if (stop_token.stop_requested()) {
-                            break;
-                        }
-                        task = std::move(requests.front());
-                        requests.pop();
-                    }
-                    if constexpr (with_state) {
-                        task(&state);
-                    } else {
-                        task();
-                    }
-                    ++work_done;
-                }
-            }
-            ++workers_stopped;
-            wait_condition.notify_all();
-        };
-        threads.reserve(num_workers);
-        for (size_t i = 0; i < num_workers; ++i) {
-            threads.emplace_back(lambda);
-        }
-    }
-
-    StatefulThreadWorker& operator=(const StatefulThreadWorker&) = delete;
-    StatefulThreadWorker(const StatefulThreadWorker&) = delete;
-
-    StatefulThreadWorker& operator=(StatefulThreadWorker&&) = delete;
-    StatefulThreadWorker(StatefulThreadWorker&&) = delete;
-
-    void QueueWork(Task work) {
-        {
-            std::unique_lock lock{queue_mutex};
-            requests.emplace(std::move(work));
-            ++work_scheduled;
-        }
-        condition.notify_one();
-    }
-
-    void WaitForRequests(std::stop_token stop_token = {}) {
-        std::stop_callback callback(stop_token, [this] {
-            for (auto& thread : threads) {
-                thread.request_stop();
-            }
-        });
-        std::unique_lock lock{queue_mutex};
-        wait_condition.wait(lock, [this] {
-            return workers_stopped >= workers_queued || work_done >= work_scheduled;
-        });
-    }
+    explicit ThreadWorker(std::size_t num_workers, const std::string& name);
+    ~ThreadWorker();
+    void QueueWork(std::function<void()>&& work);

 private:
-    std::queue<Task> requests;
+    std::vector<std::thread> threads;
+    std::queue<std::function<void()>> requests;
    std::mutex queue_mutex;
-    std::condition_variable_any condition;
-    std::condition_variable wait_condition;
-    std::atomic<size_t> work_scheduled{};
-    std::atomic<size_t> work_done{};
-    std::atomic<size_t> workers_stopped{};
-    std::atomic<size_t> workers_queued{};
-    std::string thread_name;
-    std::vector<std::jthread> threads;
+    std::condition_variable condition;
+    std::atomic_bool stop{};
 };

-using ThreadWorker = StatefulThreadWorker<>;
-
 } // namespace Common
--- a/src/common/threadsafe_queue.h
+++ b/src/common/threadsafe_queue.h
@@ -14,7 +14,7 @@
 #include <utility>

 namespace Common {
-template <typename T, bool with_stop_token = false>
+template <typename T>
 class SPSCQueue {
 public:
    SPSCQueue() {
@@ -46,13 +46,15 @@ public:
        ElementPtr* new_ptr = new ElementPtr();
        write_ptr->next.store(new_ptr, std::memory_order_release);
        write_ptr = new_ptr;
-        ++size;

-        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
-        // line before cv.wait
+        const size_t previous_size{size++};
+
+        // Acquire the mutex and then immediately release it as a fence.
        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
-        std::lock_guard lock{cv_mutex};
+        if (previous_size == 0) {
+            std::lock_guard lock{cv_mutex};
+        }
        cv.notify_one();
    }

@@ -84,7 +86,7 @@ public:
    void Wait() {
        if (Empty()) {
            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, [this] { return !Empty(); });
+            cv.wait(lock, [this]() { return !Empty(); });
        }
    }

@@ -95,19 +97,6 @@ public:
        return t;
    }

-    T PopWait(std::stop_token stop_token) {
-        if (Empty()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop_token, [this] { return !Empty(); });
-        }
-        if (stop_token.stop_requested()) {
-            return T{};
-        }
-        T t;
-        Pop(t);
-        return t;
-    }
-
    // not thread-safe
    void Clear() {
        size.store(0);
@@ -136,13 +125,13 @@ private:
    ElementPtr* read_ptr;
    std::atomic_size_t size{0};
    std::mutex cv_mutex;
-    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
+    std::condition_variable cv;
 };

 // a simple thread-safe,
 // single reader, multiple writer queue

-template <typename T, bool with_stop_token = false>
+template <typename T>
 class MPSCQueue {
 public:
    [[nodiscard]] std::size_t Size() const {
@@ -179,17 +168,13 @@ public:
        return spsc_queue.PopWait();
    }

-    T PopWait(std::stop_token stop_token) {
-        return spsc_queue.PopWait(stop_token);
-    }
-
    // not thread-safe
    void Clear() {
        spsc_queue.Clear();
    }

 private:
-    SPSCQueue<T, with_stop_token> spsc_queue;
+    SPSCQueue<T> spsc_queue;
    std::mutex write_lock;
 };
 } // namespace Common
--- a/src/common/unique_function.h
+++ b/src/common/unique_function.h
@@ -1,62 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <utility>
-
-namespace Common {
-
-/// General purpose function wrapper similar to std::function.
-/// Unlike std::function, the captured values don't have to be copyable.
-/// This class can be moved but not copied.
-template <typename ResultType, typename... Args>
-class UniqueFunction {
-    class CallableBase {
-    public:
-        virtual ~CallableBase() = default;
-        virtual ResultType operator()(Args&&...) = 0;
-    };
-
-    template <typename Functor>
-    class Callable final : public CallableBase {
-    public:
-        Callable(Functor&& functor_) : functor{std::move(functor_)} {}
-        ~Callable() override = default;
-
-        ResultType operator()(Args&&... args) override {
-            return functor(std::forward<Args>(args)...);
-        }
-
-    private:
-        Functor functor;
-    };
-
-public:
-    UniqueFunction() = default;
-
-    template <typename Functor>
-    UniqueFunction(Functor&& functor)
-        : callable{std::make_unique<Callable<Functor>>(std::move(functor))} {}
-
-    UniqueFunction& operator=(UniqueFunction&& rhs) noexcept = default;
-    UniqueFunction(UniqueFunction&& rhs) noexcept = default;
-
-    UniqueFunction& operator=(const UniqueFunction&) = delete;
-    UniqueFunction(const UniqueFunction&) = delete;
-
-    ResultType operator()(Args&&... args) const {
-        return (*callable)(std::forward<Args>(args)...);
-    }
-
-    explicit operator bool() const noexcept {
-        return static_cast<bool>(callable);
-    }
-
-private:
-    std::unique_ptr<CallableBase> callable;
-};
-
-} // namespace Common
--- a/src/common/uuid.cpp
+++ b/src/common/uuid.cpp
@@ -6,64 +6,10 @@

 #include <fmt/format.h>

-#include "common/assert.h"
 #include "common/uuid.h"

 namespace Common {

-namespace {
-
-bool IsHexDigit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-}
-
-u8 HexCharToByte(char c) {
-    if (c >= '0' && c <= '9') {
-        return static_cast<u8>(c - '0');
-    }
-    if (c >= 'a' && c <= 'f') {
-        return static_cast<u8>(c - 'a' + 10);
-    }
-    if (c >= 'A' && c <= 'F') {
-        return static_cast<u8>(c - 'A' + 10);
-    }
-    ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-    return u8{0};
-}
-
-} // Anonymous namespace
-
-u128 HexStringToU128(std::string_view hex_string) {
-    const size_t length = hex_string.length();
-
-    // Detect "0x" prefix.
-    const bool has_0x_prefix = length > 2 && hex_string[0] == '0' && hex_string[1] == 'x';
-    const size_t offset = has_0x_prefix ? 2 : 0;
-
-    // Check length.
-    if (length > 32 + offset) {
-        ASSERT_MSG(false, "hex_string has more than 32 hexadecimal characters!");
-        return INVALID_UUID;
-    }
-
-    u64 lo = 0;
-    u64 hi = 0;
-    for (size_t i = 0; i < length - offset; ++i) {
-        const char c = hex_string[length - 1 - i];
-        if (!IsHexDigit(c)) {
-            ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-            return INVALID_UUID;
-        }
-        if (i < 16) {
-            lo |= u64{HexCharToByte(c)} << (i * 4);
-        }
-        if (i >= 16) {
-            hi |= u64{HexCharToByte(c)} << ((i - 16) * 4);
-        }
-    }
-    return u128{lo, hi};
-}
-
 UUID UUID::Generate() {
    std::random_device device;
    std::mt19937 gen(device());
@@ -72,7 +18,7 @@ UUID UUID::Generate() {
 }

 std::string UUID::Format() const {
-    return fmt::format("{:016x}{:016x}", uuid[1], uuid[0]);
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
 }

 std::string UUID::FormatSwitch() const {
--- a/src/common/uuid.h
+++ b/src/common/uuid.h
@@ -5,7 +5,6 @@
 #pragma once

 #include <string>
-#include <string_view>

 #include "common/common_types.h"

@@ -13,37 +12,20 @@ namespace Common {

 constexpr u128 INVALID_UUID{{0, 0}};

-/**
- * Converts a hex string to a 128-bit unsigned integer.
- *
- * The hex string can be formatted in lowercase or uppercase, with or without the "0x" prefix.
- *
- * This function will assert and return INVALID_UUID under the following conditions:
- * - If the hex string is more than 32 characters long
- * - If the hex string contains non-hexadecimal characters
- *
- * @param hex_string Hexadecimal string
- *
- * @returns A 128-bit unsigned integer if successfully converted, INVALID_UUID otherwise.
- */
-[[nodiscard]] u128 HexStringToU128(std::string_view hex_string);
-
 struct UUID {
    // UUIDs which are 0 are considered invalid!
    u128 uuid;
    UUID() = default;
    constexpr explicit UUID(const u128& id) : uuid{id} {}
    constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-    explicit UUID(std::string_view hex_string) {
-        uuid = HexStringToU128(hex_string);
-    }

    [[nodiscard]] constexpr explicit operator bool() const {
-        return uuid != INVALID_UUID;
+        return uuid[0] != INVALID_UUID[0] && uuid[1] != INVALID_UUID[1];
    }

    [[nodiscard]] constexpr bool operator==(const UUID& rhs) const {
-        return uuid == rhs.uuid;
+        // TODO(DarkLordZach): Replace with uuid == rhs.uuid with C++20
+        return uuid[0] == rhs.uuid[0] && uuid[1] == rhs.uuid[1];
    }

    [[nodiscard]] constexpr bool operator!=(const UUID& rhs) const {
@@ -58,13 +40,6 @@ struct UUID {
        uuid = INVALID_UUID;
    }

-    [[nodiscard]] constexpr bool IsInvalid() const {
-        return uuid == INVALID_UUID;
-    }
-    [[nodiscard]] constexpr bool IsValid() const {
-        return !IsInvalid();
-    }
-
    // TODO(ogniK): Properly generate a Nintendo ID
    [[nodiscard]] constexpr u64 GetNintendoID() const {
        return uuid[0];
@@ -76,14 +51,3 @@ struct UUID {
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");

 } // namespace Common
-
-namespace std {
-
-template <>
-struct hash<Common::UUID> {
-    size_t operator()(const Common::UUID& uuid) const noexcept {
-        return uuid.uuid[1] ^ uuid.uuid[0];
-    }
-};
-
-} // namespace std
--- a/src/common/vector_math.h
+++ b/src/common/vector_math.h
@@ -667,8 +667,8 @@ template <typename T>

 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{})
-    Lerp(const X& begin, const X& end, const float t) {
+[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+                                                                     const float t) {
    return begin * (1.f - t) + end * t;
 }

--- a/src/common/x64/xbyak_abi.h
+++ b/src/common/x64/xbyak_abi.h
@@ -6,7 +6,7 @@

 #include <bitset>
 #include <initializer_list>
-#include <xbyak/xbyak.h>
+#include <xbyak.h>
 #include "common/assert.h"

 namespace Common::X64 {
--- a/src/common/x64/xbyak_util.h
+++ b/src/common/x64/xbyak_util.h
@@ -5,7 +5,7 @@
 #pragma once

 #include <type_traits>
-#include <xbyak/xbyak.h>
+#include <xbyak.h>
 #include "common/x64/xbyak_abi.h"

 namespace Common::X64 {
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -139,7 +139,6 @@ add_library(core STATIC
    frontend/input.h
    hardware_interrupt_manager.cpp
    hardware_interrupt_manager.h
-    hle/api_version.h
    hle/ipc.h
    hle/ipc_helpers.h
    hle/kernel/board/nintendo/nx/k_system_control.cpp
@@ -263,8 +262,6 @@ add_library(core STATIC
    hle/service/acc/acc_u0.h
    hle/service/acc/acc_u1.cpp
    hle/service/acc/acc_u1.h
-    hle/service/acc/async_context.cpp
-    hle/service/acc/async_context.h
    hle/service/acc/errors.h
    hle/service/acc/profile_manager.cpp
    hle/service/acc/profile_manager.h
@@ -274,22 +271,22 @@ add_library(core STATIC
    hle/service/am/applet_ae.h
    hle/service/am/applet_oe.cpp
    hle/service/am/applet_oe.h
-    hle/service/am/applets/applet_controller.cpp
-    hle/service/am/applets/applet_controller.h
-    hle/service/am/applets/applet_error.cpp
-    hle/service/am/applets/applet_error.h
-    hle/service/am/applets/applet_general_backend.cpp
-    hle/service/am/applets/applet_general_backend.h
-    hle/service/am/applets/applet_profile_select.cpp
-    hle/service/am/applets/applet_profile_select.h
-    hle/service/am/applets/applet_software_keyboard.cpp
-    hle/service/am/applets/applet_software_keyboard.h
-    hle/service/am/applets/applet_software_keyboard_types.h
-    hle/service/am/applets/applet_web_browser.cpp
-    hle/service/am/applets/applet_web_browser.h
-    hle/service/am/applets/applet_web_browser_types.h
    hle/service/am/applets/applets.cpp
    hle/service/am/applets/applets.h
+    hle/service/am/applets/controller.cpp
+    hle/service/am/applets/controller.h
+    hle/service/am/applets/error.cpp
+    hle/service/am/applets/error.h
+    hle/service/am/applets/general_backend.cpp
+    hle/service/am/applets/general_backend.h
+    hle/service/am/applets/profile_select.cpp
+    hle/service/am/applets/profile_select.h
+    hle/service/am/applets/software_keyboard.cpp
+    hle/service/am/applets/software_keyboard.h
+    hle/service/am/applets/software_keyboard_types.h
+    hle/service/am/applets/web_browser.cpp
+    hle/service/am/applets/web_browser.h
+    hle/service/am/applets/web_types.h
    hle/service/am/idle.cpp
    hle/service/am/idle.h
    hle/service/am/omm.cpp
@@ -302,10 +299,10 @@ add_library(core STATIC
    hle/service/aoc/aoc_u.h
    hle/service/apm/apm.cpp
    hle/service/apm/apm.h
-    hle/service/apm/apm_controller.cpp
-    hle/service/apm/apm_controller.h
-    hle/service/apm/apm_interface.cpp
-    hle/service/apm/apm_interface.h
+    hle/service/apm/controller.cpp
+    hle/service/apm/controller.h
+    hle/service/apm/interface.cpp
+    hle/service/apm/interface.h
    hle/service/audio/audctl.cpp
    hle/service/audio/audctl.h
    hle/service/audio/auddbg.cpp
@@ -337,8 +334,8 @@ add_library(core STATIC
    hle/service/bcat/backend/backend.h
    hle/service/bcat/bcat.cpp
    hle/service/bcat/bcat.h
-    hle/service/bcat/bcat_module.cpp
-    hle/service/bcat/bcat_module.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
    hle/service/bpc/bpc.cpp
    hle/service/bpc/bpc.h
    hle/service/btdrv/btdrv.cpp
@@ -384,8 +381,8 @@ add_library(core STATIC
    hle/service/friend/errors.h
    hle/service/friend/friend.cpp
    hle/service/friend/friend.h
-    hle/service/friend/friend_interface.cpp
-    hle/service/friend/friend_interface.h
+    hle/service/friend/interface.cpp
+    hle/service/friend/interface.h
    hle/service/glue/arp.cpp
    hle/service/glue/arp.h
    hle/service/glue/bgtc.cpp
@@ -395,8 +392,8 @@ add_library(core STATIC
    hle/service/glue/errors.h
    hle/service/glue/glue.cpp
    hle/service/glue/glue.h
-    hle/service/glue/glue_manager.cpp
-    hle/service/glue/glue_manager.h
+    hle/service/glue/manager.cpp
+    hle/service/glue/manager.h
    hle/service/grc/grc.cpp
    hle/service/grc/grc.h
    hle/service/hid/hid.cpp
@@ -437,10 +434,10 @@ add_library(core STATIC
    hle/service/lm/lm.h
    hle/service/mig/mig.cpp
    hle/service/mig/mig.h
+    hle/service/mii/manager.cpp
+    hle/service/mii/manager.h
    hle/service/mii/mii.cpp
    hle/service/mii/mii.h
-    hle/service/mii/mii_manager.cpp
-    hle/service/mii/mii_manager.h
    hle/service/mii/raw_data.cpp
    hle/service/mii/raw_data.h
    hle/service/mii/types.h
@@ -454,8 +451,6 @@ add_library(core STATIC
    hle/service/nfp/nfp.h
    hle/service/nfp/nfp_user.cpp
    hle/service/nfp/nfp_user.h
-    hle/service/ngct/ngct.cpp
-    hle/service/ngct/ngct.h
    hle/service/nifm/nifm.cpp
    hle/service/nifm/nifm.h
    hle/service/nim/nim.cpp
@@ -490,11 +485,11 @@ add_library(core STATIC
    hle/service/nvdrv/devices/nvhost_vic.h
    hle/service/nvdrv/devices/nvmap.cpp
    hle/service/nvdrv/devices/nvmap.h
+    hle/service/nvdrv/interface.cpp
+    hle/service/nvdrv/interface.h
    hle/service/nvdrv/nvdata.h
    hle/service/nvdrv/nvdrv.cpp
    hle/service/nvdrv/nvdrv.h
-    hle/service/nvdrv/nvdrv_interface.cpp
-    hle/service/nvdrv/nvdrv_interface.h
    hle/service/nvdrv/nvmemp.cpp
    hle/service/nvdrv/nvmemp.h
    hle/service/nvdrv/syncpoint_manager.cpp
@@ -507,10 +502,10 @@ add_library(core STATIC
    hle/service/olsc/olsc.h
    hle/service/pcie/pcie.cpp
    hle/service/pcie/pcie.h
+    hle/service/pctl/module.cpp
+    hle/service/pctl/module.h
    hle/service/pctl/pctl.cpp
    hle/service/pctl/pctl.h
-    hle/service/pctl/pctl_module.cpp
-    hle/service/pctl/pctl_module.h
    hle/service/pcv/pcv.cpp
    hle/service/pcv/pcv.h
    hle/service/pm/pm.cpp
@@ -521,8 +516,6 @@ add_library(core STATIC
    hle/service/psc/psc.h
    hle/service/ptm/psm.cpp
    hle/service/ptm/psm.h
-    hle/service/kernel_helpers.cpp
-    hle/service/kernel_helpers.h
    hle/service/service.cpp
    hle/service/service.h
    hle/service/set/set.cpp
@@ -535,10 +528,10 @@ add_library(core STATIC
    hle/service/set/set_sys.h
    hle/service/set/settings.cpp
    hle/service/set/settings.h
+    hle/service/sm/controller.cpp
+    hle/service/sm/controller.h
    hle/service/sm/sm.cpp
    hle/service/sm/sm.h
-    hle/service/sm/sm_controller.cpp
-    hle/service/sm/sm_controller.h
    hle/service/sockets/bsd.cpp
    hle/service/sockets/bsd.h
    hle/service/sockets/ethc.cpp
@@ -553,18 +546,18 @@ add_library(core STATIC
    hle/service/sockets/sockets_translate.h
    hle/service/spl/csrng.cpp
    hle/service/spl/csrng.h
+    hle/service/spl/module.cpp
+    hle/service/spl/module.h
    hle/service/spl/spl.cpp
    hle/service/spl/spl.h
-    hle/service/spl/spl_module.cpp
-    hle/service/spl/spl_module.h
-    hle/service/spl/spl_results.h
-    hle/service/spl/spl_types.h
    hle/service/ssl/ssl.cpp
    hle/service/ssl/ssl.h
    hle/service/time/clock_types.h
    hle/service/time/ephemeral_network_system_clock_context_writer.h
    hle/service/time/ephemeral_network_system_clock_core.h
    hle/service/time/errors.h
+    hle/service/time/interface.cpp
+    hle/service/time/interface.h
    hle/service/time/local_system_clock_context_writer.h
    hle/service/time/network_system_clock_context_writer.h
    hle/service/time/standard_local_system_clock_core.h
@@ -582,8 +575,6 @@ add_library(core STATIC
    hle/service/time/tick_based_steady_clock_core.h
    hle/service/time/time.cpp
    hle/service/time/time.h
-    hle/service/time/time_interface.cpp
-    hle/service/time/time_interface.h
    hle/service/time/time_manager.cpp
    hle/service/time/time_manager.h
    hle/service/time/time_sharedmemory.cpp
@@ -640,8 +631,6 @@ add_library(core STATIC
    memory.h
    network/network.cpp
    network/network.h
-    network/network_interface.cpp
-    network/network_interface.h
    network/sockets.h
    perf_stats.cpp
    perf_stats.h
@@ -662,19 +651,24 @@ endif()

 if (MSVC)
    target_compile_options(core PRIVATE
-        /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
-        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
-        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
+        /we4018 # 'expression' : signed/unsigned mismatch
+        /we4244 # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
+        /we4245 # 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+        /we4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
+        /we4305 # 'context' : truncation from 'type1' to 'type2'
        /we4456 # Declaration of 'identifier' hides previous local declaration
        /we4457 # Declaration of 'identifier' hides function parameter
        /we4458 # Declaration of 'identifier' hides class member
        /we4459 # Declaration of 'identifier' hides global declaration
+        /we4715 # 'function' : not all control paths return a value
    )
 else()
    target_compile_options(core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
+        -Werror=implicit-fallthrough
+        -Werror=sign-compare
        -Werror=shadow

        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -8,7 +8,6 @@
 #include <dynarmic/interface/A32/config.h>
 #include <dynarmic/interface/A32/context.h>
 #include "common/assert.h"
-#include "common/literals.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
@@ -23,8 +22,6 @@

 namespace Core {

-using namespace Common::Literals;
-
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
@@ -131,7 +128,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    if (page_table) {
        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
            page_table->pointers.data());
-        config.fastmem_pointer = page_table->fastmem_arena;
    }
    config.absolute_offset_page_table = true;
    config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
@@ -146,11 +142,11 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.wall_clock_cntpct = uses_wall_clock;

    // Code cache size
-    config.code_cache_size = 512_MiB;
-    config.far_code_offset = 400_MiB;
+    config.code_cache_size = 512 * 1024 * 1024;
+    config.far_code_offset = 256 * 1024 * 1024;

    // Safe optimizations
-    if (Settings::values.cpu_debug_mode) {
+    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
        if (!Settings::values.cpuopt_page_tables) {
            config.page_table = nullptr;
        }
@@ -175,36 +171,22 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
        if (!Settings::values.cpuopt_reduce_misalign_checks) {
            config.only_detect_misalignment_via_page_table_on_page_boundary = false;
        }
-        if (!Settings::values.cpuopt_fastmem) {
-            config.fastmem_pointer = nullptr;
-        }
    }

    // Unsafe optimizations
    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
        config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
        }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
        }
-        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
-        }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
        }
    }

-    // Curated optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
-        config.unsafe_optimizations = true;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
-    }
-
    return std::make_unique<Dynarmic::A32::Jit>(config);
 }

--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -7,7 +7,6 @@
 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/A64/config.h>
 #include "common/assert.h"
-#include "common/literals.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
@@ -25,7 +24,6 @@
 namespace Core {

 using Vector = Dynarmic::A64::Vector;
-using namespace Common::Literals;

 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
@@ -162,10 +160,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
        config.absolute_offset_page_table = true;
        config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
        config.only_detect_misalignment_via_page_table_on_page_boundary = true;
-
-        config.fastmem_pointer = page_table->fastmem_arena;
-        config.fastmem_address_space_bits = address_space_bits;
-        config.silently_mirror_fastmem = false;
    }

    // Multi-process state
@@ -186,11 +180,11 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.wall_clock_cntpct = uses_wall_clock;

    // Code cache size
-    config.code_cache_size = 512_MiB;
-    config.far_code_offset = 400_MiB;
+    config.code_cache_size = 512 * 1024 * 1024;
+    config.far_code_offset = 256 * 1024 * 1024;

    // Safe optimizations
-    if (Settings::values.cpu_debug_mode) {
+    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
        if (!Settings::values.cpuopt_page_tables) {
            config.page_table = nullptr;
        }
@@ -215,34 +209,20 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
        if (!Settings::values.cpuopt_reduce_misalign_checks) {
            config.only_detect_misalignment_via_page_table_on_page_boundary = false;
        }
-        if (!Settings::values.cpuopt_fastmem) {
-            config.fastmem_pointer = nullptr;
-        }
    }

    // Unsafe optimizations
    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
        config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
        }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
        }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
        }
-        if (Settings::values.cpuopt_unsafe_fastmem_check) {
-            config.fastmem_address_space_bits = 64;
-        }
-    }
-
-    // Curated optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
-        config.unsafe_optimizations = true;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
-        config.fastmem_address_space_bits = 64;
    }

    return std::make_shared<Dynarmic::A64::Jit>(config);
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -3,8 +3,6 @@
 // Refer to the license.txt file included.

 #include <array>
-#include <atomic>
-#include <exception>
 #include <memory>
 #include <utility>

@@ -36,9 +34,9 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/apm/apm_controller.h"
+#include "core/hle/service/apm/controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/glue/glue_manager.h"
+#include "core/hle/service/glue/manager.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -83,14 +81,10 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
    }
 }

-void KProcessDeleter(Kernel::KProcess* process) {
-    process->Destroy();
-}
-
-using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
-
 } // Anonymous namespace

+/*static*/ System System::s_instance;
+
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                         const std::string& path) {
    // To account for split 00+01+etc files.
@@ -221,9 +215,9 @@ struct System::Impl {
    }

    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window, const std::string& filepath,
-                      u64 program_id, std::size_t program_index) {
+                      std::size_t program_index) {
        app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath),
-                                       program_id, program_index);
+                                       program_index);

        if (!app_loader) {
            LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
@@ -239,8 +233,8 @@ struct System::Impl {
        }

        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
-        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
+        auto main_process = Kernel::KProcess::Create(system.Kernel());
+        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
                                            Kernel::KProcess::ProcessType::Userland)
                   .IsSuccess());
        main_process->Open();
@@ -253,7 +247,7 @@ struct System::Impl {
                                             static_cast<u32>(load_result));
        }
        AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process.get());
+        kernel.MakeCurrentProcess(main_process);
        kernel.InitializeCores();

        // Initialize cheat engine
@@ -268,16 +262,17 @@ struct System::Impl {
        if (Settings::values.gamecard_inserted) {
            if (Settings::values.gamecard_current_game) {
                fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
-            } else if (!Settings::values.gamecard_path.GetValue().empty()) {
-                const auto gamecard_path = Settings::values.gamecard_path.GetValue();
-                fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, gamecard_path));
+            } else if (!Settings::values.gamecard_path.empty()) {
+                fs_controller.SetGameCard(
+                    GetGameFileFromPath(virtual_filesystem, Settings::values.gamecard_path));
            }
        }

-        if (app_loader->ReadProgramId(program_id) != Loader::ResultStatus::Success) {
+        u64 title_id{0};
+        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})", load_result);
        }
-        perf_stats = std::make_unique<PerfStats>(program_id);
+        perf_stats = std::make_unique<PerfStats>(title_id);
        // Reset counters and set time origin to current frame
        GetAndResetPerfStats();
        perf_stats->BeginSystemFrame();
@@ -305,7 +300,10 @@ struct System::Impl {
        is_powered_on = false;
        exit_lock = false;

-        gpu_core.reset();
+        if (gpu_core) {
+            gpu_core->ShutDown();
+        }
+
        services.reset();
        service_manager.reset();
        cheat_engine.reset();
@@ -314,12 +312,11 @@ struct System::Impl {
        time_manager.Shutdown();
        core_timing.Shutdown();
        app_loader.reset();
+        gpu_core.reset();
        perf_stats.reset();
        kernel.Shutdown();
        memory.Reset();
        applet_manager.ClearAll();
-        // TODO: The main process should be freed based on KAutoObject ref counting.
-        main_process.reset();

        LOG_DEBUG(Core, "Shutdown OK");
    }
@@ -378,10 +375,9 @@ struct System::Impl {
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
    std::unique_ptr<Core::DeviceMemory> device_memory;
-    KProcessPtr main_process{nullptr, KProcessDeleter};
    Core::Memory::Memory memory;
    CpuManager cpu_manager;
-    std::atomic_bool is_powered_on{};
+    bool is_powered_on = false;
    bool exit_lock = false;

    Reporter reporter;
@@ -415,7 +411,7 @@ struct System::Impl {
    std::string status_details = "";

    std::unique_ptr<Core::PerfStats> perf_stats;
-    Core::SpeedLimiter speed_limiter;
+    Core::FrameLimiter frame_limiter;

    bool is_multicore{};
    bool is_async_gpu{};
@@ -429,20 +425,6 @@ struct System::Impl {
 System::System() : impl{std::make_unique<Impl>(*this)} {}
 System::~System() = default;

-System& System::GetInstance() {
-    if (!s_instance) {
-        throw std::runtime_error("Using System instance before its initialization");
-    }
-    return *s_instance;
-}
-
-void System::InitializeGlobalInstance() {
-    if (s_instance) {
-        throw std::runtime_error("Reinitializing Global System instance.");
-    }
-    s_instance = std::unique_ptr<System>(new System);
-}
-
 CpuManager& System::GetCpuManager() {
    return impl->cpu_manager;
 }
@@ -476,12 +458,12 @@ void System::Shutdown() {
 }

 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
-                                  u64 program_id, std::size_t program_index) {
-    return impl->Load(*this, emu_window, filepath, program_id, program_index);
+                                  std::size_t program_index) {
+    return impl->Load(*this, emu_window, filepath, program_index);
 }

 bool System::IsPoweredOn() const {
-    return impl->is_powered_on.load(std::memory_order::relaxed);
+    return impl->is_powered_on;
 }

 void System::PrepareReschedule() {
@@ -624,12 +606,12 @@ const Core::PerfStats& System::GetPerfStats() const {
    return *impl->perf_stats;
 }

-Core::SpeedLimiter& System::SpeedLimiter() {
-    return impl->speed_limiter;
+Core::FrameLimiter& System::FrameLimiter() {
+    return impl->frame_limiter;
 }

-const Core::SpeedLimiter& System::SpeedLimiter() const {
-    return impl->speed_limiter;
+const Core::FrameLimiter& System::FrameLimiter() const {
+    return impl->frame_limiter;
 }

 Loader::ResultStatus System::GetGameName(std::string& out) const {
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -94,7 +94,7 @@ class ARM_Interface;
 class CpuManager;
 class DeviceMemory;
 class ExclusiveMonitor;
-class SpeedLimiter;
+class FrameLimiter;
 class PerfStats;
 class Reporter;
 class TelemetrySession;
@@ -120,9 +120,9 @@ public:
     * Gets the instance of the System singleton class.
     * @returns Reference to the instance of the System singleton class.
     */
-    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance();
-
-    static void InitializeGlobalInstance();
+    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance() {
+        return s_instance;
+    }

    /// Enumeration representing the return values of the System Initialize and Load process.
    enum class ResultStatus : u32 {
@@ -175,7 +175,7 @@ public:
     * @returns ResultStatus code, indicating if the operation succeeded.
     */
    [[nodiscard]] ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
-                                    u64 program_id = 0, std::size_t program_index = 0);
+                                    std::size_t program_index = 0);

    /**
     * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
@@ -292,11 +292,11 @@ public:
    /// Provides a constant reference to the internal PerfStats instance.
    [[nodiscard]] const Core::PerfStats& GetPerfStats() const;

-    /// Provides a reference to the speed limiter;
-    [[nodiscard]] Core::SpeedLimiter& SpeedLimiter();
+    /// Provides a reference to the frame limiter;
+    [[nodiscard]] Core::FrameLimiter& FrameLimiter();

-    /// Provides a constant reference to the speed limiter
-    [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
+    /// Provides a constant referent to the frame limiter
+    [[nodiscard]] const Core::FrameLimiter& FrameLimiter() const;

    /// Gets the name of the current game
    [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
@@ -396,7 +396,7 @@ private:
    struct Impl;
    std::unique_ptr<Impl> impl;

-    inline static std::unique_ptr<System> s_instance{};
+    static System s_instance;
 };

 } // namespace Core
--- a/src/core/cpu_manager.cpp
+++ b/src/core/cpu_manager.cpp
@@ -21,25 +21,34 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;

-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(stop_token, core);
+void CpuManager::ThreadStart(CpuManager& cpu_manager, std::size_t core) {
+    cpu_manager.RunThread(core);
 }

 void CpuManager::Initialize() {
    running_mode = true;
    if (is_multicore) {
        for (std::size_t core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
-            core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+            core_data[core].host_thread =
+                std::make_unique<std::thread>(ThreadStart, std::ref(*this), core);
        }
    } else {
-        core_data[0].host_thread = std::jthread(ThreadStart, std::ref(*this), 0);
+        core_data[0].host_thread = std::make_unique<std::thread>(ThreadStart, std::ref(*this), 0);
    }
 }

 void CpuManager::Shutdown() {
    running_mode = false;
    Pause(false);
+    if (is_multicore) {
+        for (auto& data : core_data) {
+            data.host_thread->join();
+            data.host_thread.reset();
+        }
+    } else {
+        core_data[0].host_thread->join();
+        core_data[0].host_thread.reset();
+    }
 }

 std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
@@ -308,7 +317,7 @@ void CpuManager::Pause(bool paused) {
    }
 }

-void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
+void CpuManager::RunThread(std::size_t core) {
    /// Initialization
    system.RegisterCoreThread(core);
    std::string name;
@@ -352,10 +361,6 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
            return;
        }

-        if (stop_token.stop_requested()) {
-            break;
-        }
-
        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
        data.is_running = true;
        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
--- a/src/core/cpu_manager.h
+++ b/src/core/cpu_manager.h
@@ -78,9 +78,9 @@ private:
    void SingleCoreRunSuspendThread();
    void SingleCorePause(bool paused);

-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
+    static void ThreadStart(CpuManager& cpu_manager, std::size_t core);

-    void RunThread(std::stop_token stop_token, std::size_t core);
+    void RunThread(std::size_t core);

    struct CoreData {
        std::shared_ptr<Common::Fiber> host_context;
@@ -89,7 +89,7 @@ private:
        std::atomic<bool> is_running;
        std::atomic<bool> is_paused;
        std::atomic<bool> initialized;
-        std::jthread host_thread;
+        std::unique_ptr<std::thread> host_thread;
    };

    std::atomic<bool> running_mode{};
--- a/src/core/crypto/key_manager.cpp
+++ b/src/core/crypto/key_manager.cpp
@@ -835,7 +835,7 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
            "key_area_key_ocean_{:02X}",
            "key_area_key_system_{:02X}",
        };
-        WriteKeyToFile(category, fmt::format(fmt::runtime(kak_names.at(field2)), field1), key);
+        WriteKeyToFile(category, fmt::format(kak_names.at(field2), field1), key);
    } else if (id == S128KeyType::Master) {
        WriteKeyToFile(category, fmt::format("master_key_{:02X}", field1), key);
    } else if (id == S128KeyType::Package1) {
--- a/src/core/device_memory.cpp
+++ b/src/core/device_memory.cpp
@@ -6,7 +6,7 @@

 namespace Core {

-DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size, 1ULL << 39} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size} {}
 DeviceMemory::~DeviceMemory() = default;

 } // namespace Core
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -5,7 +5,7 @@
 #pragma once

 #include "common/common_types.h"
-#include "common/host_memory.h"
+#include "common/virtual_buffer.h"

 namespace Core {

@@ -21,30 +21,27 @@ enum : u64 {
 };
 }; // namespace DramMemoryMap

-class DeviceMemory {
+class DeviceMemory : NonCopyable {
 public:
    explicit DeviceMemory();
    ~DeviceMemory();

-    DeviceMemory& operator=(const DeviceMemory&) = delete;
-    DeviceMemory(const DeviceMemory&) = delete;
-
    template <typename T>
    PAddr GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) -
-                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
+        return (reinterpret_cast<uintptr_t>(ptr) - reinterpret_cast<uintptr_t>(buffer.data())) +
               DramMemoryMap::Base;
    }

    u8* GetPointer(PAddr addr) {
-        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
+        return buffer.data() + (addr - DramMemoryMap::Base);
    }

    const u8* GetPointer(PAddr addr) const {
-        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
+        return buffer.data() + (addr - DramMemoryMap::Base);
    }

-    Common::HostMemory buffer;
+private:
+    Common::VirtualBuffer<u8> buffer;
 };

 } // namespace Core
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -29,7 +29,7 @@ constexpr std::array partition_names{
    "logo",
 };

-XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
+XCI::XCI(VirtualFile file_, std::size_t program_index)
    : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
      partitions(partition_names.size()),
      partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
@@ -63,12 +63,12 @@ XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)

    secure_partition = std::make_shared<NSP>(
        main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]),
-        program_id, program_index);
+        program_index);

    ncas = secure_partition->GetNCAsCollapsed();
    program =
        secure_partition->GetNCA(secure_partition->GetProgramTitleID(), ContentRecordType::Program);
-    program_nca_status = secure_partition->GetProgramStatus();
+    program_nca_status = secure_partition->GetProgramStatus(secure_partition->GetProgramTitleID());
    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA) {
        program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
    }
@@ -174,10 +174,6 @@ u64 XCI::GetProgramTitleID() const {
    return secure_partition->GetProgramTitleID();
 }

-std::vector<u64> XCI::GetProgramTitleIDs() const {
-    return secure_partition->GetProgramTitleIDs();
-}
-
 u32 XCI::GetSystemUpdateVersion() {
    const auto update = GetPartition(XCIPartition::Update);
    if (update == nullptr) {
@@ -233,11 +229,9 @@ const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
 }

 std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
-    const auto program_id = secure_partition->GetProgramTitleID();
-    const auto iter = std::find_if(
-        ncas.begin(), ncas.end(), [this, type, program_id](const std::shared_ptr<NCA>& nca) {
-            return nca->GetType() == type && nca->GetTitleId() == program_id;
-        });
+    const auto iter =
+        std::find_if(ncas.begin(), ncas.end(),
+                     [type](const std::shared_ptr<NCA>& nca) { return nca->GetType() == type; });
    return iter == ncas.end() ? nullptr : *iter;
 }

--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -78,7 +78,7 @@ enum class XCIPartition : u8 { Update, Normal, Secure, Logo };

 class XCI : public ReadOnlyVfsDirectory {
 public:
-    explicit XCI(VirtualFile file, u64 program_id = 0, size_t program_index = 0);
+    explicit XCI(VirtualFile file, std::size_t program_index = 0);
    ~XCI() override;

    Loader::ResultStatus GetStatus() const;
@@ -104,7 +104,6 @@ public:
    VirtualFile GetLogoPartitionRaw() const;

    u64 GetProgramTitleID() const;
-    std::vector<u64> GetProgramTitleIDs() const;
    u32 GetSystemUpdateVersion();
    u64 GetSystemUpdateTitleID() const;

--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <cstring>
 #include <optional>
+#include <ranges>
 #include <utility>

 #include "common/logging/log.h"
--- a/src/core/file_sys/kernel_executable.h
+++ b/src/core/file_sys/kernel_executable.h
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <string>
 #include <vector>

 #include "common/common_funcs.h"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kelebek1	fd9575e081	Remove saving the layout as it's no longer needed	2021-06-03 21:47:00 +01:00
Kelebek1	8a5221a746	Correct light theme loading	2021-06-03 18:37:22 +01:00