debug

[desktop] Rework game list to use MVP architecture (#4042 )
Closes #3480 moves the game list model/worker/private stuff to qt_common for later use in QML - `qt_common/game_list/model.{cpp,h}` is the model - `yuzu/game/game_{grid,tree}.*` are the views - `yuzu/game/game_list.cpp` is the presenter This was done very lazily in a manner that "works" while largely maintaining existing structure as much as possible. Most of it is copy-paste, with some bonus reworks/cleanups thrown in. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4042 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>
2026-08-18 06:10:35 +00:00 · 2026-06-02 04:58:50 +02:00 · 2026-06-02 04:08:24 +02:00 · 2026-06-02 04:08:09 +02:00 · 2026-06-02 03:40:28 +02:00 · 2026-06-02 03:33:38 +02:00
127 changed files with 7014 additions and 2386 deletions
@@ -16,6 +16,7 @@ jobs:

      - name: Update deps
        run: |
+          set -x
          git config --local user.name "Eden CI"
          git config --local user.email "ci@eden-emu.dev"
          git config --local user.signingkey "D57652791BB25D2A"
@@ -0,0 +1,214 @@
+From ec4c1fdf526cb9ad045abf59b29ee495bbf5023a Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 20:56:35 -0400
+Subject: [PATCH] cpmutil compat
+
+---
+ CMakeLists.txt           | 31 ++++++++-----------
+ cmake/FetchOpenSSL.cmake | 64 ----------------------------------------
+ cmake/GetCPM.cmake       |  5 ----
+ 3 files changed, 13 insertions(+), 87 deletions(-)
+ delete mode 100644 cmake/FetchOpenSSL.cmake
+ delete mode 100644 cmake/GetCPM.cmake
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 5420ecc..9ffd5a0 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -19,9 +19,7 @@ include(FetchContent)
+ include(ProcessorCount)
+ include(cmake/ConfigureOpenSSL.cmake)
+ include(cmake/DetectTargetPlatform.cmake)
+-include(cmake/FetchOpenSSL.cmake)
+ include(cmake/FindVcvarsall.cmake)
+-include(cmake/GetCPM.cmake)
+ 
+ # Custom options
+ option(OPENSSL_BUILD_VERBOSE "Enable verbose output from build" OFF)
+@@ -47,9 +45,6 @@ if("${OPENSSL_TARGET_PLATFORM}" STREQUAL "")
+     detect_target_platform(OPENSSL_TARGET_PLATFORM)
+ endif()
+ 
+-# Fetch OpenSSL source
+-fetch_openssl()
+-
+ # Apply patches
+ foreach(patch IN LISTS OPENSSL_PATCH)
+     if(EXISTS "${patch}" AND NOT IS_DIRECTORY "${patch}")
+@@ -59,13 +54,13 @@ foreach(patch IN LISTS OPENSSL_PATCH)
+ 
+         execute_process(
+             COMMAND git init
+-            WORKING_DIRECTORY ${openssl_SOURCE_DIR}
+            WORKING_DIRECTORY ${OpenSSL_SOURCE_DIR}
+             OUTPUT_QUIET
+             ERROR_QUIET
+         )
+         execute_process(
+             COMMAND git apply ${patch}
+-            WORKING_DIRECTORY ${openssl_SOURCE_DIR}
+            WORKING_DIRECTORY ${OpenSSL_SOURCE_DIR}
+             OUTPUT_QUIET
+             ERROR_QUIET
+         )
+@@ -161,8 +156,8 @@ list(PREPEND OPENSSL_CONFIGURE_OPTIONS ${OPENSSL_TARGET_PLATFORM})
+ # Configure OpenSSL
+ configure_openssl(
+     COMMAND ${VCVARSALL_COMMAND}
+-    FILE ${openssl_SOURCE_DIR}/Configure
+-    BUILD_DIR ${openssl_BINARY_DIR}
+    FILE ${OpenSSL_SOURCE_DIR}/Configure
+    BUILD_DIR ${OpenSSL_BINARY_DIR}
+     OPTIONS ${OPENSSL_CONFIGURE_OPTIONS}
+ )
+ 
+@@ -203,8 +198,8 @@ endif()
+ # Parse Makefile
+ parse_makefile(${OPENSSL_MAKEFILE} "INSTALL_LIBS" OPENSSL_STATIC_LIBS)
+ parse_makefile(${OPENSSL_MAKEFILE} "INSTALL_SHLIBS" OPENSSL_SHARED_LIBS)
+-list(TRANSFORM OPENSSL_STATIC_LIBS PREPEND "${openssl_BINARY_DIR}/")
+-list(TRANSFORM OPENSSL_SHARED_LIBS PREPEND "${openssl_BINARY_DIR}/")
+list(TRANSFORM OPENSSL_STATIC_LIBS PREPEND "${OpenSSL_BINARY_DIR}/")
+list(TRANSFORM OPENSSL_SHARED_LIBS PREPEND "${OpenSSL_BINARY_DIR}/")
+ 
+ foreach(LIBRARY IN LISTS OPENSSL_STATIC_LIBS)
+     if(LIBRARY MATCHES "crypto")
+@@ -239,14 +234,14 @@ endif()
+ 
+ # Provide same targets and variables as FindOpenSSL module
+ set(OPENSSL_FOUND ON CACHE BOOL "Override FindOpenSSL variables" FORCE)
+-set(OPENSSL_INCLUDE_DIR ${openssl_SOURCE_DIR}/include ${openssl_BINARY_DIR}/include CACHE STRING "Override FindOpenSSL variables" FORCE)
+set(OPENSSL_INCLUDE_DIR ${OpenSSL_SOURCE_DIR}/include ${OpenSSL_BINARY_DIR}/include CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_CRYPTO_LIBRARY ${OPENSSL_${OPENSSL_LIBRARY_TYPE}_CRYPTO_LIBRARY} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_CRYPTO_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_SSL_LIBRARY ${OPENSSL_${OPENSSL_LIBRARY_TYPE}_SSL_LIBRARY} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_SSL_LIBRARIES ${OPENSSL_SSL_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY} ${OPENSSL_SSL_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_VERSION ${OPENSSL_CONFIGURED_VERSION} CACHE STRING "Override FindOpenSSL variables" FORCE)
+-set(OPENSSL_APPLINK_SOURCE ${openssl_SOURCE_DIR}/ms/applink.c CACHE STRING "Override FindOpenSSL variables" FORCE)
+set(OPENSSL_APPLINK_SOURCE ${OpenSSL_SOURCE_DIR}/ms/applink.c CACHE STRING "Override FindOpenSSL variables" FORCE)
+ 
+ add_library(OpenSSL::Crypto ${OPENSSL_LIBRARY_TYPE} IMPORTED GLOBAL)
+ add_library(OpenSSL::SSL ${OPENSSL_LIBRARY_TYPE} IMPORTED GLOBAL)
+@@ -308,8 +303,8 @@ if(ANDROID)
+ endif()
+ 
+ file(GLOB_RECURSE OPENSSL_SOURCES
+-    ${openssl_SOURCE_DIR}/*.[ch]
+-    ${openssl_SOURCE_DIR}/*.[ch].in
+    ${OpenSSL_SOURCE_DIR}/*.[ch]
+    ${OpenSSL_SOURCE_DIR}/*.[ch].in
+ )
+ 
+ set(OPENSSL_BUILD_OUTPUT
+@@ -322,7 +317,7 @@ add_custom_command(
+     OUTPUT ${OPENSSL_BUILD_OUTPUT}
+     COMMAND ${OPENSSL_BUILD_COMMAND}
+     DEPENDS ${OPENSSL_SOURCES}
+-    WORKING_DIRECTORY ${openssl_BINARY_DIR}
+    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
+     VERBATIM
+ )
+ 
+@@ -341,7 +336,7 @@ if(OPENSSL_TEST AND NOT CMAKE_CROSSCOMPILING)
+     add_test(
+         NAME openssl-test
+         COMMAND ${OPENSSL_BUILD_TOOL} test VERBOSE_FAILURE=yes HARNESS_JOBS=${NUMBER_OF_THREADS}
+-        WORKING_DIRECTORY ${openssl_BINARY_DIR}
+        WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
+     )
+ endif()
+ 
+@@ -356,7 +351,7 @@ if(OPENSSL_INSTALL)
+     install(CODE
+         "execute_process(
+             COMMAND ${OPENSSL_INSTALL_COMMAND}
+-            WORKING_DIRECTORY \"${openssl_BINARY_DIR}\"
+            WORKING_DIRECTORY \"${OpenSSL_BINARY_DIR}\"
+         )"
+     )
+ endif()
+diff --git a/cmake/FetchOpenSSL.cmake b/cmake/FetchOpenSSL.cmake
+deleted file mode 100644
+index a43505d..0000000
+--- a/cmake/FetchOpenSSL.cmake
+++ /dev/null
+@@ -1,64 +0,0 @@
+-function(fetch_openssl)
+-    if(EXISTS "${OPENSSL_SOURCE}" AND IS_DIRECTORY "${OPENSSL_SOURCE}")
+-        # Fetch the local OpenSSL source
+-        if(NOT IS_ABSOLUTE "${OPENSSL_SOURCE}")
+-            string(PREPEND OPENSSL_SOURCE ${CMAKE_SOURCE_DIR}/)
+-        endif()
+-
+-        string(REPLACE "\\" "/" openssl-source_SOURCE_DIR "${OPENSSL_SOURCE}")
+-        set(openssl-source_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/openssl-source-build)
+-    else()
+-        set(CPM_OPTIONS
+-            NAME openssl-source
+-            DOWNLOAD_ONLY ON
+-        )
+-
+-        if(NOT OPENSSL_CONFIGURE_VERBOSE)
+-            list(APPEND CPM_OPTIONS QUIET)
+-        endif()
+-
+-        if("${OPENSSL_SOURCE}" MATCHES "^http")
+-            # Download OpenSSL source from the internet
+-            list(APPEND CPM_OPTIONS URL ${OPENSSL_SOURCE})
+-        else()
+-            # Download OpenSSL source from the official website
+-            if("${OPENSSL_TARGET_VERSION}" STREQUAL "")
+-                set(OPENSSL_TARGET_VERSION ${PROJECT_VERSION})
+-            endif()
+-
+-            if(OPENSSL_TARGET_VERSION VERSION_EQUAL PROJECT_VERSION)
+-                list(APPEND CPM_OPTIONS URL_HASH SHA256=aaf51a1fe064384f811daeaeb4ec4dce7340ec8bd893027eee676af31e83a04f)
+-            endif()
+-
+-            if(OPENSSL_TARGET_VERSION MATCHES "^1\.1\.1[a-w]$")
+-                string(REPLACE "." "_" OPENSSL_TAGGED_VERSION ${OPENSSL_TARGET_VERSION})
+-                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/OpenSSL_${OPENSSL_TAGGED_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
+-            else()
+-                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/openssl-${OPENSSL_TARGET_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
+-            endif()
+-        endif()
+-
+-        CPMAddPackage(${CPM_OPTIONS})
+-    endif()
+-
+-    # Clean build directory if source directory has changed
+-    if(DEFINED CACHE{openssl-source_SOURCE_DIR_OLD} AND NOT openssl-source_SOURCE_DIR STREQUAL openssl-source_SOURCE_DIR_OLD)
+-        set(openssl-source_SOURCE_DIR_OLD ${openssl-source_SOURCE_DIR} CACHE INTERNAL "Previously fetched OpenSSL source")
+-
+-        if(IS_DIRECTORY ${openssl-source_BINARY_DIR})
+-            file(REMOVE_RECURSE ${openssl-source_BINARY_DIR})
+-            file(MAKE_DIRECTORY ${openssl-source_BINARY_DIR})
+-        endif()
+-    endif()
+-
+-    # Override the FindOpenSSL module
+-    FetchContent_Declare(
+-        OpenSSL
+-        SOURCE_DIR ${openssl-source_SOURCE_DIR}
+-        BINARY_DIR ${openssl-source_BINARY_DIR}
+-        OVERRIDE_FIND_PACKAGE
+-    )
+-    FetchContent_MakeAvailable(OpenSSL)
+-
+-    return(PROPAGATE openssl_SOURCE_DIR openssl_BINARY_DIR)
+-endfunction()
+diff --git a/cmake/GetCPM.cmake b/cmake/GetCPM.cmake
+deleted file mode 100644
+index bfc50f5..0000000
+--- a/cmake/GetCPM.cmake
+++ /dev/null
+@@ -1,5 +0,0 @@
+-file(
+-    DOWNLOAD https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake
+-    ${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake
+-)
+-include(${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake)
+-- 
+2.54.0
+
@@ -0,0 +1,54 @@
+From d46675fbb61eb6d51e478023ce4075e545ad4cfd Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 21:11:55 -0400
+Subject: [PATCH] use ccache
+
+---
+ CMakeLists.txt               |  1 -
+ cmake/ConfigureOpenSSL.cmake | 12 +++---------
+ 2 files changed, 3 insertions(+), 10 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 9ffd5a0..9ff14c8 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -28,7 +28,6 @@ option(OPENSSL_ENABLE_PARALLEL "Build and test in parallel if possible" ON)
+ option(OPENSSL_INSTALL "Install OpenSSL components to the <prefix> directory" OFF)
+ option(OPENSSL_INSTALL_CERT "Install cert.pem to the <openssldir> directory" OFF)
+ option(OPENSSL_TEST "Enable testing and build OpenSSL self tests" OFF)
+-option(OPENSSL_USE_CCACHE "Use ccache if available" ON)
+ 
+ if("${OPENSSL_BUILD_TARGET}" STREQUAL "")
+     # Makefile target for build
+diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
+index 211c18b..3d8cbed 100644
+--- a/cmake/ConfigureOpenSSL.cmake
+++ b/cmake/ConfigureOpenSSL.cmake
+@@ -69,15 +69,9 @@ function(apply_ccache FILE)
+         message(FATAL_ERROR "Couldn't find Makefile")
+     endif()
+ 
+-    if(OPENSSL_USE_CCACHE)
+-        find_program(CCACHE ccache)
+-
+-        if(NOT CCACHE)
+-            return()
+-        endif()
+-
+    if(USE_CCACHE)
+         file(READ ${FILE} MAKEFILE)
+-        string(REPLACE "\nCC=" "\nCC=ccache " MAKEFILE "${MAKEFILE}")
+        string(REPLACE "\nCC=" "\nCC=${CCACHE_BINARY} " MAKEFILE "${MAKEFILE}")
+ 
+         if(MSVC)
+             string(REPLACE "/Zi /Fdossl_static.pdb " "" MAKEFILE "${MAKEFILE}")
+@@ -171,4 +165,4 @@ function(configure_openssl)
+         string(REPLACE "/W3" "/W0" MAKEFILE "${MAKEFILE}")
+         file(WRITE ${OPENSSL_MAKEFILE} "${MAKEFILE}")
+     endif()
+-endfunction()
+\ No newline at end of file
+endfunction()
+-- 
+2.54.0
+
@@ -0,0 +1,28 @@
+From 4a3cc92a7abad403529ed1cb4255ca63d9252de4 Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 21:48:42 -0400
+Subject: [PATCH 2/2] use cmake compiler flags
+
+---
+ cmake/ConfigureOpenSSL.cmake | 5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
+index 3d8cbed..3012e05 100644
+--- a/cmake/ConfigureOpenSSL.cmake
+++ b/cmake/ConfigureOpenSSL.cmake
+@@ -135,7 +135,10 @@ function(configure_openssl)
+     endif()
+ 
+     execute_process(
+-        COMMAND ${CONFIGURE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E env
+            "CFLAGS=${CMAKE_C_FLAGS}"
+            "CXXFLAGS=${CMAKE_CXX_FLAGS}"
+            ${CONFIGURE_COMMAND}
+         WORKING_DIRECTORY ${CONFIGURE_BUILD_DIR}
+         ${VERBOSE_OPTION}
+         COMMAND_ERROR_IS_FATAL ANY
+-- 
+2.54.0
+
@@ -383,13 +383,20 @@ find_package(RenderDoc MODULE)
 # openssl funniness
 if (YUZU_USE_BUNDLED_OPENSSL)
    set(BUILD_SHARED_LIBS OFF)
+    AddJsonPackage(openssl-ci)
+else()
    AddJsonPackage(openssl)
+    set(OPENSSL_BUILD_VERBOSE ON)
+    set(OPENSSL_CONFIGURE_VERBOSE ON)
+
    if (OpenSSL_ADDED)
-        add_compile_definitions(YUZU_BUNDLED_OPENSSL)
+        AddJsonPackage(openssl-cmake)
    endif()
 endif()

-find_package(OpenSSL 3 REQUIRED)
+if (OpenSSL_ADDED)
+    add_compile_definitions(YUZU_BUNDLED_OPENSSL)
+endif()

 message(STATUS "Fetching needed dependencies with CPM")

@@ -1,5 +1,5 @@
 {
-    "openssl": {
+    "openssl-ci": {
        "ci": true,
        "package": "OpenSSL",
        "name": "openssl",
@@ -7,6 +7,33 @@
        "version": "3.6.0-1cb0d36b39",
        "min_version": "3"
    },
+    "openssl-cmake": {
+        "repo": "jimmy-park/openssl-cmake",
+        "hash": "2cc185c924fd70e7d886257ca0caa42b3b8f7f712f2052b4f94dde74759e27022de76178460e18c9bdfc57c366583999e198fbb6052d4e7d91c099d15a0ca63e",
+        "git_version": "3.6.2",
+        "tag": "%VERSION%",
+        "bundled": true,
+        "options": [
+            "OPENSSL_CONFIGURE_OPTIONS threads"
+        ],
+        "patches": [
+            "0001-cpmutil-compat.patch",
+            "0002-use-ccache.patch",
+            "0003-use-cmake-compiler-flags.patch"
+        ]
+    },
+    "openssl": {
+        "repo": "openssl/openssl",
+        "package": "OpenSSL",
+        "min_version": "3",
+        "version": "3",
+        "hash": "29002ce50cb95a4f4f1d0e9d3f684401fbd4eac34203dc2eef3b6334af5d44aa46bf788b63a6f5c139c383eafb7269ae87a58a9a3ad5912903b9773e545ccc0a",
+        "git_version": "3.6.2",
+        "tag": "openssl-%VERSION%",
+        "patches": [
+            "0001-add-bundled-cert.patch"
+        ]
+    },
    "boost": {
        "package": "Boost",
        "repo": "boostorg/boost",
@@ -82,6 +82,11 @@ if (ARCHITECTURE_riscv64)
    AddJsonPackage(biscuit)
 endif()

+# Lagoon
+if (ARCHITECTURE_loongarch64)
+    AddJsonPackage(lagoon)
+endif()
+
 # Vulkan stuff
 AddDependentPackages(vulkan-headers vulkan-utility-libraries)

@@ -67,6 +67,12 @@
        "tag": "v%VERSION%",
        "hash": "9697e80a7d5d9bcb3ce51051a9a24962fb90ca79d215f1f03ae6b58da8ba13a63b5dda1b4dde3d26ac6445029696b8ef2883f4e5a777b342bba01283ed293856"
    },
+    "lagoon": {
+        "repo": "loongson-community/lagoon",
+        "tag": "%VERSION%",
+        "version": "1.0.0",
+        "hash": "b9380f99c6effaeccc6d8f81d4942e852c11ad28613df637e155451556ae5826f93765bee57a5c87a9740d2bd1db463ad0f55a947772fe9d57eeabae3efa373e"
+    },
    "libadrenotools": {
        "repo": "eden-emulator/libadrenotools",
        "sha": "8ba23b42d7",
@@ -8,7 +8,7 @@
 include_directories(.)

 # Dynarmic
-if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64) AND NOT YUZU_STATIC_ROOM)
+if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64 OR ARCHITECTURE_loongarch64) AND NOT YUZU_STATIC_ROOM)
    add_subdirectory(dynarmic)
    add_library(dynarmic::dynarmic ALIAS dynarmic)
 endif()
@@ -21,20 +21,41 @@ if (YUZU_STATIC_BUILD)
    add_compile_definitions(QT_STATICPLUGIN)
 endif()

+# Build identifiers
 if (NIGHTLY_BUILD)
    add_compile_definitions(NIGHTLY_BUILD)
 endif()

+# Legacy (android only)
 if (YUZU_LEGACY)
    message(WARNING "Making legacy build. Performance may suffer.")
    add_compile_definitions(YUZU_LEGACY)
 endif()

+# Genshin Spoof (android only)
 if (GENSHIN_SPOOF)
    message(WARNING "Making Genshin spoof build")
    add_compile_definitions(GENSHIN_SPOOF)
 endif()

+# Build ID (mingw only right now)
+# Pretty much just refers to the CI "target" for this build
+if (NOT BUILD_ID)
+    if (ARCHITECTURE_x86_64)
+        set(BUILD_ID amd64)
+    elseif(ARCHITECTURE_arm64)
+        if (WIN32)
+            set(BUILD_ID arm64)
+        else()
+            set(BUILD_ID aarch64)
+        endif()
+    else()
+        set(BUILD_ID "${ARCHITECTURE}")
+    endif()
+endif()
+
+add_compile_definitions(BUILD_ID="${BUILD_ID}")
+
 # Set compilation flags
 if (MSVC AND NOT CXX_CLANG)
    set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE STRING "" FORCE)
@@ -15,7 +15,6 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.graphics.Rect
 import android.graphics.drawable.Icon
@@ -101,7 +100,6 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
    private var romSwapGeneration = 0
    private var hasEmulationSession = processHasEmulationSession
    private val romSwapStopTimeoutRunnable = Runnable { onRomSwapStopTimeout() }
-    private val pictureInPictureFailureActions: MutableSet<String> = mutableSetOf()

    private fun onRomSwapStopTimeout() {
        if (!isWaitingForRomSwapStop) {
@@ -270,18 +268,12 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
    }

    override fun onUserLeaveHint() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ||
-            !isPictureInPictureSupported() ||
-            !BooleanSetting.PICTURE_IN_PICTURE.getBoolean() ||
-            isInPictureInPictureMode
-        ) {
-            return
-        }
-
-        val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
-            .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
-        runPictureInPictureAction("enter picture-in-picture mode") {
-            enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            if (BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && !isInPictureInPictureMode) {
+                val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
+                    .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
+                enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+            }
        }
    }

@@ -661,29 +653,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
        return this.apply { setActions(pictureInPictureActions) }
    }

-    private fun isPictureInPictureSupported() =
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
-            packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
-
-    private fun runPictureInPictureAction(actionName: String, action: () -> Unit) {
-        try {
-            action()
-        } catch (e: IllegalStateException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        } catch (e: UnsupportedOperationException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        }
-    }
-
    fun buildPictureInPictureParams() {
-        if (!isPictureInPictureSupported()) {
-            return
-        }
-
        val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
            .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@@ -693,9 +663,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
                BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && isEmulationActive
            )
        }
-        runPictureInPictureAction("set picture-in-picture params") {
-            setPictureInPictureParams(pictureInPictureParamsBuilder.build())
-        }
+        setPictureInPictureParams(pictureInPictureParamsBuilder.build())
    }

    fun displayMultiplayerDialog() {
@@ -458,6 +458,8 @@
    <string name="renderer_resolution">Разрешение (портативное/в док-станции)</string>
    <string name="renderer_vsync">Режим верт. синхронизации</string>
    <string name="renderer_scaling_filter">Фильтр адаптации окна</string>
+    <string name="fsr_sharpness">Резкость FSR/SGSR</string>
+    <string name="fsr_sharpness_description">Определяет, насколько чётким будет изображение при использовании динамического контраста FSR или SGSR фильтров</string>
    <string name="renderer_anti_aliasing">Метод сглаживания</string>


@@ -497,6 +499,8 @@
    <string name="fast_gpu_time_description">Принудительно запускает большинство игр в их максимальном нативном разрешении. Используйте значение 256 для максимальной производительности и 512 для максимального качества графики.</string>
    <string name="skip_cpu_inner_invalidation">Пропустить внутреннюю инвалидацию ЦП</string>
    <string name="skip_cpu_inner_invalidation_description">Пропускает некоторые инвалидации кэша на стороне ЦП при обновлениях памяти, уменьшая нагрузку на процессор и повышая производительность. Может вызывать сбои в некоторых играх.</string>
+    <string name="antiflicker">Анти-мерцание</string>
+    <string name="antiflicker_description">Принудительно заставляет обратные вызовы ГПУ-фильтра ожидать выполнения отправленных задач на ГПУ. Используйте с Быстрым режимом ГПУ, что бы избежать мерцаний с меньшим влиянием на производительность.</string>
    <string name="fix_bloom_effects">Исправить эффекты размытия</string>
    <string name="fix_bloom_effects_description">Частично убирает размытие в LA/EOW (Adreno A6XX - A7XX/ Turnip), полностью отключает его в Burnout. Внимание: может вызывать графические артефакты в других играх.</string>
    <string name="emulate_bgr565">Эмулировать BGR565</string>
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -177,10 +177,8 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
            queued_buffers.store(0);
            release_cv.notify_one();
        }
-
-        static constexpr std::array<s16, 6> silence{};
        for (size_t i = 0; i < num_frames; i++)
-            std::memcpy(&output_buffer[i * frame_size], silence.data(), frame_size_bytes);
+            std::memset(&output_buffer[i * frame_size], 0, frame_size_bytes);
        return;
    }

@@ -141,12 +141,12 @@ add_library(
    vector_math.h
    virtual_buffer.cpp
    virtual_buffer.h
-    wall_clock.cpp
-    wall_clock.h
    zstd_compression.cpp
    zstd_compression.h
    fs/ryujinx_compat.h fs/ryujinx_compat.cpp
    fs/symlink.h fs/symlink.cpp
+    cpu_features.cpp
+    cpu_features.h
    httplib.h
    net/net.h net/net.cpp)

@@ -180,10 +180,7 @@ endif()
 if(ARCHITECTURE_x86_64)
    target_sources(
        common
-        PRIVATE x64/cpu_detect.cpp
-        x64/cpu_detect.h
-        x64/cpu_wait.cpp
-        x64/cpu_wait.h
+        PRIVATE
        x64/rdtsc.cpp
        x64/rdtsc.h
        x64/xbyak.h)
@@ -234,7 +231,7 @@ if(CXX_CLANG)
 endif()

 if (BOOST_NO_HEADERS)
-    target_link_libraries(common PUBLIC Boost::algorithm Boost::icl Boost::pool)
+    target_link_libraries(common PUBLIC Boost::algorithm Boost::heap Boost::icl Boost::pool)
 else()
    target_link_libraries(common PUBLIC Boost::headers)
 endif()
@@ -10,34 +10,32 @@
 #include <fstream>
 #include <iterator>
 #include <optional>
+#include <algorithm>
 #include <string_view>
 #include <thread>
 #include <vector>
-#include "common/bit_util.h"
-#include "common/common_types.h"
-#include "common/logging.h"
-#include "common/x64/cpu_detect.h"
-#include "common/x64/rdtsc.h"
-
 #ifdef _WIN32
 #include <windows.h>
-#endif
-
-#ifdef _MSC_VER
-#include <intrin.h>
-
-static inline u64 xgetbv(u32 index) {
-    return _xgetbv(index);
-}
-#else
-
-#if defined(__DragonFly__) || defined(__FreeBSD__)
-// clang-format off
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
 #include <sys/types.h>
 #include <machine/cpufunc.h>
-// clang-format on
+#elif defined(__ANDROID__)
+#include <sys/system_properties.h>
 #endif

+#include "common/steady_clock.h"
+#include "common/uint128.h"
+#include "common/bit_util.h"
+#include "common/common_types.h"
+#include "common/cpu_features.h"
+#include "common/logging.h"
+
+#ifdef ARCHITECTURE_x86_64
+#include "common/x64/rdtsc.h"
+#ifdef _MSC_VER
+#include <intrin.h>
+static inline u64 xgetbv(u32 index) { return _xgetbv(index); }
+#else
 static inline void __cpuidex(int info[4], u32 function_id, u32 subfunction_id) {
 #if defined(__DragonFly__) || defined(__FreeBSD__)
    // Despite the name, this is just do_cpuid() with ECX as second input.
@@ -50,11 +48,7 @@ static inline void __cpuidex(int info[4], u32 function_id, u32 subfunction_id) {
            : "a"(function_id), "c"(subfunction_id));
 #endif
 }
-
-static inline void __cpuid(int info[4], u32 function_id) {
-    return __cpuidex(info, function_id, 0);
-}
-
+static inline void __cpuid(int info[4], u32 function_id) { return __cpuidex(info, function_id, 0); }
 #define _XCR_XFEATURE_ENABLED_MASK 0
 static inline u64 xgetbv(u32 index) {
    u32 eax, edx;
@@ -62,9 +56,10 @@ static inline u64 xgetbv(u32 index) {
    return ((u64)edx << 32) | eax;
 }
 #endif // _MSC_VER
+#endif

 namespace Common {
-
+#ifdef ARCHITECTURE_x86_64
 CPUCaps::Manufacturer CPUCaps::ParseManufacturer(std::string_view brand_string) {
    if (brand_string == "GenuineIntel") {
        return Manufacturer::Intel;
@@ -76,13 +71,53 @@ CPUCaps::Manufacturer CPUCaps::ParseManufacturer(std::string_view brand_string)
    return Manufacturer::Unknown;
 }

-// Detects the various CPU features
-static CPUCaps Detect() {
+std::optional<int> GetProcessorCount() {
+#if defined(_WIN32)
+    // Get the buffer length.
+    DWORD length = 0;
+    GetLogicalProcessorInformation(nullptr, &length);
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(
+        length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
+    // Now query the core count.
+    if (!GetLogicalProcessorInformation(buffer.data(), &length)) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    return static_cast<int>(
+        std::count_if(buffer.cbegin(), buffer.cend(), [](const auto& proc_info) {
+            return proc_info.Relationship == RelationProcessorCore;
+        }));
+#elif defined(__unix__)
+    const int thread_count = std::thread::hardware_concurrency();
+    std::ifstream smt("/sys/devices/system/cpu/smt/active");
+    char state = '0';
+    if (smt) {
+        smt.read(&state, sizeof(state));
+    }
+    switch (state) {
+    case '0':
+        return thread_count;
+    case '1':
+        return thread_count / 2;
+    default:
+        return std::nullopt;
+    }
+#else
+    // Shame on you
+    return std::nullopt;
+#endif
+}
+
+/// @brief Detects the various CPU features
+const CPUCaps g_cpu_caps = [] {
    CPUCaps caps = {};

    // Assumes the CPU supports the CPUID instruction. Those that don't would likely not support
    // yuzu at all anyway
-
    int cpu_id[4];

    // Detect CPU's CPUID capabilities and grab manufacturer string
@@ -183,9 +218,8 @@ static CPUCaps Detect() {
        // https://github.com/torvalds/linux/blob/master/tools/power/x86/turbostat/turbostat.c#L5569
        // but it's easier to just estimate the TSC tick rate for these cases.
        if (caps.tsc_crystal_ratio_denominator) {
-            caps.tsc_frequency = static_cast<u64>(caps.crystal_frequency) *
-                                 caps.tsc_crystal_ratio_numerator /
-                                 caps.tsc_crystal_ratio_denominator;
+            caps.tsc_frequency = u64(caps.crystal_frequency)
+                * caps.tsc_crystal_ratio_numerator / caps.tsc_crystal_ratio_denominator;
        } else {
            caps.tsc_frequency = X64::EstimateRDTSCFrequency();
        }
@@ -197,54 +231,196 @@ static CPUCaps Detect() {
        caps.max_frequency = cpu_id[1];
        caps.bus_frequency = cpu_id[2];
    }
-
    return caps;
-}
+}();

-const CPUCaps& GetCPUCaps() {
-    static CPUCaps caps = Detect();
-    return caps;
-}
-
-std::optional<int> GetProcessorCount() {
-#if defined(_WIN32)
-    // Get the buffer length.
-    DWORD length = 0;
-    GetLogicalProcessorInformation(nullptr, &length);
-    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        LOG_ERROR(Frontend, "Failed to query core count.");
-        return std::nullopt;
-    }
-    std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(
-        length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
-    // Now query the core count.
-    if (!GetLogicalProcessorInformation(buffer.data(), &length)) {
-        LOG_ERROR(Frontend, "Failed to query core count.");
-        return std::nullopt;
-    }
-    return static_cast<int>(
-        std::count_if(buffer.cbegin(), buffer.cend(), [](const auto& proc_info) {
-            return proc_info.Relationship == RelationProcessorCore;
-        }));
-#elif defined(__unix__)
-    const int thread_count = std::thread::hardware_concurrency();
-    std::ifstream smt("/sys/devices/system/cpu/smt/active");
-    char state = '0';
-    if (smt) {
-        smt.read(&state, sizeof(state));
-    }
-    switch (state) {
-    case '0':
-        return thread_count;
-    case '1':
-        return thread_count / 2;
-    default:
-        return std::nullopt;
-    }
 #else
-    // Shame on you
-    return std::nullopt;
+
+#endif
+
+#if defined(ARCHITECTURE_x86_64)
+WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
+    : rdtsc_frequency{rdtsc_frequency_}
+    , ns_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_) : 0}
+    , us_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_) : 0}
+    , ms_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_) : 0}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
+    , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
+    , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
+    , invariant{invariant_}
+{}
+
+std::chrono::nanoseconds WallClock::GetTimeNS() const {
+    if (!invariant)
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch());
+    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_rdtsc_factor)};
+}
+
+std::chrono::microseconds WallClock::GetTimeUS() const {
+    if (!invariant)
+        return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now().time_since_epoch());
+    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_rdtsc_factor)};
+}
+
+std::chrono::milliseconds WallClock::GetTimeMS() const {
+    if (!invariant)
+        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch());
+    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_rdtsc_factor)};
+}
+
+s64 WallClock::GetCNTPCT() const {
+    if (!invariant)
+        return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
+    return MultiplyHigh(GetUptime(), cntpct_rdtsc_factor);
+}
+
+s64 WallClock::GetGPUTick() const {
+    if (!invariant)
+        return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
+    return MultiplyHigh(GetUptime(), gputick_rdtsc_factor);
+}
+
+s64 WallClock::GetUptime() const {
+    if (!invariant)
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+    return s64(Common::X64::FencedRDTSC());
+}
+
+bool WallClock::IsNative() const {
+    return invariant;
+}
+
+u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
+    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
+}
+#elif defined(HAS_NCE)
+namespace {
+[[nodiscard]] Common::WallClock::FactorType GetFixedPointFactor(u64 num, u64 den) noexcept {
+    return (Common::WallClock::FactorType(num) << 64) / den;
+}
+[[nodiscard]] u64 MultiplyHigh(u64 m, Common::WallClock::FactorType factor) noexcept {
+    return static_cast<u64>((m * factor) >> 64);
+}
+[[nodiscard]] s64 GetHostCNTFRQ() noexcept {
+    u64 cntfrq_el0 = 0;
+#ifdef ANDROID
+    std::string_view board{""};
+    char buffer[PROP_VALUE_MAX];
+    int len{__system_property_get("ro.product.board", buffer)};
+    board = std::string_view(buffer, static_cast<size_t>(len));
+    if (board == "s5e9925") { // Exynos 2200
+        cntfrq_el0 = 25600000;
+    } else if (board == "exynos2100") { // Exynos 2100
+        cntfrq_el0 = 26000000;
+    } else if (board == "exynos9810") { // Exynos 9810
+        cntfrq_el0 = 26000000;
+    } else if (board == "s5e8825") { // Exynos 1280
+        cntfrq_el0 = 26000000;
+    } else {
+        asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
+    }
+    return cntfrq_el0;
+#else
+    asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
+    return cntfrq_el0;
 #endif
 }
+} // namespace

+WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {
+    const u64 host_cntfrq = std::max<u64>(GetHostCNTFRQ(), 1);
+    ns_cntfrq_factor = GetFixedPointFactor(NsRatio::den, host_cntfrq);
+    us_cntfrq_factor = GetFixedPointFactor(UsRatio::den, host_cntfrq);
+    ms_cntfrq_factor = GetFixedPointFactor(MsRatio::den, host_cntfrq);
+    cntfrq_ns_factor = GetFixedPointFactor(host_cntfrq, NsRatio::den);
+    guest_cntfrq_factor = GetFixedPointFactor(CNTFRQ, host_cntfrq);
+    gputick_cntfrq_factor = GetFixedPointFactor(GPUTickFreq, host_cntfrq);
+}
+
+std::chrono::nanoseconds WallClock::GetTimeNS() const {
+    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_cntfrq_factor)};
+}
+
+std::chrono::microseconds WallClock::GetTimeUS() const {
+    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_cntfrq_factor)};
+}
+
+std::chrono::milliseconds WallClock::GetTimeMS() const {
+    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_cntfrq_factor)};
+}
+
+s64 WallClock::GetCNTPCT() const {
+    return MultiplyHigh(GetUptime(), guest_cntfrq_factor);
+}
+
+s64 WallClock::GetGPUTick() const {
+    return MultiplyHigh(GetUptime(), gputick_cntfrq_factor);
+}
+
+s64 WallClock::GetUptime() const {
+    s64 cntvct_el0 = 0;
+    asm volatile(
+        "dsb ish\n\t"
+        "mrs %[cntvct_el0], cntvct_el0\n\t"
+        "dsb ish\n\t"
+        : [cntvct_el0] "=r"(cntvct_el0)
+    );
+    return cntvct_el0;
+}
+
+bool WallClock::IsNative() const {
+    return true;
+}
+
+u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
+    return MultiplyHigh(ns.count(), cntfrq_ns_factor);
+}
+#else
+WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {}
+
+std::chrono::nanoseconds WallClock::GetTimeNS() const {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch());
+}
+
+std::chrono::microseconds WallClock::GetTimeUS() const {
+    return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now().time_since_epoch());
+}
+
+std::chrono::milliseconds WallClock::GetTimeMS() const {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch());
+}
+
+s64 WallClock::GetCNTPCT() const {
+    return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
+}
+
+s64 WallClock::GetGPUTick() const {
+    return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
+}
+
+s64 WallClock::GetUptime() const {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+bool WallClock::IsNative() const {
+    return false;
+}
+
+u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
+    return ns.count();
+}
+#endif
+
+// Wall clock MUST be initialized AFTER g_cpu_caps
+// C++ only guarantees ctor init in the order they appear in TU
+const WallClock g_wall_clock = [] {
+#if defined(ARCHITECTURE_x86_64)
+    auto const& caps = Common::g_cpu_caps;
+    return WallClock(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den, caps.tsc_frequency);
+#elif defined(HAS_NCE)
+    return WallClock(false, 1);
+#else
+    return WallClock(true, 1);
+#endif
+}();
 } // namespace Common
@@ -1,11 +1,14 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2013 Dolphin Emulator Project / 2015 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

+#include <optional>
+#include <string_view>
 #include <chrono>
 #include <memory>
 #include <ratio>
@@ -43,6 +46,9 @@ public:
    /// @returns Whether the clock directly uses the host's hardware clock.
    bool IsNative() const;

+    // @returns Nanoseconds to native ticks
+    u64 NsToTicks(std::chrono::nanoseconds ns) const;
+
    static inline u64 NSToCNTPCT(u64 ns) {
        return ns * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
    }
@@ -69,7 +75,6 @@ public:
        return cpu_tick * CPUTickToGPUTickRatio::num / CPUTickToGPUTickRatio::den;
    }

-protected:
    using NsRatio = std::nano;
    using UsRatio = std::micro;
    using MsRatio = std::milli;
@@ -87,31 +92,96 @@ protected:
    using CPUTickToGPUTickRatio = std::ratio<GPUTickFreq, CPUTickFreq>;

 #if defined(ARCHITECTURE_x86_64)
-    bool invariant;
    u64 rdtsc_frequency;
    u64 ns_rdtsc_factor;
    u64 us_rdtsc_factor;
    u64 ms_rdtsc_factor;
+    u64 rdtsc_ns_factor;
    u64 cntpct_rdtsc_factor;
    u64 gputick_rdtsc_factor;
+    bool invariant;
 #elif defined(HAS_NCE)
-public:
    using FactorType = unsigned __int128;
-
-    FactorType GetGuestCNTFRQFactor() const {
+    [[nodiscard]] inline FactorType GetGuestCNTFRQFactor() const {
        return guest_cntfrq_factor;
    }
-protected:
    FactorType ns_cntfrq_factor;
    FactorType us_cntfrq_factor;
    FactorType ms_cntfrq_factor;
+    FactorType cntfrq_ns_factor;
    FactorType guest_cntfrq_factor;
    FactorType gputick_cntfrq_factor;
-#else
-
 #endif
 };

-[[nodiscard]] WallClock CreateOptimalClock() noexcept;
+#ifdef ARCHITECTURE_x86_64
+/// x86/x64 CPU capabilities that may be detected by this module
+struct CPUCaps {
+    enum class Manufacturer : u8 {
+        Unknown = 0,
+        Intel = 1,
+        AMD = 2,
+        Hygon = 3,
+    };
+
+    static Manufacturer ParseManufacturer(std::string_view brand_string);
+
+    Manufacturer manufacturer;
+    char brand_string[13];
+
+    char cpu_string[48];
+
+    u32 base_frequency;
+    u32 max_frequency;
+    u32 bus_frequency;
+
+    u32 tsc_crystal_ratio_denominator;
+    u32 tsc_crystal_ratio_numerator;
+    u32 crystal_frequency;
+    u64 tsc_frequency; // Derived from the above three values
+
+    bool sse3 : 1;
+    bool ssse3 : 1;
+    bool sse4_1 : 1;
+    bool sse4_2 : 1;
+
+    bool avx : 1;
+    bool avx2 : 1;
+    bool avx512f : 1;
+    bool avx512dq : 1;
+    bool avx512cd : 1;
+    bool avx512bw : 1;
+    bool avx512vl : 1;
+    bool avx512vbmi : 1;
+    bool avx512bitalg : 1;
+
+    bool aes : 1;
+    bool bmi1 : 1;
+    bool bmi2 : 1;
+    bool f16c : 1;
+    bool fma : 1;
+    bool gfni : 1;
+    bool invariant_tsc : 1;
+    bool lzcnt : 1;
+    bool monitorx : 1;
+    bool movbe : 1;
+    bool pclmulqdq : 1;
+    bool popcnt : 1;
+    bool sha : 1;
+    bool waitpkg : 1;
+};
+#else
+struct CPUCaps {
+    bool padding;
+};
+#endif
+
+/// Detects CPU core count
+std::optional<int> GetProcessorCount();
+
+/// @brief Global cpu caps
+extern const CPUCaps g_cpu_caps;
+/// @brief Global wall clock
+extern const WallClock g_wall_clock;

 } // namespace Common
@@ -62,16 +62,20 @@ std::vector<Asset> Release::GetPlatformAssets() const {

 #ifdef _WIN32
 #ifdef ARCHITECTURE_x86_64
-    find_asset("Standard", {"amd64-msvc-standard.exe", "amd64-msvc-standard.zip", "mingw-amd64-gcc-standard.exe", "mingw-amd64-gcc-standard.zip"});
-    find_asset("PGO", {"mingw-amd64-clang-pgo.exe", "mingw-amd64-clang-pgo.zip"});
+#ifdef _MSC_VER
+    find_asset("Standard", {"amd64-msvc-standard.exe", "amd64-msvc-standard.zip"});
+#else // _MSC_VER
+    find_asset("Standard", {BUILD_ID "-gcc-standard.exe", BUILD_ID "-gcc-standard.zip"});
+    find_asset("PGO", {BUILD_ID "-clang-pgo.exe", BUILD_ID "-clang-pgo.zip"});
+#endif // _MSC_VER
 #elif defined(ARCHITECTURE_arm64)
-    find_asset("Standard", {"mingw-arm64-clang-standard.exe", "mingw-arm64-clang-standard.zip"});
-    find_asset("PGO", {"mingw-arm64-clang-pgo.exe", "mingw-arm64-clang-pgo.zip"});
-#endif
+    find_asset("Standard", {"arm64-clang-standard.exe", "arm64-clang-standard.zip"});
+    find_asset("PGO", {"arm64-clang-pgo.exe", "arm64-clang-pgo.zip"});
+#endif // ARCHITECTURE_arm64
 #elif defined(__APPLE__)
 #ifdef ARCHITECTURE_arm64
    find_asset("Standard", {".dmg", ".tar.gz"});
-#endif
+#endif // ARCHITECTURE_arm64
 #elif defined(__ANDROID__)
 #ifdef ARCHITECTURE_x86_64
    find_asset("Standard", {"chromeos.apk"});
@@ -82,9 +86,9 @@ std::vector<Asset> Release::GetPlatformAssets() const {
    find_asset("Standard", {"optimized.apk"});
 #else
    find_asset("Standard", {"standard.apk"});
-#endif
-#endif
-#endif
+#endif // GENSHIN_SPOOF
+#endif // ARCHITECTURE_arm64
+#endif // __APPLE__
    return found_assets;
 }

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -20,10 +20,14 @@
 namespace Common {

 struct SlotId {
+    static constexpr u32 TAGGED_MASK = 0x7fffffff;
+    static constexpr u32 TAGGED_VALUE = 0x80000000;
    static constexpr u32 INVALID_INDEX = (std::numeric_limits<u32>::max)();

+    constexpr u32 Value() const noexcept {
+        return index & (~TAGGED_VALUE);
+    }
    constexpr auto operator<=>(const SlotId&) const noexcept = default;
-
    constexpr explicit operator bool() const noexcept {
        return index != INVALID_INDEX;
    }
@@ -47,12 +51,12 @@ public:
        Iterator& operator++() noexcept {
            const u64* const bitset = slot_vector->stored_bitset.data();
            const u32 size = static_cast<u32>(slot_vector->stored_bitset.size()) * 64;
-            if (id.index < size) {
+            if (id.Value() < size) {
                do {
                    ++id.index;
-                } while (id.index < size && !IsValid(bitset));
-                if (id.index == size) {
-                    id.index = SlotId::INVALID_INDEX;
+                } while (id.Value() < size && !IsValid(bitset));
+                if (id.Value() == size) {
+                    id = SlotId{};
                }
            }
            return *this;
@@ -85,7 +89,7 @@ public:
            : slot_vector{slot_vector_}, id{id_} {}

        bool IsValid(const u64* bitset) const noexcept {
-            return ((bitset[id.index / 64] >> (id.index % 64)) & 1) != 0;
+            return ((bitset[id.Value() / 64] >> (id.Value() % 64)) & 1) != 0;
        }

        SlotVector<T>* slot_vector;
@@ -107,12 +111,12 @@ public:

    [[nodiscard]] T& operator[](SlotId id) noexcept {
        ValidateIndex(id);
-        return values[id.index].object;
+        return values[id.Value()].object;
    }

    [[nodiscard]] const T& operator[](SlotId id) const noexcept {
        ValidateIndex(id);
-        return values[id.index].object;
+        return values[id.Value()].object;
    }

    template <typename... Args>
@@ -125,9 +129,9 @@ public:
    }

    void erase(SlotId id) noexcept {
-        values[id.index].object.~T();
-        free_list.push_back(id.index);
-        ResetStorageBit(id.index);
+        values[id.Value()].object.~T();
+        free_list.push_back(id.Value());
+        ResetStorageBit(id.Value());
    }

    [[nodiscard]] Iterator begin() noexcept {
@@ -141,7 +145,7 @@ public:
    }

    [[nodiscard]] Iterator end() noexcept {
-        return Iterator(this, SlotId{SlotId::INVALID_INDEX});
+        return Iterator(this, SlotId{});
    }

    [[nodiscard]] size_t size() const noexcept {
@@ -175,8 +179,8 @@ private:

    void ValidateIndex(SlotId id) const noexcept {
        DEBUG_ASSERT(id);
-        DEBUG_ASSERT(id.index / 64 < stored_bitset.size());
-        DEBUG_ASSERT(((stored_bitset[id.index / 64] >> (id.index % 64)) & 1) != 0);
+        DEBUG_ASSERT(id.Value() / 64 < stored_bitset.size());
+        DEBUG_ASSERT(((stored_bitset[id.Value() / 64] >> (id.Value() % 64)) & 1) != 0);
    }

    [[nodiscard]] u32 FreeValueIndex() noexcept {
@@ -208,9 +212,7 @@ private:

        const size_t old_free_size = free_list.size();
        free_list.resize(old_free_size + (new_capacity - values_capacity));
-        std::iota(free_list.begin() + old_free_size, free_list.end(),
-                  static_cast<u32>(values_capacity));
-
+        std::iota(free_list.begin() + old_free_size, free_list.end(), u32(values_capacity));
        delete[] values;
        values = new_values;
        values_capacity = new_capacity;
@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <chrono>
+#include <limits>
 #include <string>
 #include <thread>

@@ -18,24 +20,35 @@
 #elif defined(_WIN32)
 #include <windows.h>
 #include "common/string_util.h"
+#include "common/windows/timer_resolution.h"
 #else
 #if defined(__FreeBSD__)
 #include <sys/cpuset.h>
 #include <sys/_cpuset.h>
 #include <pthread_np.h>
+// Compatibility with CPUset
+#define cpu_set_t cpuset_t
 #elif defined(__DragonFly__) || defined(__OpenBSD__) || defined(__Bitrig__)
 #include <pthread_np.h>
 #endif
 #include <pthread.h>
 #include <sched.h>
 #endif
+
 #ifndef _WIN32
 #include <unistd.h>
 #endif

-#ifdef __FreeBSD__
-#   define cpu_set_t cpuset_t
+#include "common/cpu_features.h"
+#ifdef ARCHITECTURE_x86_64
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#include <x86intrin.h>
 #endif
+#include "common/x64/rdtsc.h"
+#endif
+#include "core/core_timing.h"

 namespace Common {

@@ -144,4 +157,102 @@ void PinCurrentThreadToPerformanceCore(size_t core_id) {
    }
 }

+#ifdef ARCHITECTURE_x86_64
+// On Linux and UNIX systems, a futex would nominally be used to cover the costs
+// the idea is that it's intuitivelly cheaper to use a direct instruction as opposed to a full futex call
+// the underlying libc++ implementation uses pthread_cond_timedwait which MAY invoke a futex
+// Let's pretend the OS is too expensive to jump into, and avoid ANY context switches
+// this should *IN THEORY* lower CPU usage while just waiting for stuff effectively
+// For windows the minimal quanta resolution is about 500us, and normal CRT cond var is 1.5ms(?)
+// so may as well avoid that too
+// Let's just give ALL platforms the same mechanisms (almost) for when they have umonitor OR waitpkg
+#ifdef __clang__
+__attribute__((target("waitpkg,mwaitx")))
+#elif defined(__GNUC__)
+#pragma GCC target("waitpkg")
+#pragma GCC target("mwaitx")
+#endif
+bool Event::WaitFor(const std::chrono::nanoseconds time) {
+#ifdef _WIN32
+    auto const start = Common::X64::FencedRDTSC();
+    auto const& caps = Common::g_cpu_caps;
+    [[maybe_unused]] auto const end = start + Common::g_wall_clock.NsToTicks(time);
+    if (caps.monitorx) {
+        while (true) {
+            // Armed monitor, as per manual, MWAITX must be conditional if the condition isn't satisfied
+            // to prevent a race condition.
+            _mm_monitorx(reinterpret_cast<u64*>(std::addressof(is_set)), 0, 0);
+            if (!is_set.load()) {
+                // RDTSC may be fenced here due to atomic load
+#ifdef _MSC_VER
+                auto const now = __rdtsc();
+#else
+                auto const now = _rdtsc();
+#endif
+                if (end > now) {
+                    u32 const cycles = std::min<u32>((std::numeric_limits<u32>::max)(), s64(end) - s64(now));
+                    // See here: https://github.com/torvalds/linux/blob/948a64995aca6820abefd17f1a4258f5835c5ad9/arch/x86/lib/delay.c#L93
+                    // MWAITX accepts a 32-bit input timer which determines the total number of cycles to wait for
+                    // NOT THE TOTAL ABSOLUTE TSC VALUE, it's just a delta
+                    // BIT[1] = use a timer
+                    // Hint = 0: Use C1 state when sleepy (means slower wakeup but better savings)
+                    _mm_mwaitx(1 << 1, 0u, cycles);
+                    if (!is_set.load())
+                        return false;
+                } else
+                    return false; //timeout
+            }
+            bool expected = true;
+            if (is_set.compare_exchange_weak(expected, false, std::memory_order_release))
+                return true;
+        }
+    } else if (caps.waitpkg) {
+        // #UD If CPUID.7.0:ECX.WAITPKG[bit 5]=0.
+        while (true) {
+            _umonitor(std::addressof(is_set));
+            if (!is_set.load() && !_umwait(0, end)) //umwait is absolute time!!!
+                return false;
+            bool expected = true;
+            if (is_set.compare_exchange_weak(expected, false, std::memory_order_release))
+                return true;
+        }
+    } else {
+#ifdef _MSC_VER
+        while (!is_set.load() && end > __rdtsc())
+            Common::Windows::SleepForOneTick();
+#else
+        while (!is_set.load() && end > _rdtsc())
+            Common::Windows::SleepForOneTick();
+#endif
+        if (is_set.load())
+            Reset();
+        return true;
+    }
+#else
+    std::unique_lock lk{mutex};
+    if (!condvar.wait_for(lk, time, [this] { return is_set.load(); }))
+        return false;
+    is_set = false;
+    return true;
+#endif
+}
+#else
+bool Event::WaitFor(const std::chrono::nanoseconds time) {
+#ifdef _WIN32
+    auto const end = Common::g_wall_clock.GetTimeNS() + time;
+    while (!is_set.load() && end > Common::g_wall_clock.GetTimeNS())
+        Common::Windows::SleepForOneTick();
+    if (is_set.load())
+        Reset();
+    return true;
+#else
+    std::unique_lock lk{mutex};
+    if (!condvar.wait_for(lk, time, [this] { return is_set.load(); }))
+        return false;
+    is_set = false;
+    return true;
+#endif
+}
+#endif
+
 } // namespace Common
@@ -34,16 +34,10 @@ public:
        is_set = false;
    }

-    bool WaitFor(const std::chrono::nanoseconds& time) {
-        std::unique_lock lk{mutex};
-        if (!condvar.wait_for(lk, time, [this] { return is_set.load(); }))
-            return false;
-        is_set = false;
-        return true;
-    }
+    bool WaitFor(const std::chrono::nanoseconds time);

-    template <class Clock, class Duration>
-    bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
+    template<class Clock, class Duration>
+    bool WaitUntil(const std::chrono::time_point<Clock, Duration> time) {
        std::unique_lock lk{mutex};
        if (!condvar.wait_until(lk, time, [this] { return is_set.load(); }))
            return false;
@@ -63,9 +57,9 @@ public:
    }

 private:
+    alignas(64) std::atomic<bool> is_set{false};
    std::condition_variable condvar;
    std::mutex mutex;
-    std::atomic_bool is_set{false};
 };

 class Barrier {
@@ -1,197 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/steady_clock.h"
-#include "common/uint128.h"
-#include "common/wall_clock.h"
-
-#ifdef __ANDROID__
-#include <sys/system_properties.h>
-#endif
-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_detect.h"
-#include "common/x64/rdtsc.h"
-#endif
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
-    : invariant{invariant_}
-    , rdtsc_frequency{rdtsc_frequency_}
-    , ns_rdtsc_factor{invariant_ ? 0 : GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_)}
-    , us_rdtsc_factor{invariant_ ? 0 : GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_)}
-    , ms_rdtsc_factor{invariant_ ? 0 : GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_)}
-    , cntpct_rdtsc_factor{invariant_ ? 0 : GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_)}
-    , gputick_rdtsc_factor{invariant_ ? 0 : GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_)}
-{}
-
-std::chrono::nanoseconds WallClock::GetTimeNS() const {
-    if (invariant)
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
-    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_rdtsc_factor)};
-}
-
-std::chrono::microseconds WallClock::GetTimeUS() const {
-    if (invariant)
-        return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
-    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_rdtsc_factor)};
-}
-
-std::chrono::milliseconds WallClock::GetTimeMS() const {
-    if (invariant)
-        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
-    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_rdtsc_factor)};
-}
-
-s64 WallClock::GetCNTPCT() const {
-    if (invariant)
-        return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
-    return MultiplyHigh(GetUptime(), cntpct_rdtsc_factor);
-}
-
-s64 WallClock::GetGPUTick() const {
-    if (invariant)
-        return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
-    return MultiplyHigh(GetUptime(), gputick_rdtsc_factor);
-}
-
-s64 WallClock::GetUptime() const {
-    if (invariant)
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
-    return s64(Common::X64::FencedRDTSC());
-}
-
-bool WallClock::IsNative() const {
-    if (invariant)
-        return false;
-    return true;
-}
-#elif defined(HAS_NCE)
-namespace {
-
-[[nodiscard]] WallClock::FactorType GetFixedPointFactor(u64 num, u64 den) noexcept {
-    return (WallClock::FactorType(num) << 64) / den;
-}
-
-[[nodiscard]] u64 MultiplyHigh(u64 m, WallClock::FactorType factor) noexcept {
-    return static_cast<u64>((m * factor) >> 64);
-}
-
-[[nodiscard]] s64 GetHostCNTFRQ() noexcept {
-    u64 cntfrq_el0 = 0;
-#ifdef ANDROID
-    std::string_view board{""};
-    char buffer[PROP_VALUE_MAX];
-    int len{__system_property_get("ro.product.board", buffer)};
-    board = std::string_view(buffer, static_cast<size_t>(len));
-    if (board == "s5e9925") { // Exynos 2200
-        cntfrq_el0 = 25600000;
-    } else if (board == "exynos2100") { // Exynos 2100
-        cntfrq_el0 = 26000000;
-    } else if (board == "exynos9810") { // Exynos 9810
-        cntfrq_el0 = 26000000;
-    } else if (board == "s5e8825") { // Exynos 1280
-        cntfrq_el0 = 26000000;
-    } else {
-        asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
-    }
-    return cntfrq_el0;
-#else
-    asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
-    return cntfrq_el0;
-#endif
-}
-
-} // namespace
-
-WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {
-    const u64 host_cntfrq = std::max<u64>(GetHostCNTFRQ(), 1);
-    ns_cntfrq_factor = GetFixedPointFactor(NsRatio::den, host_cntfrq);
-    us_cntfrq_factor = GetFixedPointFactor(UsRatio::den, host_cntfrq);
-    ms_cntfrq_factor = GetFixedPointFactor(MsRatio::den, host_cntfrq);
-    guest_cntfrq_factor = GetFixedPointFactor(CNTFRQ, host_cntfrq);
-    gputick_cntfrq_factor = GetFixedPointFactor(GPUTickFreq, host_cntfrq);
-}
-
-std::chrono::nanoseconds WallClock::GetTimeNS() const {
-    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_cntfrq_factor)};
-}
-
-std::chrono::microseconds WallClock::GetTimeUS() const {
-    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_cntfrq_factor)};
-}
-
-std::chrono::milliseconds WallClock::GetTimeMS() const {
-    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_cntfrq_factor)};
-}
-
-s64 WallClock::GetCNTPCT() const {
-    return MultiplyHigh(GetUptime(), guest_cntfrq_factor);
-}
-
-s64 WallClock::GetGPUTick() const {
-    return MultiplyHigh(GetUptime(), gputick_cntfrq_factor);
-}
-
-s64 WallClock::GetUptime() const {
-    s64 cntvct_el0 = 0;
-    asm volatile(
-        "dsb ish\n\t"
-        "mrs %[cntvct_el0], cntvct_el0\n\t"
-        "dsb ish\n\t"
-        : [cntvct_el0] "=r"(cntvct_el0)
-    );
-    return cntvct_el0;
-}
-
-bool WallClock::IsNative() const {
-    return true;
-}
-#else
-WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {}
-
-std::chrono::nanoseconds WallClock::GetTimeNS() const {
-    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
-}
-
-std::chrono::microseconds WallClock::GetTimeUS() const {
-    return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
-}
-
-std::chrono::milliseconds WallClock::GetTimeMS() const {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
-}
-
-s64 WallClock::GetCNTPCT() const {
-    return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
-}
-
-s64 WallClock::GetGPUTick() const {
-    return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
-}
-
-s64 WallClock::GetUptime() const {
-    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
-}
-
-bool WallClock::IsNative() const {
-    return false;
-}
-#endif
-
-WallClock CreateOptimalClock() noexcept {
-#if defined(ARCHITECTURE_x86_64)
-    auto const& caps = GetCPUCaps();
-    return WallClock(!(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den), caps.tsc_frequency);
-#elif defined(HAS_NCE)
-    return WallClock(false, 1);
-#else
-    return WallClock(true, 1);
-#endif
-}
-
-} // namespace Common
@@ -1,82 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-FileCopyrightText: Copyright 2013 Dolphin Emulator Project / 2015 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <optional>
-#include <string_view>
-#include "common/common_types.h"
-
-namespace Common {
-
-/// x86/x64 CPU capabilities that may be detected by this module
-struct CPUCaps {
-
-    enum class Manufacturer : u8 {
-        Unknown = 0,
-        Intel = 1,
-        AMD = 2,
-        Hygon = 3,
-    };
-
-    static Manufacturer ParseManufacturer(std::string_view brand_string);
-
-    Manufacturer manufacturer;
-    char brand_string[13];
-
-    char cpu_string[48];
-
-    u32 base_frequency;
-    u32 max_frequency;
-    u32 bus_frequency;
-
-    u32 tsc_crystal_ratio_denominator;
-    u32 tsc_crystal_ratio_numerator;
-    u32 crystal_frequency;
-    u64 tsc_frequency; // Derived from the above three values
-
-    bool sse3 : 1;
-    bool ssse3 : 1;
-    bool sse4_1 : 1;
-    bool sse4_2 : 1;
-
-    bool avx : 1;
-    bool avx2 : 1;
-    bool avx512f : 1;
-    bool avx512dq : 1;
-    bool avx512cd : 1;
-    bool avx512bw : 1;
-    bool avx512vl : 1;
-    bool avx512vbmi : 1;
-    bool avx512bitalg : 1;
-
-    bool aes : 1;
-    bool bmi1 : 1;
-    bool bmi2 : 1;
-    bool f16c : 1;
-    bool fma : 1;
-    bool gfni : 1;
-    bool invariant_tsc : 1;
-    bool lzcnt : 1;
-    bool monitorx : 1;
-    bool movbe : 1;
-    bool pclmulqdq : 1;
-    bool popcnt : 1;
-    bool sha : 1;
-    bool waitpkg : 1;
-};
-
-/**
- * Gets the supported capabilities of the host CPU
- * @return Reference to a CPUCaps struct with the detected host CPU capabilities
- */
-const CPUCaps& GetCPUCaps();
-
-/// Detects CPU core count
-std::optional<int> GetProcessorCount();
-
-} // namespace Common
@@ -1,75 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <thread>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#include "common/x64/cpu_detect.h"
-#include "common/x64/cpu_wait.h"
-#include "common/x64/rdtsc.h"
-
-namespace Common::X64 {
-
-namespace {
-
-// 100,000 cycles is a reasonable amount of time to wait to save on CPU resources.
-// For reference:
-// At 1 GHz, 100K cycles is 100us
-// At 2 GHz, 100K cycles is 50us
-// At 4 GHz, 100K cycles is 25us
-constexpr auto PauseCycles = 100'000U;
-
-} // Anonymous namespace
-
-#if defined(_MSC_VER) && !defined(__clang__)
-__forceinline static void TPAUSE() {
-    static constexpr auto RequestC02State = 0U;
-    _tpause(RequestC02State, FencedRDTSC() + PauseCycles);
-}
-
-__forceinline static void MWAITX() {
-    static constexpr auto EnableWaitTimeFlag = 1U << 1;
-    static constexpr auto RequestC1State = 0U;
-
-    // monitor_var should be aligned to a cache line.
-    alignas(64) u64 monitor_var{};
-    _mm_monitorx(&monitor_var, 0, 0);
-    _mm_mwaitx(EnableWaitTimeFlag, RequestC1State, PauseCycles);
-}
-#else
-static void TPAUSE() {
-    static constexpr auto RequestC02State = 0U;
-    const auto tsc = FencedRDTSC() + PauseCycles;
-    const auto eax = static_cast<u32>(tsc & 0xFFFFFFFF);
-    const auto edx = static_cast<u32>(tsc >> 32);
-    asm volatile("tpause %0" : : "r"(RequestC02State), "d"(edx), "a"(eax));
-}
-
-static void MWAITX() {
-    static constexpr auto EnableWaitTimeFlag = 1U << 1;
-    static constexpr auto RequestC1State = 0U;
-
-    // monitor_var should be aligned to a cache line.
-    alignas(64) u64 monitor_var{};
-    asm volatile("monitorx" : : "a"(&monitor_var), "c"(0), "d"(0));
-    asm volatile("mwaitx" : : "a"(RequestC1State), "b"(PauseCycles), "c"(EnableWaitTimeFlag));
-}
-#endif
-
-void MicroSleep() {
-    static const bool has_waitpkg = GetCPUCaps().waitpkg;
-    static const bool has_monitorx = GetCPUCaps().monitorx;
-
-    if (has_waitpkg) {
-        TPAUSE();
-    } else if (has_monitorx) {
-        MWAITX();
-    } else {
-        std::this_thread::yield();
-    }
-}
-
-} // namespace Common::X64
@@ -1,10 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-namespace Common::X64 {
-
-void MicroSleep();
-
-} // namespace Common::X64
@@ -1200,7 +1200,7 @@ else()
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
    # pre-clang19 will spam with "OH DID YOU MEAN THIS?" otherwise...
-    if (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19)
+    if (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 20)
        target_compile_options(core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type-mismatch>)
    endif()
 endif()
@@ -1246,7 +1246,7 @@ if (HAS_NCE)
    target_link_libraries(core PRIVATE merry::oaknut)
 endif()

-if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64 OR ARCHITECTURE_loongarch64)
    target_sources(core PRIVATE
        arm/dynarmic/arm_dynarmic.h
        arm/dynarmic/arm_dynarmic_64.cpp
@@ -3,7 +3,7 @@

 #include <numeric>
 #include <bit>
-#include "common/wall_clock.h"
+#include "common/cpu_features.h"
 #include "common/alignment.h"
 #include "common/literals.h"
 #include "core/arm/nce/arm_nce.h"
@@ -8,15 +8,13 @@
 #include <mutex>
 #include <string>
 #include <tuple>
+#include "common/cpu_features.h"
+#include "common/cpu_features.h"

 #ifdef _WIN32
 #include "common/windows/timer_resolution.h"
 #endif

-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_wait.h"
-#endif
-
 #include "common/settings.h"
 #include "core/core_timing.h"
 #include "core/hardware_properties.h"
@@ -47,8 +45,7 @@ struct CoreTiming::Event {
    }
 };

-CoreTiming::CoreTiming() : clock{Common::CreateOptimalClock()} {}
-
+CoreTiming::CoreTiming() = default;
 CoreTiming::~CoreTiming() {
    Reset();
 }
@@ -64,31 +61,16 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
            on_thread_init();
            has_started = true;
+
+            // base frequency in MHz: 1ns (10^-9) = 1GHz (10^9)
            while (!stop_token.stop_requested()) {
                while (!paused && !stop_token.stop_requested()) {
                    paused_set = false;
                    if (auto const next_time = Advance(); next_time) {
                        // There are more events left in the queue, wait until the next event.
-                        auto wait_time = *next_time - GetGlobalTimeNs().count();
+                        auto const wait_time = *next_time - GetGlobalTimeNs().count();
                        if (wait_time > 0) {
-#ifdef _WIN32
-                            while (!paused && !event.IsSet() && wait_time > 0) {
-                                wait_time = *next_time - GetGlobalTimeNs().count();
-                                if (wait_time >= timer_resolution_ns) {
-                                    Common::Windows::SleepForOneTick();
-                                } else {
-#ifdef ARCHITECTURE_x86_64
-                                    Common::X64::MicroSleep();
-#else
-                                    std::this_thread::yield();
-#endif
-                                }
-                            }
-                            if (event.IsSet())
-                                event.Reset();
-#else
                            event.WaitFor(std::chrono::nanoseconds(wait_time));
-#endif
                        }
                    } else {
                        // Queue is empty, wait until another event is scheduled and signals us to
@@ -226,7 +208,7 @@ void CoreTiming::ResetTicks() {
 }

 u64 CoreTiming::GetClockTicks() const {
-    u64 fres = is_multicore ? clock.GetCNTPCT() : Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
+    u64 fres = is_multicore ? Common::g_wall_clock.GetCNTPCT() : Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
    if (auto const overclock = Settings::values.fast_cpu_time.GetValue(); overclock != Settings::CpuClock::Off) {
        fres = u64(f64(fres) * (1.7 + 0.3 * u32(overclock)));
    }
@@ -240,7 +222,7 @@ u64 CoreTiming::GetClockTicks() const {

 u64 CoreTiming::GetGPUTicks() const {
    return is_multicore
-        ? clock.GetGPUTick()
+        ? Common::g_wall_clock.GetGPUTick()
        : Common::WallClock::CPUTickToGPUTick(cpu_ticks);
 }

@@ -317,14 +299,14 @@ void CoreTiming::Reset() {
 /// @brief Returns current time in nanoseconds.
 std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const noexcept {
    return is_multicore
-        ? clock.GetTimeNS()
+        ? Common::g_wall_clock.GetTimeNS()
        : std::chrono::nanoseconds{Common::WallClock::CPUTickToNS(cpu_ticks)};
 }

 /// @brief Returns current time in microseconds.
 std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const noexcept {
    return is_multicore
-        ? clock.GetTimeUS()
+        ? Common::g_wall_clock.GetTimeUS()
        : std::chrono::microseconds{Common::WallClock::CPUTickToUS(cpu_ticks)};
 }

@@ -19,7 +19,7 @@

 #include "common/common_types.h"
 #include "common/thread.h"
-#include "common/wall_clock.h"
+#include "common/cpu_features.h"

 namespace Core::Timing {

@@ -142,37 +142,28 @@ public:

    void Reset();

-    Common::WallClock clock;
-
+    using heap_t = boost::heap::fibonacci_heap<CoreTiming::Event, boost::heap::compare<std::greater<>>>;
+    heap_t event_queue;
    s64 global_timer = 0;
-
 #ifdef _WIN32
    s64 timer_resolution_ns;
 #endif
-
-    using heap_t =
-        boost::heap::fibonacci_heap<CoreTiming::Event, boost::heap::compare<std::greater<>>>;
-
-    heap_t event_queue;
    u64 event_fifo_id = 0;
-
+    s64 pause_end_time{};
+    /// Cycle timing
+    u64 cpu_ticks{};
+    s64 downcount{};
    Common::Event event{};
    Common::Event pause_event{};
+    std::function<void()> on_thread_init{};
+    std::jthread timer_thread;
    mutable std::mutex basic_lock;
    std::mutex advance_lock;
-    std::jthread timer_thread;
    std::atomic<bool> paused{};
    std::atomic<bool> paused_set{};
    std::atomic<bool> wait_set{};
    std::atomic<bool> has_started{};
-    std::function<void()> on_thread_init{};
-
    bool is_multicore{};
-    s64 pause_end_time{};
-
-    /// Cycle timing
-    u64 cpu_ticks{};
-    s64 downcount{};
 };

 /// Creates a core timing event with the given name and callback.
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -12,8 +15,8 @@ Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t pro
 }

 Result BreakDebugProcess(Core::System& system, Handle debug_handle) {
-    UNIMPLEMENTED();
-    R_THROW(ResultNotImplemented);
+    LOG_WARNING(Service, "(STUBBED) called");
+    R_SUCCEED();
 }

 Result TerminateDebugProcess(Core::System& system, Handle debug_handle) {
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -372,6 +375,10 @@ bool LifecycleManager::UpdateRequestedFocusState() {
        // Mark the focus state as ready for update.
        m_requested_focus_state = new_state;

+        if (m_is_application) {
+            m_has_focus_state_changed = true;
+        }
+
        // We changed the focus state.
        return true;
    }
@@ -10,6 +10,7 @@
 #include "common/assert.h"
 #include "common/logging.h"
 #include "common/settings.h"
+#include "common/cpu_features.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/kernel.h"
@@ -28,7 +29,6 @@ BufferQueueProducer::BufferQueueProducer(Service::KernelHelpers::ServiceContext&
                                         Service::Nvidia::NvCore::NvMap& nvmap_)
    : service_context{service_context_}, core{std::move(buffer_queue_core_)}
    , slots(core->slots)
-    , clock{Common::CreateOptimalClock()}
    , nvmap(nvmap_)
 {
    buffer_wait_event = service_context.CreateEvent("BufferQueue:WaitEvent");
@@ -488,7 +488,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
        slots[slot].buffer_state = BufferState::Queued;
        slots[slot].frame_number = core->frame_counter;
        slots[slot].queue_time = timestamp;
-        slots[slot].presentation_time = clock.GetTimeNS().count();
+        slots[slot].presentation_time = Common::g_wall_clock.GetTimeNS().count();
        slots[slot].fence = fence;

        item.slot = slot;
@@ -14,7 +14,7 @@
 #include <mutex>

 #include "common/common_funcs.h"
-#include "common/wall_clock.h"
+#include "common/cpu_features.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 #include "core/hle/service/nvnflinger/binder.h"
 #include "core/hle/service/nvnflinger/buffer_queue_defs.h"
@@ -89,7 +89,6 @@ private:
    s32 next_callback_ticket{};
    s32 current_callback_ticket{};
    std::condition_variable_any callback_condition;
-    Common::WallClock clock;
    Service::Nvidia::NvCore::NvMap& nvmap;
 };

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -13,7 +13,7 @@
 #include "common/common_types.h"
 #include "common/intrusive_list.h"
 #include "common/uuid.h"
-#include "common/wall_clock.h"
+#include "common/cpu_features.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/psc/time/errors.h"
@@ -130,6 +130,10 @@ if ("riscv64" IN_LIST ARCHITECTURE)
    find_package(biscuit 0.9.1 REQUIRED)
 endif()

+if ("loongarch64" IN_LIST ARCHITECTURE)
+    find_package(lagoon REQUIRED)
+endif()
+
 if ("x86_64" IN_LIST ARCHITECTURE)
    find_package(xbyak 7 CONFIG)
 endif()
@@ -295,6 +295,20 @@ if ("riscv64" IN_LIST ARCHITECTURE)
    message(WARNING "TODO: Incomplete frontend for this host architecture")
 endif()

+if ("loongarch64" IN_LIST ARCHITECTURE)
+    target_link_libraries(dynarmic PRIVATE lagoon::lagoon)
+
+    target_sources(dynarmic PRIVATE
+        backend/loongarch64/exclusive_monitor.cpp
+        backend/loongarch64/a32_interface.cpp
+        backend/loongarch64/a64_interface.cpp
+        backend/loongarch64/code_block.h
+
+        common/spin_lock_loongarch64.cpp
+    )
+    message(WARNING "TODO: Incomplete frontend for this host architecture")
+endif()
+
 if (WIN32)
    target_sources(dynarmic PRIVATE backend/exception_handler_windows.cpp)
 elseif (APPLE)
@@ -24,7 +24,7 @@ using DoNotFastmemMarker = std::tuple<IR::LocationDescriptor, unsigned>;
 constexpr std::size_t xmrx(std::size_t x) noexcept {
    x ^= x >> 32;
    x *= 0xff51afd7ed558ccd;
-    x ^= mcl::bit::rotate_right(x, 47) ^ mcl::bit::rotate_right(x, 23);
+    x ^= std::rotr(x, 47) ^ std::rotr(x, 23);
    return x;
 }

@@ -26,6 +26,10 @@ class CodeBlock;
 namespace Dynarmic::Backend::RV64 {
 class CodeBlock;
 }  // namespace Dynarmic::Backend::RV64
+#elif defined(ARCHITECTURE_loongarch64)
+namespace Dynarmic::Backend::LoongArch64 {
+class CodeBlock;
+}  // namespace Dynarmic::Backend::LoongArch64
 #else
 #    error "Invalid architecture"
 #endif
@@ -45,6 +49,10 @@ struct FakeCall {
 struct FakeCall {
    u64 call_sepc;
 };
+#elif defined(ARCHITECTURE_loongarch64)
+struct FakeCall {
+    u64 call_pc;
+};
 #else
 #    error "Invalid architecture"
 #endif
@@ -60,6 +68,8 @@ public:
    void Register(oaknut::CodeBlock& mem, std::size_t mem_size);
 #elif defined(ARCHITECTURE_riscv64)
    void Register(RV64::CodeBlock& mem, std::size_t mem_size);
+#elif defined(ARCHITECTURE_loongarch64)
+    void Register(LoongArch64::CodeBlock& mem, std::size_t mem_size);
 #else
 #    error "Invalid architecture"
 #endif
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 /* This file is part of the dynarmic project.
@@ -28,6 +28,10 @@ void ExceptionHandler::Register(oaknut::CodeBlock&, std::size_t) {
 void ExceptionHandler::Register(RV64::CodeBlock&, std::size_t) {
    // Do nothing
 }
+#elif defined(ARCHITECTURE_loongarch64)
+void ExceptionHandler::Register(LoongArch64::CodeBlock&, std::size_t) {
+    // Do nothing
+}
 #else
 #    error "Invalid architecture"
 #endif
@@ -6,20 +6,25 @@
 * SPDX-License-Identifier: 0BSD
 */

+#include <signal.h>
+
+#include <algorithm>
+#include <bit>
 #include <cstring>
 #include <functional>
-#include <algorithm>
 #include <memory>
 #include <mutex>
-#include <shared_mutex>
 #include <optional>
-#include <bit>
-#include <fmt/format.h>
+#include <shared_mutex>
+
 #include <ankerl/unordered_dense.h>
-#include "dynarmic/backend/exception_handler.h"
+#include <fmt/format.h>
+#include <sys/mman.h>
+
 #include "common/assert.h"
-#include "dynarmic/common/context.h"
 #include "common/common_types.h"
+#include "dynarmic/backend/exception_handler.h"
+#include "dynarmic/common/context.h"
 #if defined(ARCHITECTURE_x86_64)
 #    include "dynarmic/backend/x64/block_of_code.h"
 #elif defined(ARCHITECTURE_arm64)
@@ -27,6 +32,8 @@
 #    include "dynarmic/backend/arm64/abi.h"
 #elif defined(ARCHITECTURE_riscv64)
 #    include "dynarmic/backend/riscv64/code_block.h"
+#elif defined(ARCHITECTURE_loongarch64)
+#    include "dynarmic/backend/loongarch64/code_block.h"
 #else
 #    error "Invalid architecture"
 #endif
@@ -150,6 +157,16 @@ void SigHandler::SigAction(int sig, siginfo_t* info, void* raw_context) {
        }
    }
    fmt::print(stderr, "Unhandled {} at pc {:#018x}\n", sig == SIGSEGV ? "SIGSEGV" : "SIGBUS", CTX_SEPC);
+#elif defined(ARCHITECTURE_loongarch64)
+    {
+        std::shared_lock guard(sig_handler->code_block_infos_mutex);
+        if (const auto iter = sig_handler->FindCodeBlockInfo(CTX_PC); iter != sig_handler->code_block_infos.end()) {
+            FakeCall fc = iter->second.cb(CTX_PC);
+            CTX_PC = fc.call_pc;
+            return;
+        }
+    }
+    fmt::print(stderr, "Unhandled {} at pc {:#018x}\n", sig == SIGSEGV ? "SIGSEGV" : "SIGBUS", CTX_PC);
 #else
 #    error "Invalid architecture"
 #endif
@@ -209,6 +226,10 @@ void ExceptionHandler::Register(oaknut::CodeBlock& mem, std::size_t size) {
 void ExceptionHandler::Register(RV64::CodeBlock& mem, std::size_t size) {
    impl = std::make_unique<Impl>(std::bit_cast<u64>(mem.ptr<u64>()), size);
 }
+#elif defined(ARCHITECTURE_loongarch64)
+void ExceptionHandler::Register(LoongArch64::CodeBlock& mem, std::size_t size) {
+    impl = std::make_unique<Impl>(std::bit_cast<u64>(mem.ptr<u64>()), size);
+}
 #else
 #    error "Invalid architecture"
 #endif
@@ -0,0 +1,170 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <array>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "dynarmic/interface/A32/a32.h"
+
+namespace Dynarmic::A32 {
+
+struct Jit::Impl final {
+    explicit Impl(UserConfig conf_) : conf(std::move(conf_)) {}
+
+    HaltReason Run() {
+        UNIMPLEMENTED();
+        return halt_reason;
+    }
+
+    HaltReason Step() {
+        UNIMPLEMENTED();
+        return halt_reason | HaltReason::Step;
+    }
+
+    void ClearCache() {
+        HaltExecution(HaltReason::CacheInvalidation);
+    }
+
+    void InvalidateCacheRange(u32, std::size_t) {
+        HaltExecution(HaltReason::CacheInvalidation);
+    }
+
+    void Reset() {
+        regs = {};
+        ext_regs = {};
+        cpsr = 0;
+        fpscr = 0;
+        halt_reason = {};
+    }
+
+    void HaltExecution(HaltReason hr) {
+        halt_reason |= hr;
+    }
+
+    void ClearHalt(HaltReason hr) {
+        halt_reason &= ~hr;
+    }
+
+    std::array<u32, 16>& Regs() {
+        return regs;
+    }
+
+    const std::array<u32, 16>& Regs() const {
+        return regs;
+    }
+
+    std::array<u32, 64>& ExtRegs() {
+        return ext_regs;
+    }
+
+    const std::array<u32, 64>& ExtRegs() const {
+        return ext_regs;
+    }
+
+    u32 Cpsr() const {
+        return cpsr;
+    }
+
+    void SetCpsr(u32 value) {
+        cpsr = value;
+    }
+
+    u32 Fpscr() const {
+        return fpscr;
+    }
+
+    void SetFpscr(u32 value) {
+        fpscr = value;
+    }
+
+    void ClearExclusiveState() {}
+
+    std::string Disassemble() const {
+        return {};
+    }
+
+    UserConfig conf;
+    std::array<u32, 16> regs{};
+    std::array<u32, 64> ext_regs{};
+    u32 cpsr = 0;
+    u32 fpscr = 0;
+    HaltReason halt_reason{};
+};
+
+Jit::Jit(UserConfig conf) : impl(std::make_unique<Impl>(std::move(conf))) {}
+
+Jit::~Jit() = default;
+
+HaltReason Jit::Run() {
+    return impl->Run();
+}
+
+HaltReason Jit::Step() {
+    return impl->Step();
+}
+
+void Jit::ClearCache() {
+    impl->ClearCache();
+}
+
+void Jit::InvalidateCacheRange(u32 start_address, std::size_t length) {
+    impl->InvalidateCacheRange(start_address, length);
+}
+
+void Jit::Reset() {
+    impl->Reset();
+}
+
+void Jit::HaltExecution(HaltReason hr) {
+    impl->HaltExecution(hr);
+}
+
+void Jit::ClearHalt(HaltReason hr) {
+    impl->ClearHalt(hr);
+}
+
+std::array<u32, 16>& Jit::Regs() {
+    return impl->Regs();
+}
+
+const std::array<u32, 16>& Jit::Regs() const {
+    return impl->Regs();
+}
+
+std::array<u32, 64>& Jit::ExtRegs() {
+    return impl->ExtRegs();
+}
+
+const std::array<u32, 64>& Jit::ExtRegs() const {
+    return impl->ExtRegs();
+}
+
+u32 Jit::Cpsr() const {
+    return impl->Cpsr();
+}
+
+void Jit::SetCpsr(u32 value) {
+    impl->SetCpsr(value);
+}
+
+u32 Jit::Fpscr() const {
+    return impl->Fpscr();
+}
+
+void Jit::SetFpscr(u32 value) {
+    impl->SetFpscr(value);
+}
+
+void Jit::ClearExclusiveState() {
+    impl->ClearExclusiveState();
+}
+
+std::string Jit::Disassemble() const {
+    return impl->Disassemble();
+}
+
+}  // namespace Dynarmic::A32
@@ -0,0 +1,268 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <array>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "dynarmic/interface/A64/a64.h"
+
+namespace Dynarmic::A64 {
+
+struct Jit::Impl final {
+    explicit Impl(UserConfig conf_) : conf(std::move(conf_)) {}
+
+    HaltReason Run() {
+        UNIMPLEMENTED();
+        return halt_reason;
+    }
+
+    HaltReason Step() {
+        UNIMPLEMENTED();
+        return halt_reason | HaltReason::Step;
+    }
+
+    void ClearCache() {
+        HaltExecution(HaltReason::CacheInvalidation);
+    }
+
+    void InvalidateCacheRange(u64, std::size_t) {
+        HaltExecution(HaltReason::CacheInvalidation);
+    }
+
+    void Reset() {
+        regs = {};
+        vectors = {};
+        sp = 0;
+        pc = 0;
+        fpcr = 0;
+        fpsr = 0;
+        pstate = 0;
+        halt_reason = {};
+    }
+
+    void HaltExecution(HaltReason hr) {
+        halt_reason |= hr;
+    }
+
+    void ClearHalt(HaltReason hr) {
+        halt_reason &= ~hr;
+    }
+
+    u64 GetSP() const {
+        return sp;
+    }
+
+    void SetSP(u64 value) {
+        sp = value;
+    }
+
+    u64 GetPC() const {
+        return pc;
+    }
+
+    void SetPC(u64 value) {
+        pc = value;
+    }
+
+    u64 GetRegister(std::size_t index) const {
+        return index == 31 ? sp : regs.at(index);
+    }
+
+    void SetRegister(std::size_t index, u64 value) {
+        if (index == 31) {
+            sp = value;
+            return;
+        }
+        regs.at(index) = value;
+    }
+
+    std::array<u64, 31> GetRegisters() const {
+        return regs;
+    }
+
+    void SetRegisters(const std::array<u64, 31>& value) {
+        regs = value;
+    }
+
+    Vector GetVector(std::size_t index) const {
+        return vectors.at(index);
+    }
+
+    void SetVector(std::size_t index, Vector value) {
+        vectors.at(index) = value;
+    }
+
+    std::array<Vector, 32> GetVectors() const {
+        return vectors;
+    }
+
+    void SetVectors(const std::array<Vector, 32>& value) {
+        vectors = value;
+    }
+
+    u32 GetFpcr() const {
+        return fpcr;
+    }
+
+    void SetFpcr(u32 value) {
+        fpcr = value;
+    }
+
+    u32 GetFpsr() const {
+        return fpsr;
+    }
+
+    void SetFpsr(u32 value) {
+        fpsr = value;
+    }
+
+    u32 GetPstate() const {
+        return pstate;
+    }
+
+    void SetPstate(u32 value) {
+        pstate = value;
+    }
+
+    void ClearExclusiveState() {}
+
+    bool IsExecuting() const {
+        return false;
+    }
+
+    std::string Disassemble() const {
+        return {};
+    }
+
+    UserConfig conf;
+    std::array<u64, 31> regs{};
+    std::array<Vector, 32> vectors{};
+    u64 sp = 0;
+    u64 pc = 0;
+    u32 fpcr = 0;
+    u32 fpsr = 0;
+    u32 pstate = 0;
+    HaltReason halt_reason{};
+};
+
+Jit::Jit(UserConfig conf) : impl(std::make_unique<Impl>(std::move(conf))) {}
+
+Jit::~Jit() = default;
+
+HaltReason Jit::Run() {
+    return impl->Run();
+}
+
+HaltReason Jit::Step() {
+    return impl->Step();
+}
+
+void Jit::ClearCache() {
+    impl->ClearCache();
+}
+
+void Jit::InvalidateCacheRange(u64 start_address, std::size_t length) {
+    impl->InvalidateCacheRange(start_address, length);
+}
+
+void Jit::Reset() {
+    impl->Reset();
+}
+
+void Jit::HaltExecution(HaltReason hr) {
+    impl->HaltExecution(hr);
+}
+
+void Jit::ClearHalt(HaltReason hr) {
+    impl->ClearHalt(hr);
+}
+
+u64 Jit::GetSP() const {
+    return impl->GetSP();
+}
+
+void Jit::SetSP(u64 value) {
+    impl->SetSP(value);
+}
+
+u64 Jit::GetPC() const {
+    return impl->GetPC();
+}
+
+void Jit::SetPC(u64 value) {
+    impl->SetPC(value);
+}
+
+u64 Jit::GetRegister(std::size_t index) const {
+    return impl->GetRegister(index);
+}
+
+void Jit::SetRegister(std::size_t index, u64 value) {
+    impl->SetRegister(index, value);
+}
+
+std::array<u64, 31> Jit::GetRegisters() const {
+    return impl->GetRegisters();
+}
+
+void Jit::SetRegisters(const std::array<u64, 31>& value) {
+    impl->SetRegisters(value);
+}
+
+Vector Jit::GetVector(std::size_t index) const {
+    return impl->GetVector(index);
+}
+
+void Jit::SetVector(std::size_t index, Vector value) {
+    impl->SetVector(index, value);
+}
+
+std::array<Vector, 32> Jit::GetVectors() const {
+    return impl->GetVectors();
+}
+
+void Jit::SetVectors(const std::array<Vector, 32>& value) {
+    impl->SetVectors(value);
+}
+
+u32 Jit::GetFpcr() const {
+    return impl->GetFpcr();
+}
+
+void Jit::SetFpcr(u32 value) {
+    impl->SetFpcr(value);
+}
+
+u32 Jit::GetFpsr() const {
+    return impl->GetFpsr();
+}
+
+void Jit::SetFpsr(u32 value) {
+    impl->SetFpsr(value);
+}
+
+u32 Jit::GetPstate() const {
+    return impl->GetPstate();
+}
+
+void Jit::SetPstate(u32 value) {
+    impl->SetPstate(value);
+}
+
+void Jit::ClearExclusiveState() {
+    impl->ClearExclusiveState();
+}
+
+bool Jit::IsExecuting() const {
+    return impl->IsExecuting();
+}
+
+std::string Jit::Disassemble() const {
+    return impl->Disassemble();
+}
+
+}  // namespace Dynarmic::A64
@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <cstdint>
+
+#include "common/common_types.h"
+
+namespace Dynarmic::Backend::LoongArch64 {
+
+class CodeBlock {
+public:
+    template<typename T>
+    T ptr() const noexcept {
+        return reinterpret_cast<T>(mem);
+    }
+
+private:
+    u8* mem = nullptr;
+};
+
+}  // namespace Dynarmic::Backend::LoongArch64
@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "dynarmic/interface/exclusive_monitor.h"
+
+#include <algorithm>
+
+namespace Dynarmic {
+
+ExclusiveMonitor::ExclusiveMonitor(std::size_t processor_count)
+        : exclusive_addresses(processor_count, INVALID_EXCLUSIVE_ADDRESS), exclusive_values(processor_count) {}
+
+size_t ExclusiveMonitor::GetProcessorCount() const {
+    return exclusive_addresses.size();
+}
+
+void ExclusiveMonitor::Lock() {
+    lock.Lock();
+}
+
+void ExclusiveMonitor::Unlock() {
+    lock.Unlock();
+}
+
+bool ExclusiveMonitor::CheckAndClear(std::size_t processor_id, VAddr address) {
+    const VAddr masked_address = address & RESERVATION_GRANULE_MASK;
+
+    Lock();
+    if (exclusive_addresses[processor_id] != masked_address) {
+        Unlock();
+        return false;
+    }
+
+    for (VAddr& other_address : exclusive_addresses) {
+        if (other_address == masked_address) {
+            other_address = INVALID_EXCLUSIVE_ADDRESS;
+        }
+    }
+    return true;
+}
+
+void ExclusiveMonitor::Clear() {
+    Lock();
+    std::fill(exclusive_addresses.begin(), exclusive_addresses.end(), INVALID_EXCLUSIVE_ADDRESS);
+    Unlock();
+}
+
+void ExclusiveMonitor::ClearProcessor(std::size_t processor_id) {
+    Lock();
+    exclusive_addresses[processor_id] = INVALID_EXCLUSIVE_ADDRESS;
+    Unlock();
+}
+
+}  // namespace Dynarmic
@@ -1532,7 +1532,7 @@ void EmitX64::EmitFPSingleToHalf(EmitContext& ctx, IR::Inst* inst) {
        if (ctx.FPCR().DN()) {
            ForceToDefaultNaN<32>(code, result);
        }
-        code.vcvtps2ph(result, result, static_cast<u8>(*round_imm));
+        code.vcvtps2ph(result, result, u8(*round_imm));

        ctx.reg_alloc.DefineValue(code, inst, result);
        return;
@@ -1540,7 +1540,7 @@ void EmitX64::EmitFPSingleToHalf(EmitContext& ctx, IR::Inst* inst) {

    ctx.reg_alloc.HostCall(code, inst, args[0]);
    code.mov(code.ABI_PARAM2.cvt32(), ctx.FPCR().Value());
-    code.mov(code.ABI_PARAM3.cvt32(), static_cast<u32>(rounding_mode));
+    code.mov(code.ABI_PARAM3.cvt32(), u32(rounding_mode));
    code.lea(code.ABI_PARAM4, code.ptr[code.ABI_JIT_PTR + code.GetJitStateInfo().offsetof_fpsr_exc]);
    code.CallFunction(&FP::FPConvert<u16, u32>);
 }
@@ -38,7 +38,7 @@ void EmitSignedSaturatedOp(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst)
    Xbyak::Reg addend = ctx.reg_alloc.UseGpr(code, args[1]).changeBit(size);
    Xbyak::Reg overflow = ctx.reg_alloc.ScratchGpr(code).changeBit(size);

-    constexpr u64 int_max = static_cast<u64>((std::numeric_limits<mcl::signed_integer_of_size<size>>::max)());
+    constexpr u64 int_max = u64((std::numeric_limits<std::make_signed_t<mcl::unsigned_integer_of_size<size>>>::max)());
    if constexpr (size < 64) {
        code.xor_(overflow.cvt32(), overflow.cvt32());
        code.bt(result.cvt32(), size - 1);
@@ -3553,7 +3553,7 @@ void EmitX64::EmitVectorPopulationCount(EmitContext& ctx, IR::Inst* inst) {

    EmitOneArgumentFallback(code, ctx, inst, [](VectorArray<u8>& result, const VectorArray<u8>& a) {
        std::transform(a.begin(), a.end(), result.begin(), [](u8 val) {
-            return static_cast<u8>(mcl::bit::count_ones(val));
+            return static_cast<u8>(std::popcount(val));
        });
    });
 }
@@ -1657,20 +1657,10 @@ void EmitFPVectorRoundInt(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {

    if constexpr (fsize != 16) {
        if (code.HasHostFeature(HostFeature::SSE41) && rounding != FP::RoundingMode::ToNearest_TieAwayFromZero && !exact) {
-            const u8 round_imm = [&]() -> u8 {
-                switch (rounding) {
-                case FP::RoundingMode::ToNearest_TieEven: return 0b00;
-                case FP::RoundingMode::TowardsPlusInfinity: return 0b10;
-                case FP::RoundingMode::TowardsMinusInfinity: return 0b01;
-                case FP::RoundingMode::TowardsZero: return 0b11;
-                default: UNREACHABLE();
-                }
-            }();
-
+            const auto round_imm = ConvertRoundingModeToX64Immediate(rounding);
            EmitTwoOpVectorOperation<fsize, DefaultIndexer, 3>(code, ctx, inst, [&](const Xbyak::Xmm& result, const Xbyak::Xmm& xmm_a) {
-                FCODE(roundp)(result, xmm_a, round_imm);
+                FCODE(roundp)(result, xmm_a, *round_imm);
            });
-
            return;
        }
    }
@@ -2002,19 +1992,7 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
        auto args = ctx.reg_alloc.GetArgumentInfo(inst);
        const Xbyak::Xmm src = ctx.reg_alloc.UseScratchXmm(code, args[0]);
        MaybeStandardFPSCRValue(code, ctx, fpcr_controlled, [&] {
-            const int round_imm = [&] {
-                switch (rounding) {
-                case FP::RoundingMode::ToNearest_TieEven:
-                default:
-                    return 0b00;
-                case FP::RoundingMode::TowardsPlusInfinity:
-                    return 0b10;
-                case FP::RoundingMode::TowardsMinusInfinity:
-                    return 0b01;
-                case FP::RoundingMode::TowardsZero:
-                    return 0b11;
-                }
-            }();
+            const auto round_imm = ConvertRoundingModeToX64Immediate(rounding);
            const auto perform_conversion = [&code, &ctx](const Xbyak::Xmm& src) {
                // MSVC doesn't allow us to use a [&] capture, so we have to do this instead.
                (void)ctx;
@@ -2046,7 +2024,7 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
                FCODE(mulp)(src, GetVectorOf<fsize>(code, scale_factor));
            }

-            FCODE(roundp)(src, src, u8(round_imm));
+            FCODE(roundp)(src, src, u8(*round_imm));
            const Xbyak::Xmm nan_mask = xmm0;
            if (code.HasHostFeature(HostFeature::AVX512_OrthoFloat)) {
                static constexpr u32 nan_to_zero = FixupLUT(FpFixup::PosZero, FpFixup::PosZero);
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "dynarmic/common/spin_lock.h"
+
+namespace Dynarmic {
+
+void SpinLock::Lock() noexcept {
+}
+
+void SpinLock::Unlock() noexcept {
+}
+
+}  // namespace Dynarmic
@@ -52,7 +52,7 @@ struct TranslatorVisitor final {
        u32 imm32 = imm8.ZeroExtend();
        auto carry_out = carry_in;
        if (rotate) {
-            imm32 = mcl::bit::rotate_right<u32>(imm8.ZeroExtend(), rotate * 2);
+            imm32 = std::rotr<u32>(imm8.ZeroExtend(), rotate * 2);
            carry_out = ir.Imm1(mcl::bit::get_bit<31>(imm32));
        }
        return {imm32, carry_out};
@@ -81,7 +81,7 @@ struct TranslatorVisitor final {
            }();
            return {imm32, carry_in};
        }
-        const u32 imm32 = mcl::bit::rotate_right<u32>((1 << 7) | imm12.Bits<0, 6>(), imm12.Bits<7, 11>());
+        const u32 imm32 = std::rotr<u32>((1 << 7) | imm12.Bits<0, 6>(), imm12.Bits<7, 11>());
        return {imm32, ir.Imm1(mcl::bit::get_bit<31>(imm32))};
    }

@@ -79,7 +79,7 @@ bool TranslatorVisitor::asimd_VDUP_scalar(bool D, Imm<4> imm4, size_t Vd, bool Q
        return UndefinedInstruction();
    }

-    const size_t imm4_lsb = mcl::bit::lowest_set_bit(imm4.ZeroExtend());
+    const size_t imm4_lsb = std::countr_zero(imm4.ZeroExtend());
    const size_t esize = 8u << imm4_lsb;
    const size_t index = imm4.ZeroExtend() >> (imm4_lsb + 1);
    const auto d = ToVector(Q, Vd, D);
@@ -799,7 +799,7 @@ static bool LDMHelper(A32::IREmitter& ir, bool W, Reg n, RegList list, IR::U32 s

 // LDM <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_LDM(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }
    if (W && mcl::bit::get_bit(static_cast<size_t>(n), list)) {
@@ -811,13 +811,13 @@ bool TranslatorVisitor::arm_LDM(Cond cond, bool W, Reg n, RegList list) {
    }

    const auto start_address = ir.GetRegister(n);
-    const auto writeback_address = ir.Add(start_address, ir.Imm32(u32(mcl::bit::count_ones(list) * 4)));
+    const auto writeback_address = ir.Add(start_address, ir.Imm32(u32(std::popcount(list) * 4)));
    return LDMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // LDMDA <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_LDMDA(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }
    if (W && mcl::bit::get_bit(static_cast<size_t>(n), list)) {
@@ -828,14 +828,14 @@ bool TranslatorVisitor::arm_LDMDA(Cond cond, bool W, Reg n, RegList list) {
        return true;
    }

-    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list) - 4)));
+    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list) - 4)));
    const auto writeback_address = ir.Sub(start_address, ir.Imm32(4));
    return LDMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // LDMDB <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_LDMDB(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }
    if (W && mcl::bit::get_bit(static_cast<size_t>(n), list)) {
@@ -846,14 +846,14 @@ bool TranslatorVisitor::arm_LDMDB(Cond cond, bool W, Reg n, RegList list) {
        return true;
    }

-    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list))));
+    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list))));
    const auto writeback_address = start_address;
    return LDMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // LDMIB <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_LDMIB(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }
    if (W && mcl::bit::get_bit(static_cast<size_t>(n), list)) {
@@ -865,7 +865,7 @@ bool TranslatorVisitor::arm_LDMIB(Cond cond, bool W, Reg n, RegList list) {
    }

    const auto start_address = ir.Add(ir.GetRegister(n), ir.Imm32(4));
-    const auto writeback_address = ir.Add(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list))));
+    const auto writeback_address = ir.Add(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list))));
    return LDMHelper(ir, W, n, list, start_address, writeback_address);
 }

@@ -896,7 +896,7 @@ static bool STMHelper(A32::IREmitter& ir, bool W, Reg n, RegList list, IR::U32 s

 // STM <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_STM(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }

@@ -905,13 +905,13 @@ bool TranslatorVisitor::arm_STM(Cond cond, bool W, Reg n, RegList list) {
    }

    const auto start_address = ir.GetRegister(n);
-    const auto writeback_address = ir.Add(start_address, ir.Imm32(u32(mcl::bit::count_ones(list) * 4)));
+    const auto writeback_address = ir.Add(start_address, ir.Imm32(u32(std::popcount(list) * 4)));
    return STMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // STMDA <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_STMDA(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }

@@ -919,14 +919,14 @@ bool TranslatorVisitor::arm_STMDA(Cond cond, bool W, Reg n, RegList list) {
        return true;
    }

-    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list) - 4)));
+    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list) - 4)));
    const auto writeback_address = ir.Sub(start_address, ir.Imm32(4));
    return STMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // STMDB <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_STMDB(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }

@@ -934,14 +934,14 @@ bool TranslatorVisitor::arm_STMDB(Cond cond, bool W, Reg n, RegList list) {
        return true;
    }

-    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list))));
+    const auto start_address = ir.Sub(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list))));
    const auto writeback_address = start_address;
    return STMHelper(ir, W, n, list, start_address, writeback_address);
 }

 // STMIB <Rn>{!}, <reg_list>
 bool TranslatorVisitor::arm_STMIB(Cond cond, bool W, Reg n, RegList list) {
-    if (n == Reg::PC || mcl::bit::count_ones(list) < 1) {
+    if (n == Reg::PC || std::popcount(list) < 1) {
        return UnpredictableInstruction();
    }

@@ -950,7 +950,7 @@ bool TranslatorVisitor::arm_STMIB(Cond cond, bool W, Reg n, RegList list) {
    }

    const auto start_address = ir.Add(ir.GetRegister(n), ir.Imm32(4));
-    const auto writeback_address = ir.Add(ir.GetRegister(n), ir.Imm32(u32(4 * mcl::bit::count_ones(list))));
+    const auto writeback_address = ir.Add(ir.GetRegister(n), ir.Imm32(u32(4 * std::popcount(list))));
    return STMHelper(ir, W, n, list, start_address, writeback_address);
 }

@@ -688,7 +688,7 @@ bool TranslatorVisitor::thumb16_NOP() {
 // IT{<x>{<y>{<z>}}} <cond>
 bool TranslatorVisitor::thumb16_IT(Imm<8> imm8) {
    ASSERT((imm8.Bits<0, 3>() != 0b0000) && "Decode Error");
-    if (imm8.Bits<4, 7>() == 0b1111 || (imm8.Bits<4, 7>() == 0b1110 && mcl::bit::count_ones(imm8.Bits<0, 3>()) != 1)) {
+    if (imm8.Bits<4, 7>() == 0b1111 || (imm8.Bits<4, 7>() == 0b1110 && std::popcount(imm8.Bits<0, 3>()) != 1)) {
        return UnpredictableInstruction();
    }
    if (ir.current_location.IT().IsInITBlock()) {
@@ -738,11 +738,11 @@ bool TranslatorVisitor::thumb16_PUSH(bool M, RegList reg_list) {
    if (M) {
        reg_list |= 1 << 14;
    }
-    if (mcl::bit::count_ones(reg_list) < 1) {
+    if (std::popcount(reg_list) < 1) {
        return UnpredictableInstruction();
    }

-    const u32 num_bytes_to_push = static_cast<u32>(4 * mcl::bit::count_ones(reg_list));
+    const u32 num_bytes_to_push = static_cast<u32>(4 * std::popcount(reg_list));
    const auto final_address = ir.Sub(ir.GetRegister(Reg::SP), ir.Imm32(num_bytes_to_push));
    auto address = final_address;
    for (size_t i = 0; i < 16; i++) {
@@ -764,7 +764,7 @@ bool TranslatorVisitor::thumb16_POP(bool P, RegList reg_list) {
    if (P) {
        reg_list |= 1 << 15;
    }
-    if (mcl::bit::count_ones(reg_list) < 1) {
+    if (std::popcount(reg_list) < 1) {
        return UnpredictableInstruction();
    }

@@ -851,10 +851,10 @@ bool TranslatorVisitor::thumb16_BKPT(Imm<8> /*imm8*/) {

 // STM <Rn>!, <reg_list>
 bool TranslatorVisitor::thumb16_STMIA(Reg n, RegList reg_list) {
-    if (mcl::bit::count_ones(reg_list) == 0) {
+    if (std::popcount(reg_list) == 0) {
        return UnpredictableInstruction();
    }
-    if (mcl::bit::get_bit(static_cast<size_t>(n), reg_list) && n != static_cast<Reg>(mcl::bit::lowest_set_bit(reg_list))) {
+    if (mcl::bit::get_bit(static_cast<size_t>(n), reg_list) && n != static_cast<Reg>(std::countr_zero(reg_list))) {
        return UnpredictableInstruction();
    }

@@ -873,7 +873,7 @@ bool TranslatorVisitor::thumb16_STMIA(Reg n, RegList reg_list) {

 // LDM <Rn>!, <reg_list>
 bool TranslatorVisitor::thumb16_LDMIA(Reg n, RegList reg_list) {
-    if (mcl::bit::count_ones(reg_list) == 0) {
+    if (std::popcount(reg_list) == 0) {
        return UnpredictableInstruction();
    }

@@ -53,7 +53,7 @@ static bool STMHelper(A32::IREmitter& ir, bool W, Reg n, u32 list, const IR::U32

 bool TranslatorVisitor::thumb32_LDMDB(bool W, Reg n, Imm<16> reg_list) {
    const auto regs_imm = reg_list.ZeroExtend();
-    const auto num_regs = static_cast<u32>(mcl::bit::count_ones(regs_imm));
+    const auto num_regs = static_cast<u32>(std::popcount(regs_imm));

    if (n == Reg::PC || num_regs < 2) {
        return UnpredictableInstruction();
@@ -78,7 +78,7 @@ bool TranslatorVisitor::thumb32_LDMDB(bool W, Reg n, Imm<16> reg_list) {

 bool TranslatorVisitor::thumb32_LDMIA(bool W, Reg n, Imm<16> reg_list) {
    const auto regs_imm = reg_list.ZeroExtend();
-    const auto num_regs = static_cast<u32>(mcl::bit::count_ones(regs_imm));
+    const auto num_regs = static_cast<u32>(std::popcount(regs_imm));

    if (n == Reg::PC || num_regs < 2) {
        return UnpredictableInstruction();
@@ -111,7 +111,7 @@ bool TranslatorVisitor::thumb32_PUSH(Imm<15> reg_list) {

 bool TranslatorVisitor::thumb32_STMIA(bool W, Reg n, Imm<15> reg_list) {
    const auto regs_imm = reg_list.ZeroExtend();
-    const auto num_regs = static_cast<u32>(mcl::bit::count_ones(regs_imm));
+    const auto num_regs = static_cast<u32>(std::popcount(regs_imm));

    if (n == Reg::PC || num_regs < 2) {
        return UnpredictableInstruction();
@@ -130,7 +130,7 @@ bool TranslatorVisitor::thumb32_STMIA(bool W, Reg n, Imm<15> reg_list) {

 bool TranslatorVisitor::thumb32_STMDB(bool W, Reg n, Imm<15> reg_list) {
    const auto regs_imm = reg_list.ZeroExtend();
-    const auto num_regs = static_cast<u32>(mcl::bit::count_ones(regs_imm));
+    const auto num_regs = static_cast<u32>(std::popcount(regs_imm));

    if (n == Reg::PC || num_regs < 2) {
        return UnpredictableInstruction();
@@ -55,7 +55,7 @@ std::optional<TranslatorVisitor::BitMasks> TranslatorVisitor::DecodeBitMasks(boo
    const size_t esize = size_t{1} << len;
    const u64 welem = mcl::bit::ones<u64>(S + 1);
    const u64 telem = mcl::bit::ones<u64>(d + 1);
-    const u64 wmask = mcl::bit::rotate_right(mcl::bit::replicate_element<u64>(esize, welem), R);
+    const u64 wmask = std::rotr(mcl::bit::replicate_element<u64>(esize, welem), R);
    const u64 tmask = mcl::bit::replicate_element<u64>(esize, telem);

    return BitMasks{wmask, tmask};
@@ -13,7 +13,7 @@
 namespace Dynarmic::A64 {

 bool TranslatorVisitor::DUP_elt_1(Imm<5> imm5, Vec Vn, Vec Vd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size > 3) {
        return ReservedValue();
    }
@@ -30,7 +30,7 @@ bool TranslatorVisitor::DUP_elt_1(Imm<5> imm5, Vec Vn, Vec Vd) {
 }

 bool TranslatorVisitor::DUP_elt_2(bool Q, Imm<5> imm5, Vec Vn, Vec Vd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size > 3) {
        return ReservedValue();
    }
@@ -51,7 +51,7 @@ bool TranslatorVisitor::DUP_elt_2(bool Q, Imm<5> imm5, Vec Vn, Vec Vd) {
 }

 bool TranslatorVisitor::DUP_gen(bool Q, Imm<5> imm5, Reg Rn, Vec Vd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size > 3) {
        return ReservedValue();
    }
@@ -73,7 +73,7 @@ bool TranslatorVisitor::DUP_gen(bool Q, Imm<5> imm5, Reg Rn, Vec Vd) {
 }

 bool TranslatorVisitor::SMOV(bool Q, Imm<5> imm5, Vec Vn, Reg Rd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size == 2 && !Q) {
        return UnallocatedEncoding();
    }
@@ -96,7 +96,7 @@ bool TranslatorVisitor::SMOV(bool Q, Imm<5> imm5, Vec Vn, Reg Rd) {
 }

 bool TranslatorVisitor::UMOV(bool Q, Imm<5> imm5, Vec Vn, Reg Rd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size < 3 && Q) {
        return UnallocatedEncoding();
    }
@@ -123,7 +123,7 @@ bool TranslatorVisitor::UMOV(bool Q, Imm<5> imm5, Vec Vn, Reg Rd) {
 }

 bool TranslatorVisitor::INS_gen(Imm<5> imm5, Reg Rn, Vec Vd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size > 3) {
        return ReservedValue();
    }
@@ -140,7 +140,7 @@ bool TranslatorVisitor::INS_gen(Imm<5> imm5, Reg Rn, Vec Vd) {
 }

 bool TranslatorVisitor::INS_elt(Imm<5> imm5, Imm<4> imm4, Vec Vn, Vec Vd) {
-    const size_t size = mcl::bit::lowest_set_bit(imm5.ZeroExtend());
+    const size_t size = std::countr_zero(imm5.ZeroExtend());
    if (size > 3) {
        return ReservedValue();
    }
@@ -9,6 +9,7 @@
 #pragma once

 #include <functional>
+#include <tuple>

 #include "common/assert.h"

@@ -31,6 +32,10 @@ public:
        , expected{expected}
    {}

+    constexpr Matcher(std::tuple<T, T> t) noexcept
+        : Matcher(std::get<0>(t), std::get<1>(t))
+    {}
+
    /// @brief Gets the mask for this instruction.
    constexpr inline T GetMask() const noexcept {
        return mask;
@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <cstdio>
 #include <map>
+#include <bit>

 #include <ankerl/unordered_dense.h>
 #include "boost/container/small_vector.hpp"
@@ -28,7 +29,6 @@
 #include "dynarmic/ir/opt_passes.h"
 #include "dynarmic/ir/type.h"
 #include "dynarmic/mcl/bit.hpp"
-#include "dynarmic/mcl/bit.hpp"

 namespace Dynarmic::Optimization {

@@ -1074,12 +1074,12 @@ static void ConstantPropagation(IR::Block& block) {
            break;
        case Op::BitRotateRight32:
            if (FoldShifts(inst)) {
-                ReplaceUsesWith(inst, true, mcl::bit::rotate_right<u32>(inst.GetArg(0).GetU32(), inst.GetArg(1).GetU8()));
+                ReplaceUsesWith(inst, true, std::rotr<u32>(inst.GetArg(0).GetU32(), inst.GetArg(1).GetU8()));
            }
            break;
        case Op::BitRotateRight64:
            if (FoldShifts(inst)) {
-                ReplaceUsesWith(inst, false, mcl::bit::rotate_right<u64>(inst.GetArg(0).GetU64(), inst.GetArg(1).GetU8()));
+                ReplaceUsesWith(inst, false, std::rotr<u64>(inst.GetArg(0).GetU64(), inst.GetArg(1).GetU8()));
            }
            break;
        case Op::LogicalShiftLeftMasked32:
@@ -1114,12 +1114,12 @@ static void ConstantPropagation(IR::Block& block) {
            break;
        case Op::RotateRightMasked32:
            if (inst.AreAllArgsImmediates()) {
-                ReplaceUsesWith(inst, true, mcl::bit::rotate_right<u32>(inst.GetArg(0).GetU32(), inst.GetArg(1).GetU32()));
+                ReplaceUsesWith(inst, true, std::rotr<u32>(inst.GetArg(0).GetU32(), inst.GetArg(1).GetU32()));
            }
            break;
        case Op::RotateRightMasked64:
            if (inst.AreAllArgsImmediates()) {
-                ReplaceUsesWith(inst, false, mcl::bit::rotate_right<u64>(inst.GetArg(0).GetU64(), inst.GetArg(1).GetU64()));
+                ReplaceUsesWith(inst, false, std::rotr<u64>(inst.GetArg(0).GetU64(), inst.GetArg(1).GetU64()));
            }
            break;
        case Op::Add32:
@@ -8,26 +8,15 @@
 #include <bitset>
 #include <climits>
 #include <cstddef>
+#include <concepts>
+#include <bit>

 #include "common/common_types.h"
 #include "common/assert.h"

 namespace mcl {
-namespace detail {
-template<typename T, typename U>
-concept SameHelper = std::is_same_v<T, U>;
-}  // namespace detail
-template<typename T, typename U>
-concept SameAs = detail::SameHelper<T, U> && detail::SameHelper<U, T>;
-template<typename T, typename... U>
-concept IsAnyOf = (SameAs<T, U> || ...);
-/// Integral upon which bit operations can be safely performed.
-template<typename T>
-concept BitIntegral = IsAnyOf<T, u8, u16, u32, u64, std::uintptr_t, size_t>;
-
 template<typename T>
 constexpr std::size_t bitsizeof = CHAR_BIT * sizeof(T);
-
 }  // namespace mcl

 namespace mcl::bit {
@@ -71,58 +60,37 @@ constexpr u64 swap_words_64(u64 value) {
         | ((value & 0x00000000ffffffffull) << 32);
 }

-template<BitIntegral T>
-constexpr T rotate_right(T x, size_t amount) {
-    amount %= bitsizeof<T>;
-    if (amount == 0) {
-        return x;
-    }
-    return static_cast<T>((x >> amount) | (x << (bitsizeof<T> - amount)));
-}
-
-template<BitIntegral T>
-constexpr T rotate_left(T x, size_t amount) {
-    amount %= bitsizeof<T>;
-    if (amount == 0) {
-        return x;
-    }
-    return static_cast<T>((x << amount) | (x >> (bitsizeof<T> - amount)));
-}
-
 /// Create a mask with `count` number of one bits.
-template<size_t count, BitIntegral T>
+template<size_t count, std::integral T>
 constexpr T ones() {
    static_assert(count <= bitsizeof<T>, "count larger than bitsize of T");
-
    if constexpr (count == 0) {
        return 0;
    } else {
-        return static_cast<T>(~static_cast<T>(0)) >> (bitsizeof<T> - count);
+        return T(~T(0)) >> (bitsizeof<T> - count);
    }
 }

 /// Create a mask with `count` number of one bits.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T ones(size_t count) {
    ASSERT(count <= bitsizeof<T> && "count larger than bitsize of T");
-    if (count == 0) {
+    if (count == 0)
        return 0;
-    }
-    return static_cast<T>(~static_cast<T>(0)) >> (bitsizeof<T> - count);
+    return T(~T(0)) >> (bitsizeof<T> - count);
 }

 /// Create a mask of type T for bits [begin_bit, end_bit] inclusive.
-template<size_t begin_bit, size_t end_bit, BitIntegral T>
+template<size_t begin_bit, size_t end_bit, std::integral T>
 constexpr T mask() {
    static_assert(begin_bit <= end_bit, "invalid bit range (position of beginning bit cannot be greater than that of end bit)");
    static_assert(begin_bit < bitsizeof<T>, "begin_bit must be smaller than size of T");
    static_assert(end_bit < bitsizeof<T>, "end_bit must be smaller than size of T");
-
    return ones<end_bit - begin_bit + 1, T>() << begin_bit;
 }

 /// Create a mask of type T for bits [begin_bit, end_bit] inclusive.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T mask(size_t begin_bit, size_t end_bit) {
    ASSERT(begin_bit <= end_bit && "invalid bit range (position of beginning bit cannot be greater than that of end bit)");
    ASSERT(begin_bit < bitsizeof<T> && "begin_bit must be smaller than size of T");
@@ -131,101 +99,100 @@ constexpr T mask(size_t begin_bit, size_t end_bit) {
 }

 /// Extract bits [begin_bit, end_bit] inclusive from value of type T.
-template<size_t begin_bit, size_t end_bit, BitIntegral T>
+template<size_t begin_bit, size_t end_bit, std::integral T>
 constexpr T get_bits(T value) {
    constexpr T m = mask<begin_bit, end_bit, T>();
    return (value & m) >> begin_bit;
 }

 /// Extract bits [begin_bit, end_bit] inclusive from value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T get_bits(size_t begin_bit, size_t end_bit, T value) {
    const T m = mask<T>(begin_bit, end_bit);
    return (value & m) >> begin_bit;
 }

 /// Clears bits [begin_bit, end_bit] inclusive of value of type T.
-template<size_t begin_bit, size_t end_bit, BitIntegral T>
+template<size_t begin_bit, size_t end_bit, std::integral T>
 constexpr T clear_bits(T value) {
    constexpr T m = mask<begin_bit, end_bit, T>();
    return value & ~m;
 }

 /// Clears bits [begin_bit, end_bit] inclusive of value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T clear_bits(size_t begin_bit, size_t end_bit, T value) {
    const T m = mask<T>(begin_bit, end_bit);
    return value & ~m;
 }

 /// Modifies bits [begin_bit, end_bit] inclusive of value of type T.
-template<size_t begin_bit, size_t end_bit, BitIntegral T>
+template<size_t begin_bit, size_t end_bit, std::integral T>
 constexpr T set_bits(T value, T new_bits) {
    constexpr T m = mask<begin_bit, end_bit, T>();
    return (value & ~m) | ((new_bits << begin_bit) & m);
 }

 /// Modifies bits [begin_bit, end_bit] inclusive of value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T set_bits(size_t begin_bit, size_t end_bit, T value, T new_bits) {
    const T m = mask<T>(begin_bit, end_bit);
    return (value & ~m) | ((new_bits << begin_bit) & m);
 }

 /// Extract bit at bit_position from value of type T.
-template<size_t bit_position, BitIntegral T>
+template<size_t bit_position, std::integral T>
 constexpr bool get_bit(T value) {
    constexpr T m = mask<bit_position, bit_position, T>();
    return (value & m) != 0;
 }

 /// Extract bit at bit_position from value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr bool get_bit(size_t bit_position, T value) {
    const T m = mask<T>(bit_position, bit_position);
    return (value & m) != 0;
 }

 /// Clears bit at bit_position of value of type T.
-template<size_t bit_position, BitIntegral T>
+template<size_t bit_position, std::integral T>
 constexpr T clear_bit(T value) {
    constexpr T m = mask<bit_position, bit_position, T>();
    return value & ~m;
 }

 /// Clears bit at bit_position of value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T clear_bit(size_t bit_position, T value) {
    const T m = mask<T>(bit_position, bit_position);
    return value & ~m;
 }

 /// Modifies bit at bit_position of value of type T.
-template<size_t bit_position, BitIntegral T>
+template<size_t bit_position, std::integral T>
 constexpr T set_bit(T value, bool new_bit) {
    constexpr T m = mask<bit_position, bit_position, T>();
-    return (value & ~m) | (new_bit ? m : static_cast<T>(0));
+    return (value & ~m) | (new_bit ? m : T(0));
 }

 /// Modifies bit at bit_position of value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T set_bit(size_t bit_position, T value, bool new_bit) {
    const T m = mask<T>(bit_position, bit_position);
-    return (value & ~m) | (new_bit ? m : static_cast<T>(0));
+    return (value & ~m) | (new_bit ? m : T(0));
 }

 /// Sign-extends a value that has bit_count bits to the full bitwidth of type T.
-template<size_t bit_count, BitIntegral T>
+template<size_t bit_count, std::integral T>
 constexpr T sign_extend(T value) {
    static_assert(bit_count != 0, "cannot sign-extend zero-sized value");
-
    using S = std::make_signed_t<T>;
    constexpr size_t shift_amount = bitsizeof<T> - bit_count;
-    return static_cast<T>(static_cast<S>(value << shift_amount) >> shift_amount);
+    return T(S(value << shift_amount) >> shift_amount);
 }

 /// Sign-extends a value that has bit_count bits to the full bitwidth of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T sign_extend(size_t bit_count, T value) {
    ASSERT(bit_count != 0 && "cannot sign-extend zero-sized value");
    using S = std::make_signed_t<T>;
@@ -234,78 +201,42 @@ constexpr T sign_extend(size_t bit_count, T value) {
 }

 /// Replicate an element across a value of type T.
-template<size_t element_size, BitIntegral T>
+template<size_t element_size, std::integral T>
 constexpr T replicate_element(T value) {
    static_assert(element_size <= bitsizeof<T>, "element_size is too large");
    static_assert(bitsizeof<T> % element_size == 0, "bitsize of T not divisible by element_size");
-
    if constexpr (element_size == bitsizeof<T>) {
        return value;
    } else {
-        return replicate_element<element_size * 2, T>(static_cast<T>(value | (value << element_size)));
+        return replicate_element<element_size * 2, T>(T(value | (value << element_size)));
    }
 }

 /// Replicate an element of type U across a value of type T.
-template<BitIntegral U, BitIntegral T>
+template<std::integral U, std::integral T>
 constexpr T replicate_element(T value) {
    static_assert(bitsizeof<U> <= bitsizeof<T>, "element_size is too large");
-
    return replicate_element<bitsizeof<U>, T>(value);
 }

 /// Replicate an element across a value of type T.
-template<BitIntegral T>
+template<std::integral T>
 constexpr T replicate_element(size_t element_size, T value) {
    ASSERT(element_size <= bitsizeof<T> && "element_size is too large");
    ASSERT(bitsizeof<T> % element_size == 0 && "bitsize of T not divisible by element_size");
    if (element_size == bitsizeof<T>)
        return value;
-    return replicate_element<T>(element_size * 2, static_cast<T>(value | (value << element_size)));
+    return replicate_element<T>(element_size * 2, T(value | (value << element_size)));
 }

-template<BitIntegral T>
+template<std::integral T>
 constexpr bool most_significant_bit(T value) {
    return get_bit<bitsizeof<T> - 1, T>(value);
 }

-template<BitIntegral T>
-inline size_t count_ones(T x) {
-    return std::bitset<bitsizeof<T>>(x).count();
-}
-
-template<BitIntegral T>
-constexpr size_t count_leading_zeros(T x) {
-    size_t result = bitsizeof<T>;
-    while (x != 0) {
-        x >>= 1;
-        result--;
-    }
-    return result;
-}
-
-template<BitIntegral T>
+template<std::integral T>
 constexpr int highest_set_bit(T x) {
-    int result = -1;
-    while (x != 0) {
-        x >>= 1;
-        result++;
-    }
-    return result;
-}
-
-template<BitIntegral T>
-constexpr size_t lowest_set_bit(T x) {
-    if (x == 0) {
-        return bitsizeof<T>;
-    }
-
-    size_t result = 0;
-    while ((x & 1) == 0) {
-        x >>= 1;
-        result++;
-    }
-    return result;
+    return std::bit_width(x) - 1;
 }

 }  // namespace mcl::bit
@@ -17,25 +17,25 @@ struct integer_of_size_impl {};
 template<>
 struct integer_of_size_impl<8> {
    using unsigned_type = u8;
-    using signed_type = s8;
+    using signed_type = std::make_signed_t<unsigned_type>;
 };

 template<>
 struct integer_of_size_impl<16> {
    using unsigned_type = u16;
-    using signed_type = s16;
+    using signed_type = std::make_signed_t<unsigned_type>;
 };

 template<>
 struct integer_of_size_impl<32> {
    using unsigned_type = u32;
-    using signed_type = s32;
+    using signed_type = std::make_signed_t<unsigned_type>;
 };

 template<>
 struct integer_of_size_impl<64> {
    using unsigned_type = u64;
-    using signed_type = s64;
+    using signed_type = std::make_signed_t<unsigned_type>;
 };

 }  // namespace detail
@@ -10,23 +10,12 @@

 namespace mcl {

-/// A metavalue (of type VT and value v).
-template<class VT, VT v> using value = std::integral_constant<VT, v>;
-/// A metavalue of type size_t (and value v).
-template<size_t v> using size_value = value<size_t, v>;
-/// A metavalue of type bool (and value v). (Aliases to std::bool_constant.)
-template<bool v> using bool_value = value<bool, v>;
-/// true metavalue (Aliases to std::true_type).
-using true_type = bool_value<true>;
-/// false metavalue (Aliases to std::false_type).
-using false_type = bool_value<false>;
-
 /// Is type T an instance of template class C?
 template<template<class...> class, class>
-struct is_instance_of_template : false_type {};
+struct is_instance_of_template : std::false_type {};

 template<template<class...> class C, class... As>
-struct is_instance_of_template<C, C<As...>> : true_type {};
+struct is_instance_of_template<C, C<As...>> : std::true_type {};

 /// Is type T an instance of template class C?
 template<template<class...> class C, class T>
@@ -665,7 +665,7 @@ TEST_CASE("A32: Test thumb IT instruction", "[thumb]") {
        A32::ITState it_state = [&] {
            while (true) {
                const u16 imm8 = RandInt<u16>(0, 0xFF);
-                if (mcl::bit::get_bits<0, 3>(imm8) == 0b0000 || mcl::bit::get_bits<4, 7>(imm8) == 0b1111 || (mcl::bit::get_bits<4, 7>(imm8) == 0b1110 && mcl::bit::count_ones(mcl::bit::get_bits<0, 3>(imm8)) != 1)) {
+                if (mcl::bit::get_bits<0, 3>(imm8) == 0b0000 || mcl::bit::get_bits<4, 7>(imm8) == 0b1111 || (mcl::bit::get_bits<4, 7>(imm8) == 0b1110 && std::popcount(mcl::bit::get_bits<0, 3>(imm8)) != 1)) {
                    continue;
                }
                instructions.push_back(0b1011111100000000 | imm8);
@@ -3,7 +3,6 @@

 #include <algorithm>
 #include <filesystem>
-#include <iostream>
 #include <fmt/format.h>
 #include "common/fs/fs.h"
 #include "common/fs/fs_types.h"
@@ -486,27 +486,17 @@ void TouchResource::ReadTouchInput() {
    SanitizeInput(current_touch_state);

    std::scoped_lock lock{*input_mutex};
-    if (current_touch_state.entry_count == previous_touch_state.entry_count) {
-        if (current_touch_state.entry_count < 1) {
-            return;
-        }
+    if (current_touch_state.entry_count == previous_touch_state.entry_count && current_touch_state.entry_count >= 1) {
        bool has_moved = false;
-        for (std::size_t i = 0; i < static_cast<std::size_t>(current_touch_state.entry_count);
-             i++) {
-            s32 delta_x = std::abs(static_cast<s32>(current_touch_state.states[i].position.x) -
-                                   static_cast<s32>(previous_touch_state.states[i].position.x));
-            s32 delta_y = std::abs(static_cast<s32>(current_touch_state.states[i].position.y) -
-                                   static_cast<s32>(previous_touch_state.states[i].position.y));
-            if (delta_x > 1 || delta_y > 1) {
-                has_moved = true;
-            }
+        for (std::size_t i = 0; !has_moved && i < std::size_t(current_touch_state.entry_count); i++) {
+            s32 delta_x = std::abs(s32(current_touch_state.states[i].position.x) - s32(previous_touch_state.states[i].position.x));
+            s32 delta_y = std::abs(s32(current_touch_state.states[i].position.y) - s32(previous_touch_state.states[i].position.y));
+            has_moved |= (delta_x > 1 || delta_y > 1);
        }
-        if (!has_moved) {
-            return;
+        if (has_moved) {
+            input_event->Signal();
        }
    }
-
-    input_event->Signal();
 }

 void TouchResource::OnTouchUpdate(s64 timestamp) {
@@ -31,6 +31,10 @@ add_library(qt_common STATIC
    abstract/frontend.h abstract/frontend.cpp
    abstract/progress.h abstract/progress.cpp

+    game_list/model.h game_list/model.cpp
+    game_list/worker.h game_list/worker.cpp
+    game_list/game_list_p.h
+
    qt_string_lookup.h
    qt_compat.h

@@ -17,14 +17,13 @@
 #include <QRegularExpression>
 #include <QStandardItem>
 #include <QString>
-#include <QWidget>

 #include "common/common_types.h"
 #include "common/logging.h"
 #include "common/string_util.h"
 #include "frontend_common/play_time_manager.h"
 #include "qt_common/config/uisettings.h"
-#include "yuzu/util/util.h"
+#include "qt_common/qt_common.h"

 enum class GameListItemType {
    Game = QStandardItem::UserType + 1,
@@ -204,7 +203,7 @@ public:
        setData(compatibility, CompatNumberRole);
        setText(tr(status.text));
        setToolTip(tr(status.tooltip));
-        setData(CreateCirclePixmapFromColor(status.color), Qt::DecorationRole);
+        setData(QtCommon::CreateCirclePixmapFromColor(status.color), Qt::DecorationRole);
    }

    int type() const override {
@@ -237,7 +236,7 @@ public:
        // representations of the data are always accurate and in the correct format.
        if (role == SizeRole) {
            qulonglong size_bytes = value.toULongLong();
-            GameListItem::setData(ReadableByteSize(size_bytes), Qt::DisplayRole);
+            GameListItem::setData(QtCommon::ReadableByteSize(size_bytes), Qt::DisplayRole);
            GameListItem::setData(value, SizeRole);
        } else {
            GameListItem::setData(value, role);
@@ -398,49 +397,3 @@ public:
        return false;
    }
 };
-
-class GameList;
-class QHBoxLayout;
-class QTreeView;
-class QLabel;
-class QLineEdit;
-class QToolButton;
-
-class GameListSearchField : public QWidget {
-    Q_OBJECT
-
-public:
-    explicit GameListSearchField(GameList* parent = nullptr);
-
-    QString filterText() const;
-    void setFilterResult(int visible_, int total_);
-
-    void clear();
-    void setFocus();
-
-private:
-    void changeEvent(QEvent*) override;
-    void RetranslateUI();
-
-    class KeyReleaseEater : public QObject {
-    public:
-        explicit KeyReleaseEater(GameList* gamelist_, QObject* parent = nullptr);
-
-    private:
-        GameList* gamelist = nullptr;
-        QString edit_filter_text_old;
-
-    protected:
-        // EventFilter in order to process systemkeys while editing the searchfield
-        bool eventFilter(QObject* obj, QEvent* event) override;
-    };
-    int visible;
-    int total;
-
-    QHBoxLayout* layout_filter = nullptr;
-    QTreeView* tree_view = nullptr;
-    QLabel* label_filter = nullptr;
-    QLineEdit* edit_filter = nullptr;
-    QLabel* label_filter_result = nullptr;
-    QToolButton* button_filter_close = nullptr;
-};
@@ -0,0 +1,303 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QDir>
+#include <QIcon>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QThreadPool>
+
+#include "common/logging.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/file_sys/patch_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "qt_common/config/uisettings.h"
+#include "qt_common/qt_common.h"
+#include "qt_common/util/game.h"
+
+#include "qt_common/game_list/game_list_p.h"
+#include "qt_common/game_list/worker.h"
+#include "qt_common/game_list/model.h"
+
+GameListModel::GameListModel(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
+                             FileSys::ManualContentProvider* provider_,
+                             const PlayTime::PlayTimeManager& play_time_manager_,
+                             Core::System& system_, QObject* parent)
+    : QStandardItemModel{parent}, vfs{std::move(vfs_)}, provider{provider_},
+      play_time_manager{play_time_manager_}, system{system_} {
+    watcher = new QFileSystemWatcher(this);
+    external_watcher = new QFileSystemWatcher(this);
+
+    connect(watcher, &QFileSystemWatcher::directoryChanged, this,
+            &GameListModel::RefreshGameDirectory);
+    connect(external_watcher, &QFileSystemWatcher::directoryChanged, this,
+            &GameListModel::RefreshExternalContent);
+
+    insertColumns(0, COLUMN_COUNT);
+    RetranslateUI();
+
+    setSortRole(GameListItemPath::SortRole);
+}
+
+GameListModel::~GameListModel() = default;
+
+void GameListModel::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
+    current_worker.reset();
+    removeRows(0, rowCount());
+
+    current_worker = std::make_unique<GameListWorker>(vfs, provider, game_dirs, compatibility_list,
+                                                      play_time_manager, system);
+
+    connect(current_worker.get(), &GameListWorker::DataAvailable, this, &GameListModel::WorkerEvent,
+            Qt::QueuedConnection);
+
+    QThreadPool::globalInstance()->start(current_worker.get());
+}
+
+void GameListModel::WorkerEvent() {
+    current_worker->ProcessEvents(this);
+}
+
+void GameListModel::AddDirEntry(GameListDir* entry_items) {
+    if (m_flat) {
+        return;
+    }
+    invisibleRootItem()->appendRow(entry_items);
+}
+
+void GameListModel::AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent) {
+    if (m_flat) {
+        invisibleRootItem()->appendRow(entry_items);
+    } else {
+        parent->appendRow(entry_items);
+    }
+}
+
+void GameListModel::DonePopulating(const QStringList& watch_list) {
+    emit ShowList(!IsEmpty());
+
+    if (!m_flat) {
+        invisibleRootItem()->appendRow(new GameListAddDir());
+        invisibleRootItem()->insertRow(0, new GameListFavorites());
+
+        for (const auto id : std::as_const(UISettings::values.favorited_ids)) {
+            AddFavorite(id);
+        }
+    }
+
+    emit PopulatingCompleted(watch_list);
+}
+
+bool GameListModel::IsEmpty() const {
+    for (int i = 0; i < rowCount(); i++) {
+        const QStandardItem* child = invisibleRootItem()->child(i);
+        const auto type = static_cast<GameListItemType>(child->type());
+
+        if (!child->hasChildren() &&
+            (type == GameListItemType::SdmcDir || type == GameListItemType::UserNandDir ||
+             type == GameListItemType::SysNandDir)) {
+            invisibleRootItem()->removeRow(child->row());
+            i--;
+        }
+    }
+
+    return !invisibleRootItem()->hasChildren();
+}
+
+void GameListModel::ToggleFavorite(u64 program_id) {
+    if (!UISettings::values.favorited_ids.contains(program_id)) {
+        UISettings::values.favorited_ids.append(program_id);
+        AddFavorite(program_id);
+    } else {
+        UISettings::values.favorited_ids.removeOne(program_id);
+        RemoveFavorite(program_id);
+    }
+    emit SaveConfig();
+}
+
+void GameListModel::AddFavorite(u64 program_id) {
+    auto* favorites_row = item(0);
+
+    for (int i = 1; i < rowCount() - 1; i++) {
+        const auto* folder = item(i);
+        for (int j = 0; j < folder->rowCount(); j++) {
+            if (folder->child(j)->data(GameListItemPath::ProgramIdRole).toULongLong() ==
+                program_id) {
+                QList<QStandardItem*> list;
+                for (int k = 0; k < COLUMN_COUNT; k++) {
+                    list.append(folder->child(j, k)->clone());
+                }
+                list[0]->setData(folder->child(j)->data(GameListItem::SortRole),
+                                 GameListItem::SortRole);
+                list[0]->setText(folder->child(j)->data(Qt::DisplayRole).toString());
+
+                favorites_row->appendRow(list);
+                return;
+            }
+        }
+    }
+}
+
+void GameListModel::RemoveFavorite(u64 program_id) {
+    auto* favorites_row = item(0);
+
+    for (int i = 0; i < favorites_row->rowCount(); i++) {
+        const auto* game = favorites_row->child(i);
+        if (game->data(GameListItemPath::ProgramIdRole).toULongLong() == program_id) {
+            favorites_row->removeRow(i);
+            return;
+        }
+    }
+}
+
+void GameListModel::LoadCompatibilityList() {
+    QFile compat_list{QStringLiteral(":compatibility_list/compatibility_list.json")};
+
+    if (!compat_list.open(QFile::ReadOnly | QFile::Text)) {
+        LOG_ERROR(Frontend, "Unable to open game compatibility list");
+        return;
+    }
+
+    if (compat_list.size() == 0) {
+        LOG_WARNING(Frontend, "Game compatibility list is empty");
+        return;
+    }
+
+    const QByteArray content = compat_list.readAll();
+    if (content.isEmpty()) {
+        LOG_ERROR(Frontend, "Unable to completely read game compatibility list");
+        return;
+    }
+
+    const QJsonDocument json = QJsonDocument::fromJson(content);
+    const QJsonArray arr = json.array();
+
+    for (const QJsonValue& value : arr) {
+        const QJsonObject game = value.toObject();
+        const QString compatibility_key = QStringLiteral("compatibility");
+
+        if (!game.contains(compatibility_key) || !game[compatibility_key].isDouble()) {
+            continue;
+        }
+
+        const int compatibility = game[compatibility_key].toInt();
+        const QString directory = game[QStringLiteral("directory")].toString();
+        const QJsonArray ids = game[QStringLiteral("releases")].toArray();
+
+        for (const QJsonValue& id_ref : ids) {
+            const QJsonObject id_object = id_ref.toObject();
+            const QString id = id_object[QStringLiteral("id")].toString();
+
+            compatibility_list.emplace(id.toUpper().toStdString(),
+                                       std::make_pair(QString::number(compatibility), directory));
+        }
+    }
+}
+
+void GameListModel::RefreshGameDirectory() {
+    ResetExternalWatcher();
+
+    if (!UISettings::values.game_dirs.empty() && current_worker != nullptr) {
+        LOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
+        QtCommon::system->GetFileSystemController().CreateFactories(*QtCommon::vfs);
+        PopulateAsync(UISettings::values.game_dirs);
+    }
+}
+
+void GameListModel::RefreshExternalContent() {
+    if (!UISettings::values.game_dirs.empty() && current_worker != nullptr) {
+        LOG_INFO(Frontend, "External content directory changed. Clearing metadata cache.");
+        QtCommon::Game::ResetMetadata(false);
+        QtCommon::system->GetFileSystemController().CreateFactories(*QtCommon::vfs);
+        PopulateAsync(UISettings::values.game_dirs);
+    }
+}
+
+void GameListModel::ResetExternalWatcher() {
+    auto watch_dirs = external_watcher->directories();
+    if (!watch_dirs.isEmpty()) {
+        external_watcher->removePaths(watch_dirs);
+    }
+
+    for (const std::string& dir : Settings::values.external_content_dirs) {
+        external_watcher->addPath(QString::fromStdString(dir));
+    }
+}
+
+void GameListModel::OnUpdateThemedIcons() {
+    for (int i = 0; i < invisibleRootItem()->rowCount(); i++) {
+        QStandardItem* child = invisibleRootItem()->child(i);
+
+        const int icon_size = UISettings::values.folder_icon_size.GetValue();
+
+        switch (child->data(GameListItem::TypeRole).value<GameListItemType>()) {
+        case GameListItemType::SdmcDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("sd_card"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::UserNandDir:
+        case GameListItemType::SysNandDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("chip"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::CustomDir: {
+            const UISettings::GameDir& game_dir =
+                UISettings::values.game_dirs[child->data(GameListDir::GameDirRole).toInt()];
+            const QString icon_name = QFileInfo::exists(QString::fromStdString(game_dir.path))
+                                          ? QStringLiteral("folder")
+                                          : QStringLiteral("bad_folder");
+            child->setData(
+                QIcon::fromTheme(icon_name).pixmap(icon_size).scaled(
+                    icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        }
+        case GameListItemType::AddDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("list-add"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::Favorites:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("star"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+void GameListModel::RetranslateUI() {
+    setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
+    setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
+    setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+    setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    setHeaderData(COLUMN_PLAY_TIME, Qt::Horizontal, tr("Play time"));
+}
+
+QFileSystemWatcher* GameListModel::GetWatcher() const {
+    return watcher;
+}
+
+const CompatibilityList& GameListModel::GetCompatibilityList() const {
+    return compatibility_list;
+}
+
+void GameListModel::SetFlat(bool flat) {
+    m_flat = flat;
+}
@@ -0,0 +1,98 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QFileSystemWatcher>
+#include <QStandardItemModel>
+#include <QStringList>
+#include <QVector>
+#include <memory>
+
+#include "common/common_types.h"
+#include "frontend_common/play_time_manager.h"
+#include "qt_common/config/uisettings.h"
+#include "yuzu/compatibility_list.h"
+
+namespace Core {
+class System;
+}
+
+class GameListDir;
+class GameListWorker;
+class QStandardItem;
+
+namespace FileSys {
+class ManualContentProvider;
+class VfsFilesystem;
+} // namespace FileSys
+
+class GameListModel : public QStandardItemModel {
+    Q_OBJECT
+
+public:
+    enum Column {
+        COLUMN_NAME,
+        COLUMN_FILE_TYPE,
+        COLUMN_SIZE,
+        COLUMN_PLAY_TIME,
+        COLUMN_ADD_ONS,
+        COLUMN_COMPATIBILITY,
+        COLUMN_COUNT,
+    };
+
+    explicit GameListModel(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
+                           FileSys::ManualContentProvider* provider_,
+                           const PlayTime::PlayTimeManager& play_time_manager_,
+                           Core::System& system_, QObject* parent = nullptr);
+    ~GameListModel() override;
+
+    void AddDirEntry(GameListDir* entry_items);
+    void AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent);
+    void DonePopulating(const QStringList& watch_list);
+
+    void PopulateAsync(QVector<UISettings::GameDir>& game_dirs);
+    void WorkerEvent();
+
+    bool IsEmpty() const;
+
+    void ToggleFavorite(u64 program_id);
+
+    void RefreshGameDirectory();
+    void RefreshExternalContent();
+    void ResetExternalWatcher();
+
+    void LoadCompatibilityList();
+
+    void OnUpdateThemedIcons();
+    void RetranslateUI();
+
+    QFileSystemWatcher* GetWatcher() const;
+
+    const CompatibilityList& GetCompatibilityList() const;
+
+    void SetFlat(bool flat);
+
+signals:
+    void ShowList(bool show);
+    void PopulatingCompleted(const QStringList& watch_list);
+    void SaveConfig();
+
+private:
+    friend class GameListWorker;
+
+    void AddFavorite(u64 program_id);
+    void RemoveFavorite(u64 program_id);
+
+    bool m_flat = false;
+
+    std::shared_ptr<FileSys::VfsFilesystem> vfs;
+    FileSys::ManualContentProvider* provider;
+    CompatibilityList compatibility_list;
+    const PlayTime::PlayTimeManager& play_time_manager;
+    Core::System& system;
+
+    std::unique_ptr<GameListWorker> current_worker;
+    QFileSystemWatcher* watcher = nullptr;
+    QFileSystemWatcher* external_watcher = nullptr;
+};
@@ -33,9 +33,10 @@
 #include "qt_common/qt_common.h"

 #include "yuzu/compatibility_list.h"
-#include "yuzu/game/game_list.h"
-#include "yuzu/game/game_list_p.h"
-#include "yuzu/game/game_list_worker.h"
+#include "qt_common/game_list/game_list_p.h"
+
+#include "qt_common/game_list/worker.h"
+#include "qt_common/game_list/model.h"

 namespace {

@@ -250,9 +251,9 @@ GameListWorker::~GameListWorker() {
    processing_completed.Wait();
 }

-void GameListWorker::ProcessEvents(GameList* game_list) {
+void GameListWorker::ProcessEvents(GameListModel* model) {
    while (true) {
-        std::function<void(GameList*)> func;
+        std::function<void(GameListModel*)> func;
        {
            // Lock queue to protect concurrent modification.
            std::scoped_lock lk(lock);
@@ -268,7 +269,7 @@ void GameListWorker::ProcessEvents(GameList* game_list) {
        }

        // Run the function.
-        func(game_list);
+        func(model);
    }
 }

@@ -335,7 +336,7 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {

        auto entry = MakeGameListEntry(file->GetFullPath(), name, file->GetSize(), icon, *loader,
                                       program_id, compatibility_list, play_time_manager, patch);
-        RecordEvent([=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+        RecordEvent([=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
    }
 }

@@ -417,7 +418,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                            id, compatibility_list, play_time_manager, patch);

                        RecordEvent(
-                            [=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+                            [=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
                    }
                } else {
                    std::vector<u8> icon;
@@ -434,7 +435,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                        program_id, compatibility_list, play_time_manager, patch);

                    RecordEvent(
-                        [=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+                        [=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
                }
            }
        } else if (is_dir) {
@@ -457,7 +458,7 @@ void GameListWorker::run() {
    provider->ClearAllEntries();

    const auto DirEntryReady = [&](GameListDir* game_list_dir) {
-        RecordEvent([=](GameList* game_list) { game_list->AddDirEntry(game_list_dir); });
+        RecordEvent([=](GameListModel* model) { model->AddDirEntry(game_list_dir); });
    };

    for (UISettings::GameDir& game_dir : game_dirs) {
@@ -491,6 +492,6 @@ void GameListWorker::run() {
        }
    }

-    RecordEvent([this](GameList* game_list) { game_list->DonePopulating(watch_list); });
+    RecordEvent([this](GameListModel* model) { model->DonePopulating(watch_list); });
    processing_completed.Set();
 }
@@ -26,8 +26,8 @@ namespace Core {
 class System;
 }

-class GameList;
 class GameListDir;
+class GameListModel;
 class QStandardItem;

 namespace FileSys {
@@ -58,11 +58,11 @@ public:
    /**
     * Synchronously processes any events queued by the worker.
     *
-     * AddDirEntry is called on the game list for every discovered directory.
-     * AddEntry is called on the game list for every discovered program.
-     * DonePopulating is called on the game list when processing completes.
+     * AddDirEntry is called on the model for every discovered directory.
+     * AddEntry is called on the model for every discovered program.
+     * DonePopulating is called on the model when processing completes.
     */
-    void ProcessEvents(GameList* game_list);
+    void ProcessEvents(GameListModel* model);

 signals:
    void DataAvailable();
@@ -92,7 +92,7 @@ private:

    std::mutex lock;
    std::condition_variable cv;
-    std::deque<std::function<void(GameList*)>> queued_events;
+    std::deque<std::function<void(GameListModel*)>> queued_events;
    std::atomic_bool stop_requested = false;
    Common::Event processing_completed;

@@ -5,6 +5,7 @@

 #include "common/memory_detect.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "frontend_common/data_manager.h"
 #include "hid_core/hid_core.h"
 #include "network/network.h"
 #include "qt_common.h"
@@ -13,12 +14,9 @@
 #include "common/fs/path_util.h"
 #include "common/logging.h"
 #include "common/scm_rev.h"
+#include "common/cpu_features.h"
 #include "core/memory.h"

-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_detect.h"
-#endif
-
 #include <QGuiApplication>
 #include <QStringLiteral>
 #include "core/frontend/emu_window.h"
@@ -30,6 +28,7 @@

 #include <thread>
 #include <JlCompress.h>
+#include <QPainter>

 #if !defined(WIN32) && !defined(__APPLE__)
 #include <qpa/qplatformnativeinterface.h>
@@ -90,8 +89,37 @@ Core::Frontend::EmuWindow::WindowSystemInfo GetWindowSystemInfo(QWindow* window)
    // Our Win32 Qt external doesn't have the private API.
    wsi.render_surface = reinterpret_cast<void*>(window->winId());
 #elif defined(__APPLE__)
-    wsi.render_surface = reinterpret_cast<void* (*)(id, SEL)>(objc_msgSend)(
+    id layer = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(
        reinterpret_cast<id>(window->winId()), sel_registerName("layer"));
+
+    // In Qt 6, the layer of the NSView might be a QContainerLayer.
+    // MoltenVK needs a CAMetalLayer. We search for it in sublayers.
+    Class metal_layer_class = objc_getClass("CAMetalLayer");
+    id metal_layer = nullptr;
+
+    if (layer) {
+        if (reinterpret_cast<bool (*)(id, SEL, Class)>(objc_msgSend)(
+                layer, sel_registerName("isKindOfClass:"), metal_layer_class)) {
+            metal_layer = layer;
+        } else {
+            id sublayers = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(
+                layer, sel_registerName("sublayers"));
+            if (sublayers) {
+                unsigned long count = reinterpret_cast<unsigned long (*)(id, SEL)>(objc_msgSend)(
+                    sublayers, sel_registerName("count"));
+                for (unsigned long i = 0; i < count; ++i) {
+                    id sublayer = reinterpret_cast<id (*)(id, SEL, unsigned long)>(objc_msgSend)(
+                        sublayers, sel_registerName("objectAtIndex:"), i);
+                    if (reinterpret_cast<bool (*)(id, SEL, Class)>(objc_msgSend)(
+                            sublayer, sel_registerName("isKindOfClass:"), metal_layer_class)) {
+                        metal_layer = sublayer;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    wsi.render_surface = reinterpret_cast<void*>(metal_layer ? metal_layer : layer);
 #else
    QPlatformNativeInterface* pni = QGuiApplication::platformNativeInterface();
    wsi.display_connection = pni->nativeResourceForWindow("display", window);
@@ -214,7 +242,7 @@ void Init(QWidget* root) {
    LOG_INFO(Frontend, "Eden Version: {}", yuzu_build_version);
    LogRuntimes();
 #ifdef ARCHITECTURE_x86_64
-    const auto& caps = Common::GetCPUCaps();
+    const auto& caps = Common::g_cpu_caps;
    std::string cpu_string = caps.cpu_string;
    if (caps.avx || caps.avx2 || caps.avx512f) {
        cpu_string += " | AVX";
@@ -281,4 +309,19 @@ void SetupHID() {
    system->HIDCore().ReloadInputDevices();
 }

+QString ReadableByteSize(qulonglong size) {
+    return QString::fromStdString(FrontendCommon::DataManager::ReadableBytesSize(size));
+}
+
+QPixmap CreateCirclePixmapFromColor(const QColor& color) {
+    QPixmap circle_pixmap(16, 16);
+    circle_pixmap.fill(Qt::transparent);
+    QPainter painter(&circle_pixmap);
+    painter.setRenderHint(QPainter::Antialiasing);
+    painter.setPen(color);
+    painter.setBrush(color);
+    painter.drawEllipse({circle_pixmap.width() / 2.0, circle_pixmap.height() / 2.0}, 7.0, 7.0);
+    return circle_pixmap;
+}
+
 } // namespace QtCommon
@@ -46,6 +46,20 @@ void SetupHID();
 const QString tr(const char* str);
 const QString tr(const std::string& str);

+// TODO: Find a better place for these
+
+/// Convert a size in bytes into a readable format (KiB, MiB, etc.)
+[[nodiscard]] QString ReadableByteSize(qulonglong size);
+
+/**
+ * Creates a circle pixmap from a specified color
+ * @param color The color the pixmap shall have
+ * @return QPixmap circle pixmap
+ */
+[[nodiscard]] QPixmap CreateCirclePixmapFromColor(const QColor& color);
+
+
+
 std::filesystem::path GetEdenCommand();
 } // namespace QtCommon
 #endif
@@ -33,10 +33,13 @@ QStringList GetModFolders(const QString& root, const QString& fallbackName) {
            std_path = paths[0];

        QString default_name;
-        if (!fallbackName.isEmpty())
-            default_name = fallbackName;
-        else if (!paths.empty())
+
+        // If this is an atmosphere-packed mod, the default name will end up as the game's title ID.
+        // So in this case ignore it and use the zip name instead
+        if (!paths.empty() && std_path.string().find("atmosphere") == std::string::npos)
            default_name = QString::fromStdString(std_path.filename().string());
+        else if (!fallbackName.isEmpty())
+            default_name = fallbackName;
        else
            default_name = root.split(QLatin1Char('/')).last();

@@ -462,6 +462,13 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
    ctx.AddCapability(spv::Capability::ImageGatherExtended);
    ctx.AddCapability(spv::Capability::ImageQuery);
    ctx.AddCapability(spv::Capability::SampledBuffer);
+    // TODO: this usage needs to be tracked properly
+    if (ctx.profile.support_sampled_image_array_nonuniform_indexing) {
+        if (ctx.profile.supported_spirv < 0x00010400)
+            ctx.AddExtension("SPV_EXT_descriptor_indexing");
+        ctx.AddCapability(spv::Capability::ShaderNonUniform);
+        ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);
+    }
 }

 void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
@@ -14,37 +14,10 @@

 namespace Shader::Backend::SPIRV {
 namespace {
-class DescriptorIndex {
-public:
-    explicit DescriptorIndex(EmitContext& ctx, const IR::Value& index)
-        : id{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)},
-          is_non_uniform{ctx.profile.support_sampled_image_array_nonuniform_indexing &&
-                         !index.IsImmediate()} {
-        if (!is_non_uniform) {
-            return;
-        }
-        if (ctx.profile.supported_spirv < 0x00010400) {
-            ctx.AddExtension("SPV_EXT_descriptor_indexing");
-        }
-        ctx.AddCapability(spv::Capability::ShaderNonUniform);
-        ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);
-        Decorate(ctx, id);
-    }

-    Id Value() const {
-        return id;
-    }
-
-    void Decorate(EmitContext& ctx, Id object) const {
-        if (is_non_uniform) {
-            ctx.Decorate(object, spv::Decoration::NonUniform);
-        }
-    }
-
-private:
-    Id id;
-    bool is_non_uniform;
-};
+[[nodiscard]] bool IsNonUniformDescriptor(EmitContext& ctx, const IR::Value& index) noexcept {
+    return ctx.profile.support_sampled_image_array_nonuniform_indexing && !index.IsImmediate();
+}

 class ImageOperands {
 public:
@@ -221,11 +194,13 @@ private:
 Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IR::Value& index) {
    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
    if (def.count > 1) {
-        const DescriptorIndex idx{ctx, index};
-        const Id pointer{ctx.OpAccessChain(def.pointer_type, def.id, idx.Value())};
-        idx.Decorate(ctx, pointer);
+        auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);
+        if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {
+            ctx.Decorate(idx, spv::Decoration::NonUniform);
+            ctx.non_uniform_ids.insert(idx.value);
+        }
+        const Id pointer{ctx.OpAccessChain(def.pointer_type, def.id, idx)};
        const Id object{ctx.OpLoad(def.sampled_type, pointer)};
-        idx.Decorate(ctx, object);
        return object;
    } else {
        return ctx.OpLoad(def.sampled_type, def.id);
@@ -244,13 +219,14 @@ Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& ind
    } else {
        const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
        if (def.count > 1) {
-            const DescriptorIndex idx{ctx, index};
-            const Id ptr{ctx.OpAccessChain(def.pointer_type, def.id, idx.Value())};
-            idx.Decorate(ctx, ptr);
-            const Id object{ctx.OpLoad(def.sampled_type, ptr)};
-            idx.Decorate(ctx, object);
-            const Id image{ctx.OpImage(def.image_type, object)};
-            idx.Decorate(ctx, image);
+            auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);
+            if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {
+                ctx.Decorate(idx, spv::Decoration::NonUniform);
+                ctx.non_uniform_ids.insert(idx.value);
+            }
+            const Id ptr = ctx.OpAccessChain(def.pointer_type, def.id, idx);
+            const Id object = ctx.OpLoad(def.sampled_type, ptr);
+            const Id image = ctx.OpImage(def.image_type, object);
            return image;
        }
        return ctx.OpImage(def.image_type, ctx.OpLoad(def.sampled_type, def.id));
@@ -9,6 +9,7 @@
 #include <array>

 #include <sirit/sirit.h>
+#include <ankerl/unordered_dense.h>

 #include "shader_recompiler/backend/bindings.h"
 #include "shader_recompiler/frontend/ir/program.h"
@@ -366,6 +367,9 @@ public:
    Id load_const_func_u32x2{};
    Id load_const_func_u32x4{};

+    // Sirit::Id doesn't play nice with *::set<>
+    ankerl::unordered_dense::set<u32> non_uniform_ids;
+
 private:
    void DefineCommonTypes(const Info& info);
    void DefineCommonConstants();
@@ -12,6 +12,7 @@
 #include <limits>
 #include <boost/container/small_vector.hpp>

+#include "common/settings.h"
 #include "shader_recompiler/environment.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
@@ -733,9 +734,8 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
            break;
        }
        u32 index;
-        const u32 size_shift{cbuf.count > 1 ? DynamicDescriptorSizeShift(cbuf.dynamic_offset)
-                                            : DESCRIPTOR_SIZE_SHIFT};
-        u32 count{cbuf.count};
+        u32 size_shift = cbuf.count > 1 ? DynamicDescriptorSizeShift(cbuf.dynamic_offset) : DESCRIPTOR_SIZE_SHIFT;
+        u32 count = cbuf.count;
        switch (inst->GetOpcode()) {
        case IR::Opcode::ImageRead:
        case IR::Opcode::ImageAtomicIAdd32:
@@ -821,8 +821,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
            const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
            IR::IREmitter ir{*texture_inst.block, insert_point};
            const IR::U32 shift{ir.Imm32(size_shift)};
-            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift),
-                        ir.Imm32(count - 1)));
+            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift), ir.Imm32(count - 1)));
        } else {
            inst->SetArg(0, IR::Value{});
        }
@@ -754,7 +754,7 @@ void BufferCache<P>::BindHostIndexBuffer() {
        }
    }
    if constexpr (HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const u32 new_offset = offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
+        const u32 new_offset = offset + draw_state.index_buffer.first * u32(draw_state.index_buffer.FormatSizeInBytes());
        runtime.BindIndexBuffer(buffer, new_offset, size);
    } else {
        buffer.MarkUsage(offset, size);
@@ -1252,8 +1252,7 @@ void BufferCache<P>::UpdateIndexBuffer() {
    const GPUVAddr gpu_addr_end = index_buffer_ref.EndAddress();
    const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr_begin);
    const u32 address_size = static_cast<u32>(gpu_addr_end - gpu_addr_begin);
-    const u32 draw_size =
-        (index_buffer_ref.count + index_buffer_ref.first) * index_buffer_ref.FormatSizeInBytes();
+    const u32 draw_size = (index_buffer_ref.count + index_buffer_ref.first) * u32(index_buffer_ref.FormatSizeInBytes());
    const u32 size = (std::min)(address_size, draw_size);
    if (size == 0 || !device_addr) {
        channel_state->index_buffer = NULL_BINDING;
@@ -1620,24 +1619,38 @@ void BufferCache<P>::TouchBuffer(Buffer& buffer, BufferId buffer_id) noexcept {
 template <class P>
 bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 size) {
    upload_copies.clear();
-    u64 total_size_bytes = 0;
+    u64 staging_offset = 0;
    u64 largest_copy = 0;
-    const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
-        upload_copies.push_back(BufferCopy{
-            .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
-            .size = range_size,
+    DAddr buffer_start = buffer.CpuAddr();
+    auto push = [&](u64 start, u64 end) {
+        if (start >= end) {
+            return;
+        }
+        u64 sz = end - start;
+        upload_copies.push_back({
+            .src_offset = staging_offset,
+            .dst_offset = start - buffer_start,
+            .size = sz
        });
-        total_size_bytes += range_size;
-        largest_copy = (std::max)(largest_copy, range_size);
+        staging_offset += sz;
+        largest_copy = (std::max)(largest_copy, sz);
+    };
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 addr, u64 range_size) {
+        u64 start = addr;
+        u64 end = addr + range_size;
+        gpu_modified_ranges.ForEachInRange(start, range_size, [&](u64 gstart, u64 gsize) {
+            u64 gend = gstart + gsize;
+            push(start, gstart);
+            start = (std::max)(start, gend);
+        });
+        push(start, end);
+        ClearDownload(addr, range_size);
+        gpu_modified_ranges.Subtract(addr, range_size);
    });
-    if (total_size_bytes == 0) {
+    if (upload_copies.empty()) {
        return true;
    }
-    const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
-    UploadMemory(buffer, total_size_bytes, largest_copy, copies_span);
-    any_buffer_uploaded = true;
+    UploadMemory(buffer, staging_offset, largest_copy, std::span(upload_copies));
    return false;
 }

@@ -1880,23 +1893,17 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
        return NULL_BINDING;
    }

-    // xbzk: New size logic. Fixes MCI.
-    // If ever the * comment below prove wrong, the 'if' block may be removed.
    const auto size = [&]() {
-        const bool is_nvn_cbuf = cbuf_index == 0;
-        if (is_nvn_cbuf) {
-            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
-            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
-            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
-            // Hardware-based detection: GPU addresses have non-zero upper bits
-            if (upper_32 == 0) {
-                // This is a size field, not a GPU address
-                return static_cast<u32>(next_qword);  // Return lower_32
-            }
+        const u32 memory_layout_size =
+            static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
+        const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
+        const u32 packed_size = static_cast<u32>(next_qword);
+        const bool next_qword_is_size = static_cast<u32>(next_qword >> 32) == 0 &&
+                                        packed_size != 0 &&
+                                        packed_size <= memory_layout_size;
+        if (next_qword_is_size) {
+            return packed_size;
        }
-        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
-        const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
-        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
        return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
    }();

@@ -181,12 +181,12 @@ void DmaPusher::CallMethod(u32 argument) const {
        });
    } else {
        auto subchannel = subchannels[dma_state.subchannel];
-        if (!subchannel->execution_mask[dma_state.method]) {
-            subchannel->method_sink.emplace_back(dma_state.method, argument);
-        } else {
+        if (subchannel->execution_mask[dma_state.method]) {
            subchannel->ConsumeSink();
            subchannel->current_dma_segment = dma_state.dma_get + dma_state.dma_word_offset;
            subchannel->CallMethod(dma_state.method, argument, dma_state.is_last_call);
+        } else {
+            subchannel->method_sink.emplace_back(dma_state.method, argument);
        }
    }
 }
@@ -270,31 +270,20 @@ u32 Maxwell3D::GetMaxCurrentVertices() {
 size_t Maxwell3D::EstimateIndexBufferSize() {
    GPUVAddr start_address = regs.index_buffer.StartAddress();
    GPUVAddr end_address = regs.index_buffer.EndAddress();
-    static constexpr std::array<size_t, 3> max_sizes = {(std::numeric_limits<u8>::max)(),
-                                                        (std::numeric_limits<u16>::max)(),
-                                                        (std::numeric_limits<u32>::max)()};
-    const size_t byte_size = regs.index_buffer.FormatSizeInBytes();
-    const size_t log2_byte_size = Common::Log2Ceil64(byte_size);
-    const size_t cap{GetMaxCurrentVertices() * 4 * byte_size};
-    const size_t lower_cap =
-        std::min<size_t>(static_cast<size_t>(end_address - start_address), cap);
-    return std::min<size_t>(
-        memory_manager.GetMemoryLayoutSize(start_address, byte_size * max_sizes[log2_byte_size]) /
-            byte_size,
-        lower_cap);
+    auto const byte_size = regs.index_buffer.FormatSizeInBytes();
+    auto const max_size = 1ull << (byte_size * CHAR_BIT);
+    auto const upper_cap = GetMaxCurrentVertices() * 4 * byte_size;
+    auto const lower_cap = std::min<size_t>(size_t(end_address - start_address), upper_cap);
+    return std::min<size_t>(memory_manager.GetMemoryLayoutSize(start_address, byte_size * max_size) / byte_size, lower_cap);
 }

 u32 Maxwell3D::ProcessShadowRam(u32 method, u32 argument) {
    // Keep track of the register value in shadow_state when requested.
-    const auto control = shadow_state.shadow_ram_control;
-    if (control == Regs::ShadowRamControl::Track ||
-        control == Regs::ShadowRamControl::TrackWithFilter) {
-        shadow_state.reg_array[method] = argument;
-        return argument;
-    }
-    if (control == Regs::ShadowRamControl::Replay) {
+    auto const c = shadow_state.shadow_ram_control;
+    if (c == Regs::ShadowRamControl::Track || c == Regs::ShadowRamControl::TrackWithFilter)
+        return shadow_state.reg_array[method] = argument;
+    else if (c == Regs::ShadowRamControl::Replay)
        return shadow_state.reg_array[method];
-    }
    return argument;
 }

@@ -317,10 +306,8 @@ void Maxwell3D::ConsumeSinkImpl() {

 void Maxwell3D::ProcessDirtyRegisters(u32 method, u32 argument) {
    regs.reg_array[method] = argument;
-
-    for (const auto& table : dirty.tables) {
+    for (auto const& table : dirty.tables)
        dirty.flags[table[method]] = true;
-    }
 }

 void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argument, bool is_last_call) {
@@ -2215,7 +2215,7 @@ public:
            u32 first;
            u32 count;

-            unsigned FormatSizeInBytes() const {
+            size_t FormatSizeInBytes() const {
                switch (format) {
                case IndexFormat::UnsignedByte:
                    return 1;
@@ -2224,7 +2224,7 @@ public:
                case IndexFormat::UnsignedInt:
                    return 4;
                }
-                ASSERT(false);
+                UNREACHABLE();
                return 1;
            }

@@ -3148,9 +3148,9 @@ public:
    }

    struct DirtyState {
-        using Flags = std::bitset<(std::numeric_limits<u8>::max)()>;
+        using Flags = std::bitset<(std::numeric_limits<u8>::max)() + 1>;
        using Table = std::array<u8, Regs::NUM_REGS>;
-        using Tables = std::array<Table, 2>;
+        using Tables = std::array<std::array<u8, Regs::NUM_REGS>, 2>;

        Flags flags;
        Tables tables{};
@@ -39,7 +39,7 @@ extern "C" {
 #include "video_core/textures/decoders.h"

 #if defined(ARCHITECTURE_x86_64)
-#include "common/x64/cpu_detect.h"
+#include "common/cpu_features.h"
 #endif

 #if defined(ARCHITECTURE_x86_64) \
@@ -55,9 +55,8 @@ namespace Tegra::Host1x {
 namespace {

 static bool HasSSE41() {
-#if defined(ARCHITECTURE_x86_64)
-    static bool has_sse41 = Common::GetCPUCaps().sse4_1;
-    return has_sse41;
+#ifdef ARCHITECTURE_x86_64
+    return Common::g_cpu_caps.sse4_1;
 #else
    return false;
 #endif
@@ -90,7 +90,7 @@ void ComputePipeline::Configure() {
                                              desc.is_written);
        ++ssbo_index;
    }
-    texture_cache.SynchronizeComputeDescriptors();
+    texture_cache.SynchronizeDescriptors(true);

    boost::container::static_vector<VideoCommon::ImageViewInOut, MAX_TEXTURES + MAX_IMAGES> views;
    boost::container::static_vector<VideoCommon::SamplerId, MAX_TEXTURES> samplers;
@@ -148,14 +148,14 @@ void ComputePipeline::Configure() {
            const auto handle{read_handle(desc, index)};
            views.push_back({handle.first});

-            VideoCommon::SamplerId sampler = texture_cache.GetComputeSamplerId(handle.second);
+            VideoCommon::SamplerId sampler = texture_cache.GetSamplerId(handle.second, true);
            samplers.push_back(sampler);
        }
    }
    for (const auto& desc : info.image_descriptors) {
        add_image(desc, desc.is_written);
    }
-    texture_cache.FillComputeImageViews(std::span(views.data(), views.size()));
+    texture_cache.FillImageViews(std::span(views.data(), views.size()), true);

    if (!is_built) {
        WaitForBuild();
@@ -283,7 +283,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
    size_t views_index{};
    size_t samplers_index{};

-    texture_cache.SynchronizeGraphicsDescriptors();
+    texture_cache.SynchronizeDescriptors(false);

    buffer_cache.SetUniformBuffersState(enabled_uniform_buffer_masks, &uniform_buffer_sizes);
    buffer_cache.runtime.SetBaseUniformBindings(base_uniform_bindings);
@@ -354,7 +354,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                const auto handle{read_handle(desc, index)};
                views[views_index++] = {handle.first};

-                VideoCommon::SamplerId sampler{texture_cache.GetGraphicsSamplerId(handle.second)};
+                VideoCommon::SamplerId sampler{texture_cache.GetSamplerId(handle.second, false)};
                samplers[samplers_index++] = sampler;
            }
        }
@@ -379,7 +379,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
    if constexpr (Spec::enabled_stages[4]) {
        config_stage(4);
    }
-    texture_cache.FillGraphicsImageViews<Spec::has_images>(std::span(views.data(), views_index));
+    texture_cache.FillImageViews(std::span(views.data(), views_index), false, Spec::has_images);

    texture_cache.UpdateRenderTargets(false);
    state_tracker.BindFramebuffer(texture_cache.GetFramebuffer()->Handle());
@@ -353,13 +353,13 @@ void RasterizerOpenGL::DrawTexture() {
        gpu.TickWork();
    };

-    texture_cache.SynchronizeGraphicsDescriptors();
+    texture_cache.SynchronizeDescriptors(false);
    texture_cache.UpdateRenderTargets(false);

    SyncState();

    const auto& draw_texture_state = maxwell3d->draw_manager.draw_texture_state;
-    const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
+    const auto& sampler = texture_cache.GetSampler(draw_texture_state.src_sampler, true);
    const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);

    const auto Scale = [&](auto dim) -> s32 {
@@ -436,7 +436,7 @@ void TransitionImageLayout(vk::CommandBuffer& cmdbuf, VkImage image, VkImageLayo
            .layerCount = 1,
        },
    };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                           0, barrier);
 }

@@ -69,7 +69,7 @@ void TransitionImageLayout(vk::CommandBuffer& cmdbuf, VkImage image, VkImageLayo
            .layerCount = 1,
        },
    };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                           0, barrier);
 }

@@ -171,10 +171,10 @@ void DownloadColorImage(vk::CommandBuffer& cmdbuf, VkImage image, VkBuffer buffe
        .imageOffset{.x = 0, .y = 0, .z = 0},
        .imageExtent{extent},
    };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
                           read_barrier);
    cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy);
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0,
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0,
                           memory_write_barrier, nullptr, image_write_barrier);
 }

@@ -8,7 +8,6 @@
 #include <array>
 #include <cstring>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>
@@ -172,11 +171,7 @@ try

 RendererVulkan::~RendererVulkan() {
    scheduler.RegisterOnSubmit([] {});
-    scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        void(device.GetLogical().WaitIdle());
-    }
+    void(device.GetLogical().WaitIdle());
 }

 void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {
@@ -8,7 +8,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <vulkan/vulkan_core.h>
-#include <mutex>
 #include "video_core/framebuffer_config.h"
 #include "video_core/present.h"
 #include "video_core/renderer_vulkan/present/filters.h"
@@ -32,10 +31,7 @@ BlitScreen::~BlitScreen() = default;
 void BlitScreen::WaitIdle() {
    present_manager.WaitPresent();
    scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        device.GetLogical().WaitIdle();
-    }
+    device.GetLogical().WaitIdle();
 }

 void BlitScreen::SetWindowAdaptPass() {
@@ -437,13 +437,13 @@ void BufferCacheRuntime::CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
    scheduler.RequestOutsideRenderPassOperationContext();
    scheduler.Record([src_buffer, dst_buffer, vk_copies, barrier](vk::CommandBuffer cmdbuf) {
        if (barrier) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
        }
        cmdbuf.CopyBuffer(src_buffer, dst_buffer, VideoCommon::FixSmallVectorADL(vk_copies));
        if (barrier) {
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, WRITE_BARRIER);
        }
    });
 }
@@ -457,7 +457,7 @@ void BufferCacheRuntime::PreCopyBarrier() {
    };
    scheduler.RequestOutsideRenderPassOperationContext();
    scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                               0, READ_BARRIER);
    });
 }
@@ -471,7 +471,7 @@ void BufferCacheRuntime::PostCopyBarrier() {
    };
    scheduler.RequestOutsideRenderPassOperationContext();
    scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                               0, WRITE_BARRIER);
    });
 }
@@ -495,10 +495,10 @@ void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t si

    scheduler.RequestOutsideRenderPassOperationContext();
    scheduler.Record([dest_buffer, offset, size, value](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                               0, READ_BARRIER);
        cmdbuf.FillBuffer(dest_buffer, offset, size, value);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                               0, WRITE_BARRIER);
    });
 }
@@ -454,8 +454,8 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
        const VkDescriptorSet set = descriptor_allocator.Commit();
        device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);

-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
+                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
        cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
@@ -537,7 +537,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
            cmdbuf.Dispatch(1, 1, 1);
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, write_barrier);
        });
    }
 }
@@ -589,9 +589,9 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
                .layerCount = VK_REMAINING_ARRAY_LAYERS,
            },
        };
-        cmdbuf.PipelineBarrier(is_initialized ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
-                                              : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
+        cmdbuf.PipelineBarrier(is_initialized ? vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER
+                              : VkPipelineStageFlags(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT),
+                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
    });
    for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
@@ -648,7 +648,7 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
            },
        };
        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, image_barrier);
+                       vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, image_barrier);
    });
    scheduler.Finish();
 }
@@ -125,7 +125,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
        ++ssbo_index;
    }

-    texture_cache.SynchronizeComputeDescriptors();
+    texture_cache.SynchronizeDescriptors(true);

    boost::container::small_vector<VideoCommon::ImageViewInOut, 64> views;
    boost::container::small_vector<VideoCommon::SamplerId, 64> samplers;
@@ -173,14 +173,14 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
            const auto handle{read_handle(desc, index)};
            views.push_back({handle.first});

-            VideoCommon::SamplerId sampler = texture_cache.GetComputeSamplerId(handle.second);
+            VideoCommon::SamplerId sampler = texture_cache.GetSamplerId(handle.second, true);
            samplers.push_back(sampler);
        }
    }
    for (const auto& desc : info.image_descriptors) {
        add_image(desc, desc.is_written);
    }
-    texture_cache.FillComputeImageViews(std::span(views.data(), views.size()));
+    texture_cache.FillImageViews(std::span(views.data(), views.size()), true);

    buffer_cache.UnbindComputeTextureBuffers();
    size_t index{};
@@ -49,7 +49,6 @@ using VideoCore::Surface::PixelFormatFromDepthFormat;
 using VideoCore::Surface::PixelFormatFromRenderTargetFormat;

 constexpr size_t NUM_STAGES = Maxwell::MaxShaderStage;
-constexpr size_t INLINE_IMAGE_ELEMENTS = 64;

 DescriptorLayoutBuilder MakeBuilder(const Device& device, std::span<const Shader::Info> infos) {
    DescriptorLayoutBuilder builder{device};
@@ -314,12 +313,12 @@ void GraphicsPipeline::AddTransition(GraphicsPipeline* transition) {

 template <typename Spec>
 bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
-    small_vector<VideoCommon::ImageViewInOut, INLINE_IMAGE_ELEMENTS> views;
-    small_vector<VideoCommon::SamplerId, INLINE_IMAGE_ELEMENTS> samplers;
+    boost::container::small_vector<VideoCommon::ImageViewInOut, 64> views;
+    boost::container::small_vector<VideoCommon::SamplerId, 64> samplers;
    views.reserve(num_image_elements);
    samplers.reserve(num_textures);

-    texture_cache.SynchronizeGraphicsDescriptors();
+    texture_cache.SynchronizeDescriptors(false);

    buffer_cache.SetUniformBuffersState(enabled_uniform_buffer_masks, &uniform_buffer_sizes);

@@ -384,7 +383,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                const auto handle{read_handle(desc, index)};
                views.push_back({handle.first});

-                VideoCommon::SamplerId sampler{texture_cache.GetGraphicsSamplerId(handle.second)};
+                VideoCommon::SamplerId sampler{texture_cache.GetSamplerId(handle.second, false)};
                samplers.push_back(sampler);
            }
        }
@@ -413,7 +412,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
    }
    ASSERT(views.size() == num_image_elements);
    ASSERT(samplers.size() == num_textures);
-    texture_cache.FillGraphicsImageViews<Spec::has_images>(std::span(views.data(), views.size()));
+    texture_cache.FillImageViews(std::span(views.data(), views.size()), false, Spec::has_images);

    VideoCommon::ImageViewInOut* texture_buffer_it{views.data()};
    const auto bind_stage_info{[&](size_t stage) LAMBDA_FORCEINLINE {
@@ -492,8 +492,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        device.IsExtExtendedDynamicState3BlendingSupported();
    dynamic_features.has_extended_dynamic_state_3_enables =
        device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        device.SupportsDynamicState3DepthClampEnable();
+    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
    dynamic_features.has_dynamic_state3_logic_op_enable =
        device.SupportsDynamicState3LogicOpEnable();
    dynamic_features.has_dynamic_state3_line_stipple_enable =
@@ -429,7 +429,7 @@ void PresentManager::CopyToSwapchainImpl(Frame* frame) {
        },
    };

-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, {},
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT, {},
                           {}, {}, pre_barriers);

    if (blit_supported) {
@@ -157,9 +157,8 @@ public:
        ReserveHostQuery();

        scheduler.Record([query_pool = current_query_pool,
-                          query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
+                                 query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
            const bool use_precise = Settings::IsGPULevelHigh();
-            cmdbuf.ResetQueryPool(query_pool, static_cast<u32>(query_index), 1);
            cmdbuf.BeginQuery(query_pool, static_cast<u32>(query_index),
                              use_precise ? VK_QUERY_CONTROL_PRECISE_BIT : 0);
        });
@@ -221,7 +220,8 @@ public:
        }
        PauseCounter();
        const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
            pending_sync.clear();
            sync_values_stash.clear();
            return;
@@ -846,7 +846,7 @@ public:
        scheduler.RequestOutsideRenderPassOperationContext();
        scheduler.Record([](vk::CommandBuffer cmdbuf) {
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_HOST, 0, WRITE_BARRIER);
        });

        std::scoped_lock lk(flush_guard);
@@ -1587,13 +1587,13 @@ void QueryCacheRuntime::Barriers(bool is_prebarrier) {
    impl->scheduler.RequestOutsideRenderPassOperationContext();
    if (is_prebarrier) {
        impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
        });
    } else {
        impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER_HOST, 0, WRITE_BARRIER);
        });
    }
 }
@@ -351,7 +351,7 @@ void RasterizerVulkan::DrawTexture() {
    FlushWork();

    std::scoped_lock l{texture_cache.mutex};
-    texture_cache.SynchronizeGraphicsDescriptors();
+    texture_cache.SynchronizeDescriptors(false);
    texture_cache.UpdateRenderTargets(false);

    UpdateDynamicStates();
@@ -359,7 +359,7 @@ void RasterizerVulkan::DrawTexture() {
    query_cache.NotifySegment(true);
    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, maxwell3d->regs.zpass_pixel_count_enable);
    const auto& draw_texture_state = maxwell3d->draw_manager.draw_texture_state;
-    const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
+    const auto& sampler = texture_cache.GetSampler(draw_texture_state.src_sampler, false);
    const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
    const auto* framebuffer = texture_cache.GetFramebuffer();

@@ -580,7 +580,7 @@ void RasterizerVulkan::DispatchCompute() {
        .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
    };
-    scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+    scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                               0, READ_BARRIER); });
    scheduler.Record([dim](vk::CommandBuffer cmdbuf) { cmdbuf.Dispatch(dim[0], dim[1], dim[2]); });

@@ -267,8 +267,7 @@ u64 Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_se
            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
            .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
        };
-        upload_cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                      VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+        upload_cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
        upload_cmdbuf.End();
        cmdbuf.End();

@@ -372,7 +371,7 @@ void Scheduler::EndRenderPass()
            }
            cmdbuf.EndRenderPass();
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
-                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                   0, nullptr, nullptr, vk::Span(barriers.data(), num_images));
        });

@@ -24,11 +24,8 @@ using namespace Dirty;
 using namespace VideoCommon::Dirty;
 using Tegra::Engines::Maxwell3D;
 using Regs = Maxwell3D::Regs;
-using Tables = Maxwell3D::DirtyState::Tables;
-using Table = Maxwell3D::DirtyState::Table;
-using Flags = Maxwell3D::DirtyState::Flags;

-Flags MakeInvalidationFlags() {
+Maxwell3D::DirtyState::Flags MakeInvalidationFlags() {
    static constexpr int INVALIDATION_FLAGS[]{
        Viewports,
        Scissors,
@@ -68,7 +65,7 @@ Flags MakeInvalidationFlags() {
        LineStippleEnable,
        LineStippleParams,
    };
-    Flags flags{};
+    Maxwell3D::DirtyState::Flags flags{};
    for (const int flag : INVALIDATION_FLAGS) {
        flags[flag] = true;
    }
@@ -84,7 +81,7 @@ Flags MakeInvalidationFlags() {
    return flags;
 }

-void SetupDirtyViewports(Tables& tables) {
+void SetupDirtyViewports(Maxwell3D::DirtyState::Tables& tables) {
    FillBlock(tables[0], OFF(viewport_transform), NUM(viewport_transform), Viewports);
    FillBlock(tables[0], OFF(viewports), NUM(viewports), Viewports);
    FillBlock(tables[1], OFF(surface_clip), NUM(surface_clip), Viewports);
@@ -92,26 +89,26 @@ void SetupDirtyViewports(Tables& tables) {
    tables[1][OFF(window_origin)] = Viewports;
 }

-void SetupDirtyScissors(Tables& tables) {
+void SetupDirtyScissors(Maxwell3D::DirtyState::Tables& tables) {
    FillBlock(tables[0], OFF(scissor_test), NUM(scissor_test), Scissors);
 }

-void SetupDirtyDepthBias(Tables& tables) {
+void SetupDirtyDepthBias(Maxwell3D::DirtyState::Tables& tables) {
    auto& table = tables[0];
    table[OFF(depth_bias)] = DepthBias;
    table[OFF(depth_bias_clamp)] = DepthBias;
    table[OFF(slope_scale_depth_bias)] = DepthBias;
 }

-void SetupDirtyBlendConstants(Tables& tables) {
+void SetupDirtyBlendConstants(Maxwell3D::DirtyState::Tables& tables) {
    FillBlock(tables[0], OFF(blend_color), NUM(blend_color), BlendConstants);
 }

-void SetupDirtyDepthBounds(Tables& tables) {
+void SetupDirtyDepthBounds(Maxwell3D::DirtyState::Tables& tables) {
    FillBlock(tables[0], OFF(depth_bounds), NUM(depth_bounds), DepthBounds);
 }

-void SetupDirtyStencilProperties(Tables& tables) {
+void SetupDirtyStencilProperties(Maxwell3D::DirtyState::Tables& tables) {
    const auto setup = [&](size_t position, u8 flag) {
        tables[0][position] = flag;
        tables[1][position] = StencilProperties;
@@ -125,18 +122,18 @@ void SetupDirtyStencilProperties(Tables& tables) {
    setup(OFF(stencil_back_func_mask), StencilCompare);
 }

-void SetupDirtyLineWidth(Tables& tables) {
+void SetupDirtyLineWidth(Maxwell3D::DirtyState::Tables& tables) {
    tables[0][OFF(line_width_smooth)] = LineWidth;
    tables[0][OFF(line_width_aliased)] = LineWidth;
 }

-void SetupDirtyCullMode(Tables& tables) {
+void SetupDirtyCullMode(Maxwell3D::DirtyState::Tables& tables) {
    auto& table = tables[0];
    table[OFF(gl_cull_face)] = CullMode;
    table[OFF(gl_cull_test_enabled)] = CullMode;
 }

-void SetupDirtyStateEnable(Tables& tables) {
+void SetupDirtyStateEnable(Maxwell3D::DirtyState::Tables& tables) {
    const auto setup = [&](size_t position, u8 flag) {
        tables[0][position] = flag;
        tables[1][position] = StateEnable;
@@ -157,17 +154,17 @@ void SetupDirtyStateEnable(Tables& tables) {
    setup(OFF(anti_alias_alpha_control.alpha_to_one), AlphaToOneEnable);
 }

-void SetupDirtyDepthCompareOp(Tables& tables) {
+void SetupDirtyDepthCompareOp(Maxwell3D::DirtyState::Tables& tables) {
    tables[0][OFF(depth_test_func)] = DepthCompareOp;
 }

-void SetupDirtyFrontFace(Tables& tables) {
+void SetupDirtyFrontFace(Maxwell3D::DirtyState::Tables& tables) {
    auto& table = tables[0];
    table[OFF(gl_front_face)] = FrontFace;
    table[OFF(window_origin)] = FrontFace;
 }

-void SetupDirtyStencilOp(Tables& tables) {
+void SetupDirtyStencilOp(Maxwell3D::DirtyState::Tables& tables) {
    auto& table = tables[0];
    table[OFF(stencil_front_op.fail)] = StencilOp;
    table[OFF(stencil_front_op.zfail)] = StencilOp;
@@ -182,7 +179,7 @@ void SetupDirtyStencilOp(Tables& tables) {
    tables[1][OFF(stencil_two_side_enable)] = StencilOp;
 }

-void SetupDirtyBlending(Tables& tables) {
+void SetupDirtyBlending(Maxwell3D::DirtyState::Tables& tables) {
    tables[0][OFF(color_mask_common)] = Blending;
    tables[1][OFF(color_mask_common)] = ColorMask;
    tables[0][OFF(blend_per_target_enabled)] = Blending;
@@ -196,11 +193,11 @@ void SetupDirtyBlending(Tables& tables) {
    FillBlock(tables[1], OFF(blend_per_target), NUM(blend_per_target), BlendEquations);
 }

-void SetupDirtySpecialOps(Tables& tables) {
+void SetupDirtySpecialOps(Maxwell3D::DirtyState::Tables& tables) {
    tables[0][OFF(logic_op.op)] = LogicOp;
 }

-void SetupDirtyViewportSwizzles(Tables& tables) {
+void SetupDirtyViewportSwizzles(Maxwell3D::DirtyState::Tables& tables) {
    static constexpr size_t swizzle_offset = 6;
    for (size_t index = 0; index < Regs::NumViewports; ++index) {
        tables[1][OFF(viewport_transform) + index * NUM(viewport_transform[0]) + swizzle_offset] =
@@ -208,7 +205,7 @@ void SetupDirtyViewportSwizzles(Tables& tables) {
    }
 }

-void SetupDirtyVertexAttributes(Tables& tables) {
+void SetupDirtyVertexAttributes(Maxwell3D::DirtyState::Tables& tables) {
    for (size_t i = 0; i < Regs::NumVertexAttributes; ++i) {
        const size_t offset = OFF(vertex_attrib_format) + i * NUM(vertex_attrib_format[0]);
        FillBlock(tables[0], offset, NUM(vertex_attrib_format[0]), VertexAttribute0 + i);
@@ -216,7 +213,7 @@ void SetupDirtyVertexAttributes(Tables& tables) {
    FillBlock(tables[1], OFF(vertex_attrib_format), Regs::NumVertexAttributes, VertexInput);
 }

-void SetupDirtyVertexBindings(Tables& tables) {
+void SetupDirtyVertexBindings(Maxwell3D::DirtyState::Tables& tables) {
    // Do NOT include stride here, it's implicit in VertexBuffer
    static constexpr size_t divisor_offset = 3;
    for (size_t i = 0; i < Regs::NumVertexArrays; ++i) {
@@ -228,7 +225,7 @@ void SetupDirtyVertexBindings(Tables& tables) {
    }
 }

-void SetupRasterModes(Tables &tables) {
+void SetupRasterModes(Maxwell3D::DirtyState::Tables &tables) {
    auto& table = tables[0];

    table[OFF(line_stipple_params)] = LineStippleParams;
@@ -860,12 +860,12 @@ void BlitScale(Scheduler& scheduler, VkImage src_image, VkImage dst_image, const
                .subresourceRange = subresource_range,
            },
        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, nullptr, nullptr, read_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, nullptr, nullptr, read_barriers);
        cmdbuf.BlitImage(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image,
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, regions, vk_filter);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, nullptr, nullptr, write_barriers);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, nullptr, nullptr, write_barriers);
    });
 }
 } // Anonymous namespace
@@ -1123,19 +1123,19 @@ void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
                .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
            },
        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, {}, {}, pre_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, {}, {}, pre_barriers);

        cmdbuf.CopyImageToBuffer(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, copy_buffer,
                                 vk_in_copies);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, WRITE_BARRIER, nullptr, middle_in_barrier);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, WRITE_BARRIER, nullptr, middle_in_barrier);

-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, READ_BARRIER, {}, middle_out_barrier);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, READ_BARRIER, {}, middle_out_barrier);
        cmdbuf.CopyBufferToImage(copy_buffer, dst_image, VK_IMAGE_LAYOUT_GENERAL, vk_out_copies);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, {}, {}, post_barriers);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, {}, {}, post_barriers);
    });
 }

@@ -1261,8 +1261,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                .layerCount = VK_REMAINING_ARRAY_LAYERS,
            },
        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, nullptr, nullptr, read_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, nullptr, nullptr, read_barriers);
        if (is_resolve) {
            cmdbuf.ResolveImage(src_image, VK_IMAGE_LAYOUT_GENERAL, dst_image,
                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
@@ -1274,8 +1274,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                src_image, VK_IMAGE_LAYOUT_GENERAL, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                MakeImageBlit(dst_region, src_region, dst_layers, src_layers), vk_filter);
        }
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, write_barrier);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, write_barrier);
    });
 }

@@ -1852,7 +1852,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                        .layerCount = VK_REMAINING_ARRAY_LAYERS,
                    },
                };
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                       0, read_barrier);

                for (size_t index = 0; index < buffers.size(); index++) {
@@ -1884,7 +1884,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                        .layerCount = VK_REMAINING_ARRAY_LAYERS,
                    },
                };
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                       0, memory_write_barrier, nullptr, image_write_barrier);
            });
            return;
@@ -1919,7 +1919,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                    .layerCount = VK_REMAINING_ARRAY_LAYERS,
                },
            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                   0, read_barrier);

            for (size_t index = 0; index < buffers.size(); index++) {
@@ -1951,7 +1951,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                    .layerCount = VK_REMAINING_ARRAY_LAYERS,
                },
            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                   0, memory_write_barrier, nullptr, image_write_barrier);
        });
    }
@@ -2524,8 +2524,8 @@ void TextureCacheRuntime::TransitionImageLayout(Image& image) {
        };
        scheduler.RequestOutsideRenderPassOperationContext();
        scheduler.Record([barrier](vk::CommandBuffer cmdbuf) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, barrier);
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, barrier);
        });
    }
 }
@@ -254,11 +254,12 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
    static constexpr u64 SELF_BRANCH_A = 0xE2400FFFFF87000FULL;
    static constexpr u64 SELF_BRANCH_B = 0xE2400FFFFF07000FULL;

+    code.resize(MAXIMUM_SIZE / INST_SIZE);
+
    GPUVAddr guest_addr{program_base + start_address};
    size_t offset{0};
    size_t size{BLOCK_SIZE};
    while (size <= MAXIMUM_SIZE) {
-        code.resize(size / INST_SIZE);
        u64* const data = code.data() + offset / INST_SIZE;
        gpu_memory->ReadBlock(guest_addr, data, BLOCK_SIZE);
        for (size_t index = 0; index < BLOCK_SIZE; index += INST_SIZE) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
crueter	f9149025ea	debug	2026-06-02 04:58:50 +02:00
crueter	cc8451f764	[desktop] Rework game list to use MVP architecture (#4042 ) Closes #3480 moves the game list model/worker/private stuff to qt_common for later use in QML - `qt_common/game_list/model.{cpp,h}` is the model - `yuzu/game/game_{grid,tree}.*` are the views - `yuzu/game/game_list.cpp` is the presenter This was done very lazily in a manner that "works" while largely maintaining existing structure as much as possible. Most of it is copy-paste, with some bonus reworks/cleanups thrown in. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4042 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>	2026-06-02 04:08:24 +02:00
crueter	27189f39d2	[desktop] Prefer extracred folder name over zip name for non-Atmosphere zip mods (#4043 ) e.g. Serfrost's Defogger will now be named "Serfrosts Defogger" by default, instead of "serfrosts_base_defogger_v2-4" Note that for atmosphere mods it still uses the zip folder name, since otherwise their default name will just be the game's Title ID. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4043 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-06-02 04:08:09 +02:00
crueter	683e6249c3	[cmake] Allow building OpenSSL from source (#4032 ) If YUZU_USE_BUNDLED_OPENSSL is off and OpenSSL is not installed to the system, pulls in OpenSSL and Jimmy Park's CMake wrapper, then configures + builds from source. Some patches were made on top of OpenSSL and openssl-cmake: - USE_CCACHE is respected from UseCcache.cmake - CXX/CFLAGS are passed from CMake to the configure script, which sends those to the compiler - Uses a bundled cert.h akin to the bundled OpenSSL build Closes #3614 ~~Before merge: remove verbose stuff~~ actually useful so nvm Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4032 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>	2026-06-02 03:40:28 +02:00
crueter	eaece15dbd	[svc] Stub BreakDebugProcess (#4044 ) Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4044 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>	2026-06-02 03:33:38 +02:00
xbzk	8e5419209c	[video,buffer] rewrite storagebufferbinding size() lambda to be full data driven instead of cbuf_index based (#4041 ) fixes an yxzx era bug where eden assumed NVN-style packed SSBO descriptors (u64 gpu_addr followed by size) only happen in cbuf_index == 0. Mega Man Star Force Collection proves that assumption is false. It has an unbiased/global-memory SSBO descriptor in cbuf_index == 3, offsets 0x100/0x300, but the descriptor still appears to be { address, size }. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4041 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-06-02 03:31:59 +02:00
lizzie	8fac95dcc0	[vk] Fix regressions introduced by #3997 w.r.t to marked stages for pipeline barriers (#4037 ) evil barriers :) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4037 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-06-02 01:28:39 +02:00
crueter	706a3d0764	[cmake] Disable `no-cast-function-type-mismatch` on Clang 19 (#4038 ) Suppresses this annoying warning during Android builds Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4038 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-06-02 01:28:16 +02:00
CamilleLaVey	3d19743d95	[vulkan] Fix regressions found in last stable release (#3953 ) This PR aims to fix some regressions found in the latest release 0.2.0, which were a bunch of constant crashes/ random on certain Android devices with issues with the PiP configuration, addressing some problems founds for AMD after the maintenance of 2nd Global Vulkan Maintenance. -> Fixes Final Fantasy Tactics on AMD (no longer requires of generic bits to work "all commands bit") -> Fixes some performance regressions on android due to the Tomodachi fix applied globally as common behavior (#3898, #3900) -> Fixes blittering of screen found on ARM Windows devices and QCOM stock drivers (Android and ARM Windows) related to Mario Kart 8 Deluxe strange blittering in races, caused by a strange race condition with the ResetQueryPool and mostly the workaround for presync -> Fixes issues on Luigi's Mansion 3 issue where the pause screen became black on AMD due to the early reset of queries. -> Fixes crashes on Mario Party Jamboree for AMD/ Nvidia. -> Keeps previous fixes related to crashes on AMD with other games such as Astral Chain, Fire Emblem Three Houses and Xenoblade 3 based on the lack of access to vertex fragment replaced with generic flags. -> Fixes TOTK RADV skybox lighting. -------- Credits: @melod-y @Gidoly @MaranBr @AlexWolff @Lizzie And all the people who contributed into the reporting issues/ helping with the bisect. Co-authored-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3953 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-06-02 01:06:12 +02:00
crueter	bd2d344040	[desktop] Restore metal layer search (#4033 ) This was cut out in #3916 by accident. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4033	2026-05-31 04:19:49 +02:00
lizzie	5f4a286046	[dynarmic] cleanup duplicate code and reimpls of std::* bit stuff (#4017 ) A bit of a minor cleanup - std::rotr instead of mcl::bit::rotate_right - std::rotl likewise - std::popcount instaed of "count ones" - use ConvertRoundingModeToX64Immediate where appropiate - std integral Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4017 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-31 04:18:12 +02:00
crueter	b7fcec4985	[desktop] Increase rlimit on UNIX/Apple (#4030 ) Sets max open fd limit to 8192 on non-windows platforms (or bounds it to the system hard limit). Complement to the previous VFS PR. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4030 Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-05-31 04:13:56 +02:00
MaranBr	0473747f94	[am] Fix application state notification (#4027 ) This fixed issues in Mario Kart 8 multiplayer where the native controller applet would pop up, then once A was pressed and it exited, it would freeze the game but music would continue playing. The issue was that UpdateRequestedFocusState() updates the focus state but never sets m_has_focus_state_changed for applications. Since ShouldSignalSystemEvent() checks that flag for applications, they never receive FocusStateChanged messages when LLE library applets exit. The game keeps running (hence the music) but is stuck waiting for a focus notification that never arrives. HLE applets aren't affected because their dummy process has is_process_running=false, so the game is never considered obscured in the first place. Credits: [davidcollini](https://github.com/davidcollini) Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4027 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-31 03:55:12 +02:00
lizzie	23bb909bc9	[audio_core] fix OOB copy when silencing channel on shutdown (#3969 ) when shutting down the emulator will silence any remaining audio from the output buffer however this is for some reason stored in an array instead of being a simple memset additionally, said array can be small enough (`frame_size_bytes > silence.size()`) to cause a funky noise to play at the end Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3969 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-31 02:38:26 +02:00
lizzie	e94ac63a5e	[common/thread] fix MSVC build error with _rdstc (#4029 ) fixes issue reported by @bruno Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4029 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-31 02:32:21 +02:00
Eden CI	88ff086d13	[dist, android] Update translations from Transifex for May 30 (#4028 ) Automatic translation update for May 30 Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4028 Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-05-31 02:32:12 +02:00
lizzie	116377f6d9	[vk] fix oversight with #3874 with invalid image ids (#4026 ) oopsie, forgot we had a GC fixes SSBU Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4026 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-30 21:59:18 +02:00
lizzie	7c32cf03a1	[core/core_timing] better MWAITX and WAITPKG delays (#3984 ) This implements MWAITX and WAITPKG extensions (umonitor, mwait) for CPUs that support them. Reduces wait times and bypasses the timing stuff from the OS that is slow (windows notably). generally it should answer within 0.2 to 0.5 microsecs (since most requests wait for that long). Also does a general rework of static ctors and stuff Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3984 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-30 21:59:10 +02:00
Yang Liu	ff7bbaea7d	[dynarmic] bootstrap loongarch64 host build (#4015 ) Minimal additions to make Eden compile. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4015 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-05-30 01:42:23 +02:00
MaranBr	c84d605426	[buffer_cache] Fix buffer upload overwriting GPU-modified regions (#4000 ) This fixes a bug in Super Mario Odyssey, in Bowser's Kingdom, where particles rapidly freeze and unfreeze in midair. It also fixes vertex explosions in Super Mario Party Jamboree. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4000 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-05-29 14:01:06 +02:00
lizzie	def03f6589	[video_core] fix redundant resize-copy overload and just use default-init resize, to reduce stutter on Mario BP (#3874 ) before vs. after Mario Brothership kept remaking vectors of sizes 256 AND 4095 (TIC) and 1215 AND 524287 (TSC) every single frame, which resulted in a noticeable overhead the main cause was because of using `resize(n, c)` instead of `resize(n)` (also to aggressively resize for more room beforehand), the copy overload of resize does a copy of... well.. the value over the entire vector, additionally __append() keeps getting called because the capacity goes bonkers and all over the place ![image](/attachments/e3ba07fb-1c85-4d56-9b81-bb16a8150c15) ![image](/attachments/5c4eba26-015a-4c95-9b24-b41695a62e51) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3874 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-05-29 03:28:47 +02:00
lizzie	5ea24621cf	[vk] fix LM3 and TL:LTD multiple NonUniform annotations (#3997 ) should fix AMD Signed-off-by: lizzie lizzie@eden-emu.dev Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3997 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-05-29 03:28:10 +02:00
crueter	251a3470dc	[desktop] Set max stdio limit to 2048 on MSVCRT environments (#4023 ) Such as MINGW64. I legitimately don't have an explanation for this. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4023 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>	2026-05-28 21:22:28 +02:00
crueter	08f65cbd01	[frontend] Fix auto updater flavors on Windows (#4019 ) Matches the build ID and compiler now. Note that this could still use some work on the Windows side of things. Ideally, it would just replace the executables in place; however, I think using the setup files will be better. Most of my concerns w.r.t this issue is that users will want to install multiple in the same place; however, I think it's fair to just not support the older versions at all for now. If users really want to do that, they can use the portable versions and cry about it. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4019 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev>	2026-05-28 20:36:16 +02:00
lizzie	8fd495f906	[video_core] fix std::bitset<> dirty tracker OOB, fix slightly wrong index format estimate (#4006 ) u8 may have been 0xff, (aka. 255), but bitset was only 255 elements, so doing bitset[255] is technically OOB additionally the max size estimate for index formats was not correct, there can be up to 256 elements with a u8 format index, not just 255 Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4006 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-05-27 00:04:27 +02:00