[vulkan] Restored Presync + ConditionalRendering workaround for QCOM drivers

[vulkan] Add EAC formats on the query format table
[vic] Update logging for codec used
2026-08-14 12:56:09 +00:00 · 2026-07-07 23:26:53 -04:00 · 2026-07-07 23:21:41 -04:00 · 2026-07-07 22:27:19 -04:00 · 2026-07-07 20:39:28 -04:00 · 2026-07-07 20:13:56 -04:00
171 changed files with 5288 additions and 3146 deletions
@@ -0,0 +1,20 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 16c6092..9e75548 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -8,7 +8,14 @@ project(adrenotools LANGUAGES CXX C)
+ 
+ set(GEN_INSTALL_TARGET OFF CACHE BOOL "")
+ 
+-add_subdirectory(lib/linkernsbypass)
+include(CPM)
+set(CPM_USE_LOCAL_PACKAGES OFF)
+
+CPMAddPackage(
+    NAME linkernsbypass
+    URL "https://github.com/bylaws/liblinkernsbypass/archive/aa3975893d.zip"
+    URL_HASH SHA512=43d3d146facb7ec99d066a9b8990369ab7b9eec0d5f9a67131b0a0744fde0af27d884ca1f2a272cd113718a23356530ed97703c8c0659c4c25948d50c106119e
+)
+ 
+ set(LIB_SOURCES src/bcenabler.cpp
+                 src/driver.cpp
@@ -1,26 +0,0 @@
-From 52bbc5af6523daa22ad62fe4b84bc8d623d11a53 Mon Sep 17 00:00:00 2001
-From: crueter <crueter@eden-emu.dev>
-Date: Fri, 26 Jun 2026 01:09:40 -0400
-Subject: [PATCH] use cpmfile def for linkernsbypass
-
---
- CMakeLists.txt | 3 ++-
- 1 file changed, 2 insertions(+), 1 deletion(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 16c6092..85b242c 100644
--- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -8,7 +8,8 @@ project(adrenotools LANGUAGES CXX C)
- 
- set(GEN_INSTALL_TARGET OFF CACHE BOOL "")
- 
-add_subdirectory(lib/linkernsbypass)
-+include(CPMUtil)
-+AddJsonPackage(linkernsbypass)
- 
- set(LIB_SOURCES src/bcenabler.cpp
-                 src/driver.cpp
-- 
-2.54.0
-
@@ -270,7 +270,7 @@ if (ANDROID AND YUZU_DOWNLOAD_ANDROID_VVL)
    set(abi ${CMAKE_ANDROID_ARCH_ABI})

    set(vvl_lib_path "${CMAKE_CURRENT_SOURCE_DIR}/src/android/app/src/main/jniLibs/${abi}/")
-    file(COPY "${vulkan-validation-layers_SOURCE_DIR}/${abi}/libVkLayer_khronos_validation.so"
+    file(COPY "${VVL_SOURCE_DIR}/${abi}/libVkLayer_khronos_validation.so"
        DESTINATION "${vvl_lib_path}")
 endif()

@@ -3,10 +3,11 @@
        "hash": "1229f345b014f7ca544dedb4edb3311e41ba736f9aa9a67f88b5f26f3c983288c6bb6cdedcfb0b8a02c63088a37e6a0d7ba97d9c2a4d721b213916327cffe28a",
        "min_version": "0.9.1",
        "repo": "lioncash/biscuit",
-        "version": "v0.19.0"
+        "tag": "v%VERSION%",
+        "version": "0.19.0"
    },
    "boost": {
-        "artifact": "%VERSION%-cmake.tar.xz",
+        "artifact": "%TAG%-cmake.tar.xz",
        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
        "min_version": "1.57",
@@ -15,13 +16,15 @@
            "0001-clang-cl.patch"
        ],
        "repo": "boostorg/boost",
-        "version": "boost-1.90.0"
+        "tag": "boost-%VERSION%",
+        "version": "1.90.0"
    },
    "boost_headers": {
        "bundled": true,
        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
        "repo": "boostorg/headers",
-        "version": "boost-1.90.0"
+        "tag": "boost-%VERSION%",
+        "version": "1.90.0"
    },
    "catch2": {
        "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",
@@ -31,7 +34,8 @@
            "0001-solaris-isnan-fix.patch"
        ],
        "repo": "catchorg/Catch2",
-        "version": "v3.13.0"
+        "tag": "v%VERSION%",
+        "version": "3.13.0"
    },
    "cpp-jwt": {
        "find_args": "CONFIG",
@@ -44,7 +48,8 @@
            "0001-fix-missing-decl.patch"
        ],
        "repo": "arun11299/cpp-jwt",
-        "version": "7f24eb4c32"
+        "sha": "7f24eb4c32",
+        "version": "1.5.1"
    },
    "cubeb": {
        "find_args": "CONFIG",
@@ -56,26 +61,31 @@
            "BUNDLE_SPEEX ON"
        ],
        "repo": "mozilla/cubeb",
-        "version": "fa02160712"
+        "sha": "fa02160712",
+        "version": "0.0.0"
    },
    "discord-rpc": {
        "find_args": "MODULE",
        "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3",
        "package": "DiscordRPC",
        "repo": "eden-emulator/discord-rpc",
-        "version": "0d8b2d6a37"
+        "sha": "0d8b2d6a37",
+        "version": "3.4.1"
    },
    "enet": {
        "find_args": "MODULE",
        "hash": "a0d2fa8c957704dd49e00a726284ac5ca034b50b00d2b20a94fa1bbfbb80841467834bfdc84aa0ed0d6aab894608fd6c86c3b94eee46343f0e6d9c22e391dbf9",
        "min_version": "1.3",
        "repo": "lsalzman/enet",
-        "version": "v1.3.18"
+        "tag": "v%VERSION%",
+        "version": "1.3.18"
    },
    "ffmpeg": {
+        "bundled": true,
        "hash": "ed177621176b3961bdcaa339187d3a7688c1c8b060b79c4bb0257cbc67ad7021ae5d5adca5303b45625abbbe3d9aafdd87ce777b8690ac295290d744c875489a",
        "repo": "FFmpeg/FFmpeg",
-        "version": "c7b5f1537d"
+        "sha": "c7b5f1537d",
+        "version": "8.0.1"
    },
    "ffmpeg-ci": {
        "ci": true,
@@ -89,20 +99,23 @@
        "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
        "min_version": "8",
        "repo": "fmtlib/fmt",
+        "tag": "%VERSION%",
        "version": "12.1.0"
    },
    "frozen": {
        "hash": "b8dfe741c82bc178dfc9749d4ab5a130cee718d9ee7b71d9b547cf5f7f23027ed0152ad250012a8546399fcc1e12187efc68d89d6731256c4d2df7d04eef8d5c",
        "package": "frozen",
        "repo": "serge-sans-paille/frozen",
-        "version": "61dce5ae18"
+        "sha": "61dce5ae18",
+        "version": "1.2.0"
    },
    "gamemode": {
        "find_args": "MODULE",
        "hash": "e87ec14ed3e826d578ebf095c41580069dda603792ba91efa84f45f4571a28f4d91889675055fd6f042d7dc25b0b9443daf70963ae463e38b11bcba95f4c65a9",
        "min_version": "1.7",
        "repo": "FeralInteractive/gamemode",
-        "version": "ce6fe122f3"
+        "sha": "ce6fe122f3",
+        "version": "1.8.2"
    },
    "httplib": {
        "find_args": "MODULE GLOBAL",
@@ -115,20 +128,23 @@
            "0001-mingw.patch"
        ],
        "repo": "yhirose/cpp-httplib",
-        "version": "v0.46.0"
+        "tag": "v%VERSION%",
+        "version": "0.46.0"
    },
    "lagoon": {
        "hash": "b9380f99c6effaeccc6d8f81d4942e852c11ad28613df637e155451556ae5826f93765bee57a5c87a9740d2bd1db463ad0f55a947772fe9d57eeabae3efa373e",
        "repo": "loongson-community/lagoon",
+        "tag": "%VERSION%",
        "version": "1.0.0"
    },
    "libadrenotools": {
        "hash": "f6526620cb752876edc5ed4c0925d57b873a8218ee09ad10859ee476e9333259784f61c1dcc55a2bcba597352d18aff22cd2e4c1925ec2ae94074e09d7da2265",
        "patches": [
-            "0001-use-cpmfile-def-for-linkernsbypass.patch"
+            "0001-linkerns-cpm.patch"
        ],
        "repo": "eden-emulator/libadrenotools",
-        "version": "8ba23b42d7"
+        "sha": "8ba23b42d7",
+        "version": "1.0.0"
    },
    "libusb": {
        "find_args": "MODULE",
@@ -137,52 +153,53 @@
            "0001-netbsd-gettime.patch"
        ],
        "repo": "libusb/libusb",
-        "version": "v1.0.29"
-    },
-    "linkernsbypass": {
-        "bundled": "true",
-        "hash": "bbe3f1f08e2bc7172b36e8f052912cc374289fc9a8e5a39ae7547a0c232de8f57ba24883451896b7a9a5d1be0e4de5c5b0f70c2022eda18d7d5a754847521800",
-        "repo": "bylaws/liblinkernsbypass",
-        "version": "aa3975893d"
+        "tag": "v%VERSION%",
+        "version": "1.0.29"
    },
    "llvm-mingw": {
        "artifact": "clang-rt-builtins.tar.zst",
        "git_host": "git.eden-emu.dev",
        "hash": "d902392caf94e84f223766e2cc51ca5fab6cae36ab8dc6ef9ef6a683ab1c483bfcfe291ef0bd38ab16a4ecc4078344fa8af72da2f225ab4c378dee23f6186181",
        "repo": "eden-emu/llvm-mingw",
+        "tag": "%VERSION%",
        "version": "20250828"
    },
    "lz4": {
        "hash": "35c21a5d9cfb5bbf314a5321d02b36819491d2ee3cf8007030ca09d13ca4dae672247b7aeab553e973093604fc48221cb03dc92197c6efe8fc3746891363fdab",
        "name": "lz4",
        "repo": "lz4/lz4",
+        "sha": "ebb370ca83",
        "source_subdir": "build/cmake",
-        "version": "ebb370ca83"
+        "version": "1.10.0"
    },
    "moltenvk": {
        "artifact": "MoltenVK-macOS.tar",
        "bundled": true,
        "hash": "5695b36ca5775819a71791557fcb40a4a5ee4495be6b8442e0b666d0c436bec02aae68cc6210183f7a5c986bdbec0e117aecfad5396e496e9c2fd5c89133a347",
        "repo": "V380-Ori/Ryujinx.MoltenVK",
-        "version": "v1.4.1-ryujinx"
+        "tag": "v%VERSION%-ryujinx",
+        "version": "1.4.1"
    },
    "nlohmann": {
        "hash": "6cc1e86261f8fac21cc17a33da3b6b3c3cd5c116755651642af3c9e99bb3538fd42c1bd50397a77c8fb6821bc62d90e6b91bcdde77a78f58f2416c62fc53b97d",
        "min_version": "3.8",
        "package": "nlohmann_json",
        "repo": "nlohmann/json",
-        "version": "v3.12.0"
+        "tag": "v%VERSION%",
+        "version": "3.12.0"
    },
    "oaknut": {
        "hash": "9697e80a7d5d9bcb3ce51051a9a24962fb90ca79d215f1f03ae6b58da8ba13a63b5dda1b4dde3d26ac6445029696b8ef2883f4e5a777b342bba01283ed293856",
        "min_version": "2.0.1",
        "repo": "eden-emulator/oaknut",
-        "version": "v2.0.3"
+        "tag": "v%VERSION%",
+        "version": "2.0.3"
    },
    "oboe": {
        "bundled": true,
        "hash": "ce4011afe7345370d4ead3b891cd69a5ef224b129535783586c0ca75051d303ed446e6c7f10bde8da31fff58d6e307f1732a3ffd03b249f9ef1fd48fd4132715",
        "repo": "google/oboe",
+        "tag": "%VERSION%",
        "version": "1.10.0"
    },
    "openssl": {
@@ -193,7 +210,8 @@
            "0001-add-bundled-cert.patch"
        ],
        "repo": "openssl/openssl",
-        "version": "openssl-3.6.2"
+        "tag": "openssl-%VERSION%",
+        "version": "3.6.2"
    },
    "openssl-ci": {
        "ci": true,
@@ -216,6 +234,7 @@
            "0004-use-shell-wrapper.patch"
        ],
        "repo": "jimmy-park/openssl-cmake",
+        "tag": "%VERSION%",
        "version": "3.6.2"
    },
    "opus": {
@@ -231,7 +250,8 @@
            "0002-no-install.patch"
        ],
        "repo": "xiph/opus",
-        "version": "a3f0ec02b3"
+        "sha": "a3f0ec02b3",
+        "version": "1.5.2"
    },
    "quazip": {
        "hash": "609c240c7f029ac26a37d8fbab51bc16284e05e128b78b9b9c0e95d083538c36047a67d682759ac990e4adb0eeb90f04f1ea7fe2253bbda7e7e3bcce32e53dd8",
@@ -244,14 +264,16 @@
        ],
        "package": "QuaZip-Qt6",
        "repo": "stachenov/quazip",
-        "version": "2e95c9001b"
+        "sha": "2e95c9001b",
+        "version": "1.5"
    },
    "sdl3": {
        "hash": "df5a323af7ac366661a3c0e887969c72584d232f3cc211419d59b0487b620b6b2859d4549c9e8df002ee489290062e466fcfddf7edc0872a37b1f2845e81c0f3",
        "min_version": "3.2.10",
        "package": "SDL3",
        "repo": "libsdl-org/SDL",
-        "version": "release-3.4.8"
+        "tag": "release-%VERSION%",
+        "version": "3.4.8"
    },
    "sdl3-ci": {
        "ci": true,
@@ -266,16 +288,19 @@
        "hash": "b937c18a7b6277d77ca7ebfb216af4984810f77af4c32d101b7685369a4bd5eb61406223f82698e167e6311a728d07415ab59639fdf19eff71ad6dc2abfda989",
        "package": "SimpleIni",
        "repo": "brofield/simpleini",
-        "version": "v4.25"
+        "tag": "v%VERSION%",
+        "version": "4.25"
    },
    "sirit": {
+        "artifact": "sirit-source-%VERSION%.tar.zst",
        "find_args": "CONFIG",
-        "hash": "b7cd6885acae3fc8698288d19febba0dd45e4a02a2b6563d2eb995a988d0847046e8d16a5dea7e0bf832b4321bcec134cdbafc553f6ede039e4cf34525c5dce5",
        "options": [
            "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
        ],
        "repo": "eden-emulator/sirit",
-        "version": "v1.0.5"
+        "tag": "v%VERSION%",
+        "version": "1.0.5",
+        "hash": "10b3ff60bdcad428bb4f54360ff749212333a1d24c0b3ed99e466b1bfcf99d2db6cf596c0f965854a2095dfef9b7ce4e045edb070fa9f76eb3b295ab03a4a293"
    },
    "sirit-ci": {
        "ci": true,
@@ -285,13 +310,13 @@
        "version": "1.0.5"
    },
    "spirv-headers": {
-        "hash": "d624371dd455c66a300344c89812598ffe11b5eedba555779f789e85c29dc67317741858c60e0744a1e6755cc0d2759b8659f0674f4cc31479c4cb6fc25ed23b",
+        "hash": "cae8cd179c9013068876908fecc1d158168310ad6ac250398a41f0f5206ceff6469e2aaeab9c820bce9d1b08950c725c89c46e94b89a692be9805432cf749396",
        "options": [
            "SPIRV_WERROR OFF"
        ],
        "package": "SPIRV-Headers",
        "repo": "KhronosGroup/SPIRV-Headers",
-        "version": "vulkan-sdk-1.4.341.0"
+        "sha": "04f10f650d"
    },
    "tzdb": {
        "artifact": "%VERSION%.tar.gz",
@@ -299,6 +324,7 @@
        "hash": "cce65a12bf90f4ead43b24a0b95dfad77ac3d9bfbaaf66c55e6701346e7a1e44ca5d2f23f47ee35ee02271eb1082bf1762af207aad9fb236f1c8476812d008ed",
        "package": "nx_tzdb",
        "repo": "eden-emu/tzdb_to_nx",
+        "tag": "%VERSION%",
        "version": "230326"
    },
    "unordered-dense": {
@@ -310,40 +336,46 @@
            "0001-avoid-memset-when-clearing-an-empty-table.patch"
        ],
        "repo": "martinus/unordered_dense",
-        "version": "7b55cab841"
+        "sha": "7b55cab841",
+        "version": "4.8.1"
    },
    "vulkan-headers": {
        "hash": "d2846ea228415772645eea4b52a9efd33e6a563043dd3de059e798be6391a8f0ca089f455ae420ff22574939ed0f48ed7c6ff3d5a9987d5231dbf3b3f89b484b",
        "min_version": "1.4.317",
        "package": "VulkanHeaders",
        "repo": "KhronosGroup/Vulkan-Headers",
-        "version": "v1.4.345"
+        "tag": "v%VERSION%",
+        "version": "1.4.345"
    },
    "vulkan-memory-allocator": {
        "find_args": "CONFIG",
        "hash": "deb5902ef8db0e329fbd5f3f4385eb0e26bdd9f14f3a2334823fb3fe18f36bc5d235d620d6e5f6fe3551ec3ea7038638899db8778c09f6d5c278f5ff95c3344b",
        "package": "VulkanMemoryAllocator",
        "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator",
-        "version": "v3.3.0"
+        "tag": "v%VERSION%",
+        "version": "3.3.0"
    },
    "vulkan-utility-libraries": {
        "hash": "114f6b237a6dcba923ccc576befb5dea3f1c9b3a30de7dc741f234a831d1c2d52d8a224afb37dd57dffca67ac0df461eaaab6a5ab5e503b393f91c166680c3e1",
        "package": "VulkanUtilityLibraries",
        "repo": "KhronosGroup/Vulkan-Utility-Libraries",
-        "version": "v1.4.345"
+        "tag": "v%VERSION%",
+        "version": "1.4.345"
    },
    "vulkan-validation-layers": {
-        "artifact": "android-binaries-%NUMERIC_VERSION%.zip",
+        "artifact": "android-binaries-%VERSION%.zip",
        "hash": "8812ae84cbe49e6a3418ade9c458d3be6d74a3dffd319d4502007b564d580998056e8190414368ec11b27bc83993c7a0dad713c31bcc3d9553b51243efee3753",
-        "numeric_version": "1.4.341.0",
+        "package": "VVL",
        "repo": "KhronosGroup/Vulkan-ValidationLayers",
-        "version": "vulkan-sdk-%NUMERIC_VERSION%"
+        "tag": "vulkan-sdk-%VERSION%",
+        "version": "1.4.341.0"
    },
    "xbyak": {
        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
        "package": "xbyak",
        "repo": "herumi/xbyak",
-        "version": "v7.35.2"
+        "tag": "v%VERSION%",
+        "version": "7.35.2"
    },
    "zlib": {
        "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
@@ -354,7 +386,8 @@
        ],
        "package": "ZLIB",
        "repo": "madler/zlib",
-        "version": "v1.3.2"
+        "tag": "v%VERSION%",
+        "version": "1.3.2"
    },
    "zstd": {
        "find_args": "MODULE",
@@ -364,7 +397,8 @@
            "ZSTD_BUILD_SHARED OFF"
        ],
        "repo": "facebook/zstd",
+        "sha": "b8d6101fba",
        "source_subdir": "build/cmake",
-        "version": "b8d6101fba"
+        "version": "1.5.7"
    }
 }
@@ -8,7 +8,6 @@ CPMUtil is a wrapper around CPM that aims to reduce boilerplate and add useful u
  - [Common Properties](#common-properties)
  - [Standard Packages](#standard-packages)
    - [Versioning](#versioning)
-    - [Artifact Naming Errata](#artifact-naming-errata)
    - [Patches](#patches)
  - [Pre-built CI Packages](#pre-built-ci-packages)
  - [Usage](#usage)
@@ -23,18 +22,12 @@ CPMUtil is a wrapper around CPM that aims to reduce boilerplate and add useful u
  - [Addendum: Module Path Packages](#addendum-module-path-packages)
    - [Example: OpenSSL](#example-openssl)
  - [Addendum: Adding Qt](#addendum-adding-qt)
-  - [Addendum: Package-Specific Overrides](#addendum-package-specific-overrides)
-  - [Addendum: Supply-Chain Security](#addendum-supply-chain-security)
-    - [Checksumming](#checksumming)
-    - [Caching](#caching)
-    - [Immutable Commit Hashes](#immutable-commit-hashes)

 ## Global Options

- `CPMUTIL_FORCE_SYSTEM` (default `OFF`): Require all CPM dependencies to use system packages.
-  - You may optionally override this for each package: [Package-Specific Overrides](#addendum-package-specific-overrides)
+- `CPMUTIL_FORCE_SYSTEM` (default `OFF`): Require all CPM dependencies to use system packages. NOT RECOMMENDED!
+  - You may optionally override this (section)
 - `CPMUTIL_FORCE_BUNDLED` (default `ON` on MSVC and Android, `OFF` elsewhere): Require all CPM dependencies to use bundled packages.
-  - You may optionally override this for each package: [Package-Specific Overrides](#addendum-package-specific-overrides)
 - `CPMUTIL_PATCH_DIR` (default `${PROJECT_SOURCE_DIR}/.patch`): Path to patches used in packages. Stored as `<PATCH DIR>/json-package-name/0001-patch-name.patch`, etc.
 - `CPM_SOURCE_CACHE` (default `${PROJECT_SOURCE_DIR}/.cache/cpm`): Where downloaded dependencies get stored.

@@ -57,25 +50,23 @@ And may optionally define other properties like:
 For instance:

 ```json
-{
-  "fmt": {
-      "repo": "fmtlib/fmt",
-      "version": "12.1.0",
-      "hash": "f0da8...23f2",
-      "min_version": "8",
-      "options": [
-          "FMT_TEST ON"
-      ],
-      "patches": [
-         "0001-disable-reference-copy.patch"
-      ]
-  }
+"fmt": {
+    "repo": "fmtlib/fmt",
+    "tag": "12.1.0",
+    "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
+    "min_version": "8",
+    "options": [
+      "FMT_TEST ON"
+    ],
+    "patches": [
+      "0001-disable-reference-copy.patch"
+    ]
 }
 ```

 Calling `AddJsonPackage(fmt)`:

- Searches for a system package named `fmt` of version 8 or higher (`find_package(fmt 8)`)
+- Searches for a system package named `fmt` of version 8 or higher
 - If found, uses the system package and caches it for future use
 - If not found:
  - Downloads fmt 12.1.0 from the GitHub Archive into `.cache/cpm/fmt/12.1.0`
@@ -94,82 +85,63 @@ These JSON properties are used by standard and CI packages alike.
 - `package`: The package name used by `find_package` to check for the existence of a system package.
  - If unset, defaults to the JSON key
 - `repo`: The Git repository the package is stored in, if applicable.
- `version`: The version of the package. This is required.
-  - Generally, this should be a 10-wide Git commit hash or Git tag.
-  - Tags must be fully qualified and include prefixes and suffixes, e.g. `boost-1.88.0`
+- `version`: The version of the package to download. This is required.
+- `min_version`: The minimum required version of the package, if a system package is desired.
 - `git_host`: The Git host the package is stored in, if applicable. Defaults to `github.com`.

 ## Standard Packages

 Normal packages, like the prior `fmt` example, *must* also define:

- `hash`: The SHA512 hash of the downloaded artifact. CPMUtil generally computes this for you--if not, use `tools/cpmutil.sh package hash <JSON key>`
- `min_version`: The minimum required version of the package, if a system package is desired.
-
-And may optionally define:
-
- `url`: Download from a raw URL.
- `artifact`: A GitHub/Forgejo/Gitea release artifact. Requires `repo` to be set and valid.
- `numeric_version`: Replaces `%NUMERIC_VERSION%` in artifact and version definitions; see [Artifact Naming Errata](#artifact-naming-errata).
-
-See [Versioning](#versioning) for version/artifact information.
+- `hash`: The SHA512 hash of the downloaded artifact. CPMUtil generally computes this for you.
+- A valid version/URL identifier:
+  - `url`: Download from a raw URL.
+  - `sha`: A short or fully-qualified Git commit sha. CPMUtil recommends using 10-character wide shas.
+  - `tag`: A Git tag. See [Versioning](#versioning) for its relation to `version`.
+  - `artifact`: A GitHub/Forgejo/Gitea release artifact (requires `tag`). See [Versioning](#versioning) for its relation to `tag` and `version`.

 The following are optional to define:

 - `source_subdir`: A subdirectory containing the `CMakeLists.txt` to configure a project. Useful for projects like `zstd`.
- `bundled`: Force the usage of a bundled package. Useful for packages where the system package is broken or nonexistent; e.g. external fragment shaders or data archives.
-  - Note that this will conflict with `CPMUTIL_FORCE_SYSTEM`; for this reason, when using non-library archives, it may be best to allow the user to download and extract the archive manually and specify a local directory to it.
+- `bundled`: Force the usage of a bundled package. Useful for packages where the system package is broken or nonexistent; e.g. including external fragment shaders.
 - `find_args`: Additional arguments passed to `find_package`, e.g. `MODULE`
 - `patches`: Array of in-tree patches to apply to the downloaded source code. See [#Patches](TODO).
 - `options`: Array of CMake options to apply before configuring the package, e.g. `"FMT_TEST ON"`.

 ### Versioning

-When fetching from a Git repository, there are generally three methods of versioning:
+When using tags or artifacts, it may be cumbersome to repeat the version multiple times; especially if it's constantly changing. For this purpose, `tag` and `artifact` both support basic version text replacement.

- Commit hashes
- Git tags
- Release artifacts
+`tag` can use `%VERSION%` to have its version replaced with the `version` defined for the package, e.g. for OpenSSL; when downloading, `tag` will evaluate to `openssl-3.6.2`:

-When `repo` is set, `version` field can be set to any commitish value, including commit hashes or Git tags. In the case of artifacts, `version` must be a Git tag, and `artifact` must be set to a release artifact attached to that tag. Many repositories intentionally version the filenames of their release artifacts; for this purpose, CPMUtil allows you to implant the version number into the artifact name. To do so, add `%VERSION%` to the artifact name; CPMUtil will then automatically replace `%VERSION%` with the `version` field. This means that when changing versions, you only need to update the version, not the artifact!
+```json
+"openssl": {
+    "repo": "openssl/openssl",
+    "version": "3.6.2",
+    "tag": "openssl-%VERSION%"
+}
+```

-Take Boost as an example. The artifact for Boost 1.90.0 is `boost-1.90.0-cmake.tar.xz`, and the tag is `boost-1.90.0`. Thus, we can set the artifact to `%VERSION%-cmake.tar.xz`:
+`artifact` also supports `%VERSION%` replacement, and can also use `%TAG%` to be replaced by the computed tag. Take this Boost definition:

 ```json
 "boost": {
    "repo": "boostorg/boost",
-    "version": "boost-1.90.0",
-    "artifact": "%VERSION%-cmake.tar.xz"
+    "tag": "boost-%VERSION%",
+    "version": "1.90.0"
 }
 ```

-The artifact will then evaluate as `boost-1.90.0-cmake.tar.xz`.
+Boost's artifact for this version is stored in `boost-1.90.0-cmake.tar.xz`. Notice that the computed tag,`boost-1.90.0`, is in the name of the artifact! Thus, `artifact` can be either:

-### Artifact Naming Errata
+- `boost-%VERSION%-cmake.tar.xz`
+- Or, even simpler: `%TAG%-cmake.tar.xz`

-While `%VERSION%` replacement is generally good enough for well-packaged projects, occasionally there may be some problematic packages. Take, for instance, Vulkan Validation Layers:
-
- Tag (`version`): `vulkan-sdk-1.4.341.0`
- Artifact: `android-binaries-1.4.341.0.zip`
-
-Attempting to add version replacement to the artifact definition **would not work here!** In this case, you must utilize the `numeric_version` field described earlier; we would set `numeric_version` to `1.4.341.0` and add `%NUMERIC_VERSION%` replacements into our artifact and version fields:
-
-```json
-"vulkan-validation-layers": {
-    "artifact": "android-binaries-%NUMERIC_VERSION%.zip",
-    "repo": "KhronosGroup/Vulkan-ValidationLayers",
-    "version": "vulkan-sdk-%NUMERIC_VERSION%",
-    "numeric_version": "1.4.341.0"
-},
-```
-
-`artifact` will thus evaluate to `android-binaries-1.4.341.0.zip`, and `version` to `vulkan-sdk-1.4.341.0`. CPMUtil's auto-updater will also account for this and only update `numeric_version`!
+Future updates need only change the `version` identifier, and the artifact and tag will automatically be updated!

 ### Patches

-CPMUtil is able to apply in-place source tree patches to downloaded packages. These are defined in JSON as an array of names, preferably using `git-format-patch`'s scheme of `<4 digit number>-patch-name.patch`.
-
-They are stored in `<CPMUTIL_PATCH_DIR>/<json-key>` (remember that `CPMUTIL_PATCH_DIR` defaults to `$ROOT/.patch`); e.g. `boost` patches would be in `.patch/boost`. Let's say we've made three patches and want to add them; in the Boost JSON definition, we would add:
+CPMUtil is able to apply in-place source tree patches to downloaded packages. These are defined in JSON as an array of names, preferably using `git-format-patch`'s scheme of `<4 digit number>-patch-name.patch`. These are stored in `<CPMUTIL_PATCH_DIR>/<json-key>` (remember that `CPMUTIL_PATCH_DIR` defaults to `$ROOT/.patch`); e.g. `boost` patches would be in `.patch/boost`. Let's say we've made three patches and want to add them; in the Boost JSON definition, we would add:

 ```json
 "patches": [
@@ -179,7 +151,7 @@ They are stored in `<CPMUTIL_PATCH_DIR>/<json-key>` (remember that `CPMUTIL_PATC
 ]
 ```

-Then, when Boost is downloaded, it will apply these patches to the source tree in the order they are defined (compound/dependent patches are okay!). Note that when you add, remove, or modify patches, CPMUtil will invalidate your downloaded cache and re-fetch the source.
+Then, when Boost is downloaded, it will apply these patches in order to the source tree.

 To learn how to make patches, see [Addendum: Making Patches](#addendum-making-patches).

@@ -227,9 +199,12 @@ If you're only concerned with basic usage, you can stop reading. For more advanc

 CPMUtil stores downloaded packages within `.cache/cpm` by default (see `CPM_SOURCE_CACHE`). Subdirectories stored within are lowercase representations of the `find_package` name for the package; for instance, a `vulkan-headers` definition with `package: "VulkanHeaders"` would be stored in `.cache/cpm/vulkanheaders`.

-Within these subdirectories, additional directories are created for each individual version, corresponding directly to their `version` field. CI packages use `<platform>-<architecture>-<version>` unconditionally.
+Within these subdirectories, additional directories are created for each individual version:

-To see the cache directory for a given package, use `tools/cpmutil.sh package dir <JSON key>`.
+- A four-character shorthand of `sha`, if defined
+- If `sha` is not defined, the fully qualified `version` is used
+
+CI packages use `<platform>-<architecture>-<version>` unconditionally.

 ## Addendum: Making Patches

@@ -267,7 +242,7 @@ If you are packaging a project that uses CPMUtil, read this!

 For sandboxed environments (e.g. Gentoo, nixOS) you must install all dependencies to the system beforehand and set `-DCPMUTIL_FORCE_SYSTEM=ON`. If a dependency is missing, get creating!

-Alternatively, if CPMUtil pulls in a package that has no suitable way to install or use a system version, download it separately and pass `-D<PackageName>_CUSTOM_DIR=/path/to/downloaded/dir`.
+Alternatively, if CPMUtil pulls in a package that has no suitable way to install or use a system version, download it separately and pass `-DPackageName_DIR=/path/to/downloaded/dir` (e.g. shaders)

 ### Unsandboxed

@@ -288,12 +263,14 @@ Using the prior Vulkan example:
    "repo": "KhronosGroup/Vulkan-Headers",
    "package": "VulkanHeaders",
    "min_version": "1.4.317",
-    "version": "v1.4.342"
+    "version": "1.4.342",
+    "tag": "v%VERSION%"
 },
 "vulkan-utility-libraries": {
    "repo": "KhronosGroup/Vulkan-Utility-Libraries",
    "package": "VulkanUtilityLibraries",
-    "version": "v1.4.342"
+    "version": "1.4.342",
+    "tag": "v%VERSION%"
 }
 ```

@@ -341,32 +318,3 @@ AddQt(QDash-CI/Qt 6.11.1)
 ```

 Then, call `find_package(Qt6 ...)` and it will pull Qt from your downloaded source.
-
-## Addendum: Package-Specific Overrides
-
-There are three variables that CPMUtil defines for each package; these can be overriden by the user or in your CMake. `package` refers either to the `package` value in the JSON, or the package's JSON key if unset (see `package` in [Common Properties](#common-properties)):
-
- `<package>_FORCE_BUNDLED`: Forcefully bundle the package. This has the same effect as `CPMUTIL_FORCE_BUNDLED`, but only for this package.
- `<package>_FORCE_BUNDLED`: Forcefully use the system package, failing if it can't be found. This has the same effect as `SYSTEM`, but only for this package.
- `<package>_CUSTOM_DIR`: Path to an extracted copy of the package. CPMUtil will not attempt to download the package and will instead use the custom directory.
-  - For an example, see [CPMUtil's test case](https://git.crueter.xyz/CMake/CPMUtil/src/branch/master/tests/dir/CMakeLists.txt)
-
-Additionally, in CMake, you can add `FORCE_BUNDLED_PACKAGE ON` to your `AddJsonPackage` command--note that you will have to use the `NAME <key>` syntax as described in [Module Path Packages](#addendum-module-path-packages). This will overrule *all* other overrides, including `CPMUTIL_FORCE_SYSTEM` and `<package>_FORCE_SYSTEM`--use with caution!
-
-## Addendum: Supply-Chain Security
-
-Many package managers suffer from the issue of supply chain security, specifically in regards to silent overwrites of existing packages or archives, e.g. tag sliding and artifact overwriting. CPMUtil has three methods to protect against this.
-
-### Checksumming
-
-CPMUtil *requires* SHA512 checksums for standard packages, and soon will for CI packages as well. If an attacker or compromised account slides a tag, overwrites a release artifact, or otherwise attempts to compromise anything that CPMUtil may fetch, **CPMUtil will not allow the download to continue!** This means that consumers of your build system can **only** download an artifact if the contents of the artifact are *exactly* indentical to what it was when it was configured--any changes at all will be rejected by CPMUtil.
-
-### Caching
-
-CPMUtil uses a mutable cache system, stored by default in `.cache/cpm`. Dependencies are downloaded and extracted here, and can be reused infinitely. This means that, for instance, if a package is compromised but you already have a cached local copy, you won't have to worry at all!
-
-### Immutable Commit Hashes
-
-CPMUtil is capable of using immutable Git commit hashes for its artifacts. These are (barring SHA1 collisions) completely immune to supply chain attacks--that is, unless the entire root server gets compromised to serve infected artifacts/source code; at which point there are much larger issues to worry about. This means that once you set a package to use a Git commit hash for its version, **it will stay the same forever**. This is useful if you want to ensure that consumers are never faced with download failures stemming from hash mismatches in case of compromised artifacts.
-
-Do note, however, that this will render the package incompatible with CPMUtil's built-in auto-updater, so you will have to manually update the package.
@@ -311,9 +311,8 @@ dispatcher, which will return control to the host.
 SetTerm(IR::Term::LinkBlockFast{next})
 ```

-This terminal instruction jumps to the basic block described by `next` unconditionally. This promises guarantees that must be held at runtime - i.e that the program wont hang,
-
-This is a valid expression if contained within another block (say a `Terminal::If`) and the semantics allow it to be so.
+This terminal instruction jumps to the basic block described by `next` unconditionally.
+This promises guarantees that must be held at runtime - i.e that the program wont hang,

 ### Terminal: PopRSBHint

@@ -14,7 +14,7 @@ Use this guide whenever you want to modify the Date or Time that Eden reports to

 ## Steps

-1. Navigate to *Emulation > Configure*.    
+1. Navigate to *Emulation → Configure*.    
 2. Click on the **System** item on the left-hand side navigation, then check the *Custom RTC Date* box.
 3. The Date/Time option now becomes editable. Set it to the value you want and hit **OK**.
 4. GREAT SCOTT! We have time traveled! You can of course go forward or backward in time (as long as it is not before the year 1970) and your game should update accordingly (e.g. certain *Super Mario Odyssey* moons that take time for flowers to grow will now be fully grown.).
@@ -30,7 +30,7 @@ Use this guide for when you want to configure specific controller settings to be

 #### Steps
 1. Launch Eden and wait for it to load.
-2. Navigate to *Emulation > Configure...*
+2. Navigate to *Emulation > Configure…*
 3. Select **Controls** from the left-hand menu and configure your controller for the way you want it to be in game.
 4. Select **New** and enter a name for the profile in the box that appears. Press **OK** to save the profile settings.
 5. Select **OK** to close the settings menu.
@@ -16,14 +16,14 @@ Use this guide when you want to use the Steam Deck's native gyro functionality f
 ### Steps

 1. Go into Steam Deck's Desktop Mode, and use the shortcut to launch EmuDeck.
-2. Install [SteamDeckGyroDSU](https://github.com/kmicki/SteamDeckGyroDSU/releases) by going to *3rd Party Tools > Gyroscope* and clicking **Install.**
+2. Install [SteamDeckGyroDSU](https://github.com/kmicki/SteamDeckGyroDSU/releases) by going to *3rd Party Tools > Gyroscope* and clicking **Install.**
    a. Alternatively you can install [SteamDeckGyroDSU](https://github.com/kmicki/SteamDeckGyroDSU/releases) manually following the GitHub page instructions. 
 3. Upon completion of the installation. You will need to reboot your Steam Deck.  Do so before continuing on.
 4. Go back into the Steam Deck Desktop Mode and open the Dolphin File Explorer.
-5. Navigate to the following directory to see you controller configuration: `/home/deck/.config/Eden`
-6. *Right-Click* the **qt-config.ini** file and open it with ***Kate***
-7. Look for the following line: `player_0_motionleft=[empty]`.
-8. Change the line to now say: `player_0_motionleft="motion:0,pad:0,port:26760,guid:0000000000000000000000007f000001,engine:cemuhookudp"`
+5. Navigate to the following directory to see you controller configuration: `/home/deck/.config/Eden`
+6. *Right-Click* the **qt-config.ini** file and open it with ***Kate***
+7. Look for the following line: `player_0_motionleft=[empty]`.
+8. Change the line to now say: `player_0_motionleft="motion:0,pad:0,port:26760,guid:0000000000000000000000007f000001,engine:cemuhookudp"`
 9. Save the file and open Eden.
-10. Launch a compatible title, like *The Legend of Zelda: Breath of the Wild*.
-11. Test the gyro capabilities, for the above mentioned title, it is accessed by holding down the **R Trigger** and moving the Steam Deck around.
+10. Launch a compatible title, like *The Legend of Zelda: Breath of the Wild*.
+11. Test the gyro capabilities, for the above mentioned title, it is accessed by holding down the **R Trigger** and moving the Steam Deck around.
@@ -4,7 +4,7 @@ Use this guide when you want to install Updates or DLC for your games in Eden.

 <aside>

-***NOTE***: This applies to separate Update/DLC files, not "merged" NSP/XCI's which include the base game and Updates/DLC applied on top of them in a single file.  These files work in Eden, but would not require the following steps.
+***NOTE***: This applies to separate Update/DLC files, not “merged” NSP/XCI’s which include the base game and Updates/DLC applied on top of them in a single file.  These files work in Eden, but would not require the following steps.

 </aside>

@@ -10,7 +10,7 @@ This FAQ will serve as a general quick question and answer simple questions.
 No - The only emulator that has this kind of functionality is *Ryujinx* and it's forks.  This solution requires loading a custom module on a modded switch console to work.

 ### Can I Play Online Games?
-No - This would require hijacking requests to Nintendo's official servers to a custom server infrastructure built to emulate that functionality.  This is how services like [*Pretendo*](https://pretendo.network/) operate.  As such, you would not be able to play "Online", you can however play multiplayer games.
+No - This would require hijacking requests to Nintendo's official servers to a custom server infrastructure built to emulate that functionality.  This is how services like [*Pretendo*](https://pretendo.network/) operate.  As such, you would not be able to play “Online”, you can however play multiplayer games.

 ### What's the Difference Between Online and Multiplayer?
 I have chosen the wording carefully here for a reason.  
@@ -21,7 +21,7 @@ I have chosen the wording carefully here for a reason.
 The rule of thumb here is simple: If a game supports the ability to communicate without a server (Local Wireless, LAN, etc.) you will be able to play with other users.  If it requires a server to function - it will not.  You will need to look up if your title support Local Wireless/LAN play as an option.

 ### How Does Multiplayer Work on Eden Exactly?
-Eden's multiplayer works by emulating the Switch's local wireless (LDN) system, then tunneling that traffic over the internet through "rooms" that act like lobbies. Each player runs their own instance of the emulator, and as long as everyone joins the same room and the game supports local wireless multiplayer, the emulated consoles see each other as if they were on the same local network. This design avoids typical one-save netplay issues because every user keeps an independent save and console state while only the in-game wireless packets are forwarded through the room server.  In practice, you pick or host a room, configure your network interface/port forwarding if needed, then launch any LDN-capable game; from the game's perspective it is just doing standard local wireless, while the emulator handles discovery and communication over the internet or LAN.
+Eden's multiplayer works by emulating the Switch's local wireless (LDN) system, then tunneling that traffic over the internet through “rooms” that act like lobbies. Each player runs their own instance of the emulator, and as long as everyone joins the same room and the game supports local wireless multiplayer, the emulated consoles see each other as if they were on the same local network. This design avoids typical one-save netplay issues because every user keeps an independent save and console state while only the in-game wireless packets are forwarded through the room server.  In practice, you pick or host a room, configure your network interface/port forwarding if needed, then launch any LDN-capable game; from the game's perspective it is just doing standard local wireless, while the emulator handles discovery and communication over the internet or LAN.

 ### What Do I Need to Do?
 That depends entirely on what your goal is and your level of technical ability, you have a 2 options on how to proceed.  
@@ -71,7 +71,7 @@ There are 2 primary methods that you can use to connect to an existing room, dep
 </aside>

 ## Joining a Public Lobby
-1. Open Eden and navigate to *Multiplayer > Browse Public Game Lobby*.
+1. Open Eden and navigate to *Multiplayer → Browse Public Game Lobby*.
 2. The **Public Room Browser** will now open and display a list of publicly accessible rooms.  Find one you want to connect to and double click it.
    
    <aside>
@@ -84,7 +84,7 @@ There are 2 primary methods that you can use to connect to an existing room, dep
 ### Direct Connecting to a Room
 If the hoster has not made the lobby public, or you don't want to find it in the public game browser - use this option to connect.

-1. Open Eden and navigate to *Multiplayer > Direct Connect*.
+1. Open Eden and navigate to *Multiplayer → Direct Connect*.
 2. Enter the *Server Address, Port*, *Nickname* (what your user will be called in the room), and a *Password* (if the hoster set one, otherwise leave it blank) and hit **Connect.**
 3. You will now see a window showing everyone on the lobby, or an error message.

@@ -101,7 +101,7 @@ Use this guide for when you want to host a multiplayer lobby to play with others
 - Ability to allow programs through the firewall on your device.

 ### Steps
-1. Open Eden and navigate to *Emulation > Multiplayer > Create Room.*    
+1. Open Eden and navigate to *Emulation → Multiplayer → Create Room.*    
 2. Fill out the following information in the popup dialog box.
    
    
@@ -144,7 +144,7 @@ Quite often the person with whom you want to play is located off of your interna

 Port forwarding is a networking technique that directs incoming traffic arriving at a specific port on a router or firewall to a designated device and port inside a private local network. When an external client contacts the public IP address of the router on that port, the router rewrites the packet's destination information (IP address and sometimes port number) and forwards it to the internal host that is listening on the corresponding service. This allows services such as web servers, game servers, or remote desktop sessions hosted behind NAT (Network Address Translation) to be reachable from the wider Internet despite the devices themselves having non-routable private addresses.

-The process works by creating a static mapping-often called a "port-forward rule"-in the router's configuration. The rule specifies three pieces of data: the external (public) port, the internal (private) IP address of the target machine, and the internal port on which that machine expects the traffic. When a packet arrives, the router checks its NAT table, matches the external port to a rule, and then translates the packet's destination to the internal address before sending it onward. Responses from the internal host are similarly rewritten so they appear to come from the router's public IP, completing the bidirectional communication loop. This mechanism enables seamless access to services inside a protected LAN without exposing the entire network. 
+The process works by creating a static mapping—often called a “port-forward rule”—in the router's configuration. The rule specifies three pieces of data: the external (public) port, the internal (private) IP address of the target machine, and the internal port on which that machine expects the traffic. When a packet arrives, the router checks its NAT table, matches the external port to a rule, and then translates the packet's destination to the internal address before sending it onward. Responses from the internal host are similarly rewritten so they appear to come from the router's public IP, completing the bidirectional communication loop. This mechanism enables seamless access to services inside a protected LAN without exposing the entire network. 

 For our purposes we would pick the port we want to expose (*e.g. 24872*) and we would access our router's configuration and create a port-forward rule to send the traffic from an external connection to your local machine over our specified port (*24872)*.  The exact way to do so, varies greatly by router manufacturer - and sometimes require contacting your ISP to do so depending on your agreement.  You can look up your router on [*portforward.com*](https://portforward.com/router.htm) which may have instructions on how to do so for your specific equipment.  If it is not there, you will have to use Google/ChatGPT to determine the steps for your equipment.

@@ -160,7 +160,7 @@ Remember you can't have one port open for multiple devices at the same time - yo
    </aside>
    

-Using a Tunnelling service may be the solution to avoid port forward, but also avoid worrying about your users setup. A tunnelling service works by having a lightweight client run on the machine that hosts the game server. That client immediately opens an **outbound** encrypted connection (typically over TLS/QUIC) to a relay node operated by the tunnel provider's cloud infrastructure. Because outbound traffic is almost always allowed through NAT routers and ISP firewalls, the tunnel can be established even when the host sits behind carrier-grade NAT or a strict firewall. The tunnel provider then assigns a public address (e.g., `mygame.playit.gg:12345`). When a remote player connects to that address, the traffic reaches the the tunnel provider relay, which forwards it through the already-established tunnel back to the client on the private network, and finally onto the local game server's port. In effect, the server appears to the Internet as if it were listening on the public address, while the host never needs to configure port-forwarding rules or expose its own IP directly.
+Using a Tunnelling service may be the solution to avoid port forward, but also avoid worrying about your users setup. A tunnelling service works by having a lightweight client run on the machine that hosts the game server. That client immediately opens an **outbound** encrypted connection (typically over TLS/QUIC) to a relay node operated by the tunnel provider's cloud infrastructure. Because outbound traffic is almost always allowed through NAT routers and ISP firewalls, the tunnel can be established even when the host sits behind carrier-grade NAT or a strict firewall. The tunnel provider then assigns a public address (e.g., `mygame.playit.gg:12345`). When a remote player connects to that address, the traffic reaches the the tunnel provider relay, which forwards it through the already-established tunnel back to the client on the private network, and finally onto the local game server's port. In effect, the server appears to the Internet as if it were listening on the public address, while the host never needs to configure port-forwarding rules or expose its own IP directly.

 For our purposes we would spawn the listener for the port that way chose when hosting our room.  The user would connect to our assigned public address/port combination, and it would be routed to our machine.  The tunnel must remain active for as long as you want the connection to remain open.  Closing the terminal will kill the tunnel and disconnect the users.

@@ -204,7 +204,7 @@ Use this guide when you need to determine the connection information for the Pub
 ### Method 1: Grabbing the Address from the Log File
 1. Open Eden and Connect to the room you want to identify.
    1. See the *Joining a Multiplayer Room* section for instructions on how to do so if you need them.
-2. Go to *File > Open Eden Folder*, then open the **config** folder.
+2. Go to *File → Open Eden Folder*, then open the **config** folder.
 3. Open the the **qt-config.ini** file in a text editor.
 4. Search for the following keys: 
    1. `Multiplayer\ip=` 
@@ -286,7 +286,7 @@ This guide will assume you are the one hosting the game and go over things *Pars
    2. If you are joining a game, you will have to send a connection request the host will have to accept.
 3. Verify that the remote player can see the screen and that there is no issues with the connection.
 4. Launch Eden.
-5. Navigate to *Emulation > Configure*.
+5. Navigate to *Emulation → Configure*.
 6. Select the **Controls** tab.
 7. Set up your controller, if necessary.
 8. Select the **Player 2** tab and select the **Connect Controller** checkbox.  This enables inputs from another device to be seen as a second controller.
@@ -33,12 +33,12 @@ Use this guide to get starting using the Eden emulator.
    
    <aside>

-    ***INFO***: You may get a "*Windows protected your PC"* SmartScreen message that appears.  This is just Windows Defender saying it did not recognize the application and did not run it - Eden is completely safe.  Click **More info** and then **Run anyway** to dismiss this message.
+    ***INFO***: You may get a “*Windows protected your PC”* SmartScreen message that appears.  This is just Windows Defender saying it did not recognize the application and did not run it - Eden is completely safe.  Click **More info** and then **Run anyway** to dismiss this message.
    
    </aside>
 4. Eden will now launch and notify you about missing Decryption keys. Close the dialog box by hitting **OK**.
-5. Navigate to **Tools > Install Decryption Keys**, navigate to the folder containing your key files and select the file, you should only be able to select one.
-6. Navigate to **Tools > Install Firmware**, *Select **From Folder*** or ***From ZIP*** - depending on how your firmware is stored, navigate to where it is stored and select it.    
+5. Navigate to **Tools → Install Decryption Keys**, navigate to the folder containing your key files and select the file, you should only be able to select one.
+6. Navigate to **Tools → Install Firmware**, *Select **From Folder*** or ***From ZIP*** - depending on how your firmware is stored, navigate to where it is stored and select it.    
 7. Double-Click the main window to add the folder containing your games.
 8. Go to *Emulation > Configure > Input* and set up your controller of choice. Click **OK** to close the dialog window.
 9. Double-Click a game to run it.
@@ -72,8 +72,8 @@ Use this guide to get starting using the Eden emulator.
    
 4. If you have had a different Switch emulator installed, it will detect and ask if you want to import those settings.  Make your selection to close the screen.
 5. Eden will now launch and notify you about missing Encryption keys. Close the dialog box by hitting **OK**.
-6. Navigate to **Tools > Install Decryption Keys**, navigate to the folder containing your ***prod.keys*** file and select the file and hit **Open**.
-7. Navigate to **Tools > Install Firmware >** *Select **From Folder*** or ***From ZIP*** - depending on how your firmware is stored, navigate to where it is stored and select it.
+6. Navigate to **Tools → Install Decryption Keys**, navigate to the folder containing your ***prod.keys*** file and select the file and hit **Open**.
+7. Navigate to **Tools → Install Firmware →** *Select **From Folder*** or ***From ZIP*** - depending on how your firmware is stored, navigate to where it is stored and select it.
 8. Double-Click the main window to add the folder containing your games.
 9. Go to *Emulation > Configure > Input* and set up your controller. Click **OK** to close the dialog window.
 10. Double-Click a game to run it.
@@ -22,7 +22,7 @@ Use this guide when you need to allow Eden to run on a Mac system, but are being

 ### Why am I Seeing This?

-Recent versions of MacOS (Catalina & newer) introduced the **Gatekeeper** security functionality, requiring software to be signed by Apple or a trusted (aka - paying) developer.  If the signature isn't on the list of trusted ones, it will stop the program from executing and display the message above.
+Recent versions of MacOS (Catalina & newer) introduced the **Gatekeeper** security functionality, requiring software to be signed by Apple or a trusted (aka - paying) developer.  If the signature isn’t on the list of trusted ones, it will stop the program from executing and display the message above.

 ---

@@ -20,7 +20,7 @@ Use this when you want to import the Eden AppImage into your Steam Library along

 #### Initial Setup

-1. Press the **STEAM** button and then go to *Power > Switch to Desktop* to enter the Desktop mode.
+1. Press the **STEAM** button and then go to *Power → Switch to Desktop* to enter the Desktop mode.

 2. Install ***Steam ROM Manager*** (if needed), there are 2 ways you can accomplish this, either manually or through [*EmuDeck*](https://www.emudeck.com/#downloads).

@@ -53,8 +53,8 @@ Use this when you want to import the Eden AppImage into your Steam Library along

 EmuDeck will automatically create an *Emulators - Emulators* parser for ***Steam ROM Manager*** that uses shell scripts to launch them.  We will follow this convention.

-1. In the file explorer go to your **EmuDeck installation folder > tools > launchers**
-2. Right-Click some empty space and hit **Create New > Text File,** call this new file ***eden.sh*** instead of ***Text File.txt***
+1. In the file explorer go to your **EmuDeck installation folder → tools → launchers**
+2. Right-Click some empty space and hit **Create New → Text File,** call this new file ***eden.sh*** instead of ***Text File.txt***
 3. Right-Click the ***eden.sh*** file you created and hit ***Open with Kate***.
 4. Paste the following code into the contents of the file, save and close the file.
    
@@ -103,7 +103,7 @@ We will need to create a new parser for the Emulators.  Unlike with the EmuDeck
    
    <aside>
        
-    ***TIP***: You may need to go to **Settings > Theme** and set it to *Classic* to view this option.
+    ***TIP***: You may need to go to **Settings → Theme** and set it to *Classic* to view this option.
    
    </aside>

@@ -119,7 +119,7 @@ We will need to create a new parser for the Emulators.  Unlike with the EmuDeck
    2. Parser Specific Configuration
        1. **Search Glob**: *${title}@(.AppImage|.APPIMAGE|.appimage)*
    3. Executable Configuration
-        1. **Executable Modifier**: *"${exePath}"*
+        1. **Executable Modifier**: *"${exePath}”*
    4. Title Modification Configuration
        1. **Title Modifier**: *${fuzzyTitle}*
    
@@ -181,7 +181,7 @@ Use this when you want to import your games inside Eden into Steam to launch wit

 ### Steps

-1. Press the **STEAM** button and then go to *Power > Switch to Desktop* to enter the Desktop mode.
+1. Press the **STEAM** button and then go to *Power → Switch to Desktop* to enter the Desktop mode.

 1. Install ***Steam ROM Manager***, there are 2 ways you can accomplish this, either manually or through [*EmuDeck*](https://www.emudeck.com/#downloads).

@@ -215,7 +215,7 @@ Use this when you want to import your games inside Eden into Steam to launch wit
    
    <aside>
    
-    ***TIP***: Your layout may look different depending on how you installed *Steam ROM Manager*.  You may need to go to **Settings > Theme** and change it to *Classic* to follow along.
+    ***TIP***: Your layout may look different depending on how you installed *Steam ROM Manager*.  You may need to go to **Settings → Theme** and change it to *Classic* to follow along.
    
    </aside>
    
@@ -229,13 +229,13 @@ Use this when you want to import your games inside Eden into Steam to launch wit
    2. Change the **Parser title** from *Nintendo Switch - Yuzu* to *Nintendo Switch - Eden.*
    3. Hit the **Browse** option under the *ROMs directory* section.  Select the directory containing your Switch ROMs.
    4. Under *Steam collections*, you can add a Steam category name.  This just organizes the games under a common category in your Steam Library, this is optional but recommended.
-    5. Scroll down slightly to the **Executable Configuration > Executable**, select **Browse** and select the Eden AppImage.
+    5. Scroll down slightly to the **Executable Configuration → Executable**, select **Browse** and select the Eden AppImage.
    6. Leave everything else the same and hit **Save** to save the parser.
    ---
    
 4. Click the Eden parser to view the options on the right, select **Test** at the bottom of the screen to ensure that *Steam ROM Manager* detects your games correctly.
 1. *Steam ROM Manager* will start to scan the specified ROMs directory and match them to games.  Look over the results to ensure they are accurate.  If you do not see any entries - check your parsers ROMs directory field.
-1. When you are happy with the results, click the **Add Games** > **Parse** to start the actual Parsing.
+1. When you are happy with the results, click the **Add Games** → **Parse** to start the actual Parsing.
 1. The program will now identify the games and pull artwork from [*SteamGridDB*](https://www.steamgriddb.com/).
 2. Review the game matches and ensure everything is there.
    
@@ -30,15 +30,15 @@ Use this guide for when you want to configure automated backup/syncing of your E

 ## Overview

-Rather than giving a breakdown of all the platforms and configurations, those will be in the platform's specific guides - this will serve as a general overview of Syncthing.
+Rather than giving a breakdown of all the platforms and configurations, those will be in the platform’s specific guides - this will serve as a general overview of Syncthing.

 ### What is Syncthing Anyway?

-Syncthing is a continuous file synchronization program (in the layman's - make sure 2 or more systems with the same files are always up to date).  This is perfect for game saves where we would want to play on 1 device, save our game, and then continue playing it on another device.  This technology is what Epic/Steam/etc. use to allow you to do this on games run through their respective services.  Syncthing is an open source implementation of this technology that you control, rather than relying on a 3rd party.  This has a few key benefits, most notably - better security, privacy, and speed (when on your LAN).
+Syncthing is a continuous file synchronization program (in the layman’s - make sure 2 or more systems with the same files are always up to date).  This is perfect for game saves where we would want to play on 1 device, save our game, and then continue playing it on another device.  This technology is what Epic/Steam/etc. use to allow you to do this on games run through their respective services.  Syncthing is an open source implementation of this technology that you control, rather than relying on a 3rd party.  This has a few key benefits, most notably - better security, privacy, and speed (when on your LAN).

 ### What are some common issues?

-Syncthing is fairly robust and doesn't have many issues luckily, but there are some things you should watch out for (almost all of them a user issue).
+Syncthing is fairly robust and doesn’t have many issues luckily, but there are some things you should watch out for (almost all of them a user issue).

 - Sync conflicts
    - If for whatever reason you update the same file on 2 different machines, the system does not know which updated file is considered the one to sync across.  This results in a ***sync conflict*** where it may not sync the files as you would expect.  Worst case scenario, this can result in your save progress being lost if you are not careful.  When one of these occurs, it will create a copy of the file and store it with a specific name, like this example, *Paper Mario.sync-conflict-20251102-072925-TZBBN6S.srm.* To resolve this, you must remove the other files and remove the *.sync-conflict-<TIMESTAMP>-<Syncthing Device ID>* from the file name of the file you want to keep.
@@ -86,7 +86,7 @@ Use this when you want to set this machine as the initial source of truth (push

 1. Right-Click the *Syncthing* Tray icon in your taskbar and select **Open Syncthing.**
 2. You will now have a browser window open up to a web GUI to configure *Syncthing*.  You will get a pop up about allowing anonymous usage and setting a password, make your selections to close them.
-3. We'll start by adding the folder with our save files that we want to sync by Pressing **+ Add Folder**.
+3. We’ll start by adding the folder with our save files that we want to sync by Pressing **+ Add Folder**.
 4. A pop-up window will appear, fill in the Folder label field with whatever you want to call it, like Switch Saves.
 5. Enter the Full folder path to where your save files are stored on this machine.
    
@@ -105,7 +105,7 @@ Use this when you want to set this machine as the initial source of truth (push

 Use this when you want to set this machine up as a child (pull files from the other devices).  Afterwards they will all be equal partners, not a parent/child relationship, this just helps with initial setup.

-1. Install Syncthing Tray on the client device following the section above.  Copy the child's ID and store it so it is accessible to the Parent.
+1. Install Syncthing Tray on the client device following the section above.  Copy the child’s ID and store it so it is accessible to the Parent.
 2. ***ON THE PARENT***: Right-Click the *Syncthing* Tray icon in your taskbar and select **Open Syncthing** if it is not open already**.**
 3. You will now have a browser window open up to a web GUI to configure *Syncthing*.  You will get a pop up about allowing anonymous usage and setting a password, make your selections to close them.
 4. Navigate down to **+ Add Remote Device**, we are going to add our Child device, so I hope you have its ID handy.  If not, go back and get it.
@@ -126,7 +126,7 @@ Use this when you want to set this machine up as a child (pull files from the ot
    
    </aside>

-13. *Syncthing* will now pull all the files from the Parent and store them in your local save directory.  At this point the files are in sync and alterations to one will affect the other and both can be considered "*Parents*" for other devices you want to add.  Repeat these steps for as many devices you want.
+13. *Syncthing* will now pull all the files from the Parent and store them in your local save directory.  At this point the files are in sync and alterations to one will affect the other and both can be considered “*Parents*” for other devices you want to add.  Repeat these steps for as many devices you want.

 ## Linux

@@ -166,9 +166,9 @@ Use this when you want to set this machine up as a child (pull files from the ot
 Use this when you want to set this machine as the initial source of truth (push files out to all the other devices).  Afterwards they will all be equal partners, not a parent/child relationship, this just helps with initial setup.

 1. Right-Click the *Syncthing* Tray icon in your taskbar and select **Open Syncthing.** 
-    1. If you don't have a taskbar in your distro, you can also reach it directly by opening a web browser to: *http://127.0.0.1:8384/.*    
+    1. If you don’t have a taskbar in your distro, you can also reach it directly by opening a web browser to: *http://127.0.0.1:8384/.*    
 2. You will now have a browser window open up to a web GUI to configure *Syncthing*.  You will get a pop up about allowing anonymous usage and setting a password, make your selections to close them.
-3. We'll start by adding the folder with our save files that we want to sync by Pressing **+ Add Folder**.
+3. We’ll start by adding the folder with our save files that we want to sync by Pressing **+ Add Folder**.
 4. A pop-up window will appear, fill in the Folder label field with whatever you want to call it, like Switch Saves.
 5. Enter the Full folder path to where your save files are stored on this machine.
    
@@ -187,7 +187,7 @@ Use this when you want to set this machine as the initial source of truth (push

 Use this when you want to set this machine up as a child (pull files from the other devices).  Afterwards they will all be equal partners, not a parent/child relationship, this just helps with initial setup.

-1. Install Syncthing Tray on the client device following the section above.  Copy the child's ID and store it so it is accessible to the Parent.
+1. Install Syncthing Tray on the client device following the section above.  Copy the child’s ID and store it so it is accessible to the Parent.
 2. ***ON THE PARENT***: Right-Click the *Syncthing* Tray icon in your taskbar and select **Open Syncthing** if it is not open already**.** 
 3. You will now have a browser window open up to a web GUI to configure *Syncthing*.  You will get a pop up about allowing anonymous usage and setting a password, make your selections to close them.
 4. Navigate down to **+ Add Remote Device**, we are going to add our Child device, so I hope you have its ID handy.  If not, go back and get it.
@@ -208,4 +208,4 @@ Use this when you want to set this machine up as a child (pull files from the ot
    
    </aside>
    
-13. *Syncthing* will now pull all the files from the Parent and store them in your local save directory.  At this point the files are in sync and alterations to one will affect the other and both can be considered "*Parents*" for other devices you want to add.  Repeat these steps for as many devices you want.
+13. *Syncthing* will now pull all the files from the Parent and store them in your local save directory.  At this point the files are in sync and alterations to one will affect the other and both can be considered “*Parents*” for other devices you want to add.  Repeat these steps for as many devices you want.
@@ -68,7 +68,7 @@ Faulting package-relative application ID:
 2. Confirm there are no logs created in the log directory.
    1. See the [How to Access Logs](./HowToAccessLogs.md) page for the log location if you need it.
    2. If there are any entries in here since you tried step 1, this is likely not your issue.
-3. Navigate to your *Windows Event Viewer* (Start Menu > **eventvwr.msc)**. 
+3. Navigate to your *Windows Event Viewer* (Start Menu → **eventvwr.msc)**. 
 4. Expand **Windows Logs** and select **Application.**
    
 5. Look for an entry with the Level of Error, and look for a message similar to the following
@@ -30,14 +30,14 @@ TBD

    </aside>

-1. Navigate to the Amiibo section of the game.  The method for initiating the scanning varies from game to game, for *Captain Toad's Treasure Tracker*, you need to go to the press the **+** button when on the level select.  You will need to look up how to do so with your specific game.
+1. Navigate to the Amiibo section of the game.  The method for initiating the scanning varies from game to game, for *Captain Toad’s Treasure Tracker*, you need to go to the press the **+** button when on the level select.  You will need to look up how to do so with your specific game.
 2. Upon activating the Amiibo scan functionality, you should get a Scan page.  Eden is now looking for an Amiibo file to be loaded, which emulates scanning an Amiibo on actual hardware.
-3. Navigate to **File > Load/Remove Amiibo...**, or press the hotkey to do the same (**F2** on keyboard by default).
+3. Navigate to **File > Load/Remove Amiibo…**, or press the hotkey to do the same (**F2** on keyboard by default).
 4. In the file explorer that opens, navigate to the amiibo file you want to use.

    <aside>

-    ***NOTE***: It seems the scanning functionality is spotty and will sometimes throw a "*The current game is not looking for amiibos*" message, even though it is.  Usually you just need to try loading it again or restarting the scanning from the game.  In some situations it was only resolved by restarting the game.
+    ***NOTE***: It seems the scanning functionality is spotty and will sometimes throw a "*The current game is not looking for amiibos*” message, even though it is.  Usually you just need to try loading it again or restarting the scanning from the game.  In some situations it was only resolved by restarting the game.

    </aside>

@@ -58,24 +58,24 @@ Community Member [Ninjistix](https://github.com/Ninjistix) created a utility (Wi
 ```
 [Super Mario Bros. Wonder - Various] <- Optional

-[# 1. Always Star Power]
+[♯ 1. Always Star Power]
 040E0000 00880580 52800035

-[# 2. Star Power + Bubble Mode (Invincible)]
+[♯ 2. Star Power + Bubble Mode (Invincible)]
 040E0000 00880580 52800075

-[# 3. Can Fast Travel to Any Course and World]
+[♯ 3. Can Fast Travel to Any Course and World]
 040E0000 00935E10 52800036
 040E0000 0048A528 52800028
 040E0000 005D9F58 52800028

-[# 4. Got All Top of Flag Poles]
+[♯ 4. Got All Top of Flag Poles]
 040E0000 0048A818 52800028
 ```

 ### Step 3: Enabling/Disabling Cheats

-Cheats are enabled by default, but can be disabled so they don't affect gameplay fairly easily using the game properties.
+Cheats are enabled by default, but can be disabled so they don’t affect gameplay fairly easily using the game properties.

 1. Open Eden and press and hold the game you want to apply the cheat to.
 2. Scroll down on the properties until you see **Add-ons**, select this option.
@@ -130,24 +130,24 @@ Community Member [Ninjistix](https://github.com/Ninjistix) created a utility (Wi
 ```
 [Super Mario Bros. Wonder - Various] <- Optional

-[# 1. Always Star Power]
+[♯ 1. Always Star Power]
 040E0000 00880580 52800035

-[# 2. Star Power + Bubble Mode (Invincible)]
+[♯ 2. Star Power + Bubble Mode (Invincible)]
 040E0000 00880580 52800075

-[# 3. Can Fast Travel to Any Course and World]
+[♯ 3. Can Fast Travel to Any Course and World]
 040E0000 00935E10 52800036
 040E0000 0048A528 52800028
 040E0000 005D9F58 52800028

-[# 4. Got All Top of Flag Poles]
+[♯ 4. Got All Top of Flag Poles]
 040E0000 0048A818 52800028
 ```

 ### Step 3: Enabling/Disabling Cheats

-Cheats are enabled by default, but can be disabled so they don't affect gameplay fairly easily using the game properties.
+Cheats are enabled by default, but can be disabled so they don’t affect gameplay fairly easily using the game properties.

 1. *Right-Click* the game and select *Configure Game*.
 2. In the **Add-Ons** section, locate the cheat you wish to enable.
@@ -59,6 +59,11 @@ endif()
 if (PLATFORM_PS4 OR PLATFORM_MANAGARM)
    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+elseif (ANDROID)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --enable-mediacodec
+        --enable-jni
+    )
 elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
    find_package(PkgConfig REQUIRED)
    pkg_check_modules(LIBVA libva)
@@ -27,7 +27,7 @@ if (ARCHITECTURE_arm64)
    target_link_libraries(yuzu-android PRIVATE adrenotools)
 endif()

-target_link_libraries(yuzu-android PRIVATE OpenSSL::SSL cpp-jwt::cpp-jwt)
+target_link_libraries(yuzu-android PRIVATE ${FFmpeg_LIBRARIES} OpenSSL::SSL cpp-jwt::cpp-jwt)
 if (ENABLE_UPDATE_CHECKER)
    target_compile_definitions(yuzu-android PUBLIC ENABLE_UPDATE_CHECKER)
 endif()
@@ -36,6 +36,10 @@
 #include <frontend_common/content_manager.h>
 #include <jni.h>

+extern "C" {
+#include <libavcodec/jni.h>
+}
+
 #include "common/android/multiplayer/multiplayer.h"
 #include "common/android/android_common.h"
 #include "common/android/id_cache.h"
@@ -680,6 +684,13 @@ const char* fallback_cpu_detection() {

 } // namespace

+extern "C" {
+jint InitFFmpegOnLoad(JavaVM* vm) {
+    av_jni_set_java_vm(vm, nullptr);
+    return 0;
+}
+}
+
 extern "C" {

 void Java_org_yuzu_yuzu_1emu_NativeLibrary_surfaceChanged(JNIEnv* env, jobject instance,
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -184,9 +181,8 @@ MemoryPoolInfo::ResultState PoolMapper::Update(MemoryPoolInfo& pool,
        return MemoryPoolInfo::ResultState::Success;
    }

-    if (in_params.address == 0 || in_params.size == 0
-    || !Common::IsAligned(in_params.address, Core::Memory::YUZU_PAGESIZE)
-    || !Common::IsAligned(in_params.size, Core::Memory::YUZU_PAGESIZE)) {
+    if (in_params.address == 0 || in_params.size == 0 || !Common::Is4KBAligned(in_params.address) ||
+        !Common::Is4KBAligned(in_params.size)) {
        return MemoryPoolInfo::ResultState::BadParam;
    }

@@ -155,7 +155,7 @@ void SinkStream::ProcessAudioIn(std::span<const s16> input_buffer, std::size_t n
        std::memcpy(&last_frame[0], &input_buffer[(frames_written - 1) * frame_size], frame_size_bytes);
    }

-    // update sample counts fuer audio-ins
+    // update sample counts für audio-ins
    {
        std::scoped_lock lk{sample_count_lock};
        last_sample_count_update_time = system.CoreTiming().GetGlobalTimeNs();
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2014 Jannik Vogel <email@jannikvogel.de>
 // SPDX-License-Identifier: CC0-1.0

@@ -37,6 +34,12 @@ template <typename T>
    return static_cast<T>(value - value % size);
 }

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

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

@@ -427,8 +427,11 @@ namespace Common::Android {
    extern "C" {
 #endif

+    jint InitFFmpegOnLoad(JavaVM *vm);
+
    jint JNI_OnLoad(JavaVM *vm, void *reserved) {
        s_java_vm = vm;
+        InitFFmpegOnLoad(vm);

        JNIEnv *env;
        if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION) != JNI_OK)
@@ -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

 #pragma once
@@ -455,17 +455,23 @@ void IterateDirEntriesRecursively(const std::filesystem::path& path, const DirEn
        return;
    }

+    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
    std::error_code ec;
    bool callback_error = false;
-    // MSVC should now be fixed... right... right?!?!?!
-    for (const auto& entry : fs::recursive_directory_iterator(path, ec)) {
+    for (const auto& entry : fs::directory_iterator(path, ec)) {
        if ((True(filter & DirEntryFilter::File) && entry.status().type() == fs::file_type::regular)
        || (True(filter & DirEntryFilter::Directory) && entry.status().type() == fs::file_type::directory)) {
            if (!callback(entry)) {
                callback_error = true;
            }
        }
+        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
+        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
+        if (entry.status().type() == fs::file_type::directory) {
+            IterateDirEntriesRecursively(entry.path(), callback, filter);
+        }
    }
+
    if (callback_error || ec) {
        LOG_ERROR(Common_Filesystem, "Failed to visit all the directory entries of path={}, ec_message={}, callback_error={}", PathToUTF8String(path), ec.message(), callback_error);
    } else {
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
@@ -13,6 +13,8 @@

 namespace Common {

+constexpr float PI = 3.1415926535f;
+
 template <class T>
 struct Rectangle {
    T left{};
@@ -791,8 +791,8 @@ struct Values {
                                                "program_args",
                                                Category::System,
                                                Specialization::Default,
-                                                true,    // save_ - persist in config file
-                                                false};  // runtime_modifiable_ - startup-only
+                                                true,    // save_ — persist in config file
+                                                false};  // runtime_modifiable_ — startup-only
    Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
    Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
    Setting<bool> dump_guest_shaders{
@@ -1,12 +1,8 @@
-// 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

-#define STB_IMAGE_IMPLEMENTATION 1
-#define STB_IMAGE_RESIZE_IMPLEMENTATION 1
-#define STB_IMAGE_WRITE_IMPLEMENTATION 1
-#define STBI_ONLY_JPEG 1
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION

 #include "common/stb.h"
@@ -1,12 +1,8 @@
-// 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

 #pragma once

-#define STBI_ONLY_JPEG 1
 #include <stb_image.h>
 #include <stb_image_resize.h>
 #include <stb_image_write.h>
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -48,10 +48,22 @@ static s64 GetSystemTimeNS() {

 SteadyClock::time_point SteadyClock::Now() noexcept {
 #if defined(_WIN32)
-    static const auto timer_freq = WindowsQueryPerformanceFrequency();
+    static const auto freq = WindowsQueryPerformanceFrequency();
    const auto counter = WindowsQueryPerformanceCounter();
-    const auto whole = (counter / timer_freq) * period::den;
-    const auto part = (counter % timer_freq) * period::den / timer_freq;
+
+    // 10 MHz is a very common QPC frequency on modern PCs.
+    // Optimizing for this specific frequency can double the performance of
+    // this function by avoiding the expensive frequency conversion path.
+    static constexpr s64 TenMHz = 10'000'000;
+
+    if (freq == TenMHz) [[likely]] {
+        static_assert(period::den % TenMHz == 0);
+        static constexpr s64 Multiplier = period::den / TenMHz;
+        return time_point{duration{counter * Multiplier}};
+    }
+
+    const auto whole = (counter / freq) * period::den;
+    const auto part = (counter % freq) * period::den / freq;
    return time_point{duration{whole + part}};
 #elif defined(__APPLE__)
    return time_point{duration{clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW)}};
@@ -108,7 +108,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,

 struct System::Impl {
    explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, hid_core{kernel}, cpu_manager{system},
+        : kernel{system}, fs_controller{system}, hid_core{system.Kernel()}, cpu_manager{system},
          reporter{system}, applet_manager{system}, frontend_applets{system}, profile_manager{} {}

    u64 program_id;
@@ -11,8 +11,6 @@
 #include <algorithm>
 #include <vector>

-#include <boost/container/deque.hpp>
-
 #include "common/address_space.h"
 #include "common/address_space.inc"
 #include "common/alignment.h"
@@ -35,23 +33,21 @@ public:

    void GatherValues(u32 start_entry, Common::ScratchBuffer<u32>& buffer) {
        buffer.resize(8);
-        const auto add_value = [&buffer](u32 value, size_t index) {
-            if (buffer.size() < index + 1)
-                buffer.resize(index + 8);
+        buffer.resize(0);
+        size_t index = 0;
+        const auto add_value = [&](u32 value) {
+            buffer.resize(index + 1);
            buffer[index++] = value;
-            return index;
        };

-        size_t index = 0;
        u32 iter_entry = start_entry;
        Entry* current = &storage[iter_entry - 1];
-        index = add_value(current->value, index);
+        add_value(current->value);
        while (current->next_entry != 0) {
            iter_entry = current->next_entry;
            current = &storage[iter_entry - 1];
-            index = add_value(current->value, index);
+            add_value(current->value);
        }
-        buffer.resize(index);
    }

    u32 Register(u32 value) {
@@ -128,8 +124,8 @@ private:
        u32 value{};
    };

-    std::vector<Entry> storage;
-    boost::container::deque<u32> free_entries;
+    std::deque<Entry> storage;
+    std::deque<u32> free_entries;
 };

 struct EmptyAllocator {
@@ -623,7 +619,7 @@ template <typename Traits>
 void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size, s32 delta) {
    Common::ScopedRangeLock lk(counter_guard, addr, size);
    UpdatePagesCachedCountNoLock(addr, size, delta);
-}
+} 

 template <typename Traits>
 void DeviceMemoryManager<Traits>::UpdatePagesCachedBatch(std::span<const std::pair<DAddr, size_t>> ranges, s32 delta) {
@@ -106,7 +106,7 @@ void PhysicalCore::RunThread(KernelCore& kernel, Kernel::KThread* thread) {
        }

        // Determine why we stopped.
-        // If a step completed successfully, skip other halt reason handlers
+        // If a step completed successfully, skip other halt reason handlers —
        // the step takes priority (e.g. step may also set InstructionBreakpoint
        // if the next instruction happens to be a breakpoint).
        const bool step_completed = True(hr & Core::HaltReason::StepThread)
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -32,13 +32,14 @@ constexpr bool IsValidAddressRange(u64 address, u64 size) {
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
-Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr, u64 src_addr, u64 size) {
-    if (!Common::IsAligned(dst_addr, Core::Memory::YUZU_PAGESIZE)) {
+Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr, u64 src_addr,
+                                  u64 size) {
+    if (!Common::Is4KBAligned(dst_addr)) {
        LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
        R_THROW(ResultInvalidAddress);
    }

-    if (!Common::IsAligned(src_addr, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(src_addr)) {
        LOG_ERROR(Kernel_SVC, "Source address is not aligned to 4KB, 0x{:016X}", src_addr);
        R_THROW(ResultInvalidSize);
    }
@@ -48,7 +49,7 @@ Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr
        R_THROW(ResultInvalidSize);
    }

-    if (!Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(size)) {
        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
        R_THROW(ResultInvalidSize);
    }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -33,12 +33,12 @@ Result SetHeapSize(Core::System& system, u64* out_address, u64 size) {
 Result MapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size={:#X}", addr, size);

-    if (!Common::IsAligned(addr, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(addr)) {
        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
        R_THROW(ResultInvalidAddress);
    }

-    if (!Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(size)) {
        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, {:#X}", size);
        R_THROW(ResultInvalidSize);
    }
@@ -82,12 +82,12 @@ Result MapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
 Result UnmapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size={:#X}", addr, size);

-    if (!Common::IsAligned(addr, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(addr)) {
        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
        R_THROW(ResultInvalidAddress);
    }

-    if (!Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(size)) {
        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, {:#X}", size);
        R_THROW(ResultInvalidSize);
    }
@@ -140,19 +140,19 @@ Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst
              "src_address=0x{:016X}, size=0x{:016X}",
              process_handle, dst_address, src_address, size);

-    if (!Common::IsAligned(src_address, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(src_address)) {
        LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
                  src_address);
        R_THROW(ResultInvalidAddress);
    }

-    if (!Common::IsAligned(dst_address, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(dst_address)) {
        LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
                  dst_address);
        R_THROW(ResultInvalidAddress);
    }

-    if (size == 0 || !Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
+    if (size == 0 || !Common::Is4KBAligned(size)) {
        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size);
        R_THROW(ResultInvalidSize);
    }
@@ -190,7 +190,6 @@ Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst
        R_THROW(ResultInvalidCurrentMemory);
    }

-    R_UNLESS(page_table.CanContain(dst_address, size, KMemoryState::AliasCode), ResultInvalidCurrentMemory);
    R_RETURN(page_table.MapCodeMemory(dst_address, src_address, size));
 }

@@ -201,19 +200,19 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
              "size=0x{:016X}",
              process_handle, dst_address, src_address, size);

-    if (!Common::IsAligned(dst_address, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(dst_address)) {
        LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
                  dst_address);
        R_THROW(ResultInvalidAddress);
    }

-    if (!Common::IsAligned(src_address, Core::Memory::YUZU_PAGESIZE)) {
+    if (!Common::Is4KBAligned(src_address)) {
        LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
                  src_address);
        R_THROW(ResultInvalidAddress);
    }

-    if (size == 0 || !Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
+    if (size == 0 || !Common::Is4KBAligned(size)) {
        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size);
        R_THROW(ResultInvalidSize);
    }
@@ -251,7 +250,6 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
        R_THROW(ResultInvalidCurrentMemory);
    }

-    R_UNLESS(page_table.CanContain(dst_address, size, KMemoryState::AliasCode), ResultInvalidCurrentMemory);
    R_RETURN(page_table.UnmapCodeMemory(dst_address, src_address, size));
 }

@@ -23,13 +23,11 @@ TimeZoneService::TimeZoneService(
    Core::System& system_, FileTimestampWorker& file_timestamp_worker,
    bool can_write_timezone_device_location, TimeZoneBinary& time_zone_binary,
    std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
-    : ServiceFramework{system_, "ITimeZoneService"}
-    , m_can_write_timezone_device_location{can_write_timezone_device_location}
-    , m_file_timestamp_worker{file_timestamp_worker}
-    , m_wrapped_service{std::move(time_zone_service)}
-    , m_operation_event{system}
-    , m_time_zone_binary{time_zone_binary}
-{
+    : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
+      m_can_write_timezone_device_location{can_write_timezone_device_location},
+      m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
+                                                          time_zone_service)},
+      m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
@@ -50,7 +48,8 @@ TimeZoneService::TimeZoneService(
    // clang-format on
    RegisterHandlers(functions);

-    m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+    m_set_sys =
+        m_system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
 }

 TimeZoneService::~TimeZoneService() = default;
@@ -90,7 +89,7 @@ Result TimeZoneService::SetDeviceLocationName(

    std::scoped_lock m{m_list_mutex};
    for (auto& operation_event : m_list_nodes) {
-        operation_event.m_event->Signal(system.Kernel());
+        operation_event.m_event->Signal(m_system.Kernel());
    }
    R_SUCCEED();
 }
@@ -1,6 +1,3 @@
-// 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

@@ -80,7 +77,9 @@ public:
                                 const Service::PSC::Time::CalendarTime& calendar_time);

 private:
+    Core::System& m_system;
    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
+
    bool m_can_write_timezone_device_location;
    FileTimestampWorker& m_file_timestamp_worker;
    std::shared_ptr<Service::PSC::Time::TimeZoneService> m_wrapped_service;
@@ -7,12 +7,10 @@
 #include <algorithm>
 #include <vector>
 #include <optional>
-#include <string>
-
-#define STBI_ONLY_JPEG 1
 #include <stb_image.h>
 #include <stb_image_resize.h>
 #include <stb_image_write.h>
+#include <string>

 #include "common/settings.h"
 #include "core/file_sys/control_metadata.h"
@@ -32,13 +32,11 @@ Alarm::~Alarm() {
    m_ctx.CloseEvent(m_event);
 }

-Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock, PowerStateRequestManager& power_state_request_manager)
-    : m_system{system}
-    , m_ctx{system, "Psc:Alarms"}
-    , m_steady_clock{steady_clock}
-    , m_power_state_request_manager{power_state_request_manager}
-    , m_event{m_ctx.CreateEvent("Psc:Alarms:Event")}
-{}
+Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
+               PowerStateRequestManager& power_state_request_manager)
+    : m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock},
+      m_power_state_request_manager{power_state_request_manager}, m_event{m_ctx.CreateEvent(
+                                                                      "Psc:Alarms:Event")} {}

 Alarms::~Alarms() {
    m_ctx.CloseEvent(m_event);
@@ -134,9 +132,7 @@ Result Alarms::UpdateClosestAndSignal(Kernel::KernelCore& kernel) {
 }

 IAlarmService::IAlarmService(Core::System& system_, std::shared_ptr<TimeManager> manager)
-    : ServiceFramework{system_, "time:al"}
-    , m_alarms{manager->m_alarms}
-{
+    : ServiceFramework{system_, "time:al"}, m_system{system}, m_alarms{manager->m_alarms} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &IAlarmService::CreateWakeupAlarm, "CreateWakeupAlarm"},
@@ -74,7 +74,8 @@ struct Alarm : public Common::IntrusiveListBaseNode<Alarm> {

 class Alarms {
 public:
-    explicit Alarms(Core::System& system, StandardSteadyClockCore& steady_clock, PowerStateRequestManager& power_state_request_manager);
+    explicit Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
+                    PowerStateRequestManager& power_state_request_manager);
    ~Alarms();

    Kernel::KEvent& GetEvent() {
@@ -109,17 +110,21 @@ private:
 class IAlarmService final : public ServiceFramework<IAlarmService> {
 public:
    explicit IAlarmService(Core::System& system, std::shared_ptr<TimeManager> manager);
+
    ~IAlarmService() override = default;

 private:
    void CreateWakeupAlarm(HLERequestContext& ctx);
    void CreateBackgroundTaskAlarm(HLERequestContext& ctx);
+
+    Core::System& m_system;
    Alarms& m_alarms;
 };

 class ISteadyClockAlarm final : public ServiceFramework<ISteadyClockAlarm> {
 public:
    explicit ISteadyClockAlarm(Core::System& system, Alarms& alarms, AlarmType type);
+
    ~ISteadyClockAlarm() override = default;

 private:
@@ -1,6 +1,3 @@
-// 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

@@ -11,9 +8,8 @@ namespace Service::PSC::Time {

 IPowerStateRequestHandler::IPowerStateRequestHandler(
    Core::System& system_, PowerStateRequestManager& power_state_request_manager)
-    : ServiceFramework{system_, "time:p"}
-    , m_power_state_request_manager{power_state_request_manager}
-{
+    : ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
+                                                                 power_state_request_manager} {
    // clang-format off
        static const FunctionInfo functions[] = {
            {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},
@@ -1,6 +1,3 @@
-// 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

@@ -20,13 +17,16 @@ namespace Service::PSC::Time {

 class IPowerStateRequestHandler final : public ServiceFramework<IPowerStateRequestHandler> {
 public:
-    explicit IPowerStateRequestHandler(Core::System& system, PowerStateRequestManager& power_state_request_manager);
+    explicit IPowerStateRequestHandler(Core::System& system,
+                                       PowerStateRequestManager& power_state_request_manager);
+
    ~IPowerStateRequestHandler() override = default;

    Result GetPowerStateRequestEventReadableHandle(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result GetAndClearPowerStateRequest(Out<bool> out_cleared, Out<u32> out_priority);

 private:
+    Core::System& m_system;
    PowerStateRequestManager& m_power_state_request_manager;
 };

@@ -15,7 +15,7 @@ namespace Service::PSC::Time {

 ServiceManager::ServiceManager(Core::System& system_, std::shared_ptr<TimeManager> time,
                               ServerManager* server_manager)
-    : ServiceFramework{system_, "time:m"}, m_time{std::move(time)},
+    : ServiceFramework{system_, "time:m"}, m_system{system}, m_time{std::move(time)},
      m_server_manager{*server_manager},
      m_local_system_clock{m_time->m_standard_local_system_clock},
      m_user_system_clock{m_time->m_standard_user_system_clock},
@@ -26,7 +26,7 @@ ServiceManager::ServiceManager(Core::System& system_, std::shared_ptr<TimeManage
      m_local_system_context_writer{m_time->m_local_system_clock_context_writer},
      m_network_system_context_writer{m_time->m_network_system_clock_context_writer},
      m_ephemeral_system_context_writer{m_time->m_ephemeral_network_clock_context_writer},
-      m_local_operation{system_}, m_network_operation{system_}, m_ephemeral_operation{system_} {
+      m_local_operation{m_system}, m_network_operation{m_system}, m_ephemeral_operation{m_system} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0,   D<&ServiceManager::GetStaticServiceAsUser>, "GetStaticServiceAsUser"},
@@ -93,7 +93,7 @@ Result ServiceManager::SetupStandardSteadyClockCore(bool is_rtc_reset_detected,
    m_steady_clock.Initialize(clock_source_id, rtc_offset, internal_offset, test_offset,
                              is_rtc_reset_detected);
    auto time = m_steady_clock.GetRawTime();
-    auto ticks = system.CoreTiming().GetClockTicks();
+    auto ticks = m_system.CoreTiming().GetClockTicks();
    auto boot_time = time - ConvertToTimeSpan(ticks).count();
    m_shared_memory.SetSteadyClockTimePoint(clock_source_id, boot_time);
    m_steady_clock.SetContinuousAdjustment(clock_source_id, boot_time);
@@ -219,7 +219,7 @@ Result ServiceManager::SetStandardSteadyClockBaseTime(s64 base_time) {

    m_steady_clock.SetRtcOffset(base_time);
    auto time = m_steady_clock.GetRawTime();
-    auto ticks = system.CoreTiming().GetClockTicks();
+    auto ticks = m_system.CoreTiming().GetClockTicks();
    auto diff = time - ConvertToTimeSpan(ticks).count();
    m_shared_memory.UpdateBaseTime(diff);
    m_steady_clock.UpdateContinuousAdjustmentTime(diff);
@@ -241,7 +241,7 @@ Result ServiceManager::GetClosestAlarmUpdatedEvent(
 Result ServiceManager::CheckAndSignalAlarms() {
    LOG_DEBUG(Service_Time, "called.");

-    m_alarms.CheckAndSignal(system.Kernel());
+    m_alarms.CheckAndSignal(m_system.Kernel());
    R_SUCCEED();
 }

@@ -277,16 +277,16 @@ void ServiceManager::SetupSAndP() {
        m_is_s_and_p_setup = true;
        m_server_manager.RegisterNamedService(
            "time:s", std::make_shared<StaticService>(
-                          system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
+                          m_system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
        m_server_manager.RegisterNamedService("time:p",
                                              std::make_shared<IPowerStateRequestHandler>(
-                                                  system, m_time->m_power_state_request_manager));
+                                                  m_system, m_time->m_power_state_request_manager));
    }
 }

 Result ServiceManager::GetStaticService(OutInterface<StaticService> out_service,
                                        StaticServiceSetupInfo setup_info, const char* name) {
-    *out_service = std::make_shared<StaticService>(system, setup_info, m_time, name);
+    *out_service = std::make_shared<StaticService>(m_system, setup_info, m_time, name);
    R_SUCCEED();
 }

@@ -1,6 +1,3 @@
-// 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

@@ -63,8 +60,10 @@ public:
 private:
    void CheckAndSetupServicesSAndP();
    void SetupSAndP();
-    Result GetStaticService(OutInterface<StaticService> out_service, StaticServiceSetupInfo setup_info, const char* name);
+    Result GetStaticService(OutInterface<StaticService> out_service,
+                            StaticServiceSetupInfo setup_info, const char* name);

+    Core::System& m_system;
    std::shared_ptr<TimeManager> m_time;
    ServerManager& m_server_manager;
    bool m_is_s_and_p_setup{};
@@ -35,7 +35,7 @@ constexpr Result GetTimeFromTimePointAndContext(s64* out_time, SteadyClockTimePo

 StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup_info,
                             std::shared_ptr<TimeManager> time, const char* name)
-    : ServiceFramework{system_, name}, m_setup_info{setup_info}, m_time{time},
+    : ServiceFramework{system_, name}, m_system{system}, m_setup_info{setup_info}, m_time{time},
      m_local_system_clock{m_time->m_standard_local_system_clock},
      m_user_system_clock{m_time->m_standard_user_system_clock},
      m_network_system_clock{m_time->m_standard_network_system_clock},
@@ -72,7 +72,7 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
 Result StaticService::GetStandardUserSystemClock(OutInterface<SystemClock> out_service) {
    LOG_DEBUG(Service_Time, "called.");

-    *out_service = std::make_shared<SystemClock>(system, m_user_system_clock,
+    *out_service = std::make_shared<SystemClock>(m_system, m_user_system_clock,
                                                 m_setup_info.can_write_user_clock,
                                                 m_setup_info.can_write_uninitialized_clock);
    R_SUCCEED();
@@ -81,7 +81,7 @@ Result StaticService::GetStandardUserSystemClock(OutInterface<SystemClock> out_s
 Result StaticService::GetStandardNetworkSystemClock(OutInterface<SystemClock> out_service) {
    LOG_DEBUG(Service_Time, "called.");

-    *out_service = std::make_shared<SystemClock>(system, m_network_system_clock,
+    *out_service = std::make_shared<SystemClock>(m_system, m_network_system_clock,
                                                 m_setup_info.can_write_network_clock,
                                                 m_setup_info.can_write_uninitialized_clock);
    R_SUCCEED();
@@ -91,7 +91,7 @@ Result StaticService::GetStandardSteadyClock(OutInterface<SteadyClock> out_servi
    LOG_DEBUG(Service_Time, "called.");

    *out_service =
-        std::make_shared<SteadyClock>(system, m_time, m_setup_info.can_write_steady_clock,
+        std::make_shared<SteadyClock>(m_system, m_time, m_setup_info.can_write_steady_clock,
                                      m_setup_info.can_write_uninitialized_clock);
    R_SUCCEED();
 }
@@ -100,7 +100,7 @@ Result StaticService::GetTimeZoneService(OutInterface<TimeZoneService> out_servi
    LOG_DEBUG(Service_Time, "called.");

    *out_service =
-        std::make_shared<TimeZoneService>(system, m_time->m_standard_steady_clock, m_time_zone,
+        std::make_shared<TimeZoneService>(m_system, m_time->m_standard_steady_clock, m_time_zone,
                                          m_setup_info.can_write_timezone_device_location);
    R_SUCCEED();
 }
@@ -108,7 +108,7 @@ Result StaticService::GetTimeZoneService(OutInterface<TimeZoneService> out_servi
 Result StaticService::GetStandardLocalSystemClock(OutInterface<SystemClock> out_service) {
    LOG_DEBUG(Service_Time, "called.");

-    *out_service = std::make_shared<SystemClock>(system, m_local_system_clock,
+    *out_service = std::make_shared<SystemClock>(m_system, m_local_system_clock,
                                                 m_setup_info.can_write_local_clock,
                                                 m_setup_info.can_write_uninitialized_clock);
    R_SUCCEED();
@@ -117,7 +117,7 @@ Result StaticService::GetStandardLocalSystemClock(OutInterface<SystemClock> out_
 Result StaticService::GetEphemeralNetworkSystemClock(OutInterface<SystemClock> out_service) {
    LOG_DEBUG(Service_Time, "called.");

-    *out_service = std::make_shared<SystemClock>(system, m_ephemeral_network_clock,
+    *out_service = std::make_shared<SystemClock>(m_system, m_ephemeral_network_clock,
                                                 m_setup_info.can_write_network_clock,
                                                 m_setup_info.can_write_uninitialized_clock);
    R_SUCCEED();
@@ -222,7 +222,7 @@ Result StaticService::CalculateMonotonicSystemClockBaseTimePoint(

    auto one_second_ns{
        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
-    auto ticks{system.CoreTiming().GetClockTicks()};
+    auto ticks{m_system.CoreTiming().GetClockTicks()};
    auto current_time_ns{ConvertToTimeSpan(ticks).count()};
    *out_time = ((context.offset + time_point.time_point) - (current_time_ns / one_second_ns));

@@ -1,6 +1,3 @@
-// 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

@@ -71,6 +68,8 @@ private:
    Result GetClockSnapshotImpl(OutClockSnapshot out_snapshot,
                                const SystemClockContext& user_context,
                                const SystemClockContext& network_context, TimeType type);
+
+    Core::System& m_system;
    StaticServiceSetupInfo m_setup_info;
    std::shared_ptr<TimeManager> m_time;
    StandardLocalSystemClockCore& m_local_system_clock;
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -13,11 +13,10 @@ namespace Service::PSC::Time {

 SteadyClock::SteadyClock(Core::System& system_, std::shared_ptr<TimeManager> manager,
                         bool can_write_steady_clock, bool can_write_uninitialized_clock)
-    : ServiceFramework{system_, "ISteadyClock"}
-    , m_clock_core{manager->m_standard_steady_clock}
-    , m_can_write_steady_clock{can_write_steady_clock}
-    , m_can_write_uninitialized_clock{can_write_uninitialized_clock}
-{
+    : ServiceFramework{system_, "ISteadyClock"}, m_system{system},
+      m_clock_core{manager->m_standard_steady_clock},
+      m_can_write_steady_clock{can_write_steady_clock}, m_can_write_uninitialized_clock{
+                                                            can_write_uninitialized_clock} {
    // clang-format off
         static const FunctionInfo functions[] = {
        {0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},
@@ -1,6 +1,3 @@
-// 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

@@ -35,6 +32,8 @@ public:
    Result GetInternalOffset(Out<s64> out_internal_offset);

 private:
+    Core::System& m_system;
+
    StandardSteadyClockCore& m_clock_core;
    bool m_can_write_steady_clock;
    bool m_can_write_uninitialized_clock;
@@ -1,6 +1,3 @@
-// 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

@@ -11,12 +8,11 @@

 namespace Service::PSC::Time {

-SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock, bool can_write_uninitialized_clock)
-    : ServiceFramework{system_, "ISystemClock"}
-    , m_clock_core{clock_core}
-    , m_can_write_clock{can_write_clock}
-    , m_can_write_uninitialized_clock{can_write_uninitialized_clock}
-{
+SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock,
+                         bool can_write_uninitialized_clock)
+    : ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core},
+      m_can_write_clock{can_write_clock}, m_can_write_uninitialized_clock{
+                                              can_write_uninitialized_clock} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"},
@@ -76,7 +72,7 @@ Result SystemClock::GetOperationEventReadableHandle(
    LOG_DEBUG(Service_Time, "called.");

    if (!m_operation_event) {
-        m_operation_event = std::make_unique<OperationEvent>(system);
+        m_operation_event = std::make_unique<OperationEvent>(m_system);
        R_UNLESS(m_operation_event != nullptr, ResultFailed);

        m_clock_core.LinkOperationEvent(*m_operation_event);
@@ -1,6 +1,3 @@
-// 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

@@ -21,7 +18,9 @@ namespace Service::PSC::Time {

 class SystemClock final : public ServiceFramework<SystemClock> {
 public:
-    explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core, bool can_write_clock, bool can_write_uninitialized_clock);
+    explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core,
+                         bool can_write_clock, bool can_write_uninitialized_clock);
+
    ~SystemClock() override = default;

    Result GetCurrentTime(Out<s64> out_time);
@@ -31,6 +30,8 @@ public:
    Result GetOperationEventReadableHandle(OutCopyHandle<Kernel::KReadableEvent> out_event);

 private:
+    Core::System& m_system;
+
    SystemClockCore& m_clock_core;
    bool m_can_write_clock;
    bool m_can_write_uninitialized_clock;
@@ -15,11 +15,9 @@ namespace Service::PSC::Time {

 TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core,
                                 TimeZone& time_zone, bool can_write_timezone_device_location)
-    : ServiceFramework{system_, "ITimeZoneService"}
-    , m_clock_core{clock_core}
-    , m_time_zone{time_zone}
-    , m_can_write_timezone_device_location{can_write_timezone_device_location}
-{
+    : ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core},
+      m_time_zone{time_zone}, m_can_write_timezone_device_location{
+                                  can_write_timezone_device_location} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
@@ -1,6 +1,3 @@
-// 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

@@ -59,6 +56,8 @@ public:
                                 const CalendarTime& calendar_time);

 private:
+    Core::System& m_system;
+
    StandardSteadyClockCore& m_clock_core;
    TimeZone& m_time_zone;
    bool m_can_write_timezone_device_location;
@@ -17,14 +17,10 @@ bool TranslatorVisitor::arm_B(Cond cond, Imm<24> imm24) {
    if (!ArmConditionPassed(cond)) {
        return true;
    }
+
    const u32 imm32 = mcl::bit::sign_extend<26, u32>(imm24.ZeroExtend() << 2) + 8;
    const auto new_location = ir.current_location.AdvancePC(imm32);
-    // pattern match => b .
-    if (imm32 == 0) {
-        ir.SetTerm(IR::Term::LinkBlock{new_location});
-    } else {
-        ir.SetTerm(IR::Term::LinkBlockFast{new_location});
-    }
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -39,7 +35,7 @@ bool TranslatorVisitor::arm_BL(Cond cond, Imm<24> imm24) {

    const u32 imm32 = mcl::bit::sign_extend<26, u32>(imm24.ZeroExtend() << 2) + 8;
    const auto new_location = ir.current_location.AdvancePC(imm32);
-    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -50,7 +46,7 @@ bool TranslatorVisitor::arm_BLX_imm(bool H, Imm<24> imm24) {

    const u32 imm32 = mcl::bit::sign_extend<26, u32>((imm24.ZeroExtend() << 2)) + (H ? 2 : 0) + 8;
    const auto new_location = ir.current_location.AdvancePC(imm32).SetTFlag(true);
-    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -56,10 +56,11 @@ bool TranslatorVisitor::arm_MSR_imm(Cond cond, unsigned mask, int rotate, Imm<8>
    if (write_e) {
        const bool E = (imm32 & 0x00000200) != 0;
        if (E != ir.current_location.EFlag()) {
-            ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location.AdvancePC(4).SetEFlag(E)});
+            ir.SetTerm(IR::Term::LinkBlock{ir.current_location.AdvancePC(4).SetEFlag(E)});
            return false;
        }
    }
+
    return true;
 }

@@ -111,7 +112,7 @@ bool TranslatorVisitor::arm_RFE() {

 // SETEND <endian_specifier>
 bool TranslatorVisitor::arm_SETEND(bool E) {
-    ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location.AdvancePC(4).SetEFlag(E)});
+    ir.SetTerm(IR::Term::LinkBlock{ir.current_location.AdvancePC(4).SetEFlag(E)});
    return false;
 }

@@ -803,7 +803,7 @@ bool TranslatorVisitor::thumb16_SETEND(bool E) {
        return true;
    }

-    ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location.AdvancePC(2).SetEFlag(E).AdvanceIT()});
+    ir.SetTerm(IR::Term::LinkBlock{ir.current_location.AdvancePC(2).SetEFlag(E).AdvanceIT()});
    return false;
 }

@@ -906,8 +906,9 @@ bool TranslatorVisitor::thumb16_CBZ_CBNZ(bool nonzero, Imm<1> i, Imm<5> imm5, Re
    ir.SetCheckBit(ir.IsZero(rn));

    const auto [cond_pass, cond_fail] = [this, imm, nonzero] {
-        const auto skip = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(2).AdvanceIT()};
-        const auto branch = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(imm + 4).AdvanceIT()};
+        const auto skip = IR::Term::LinkBlock{ir.current_location.AdvancePC(2).AdvanceIT()};
+        const auto branch = IR::Term::LinkBlock{ir.current_location.AdvancePC(imm + 4).AdvanceIT()};
+
        if (nonzero) {
            return std::make_pair(skip, branch);
        } else {
@@ -974,10 +975,10 @@ bool TranslatorVisitor::thumb16_B_t1(Cond cond, Imm<8> imm8) {
    }

    const s32 imm32 = static_cast<s32>((imm8.SignExtend<u32>() << 1) + 4);
-    const auto then_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(imm32).AdvanceIT()};
-    const auto else_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(2).AdvanceIT()};
+    const auto then_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
+    const auto else_location = ir.current_location.AdvancePC(2).AdvanceIT();

-    ir.SetTerm(IR::Term::If{cond, then_, else_});
+    ir.SetTerm(IR::Term::If{cond, IR::Term::LinkBlock{then_location}, IR::Term::LinkBlock{else_location}});
    return false;
 }

@@ -989,12 +990,8 @@ bool TranslatorVisitor::thumb16_B_t2(Imm<11> imm11) {

    const s32 imm32 = static_cast<s32>((imm11.SignExtend<u32>() << 1) + 4);
    const auto next_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
-    // pattern (b +#0)
-    if (imm32 == 0) {
-        ir.SetTerm(IR::Term::LinkBlock{next_location});
-    } else {
-        ir.SetTerm(IR::Term::LinkBlockFast{next_location});
-    }
+
+    ir.SetTerm(IR::Term::LinkBlock{next_location});
    return false;
 }

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* This file is part of the dynarmic project.
 * Copyright (c) 2016 MerryMage
 * SPDX-License-Identifier: 0BSD
@@ -23,8 +20,10 @@ bool TranslatorVisitor::thumb32_BL_imm(Imm<1> S, Imm<10> hi, Imm<1> j1, Imm<1> j
    ir.SetRegister(Reg::LR, ir.Imm32((ir.current_location.PC() + 4) | 1));

    const s32 imm32 = static_cast<s32>((concatenate(S, i1, i2, hi, lo).SignExtend<u32>() << 1) + 4);
-    auto const new_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
-    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
+    const auto new_location = ir.current_location
+                                  .AdvancePC(imm32)
+                                  .AdvanceIT();
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -45,8 +44,11 @@ bool TranslatorVisitor::thumb32_BLX_imm(Imm<1> S, Imm<10> hi, Imm<1> j1, Imm<1>
    ir.SetRegister(Reg::LR, ir.Imm32((ir.current_location.PC() + 4) | 1));

    const s32 imm32 = static_cast<s32>(concatenate(S, i1, i2, hi, lo).SignExtend<u32>() << 1);
-    const auto new_location = ir.current_location.SetPC(ir.AlignPC(4) + imm32).SetTFlag(false).AdvanceIT();
-    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
+    const auto new_location = ir.current_location
+                                  .SetPC(ir.AlignPC(4) + imm32)
+                                  .SetTFlag(false)
+                                  .AdvanceIT();
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -59,13 +61,10 @@ bool TranslatorVisitor::thumb32_B(Imm<1> S, Imm<10> hi, Imm<1> j1, Imm<1> j2, Im
    }

    const s32 imm32 = static_cast<s32>((concatenate(S, i1, i2, hi, lo).SignExtend<u32>() << 1) + 4);
-    auto const new_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
-    // Pattern to halt execution (b +#0)
-    if (imm32 == 0) {
-        ir.SetTerm(IR::Term::LinkBlock{new_location});
-    } else {
-        ir.SetTerm(IR::Term::LinkBlockFast{new_location});
-    }
+    const auto new_location = ir.current_location
+                                  .AdvancePC(imm32)
+                                  .AdvanceIT();
+    ir.SetTerm(IR::Term::LinkBlock{new_location});
    return false;
 }

@@ -76,9 +75,13 @@ bool TranslatorVisitor::thumb32_B_cond(Imm<1> S, Cond cond, Imm<6> hi, Imm<1> i1

    // Note: i1 and i2 were not inverted from encoding and are opposite compared to the other B instructions.
    const s32 imm32 = static_cast<s32>((concatenate(S, i2, i1, hi, lo).SignExtend<u32>() << 1) + 4);
-    const auto then_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(imm32).AdvanceIT()};
-    const auto else_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(4).AdvanceIT()};
-    ir.SetTerm(IR::Term::If{cond, then_, else_});
+    const auto then_location = ir.current_location
+                                   .AdvancePC(imm32)
+                                   .AdvanceIT();
+    const auto else_location = ir.current_location
+                                   .AdvancePC(4)
+                                   .AdvanceIT();
+    ir.SetTerm(IR::Term::If{cond, IR::Term::LinkBlock{then_location}, IR::Term::LinkBlock{else_location}});
    return false;
 }

@@ -14,8 +14,8 @@ bool TranslatorVisitor::B_cond(Imm<19> imm19, Cond cond) {
    const s64 offset = concatenate(imm19, Imm<2>{0}).SignExtend<s64>();
    const u64 target = ir.PC() + offset;

-    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
-    const auto cond_fail = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
+    const auto cond_pass = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
+    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
    ir.SetTerm(IR::Term::If{cond, cond_pass, cond_fail});
    return false;
 }
@@ -26,9 +26,9 @@ bool TranslatorVisitor::B_uncond(Imm<26> imm26) {
    // Pattern to halt execution (B .)
    if (target == ir.PC()) {
        ir.SetTerm(IR::Term::LinkBlock{ir.current_location->SetPC(target)});
-    } else {
-        ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location->SetPC(target)});
+        return false;
    }
+    ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location->SetPC(target)});
    return false;
 }

@@ -79,8 +79,8 @@ bool TranslatorVisitor::CBZ(bool sf, Imm<19> imm19, Reg Rt) {
    ir.SetCheckBit(ir.IsZero(operand1));

    const u64 target = ir.PC() + offset;
-    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
-    const auto cond_fail = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
+    const auto cond_pass = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
+    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
    ir.SetTerm(IR::Term::CheckBit{cond_pass, cond_fail});
    return false;
 }
@@ -94,8 +94,8 @@ bool TranslatorVisitor::CBNZ(bool sf, Imm<19> imm19, Reg Rt) {
    ir.SetCheckBit(ir.IsZero(operand1));

    const u64 target = ir.PC() + offset;
-    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
-    const auto cond_fail = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
+    const auto cond_pass = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
+    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
    ir.SetTerm(IR::Term::CheckBit{cond_pass, cond_fail});
    return false;
 }
@@ -110,8 +110,8 @@ bool TranslatorVisitor::TBZ(Imm<1> b5, Imm<5> b40, Imm<14> imm14, Reg Rt) {
    ir.SetCheckBit(ir.TestBit(operand, ir.Imm8(bit_pos)));

    const u64 target = ir.PC() + offset;
-    const auto cond_1 = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
-    const auto cond_0 = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
+    const auto cond_1 = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
+    const auto cond_0 = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
    ir.SetTerm(IR::Term::CheckBit{cond_1, cond_0});
    return false;
 }
@@ -126,8 +126,8 @@ bool TranslatorVisitor::TBNZ(Imm<1> b5, Imm<5> b40, Imm<14> imm14, Reg Rt) {
    ir.SetCheckBit(ir.TestBit(operand, ir.Imm8(bit_pos)));

    const u64 target = ir.PC() + offset;
-    const auto cond_1 = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
-    const auto cond_0 = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
+    const auto cond_1 = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
+    const auto cond_0 = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
    ir.SetTerm(IR::Term::CheckBit{cond_1, cond_0});
    return false;
 }
@@ -1,11 +1,7 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/settings.h"
-#include "common/assert.h"
 #include "hid_core/frontend/emulated_console.h"
 #include "hid_core/frontend/input_converter.h"

@@ -312,15 +308,17 @@ void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {

 int EmulatedConsole::SetCallback(ConsoleUpdateCallback update_callback) {
    std::scoped_lock lock{callback_mutex};
-    ++last_callback_key;
    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
-    return last_callback_key;
+    return last_callback_key++;
 }

 void EmulatedConsole::DeleteCallback(int key) {
    std::scoped_lock lock{callback_mutex};
-    auto const it = callback_list.find(key);
-    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
-    callback_list.erase(it);
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
 }
 } // namespace Core::HID
@@ -10,7 +10,6 @@

 #include <ranges>
 #include "common/thread.h"
-#include "common/assert.h"
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/frontend/input_converter.h"
 #include "hid_core/hid_util.h"
@@ -1877,9 +1876,12 @@ NpadColor EmulatedController::GetNpadColor(u32 color) {

 void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
    std::unique_lock lock{callback_mutex};
-    for (auto const& p : callback_list) {
-        auto const& poller = p.second;
-        if (is_npad_service_update || !poller.is_npad_service) {
+    for (const auto& poller_pair : callback_list) {
+        const ControllerUpdateCallback& poller = poller_pair.second;
+        if (!is_npad_service_update && poller.is_npad_service) {
+            continue;
+        }
+        if (poller.on_change) {
            poller.on_change(type);
        }
    }
@@ -1887,16 +1889,18 @@ void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npa

 int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
    std::unique_lock lock{callback_mutex};
-    ++last_callback_key;
    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
-    return last_callback_key;
+    return last_callback_key++;
 }

 void EmulatedController::DeleteCallback(int key) {
    std::unique_lock lock{callback_mutex};
-    auto const it = callback_list.find(key);
-    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
-    callback_list.erase(it);
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
 }

 void EmulatedController::StatusUpdate() {
@@ -1,13 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
 #include <fmt/ranges.h>

-#include "common/assert.h"
 #include "hid_core/frontend/emulated_devices.h"
 #include "hid_core/frontend/input_converter.h"

@@ -471,15 +467,17 @@ void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {

 int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) {
    std::scoped_lock lock{callback_mutex};
-    ++last_callback_key;
    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
-    return last_callback_key;
+    return last_callback_key++;
 }

 void EmulatedDevices::DeleteCallback(int key) {
    std::scoped_lock lock{callback_mutex};
-    auto const it = callback_list.find(key);
-    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
-    callback_list.erase(it);
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
 }
 } // namespace Core::HID
@@ -1,11 +1,7 @@
-// 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 <cmath>
-#include <numbers>

 #include "common/math_util.h"
 #include "hid_core/frontend/motion_input.h"
@@ -149,7 +145,7 @@ void MotionInput::UpdateOrientation(u64 elapsed_time) {
    }

    const auto normal_accel = accel.Normalized();
-    auto rad_gyro = gyro * std::numbers::pi_v<float> * 2.f;
+    auto rad_gyro = gyro * Common::PI * 2;
    const f32 swap = rad_gyro.x;
    rad_gyro.x = rad_gyro.y;
    rad_gyro.y = -swap;
@@ -276,7 +272,7 @@ Common::Vec3f MotionInput::GetEulerAngles() const {

    return {
        std::atan2(sinr_cosp, cosr_cosp),
-        2 * std::atan2(sinp, cosp) - float(std::numbers::pi_v<float>) / 2,
+        2 * std::atan2(sinp, cosp) - Common::PI / 2,
        std::atan2(siny_cosp, cosy_cosp),
    };
 }
@@ -24,8 +24,7 @@ HIDCore::HIDCore(Kernel::KernelCore& kernel_)
    , player_8{std::make_unique<EmulatedController>(NpadIdType::Player8)}
    , other{std::make_unique<EmulatedController>(NpadIdType::Other)}
    , handheld{std::make_unique<EmulatedController>(NpadIdType::Handheld)}
-    , console{std::make_unique<EmulatedConsole>()}
-    , devices{std::make_unique<EmulatedDevices>()}
+    , console{std::make_unique<EmulatedConsole>()}, devices{std::make_unique<EmulatedDevices>()}
    , kernel{kernel_}
 {}

@@ -45,17 +45,29 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service
        AbstractPad{hid_core_.kernel},
    }}
 {
+    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
+        for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
+            auto& controller = controller_data[aruid_index][i];
+            controller.device = hid_core.GetEmulatedControllerByIndex(i);
+            Core::HID::ControllerUpdateCallback engine_callback{
+                .on_change = [this, i, kernel = &hid_core.kernel](Core::HID::ControllerTriggerType type) {
+                    ControllerUpdate(*kernel, type, i);
+                },
+                .is_npad_service = true,
+            };
+            controller.callback_key = controller.device->SetCallback(engine_callback);
+        }
+    }
    for (std::size_t i = 0; i < abstracted_pads.size(); ++i) {
        abstracted_pads[i].SetNpadId(IndexToNpadIdType(i));
    }
 }

 NPad::~NPad() {
-    for (std::size_t aruid = 0; aruid < AruidIndexMax; ++aruid) {
-        for (std::size_t i = 0; i < controller_data[aruid].size(); ++i) {
-            if (auto& controller = controller_data[aruid][i]; controller.device && controller.callback_key) {
-                controller.device->DeleteCallback(controller.callback_key);
-            }
+    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
+        for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
+            auto& controller = controller_data[aruid_index][i];
+            controller.device->DeleteCallback(controller.callback_key);
        }
    }
 }
@@ -89,16 +101,6 @@ Result NPad::Activate(u64 aruid) {
    for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
        auto& controller = controller_data[aruid_index][i];
        controller.shared_memory = &data->shared_memory_format->npad.npad_entry[i].internal_state;
-        controller.device = hid_core.GetEmulatedControllerByIndex(i);
-        if (!controller.callback_key) {
-            Core::HID::ControllerUpdateCallback engine_callback{
-                .on_change = [this, i](Core::HID::ControllerTriggerType type) {
-                    ControllerUpdate(hid_core.kernel, type, i);
-                },
-                .is_npad_service = true,
-            };
-            controller.callback_key = controller.device->SetCallback(engine_callback);
-        }
    }

    // Prefill controller buffers
@@ -1,10 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

-#include <numbers>
 #include "common/math_util.h"
 #include "hid_core/resources/touch_screen/gesture_handler.h"

@@ -215,7 +214,7 @@ void GestureHandler::UpdatePanEvent(GestureState& next_state, GestureType& type)
    if (std::abs(angle_between_two_lines) > AngleThreshold) {
        type = GestureType::Rotate;
        next_state.scale = 0;
-        next_state.rotation_angle = angle_between_two_lines * 180.0f / float(std::numbers::pi_v<float>);
+        next_state.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
    }
 }

@@ -3,8 +3,6 @@
 // SPDX-FileCopyrightText: 2018 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include <array>
-#include <numbers>
 #include "common/logging.h"
 #include "common/math_util.h"
 #include "common/param_package.h"
@@ -148,9 +146,9 @@ public:
            break;
        }
        case SDL_SENSOR_GYRO: {
-            motion.gyro_x = event.data[0] / (f32(std::numbers::pi_v<float>) * 2);
-            motion.gyro_y = -event.data[2] / (f32(std::numbers::pi_v<float>) * 2);
-            motion.gyro_z = event.data[1] / (f32(std::numbers::pi_v<float>) * 2);
+            motion.gyro_x = event.data[0] / (Common::PI * 2);
+            motion.gyro_y = -event.data[2] / (Common::PI * 2);
+            motion.gyro_z = event.data[1] / (Common::PI * 2);
            break;
        }
        }
@@ -950,39 +948,34 @@ ButtonMapping SDLDriver::GetButtonMappingForDevice(const Common::ParamPackage& p
    }
    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));

+    auto* controller = joystick->GetSDLGameController();
+    if (controller == nullptr) {
+        return {};
+    }
+
    // This list is missing ZL/ZR since those are not considered buttons in SDL GameController.
    // We will add those afterwards
-    ButtonBindings switch_to_sdl_button = GetDefaultButtonBinding(joystick);
+    ButtonBindings switch_to_sdl_button;
+
+    switch_to_sdl_button = GetDefaultButtonBinding(joystick);
+
    // Add the missing bindings for ZL/ZR
    static constexpr ZButtonBindings switch_to_sdl_axis{{
        {Settings::NativeButton::ZL, SDL_GAMEPAD_AXIS_LEFT_TRIGGER},
        {Settings::NativeButton::ZR, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER},
    }};
-    if (auto* controller = joystick->GetSDLGameController(); controller) {
-        // Parameters contain two joysticks return dual
-        if (params.Has("guid2")) {
-            const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
-            if (joystick2->GetSDLGameController())
-                return GetDualControllerMapping(joystick, joystick2, switch_to_sdl_button, switch_to_sdl_axis);
+
+    // Parameters contain two joysticks return dual
+    if (params.Has("guid2")) {
+        const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
+
+        if (joystick2->GetSDLGameController() != nullptr) {
+            return GetDualControllerMapping(joystick, joystick2, switch_to_sdl_button,
+                                            switch_to_sdl_axis);
        }
-        return GetSingleControllerMapping(joystick, switch_to_sdl_button, switch_to_sdl_axis);
    }
-    // Default mappings for when the controller doesn't have an associated gamepad
-    // This fixes issues where SDL uses a backend which doesn't support gamepad remappings
-    ButtonMapping mapping;
-    for (const auto& pair : switch_to_sdl_button) {
-        SDL_GamepadBinding binding{};
-        binding.input_type = SDL_GAMEPAD_BINDTYPE_BUTTON;
-        binding.input.button = pair.second;
-        mapping.insert_or_assign(pair.first, BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-    for (const auto& pair : switch_to_sdl_axis) {
-        SDL_GamepadBinding binding{};
-        binding.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
-        binding.input.axis.axis = pair.second;
-        mapping.insert_or_assign(pair.first, BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-    return mapping;
+
+    return GetSingleControllerMapping(joystick, switch_to_sdl_button, switch_to_sdl_axis);
 }

 ButtonBindings SDLDriver::GetDefaultButtonBinding(
@@ -1,12 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <chrono>
 #include <cmath>
-#include <numbers>
 #include "common/math_util.h"
 #include "common/settings.h"
 #include "input_common/helpers/stick_from_buttons.h"
@@ -19,8 +15,9 @@ public:
    // do not play nicely with the theoretical maximum range.
    // Using a value one lower from the maximum emulates real stick behavior.
    static constexpr float MAX_RANGE = 32766.0f / 32767.0f;
+    static constexpr float TAU = Common::PI * 2.0f;
    // Use wider angle to ease the transition.
-    static constexpr float APERTURE = float((std::numbers::pi_v<float> / 2.f)) * 0.15f;
+    static constexpr float APERTURE = TAU * 0.15f;

    using Button = std::unique_ptr<Common::Input::InputDevice>;

@@ -69,13 +66,13 @@ public:
    bool IsAngleGreater(float old_angle, float new_angle) const {
        const float top_limit = new_angle + APERTURE;
        return (old_angle > new_angle && old_angle <= top_limit) ||
-               (old_angle + f32((std::numbers::pi_v<float> / 2.f)) > new_angle && old_angle + f32((std::numbers::pi_v<float> / 2.f)) <= top_limit);
+               (old_angle + TAU > new_angle && old_angle + TAU <= top_limit);
    }

    bool IsAngleSmaller(float old_angle, float new_angle) const {
        const float bottom_limit = new_angle - APERTURE;
        return (old_angle >= bottom_limit && old_angle < new_angle) ||
-               (old_angle - f32((std::numbers::pi_v<float> / 2.f)) >= bottom_limit && old_angle - f32((std::numbers::pi_v<float> / 2.f)) < new_angle);
+               (old_angle - TAU >= bottom_limit && old_angle - TAU < new_angle);
    }

    float GetAngle(std::chrono::time_point<std::chrono::steady_clock> now) const {
@@ -90,16 +87,16 @@ public:

        if (IsAngleGreater(new_angle, goal_angle)) {
            new_angle -= modifier_angle * time_difference;
-            if (new_angle < 0.f) {
-                new_angle += f32((std::numbers::pi_v<float> / 2.f));
+            if (new_angle < 0) {
+                new_angle += TAU;
            }
            if (!IsAngleGreater(new_angle, goal_angle)) {
                return goal_angle;
            }
        } else if (IsAngleSmaller(new_angle, goal_angle)) {
            new_angle += modifier_angle * time_difference;
-            if (new_angle >= f32((std::numbers::pi_v<float> / 2.f))) {
-                new_angle -= f32((std::numbers::pi_v<float> / 2.f));
+            if (new_angle >= TAU) {
+                new_angle -= TAU;
            }
            if (!IsAngleSmaller(new_angle, goal_angle)) {
                return goal_angle;
@@ -111,14 +108,45 @@ public:
    }

    void SetGoalAngle(bool r, bool l, bool u, bool d) {
-        if (r && !u && !d) goal_angle = f32(std::numbers::pi_v<float>) * 0.00f; //right
-        if (r && u && !d)  goal_angle = f32(std::numbers::pi_v<float>) * 0.25f; //upper right
-        if (u && !l && !r) goal_angle = f32(std::numbers::pi_v<float>) * 0.50f; //up
-        if (l && u && !d)  goal_angle = f32(std::numbers::pi_v<float>) * 0.75f; //upper left
-        if (l && !u && !d) goal_angle = f32(std::numbers::pi_v<float>) * 1.00f; //left
-        if (l && !u && d)  goal_angle = f32(std::numbers::pi_v<float>) * 1.25f; //bottom left
-        if (d && !l && !r) goal_angle = f32(std::numbers::pi_v<float>) * 1.50f; //down
-        if (r && !u && d)  goal_angle = f32(std::numbers::pi_v<float>) * 1.75f; //bottom right
+        // Move to the right
+        if (r && !u && !d) {
+            goal_angle = 0.0f;
+        }
+
+        // Move to the upper right
+        if (r && u && !d) {
+            goal_angle = Common::PI * 0.25f;
+        }
+
+        // Move up
+        if (u && !l && !r) {
+            goal_angle = Common::PI * 0.5f;
+        }
+
+        // Move to the upper left
+        if (l && u && !d) {
+            goal_angle = Common::PI * 0.75f;
+        }
+
+        // Move to the left
+        if (l && !u && !d) {
+            goal_angle = Common::PI;
+        }
+
+        // Move to the bottom left
+        if (l && !u && d) {
+            goal_angle = Common::PI * 1.25f;
+        }
+
+        // Move down
+        if (d && !l && !r) {
+            goal_angle = Common::PI * 1.5f;
+        }
+
+        // Move to the bottom right
+        if (r && !u && d) {
+            goal_angle = Common::PI * 1.75f;
+        }
    }

    void UpdateUpButtonStatus(const Common::Input::CallbackStatus& button_callback) {
@@ -4,7 +4,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/logging.h"
-#include "common/assert.h"
 #include "input_common/input_engine.h"

 namespace InputCommon {
@@ -464,9 +463,8 @@ const std::string& InputEngine::GetEngineName() const {

 int InputEngine::SetCallback(InputIdentifier input_identifier) {
    std::scoped_lock lock{mutex_callback};
-    ++last_callback_key;
    callback_list.insert_or_assign(last_callback_key, std::move(input_identifier));
-    return last_callback_key;
+    return last_callback_key++;
 }

 void InputEngine::SetMappingCallback(MappingCallback callback) {
@@ -476,9 +474,12 @@ void InputEngine::SetMappingCallback(MappingCallback callback) {

 void InputEngine::DeleteCallback(int key) {
    std::scoped_lock lock{mutex_callback};
-    auto const it = callback_list.find(key);
-    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
-    callback_list.erase(it);
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
 }

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -665,8 +665,6 @@ void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU3
                     const IR::Value& clamp, const IR::Value& segmentation_mask);
 void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 index,
                          const IR::Value& clamp, const IR::Value& segmentation_mask);
-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 lane);
-void EmitQuadSwap(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 direction);
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a, ScalarF32 op_b,
                     ScalarU32 swizzle);
 void EmitDPdxFine(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a);
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -100,26 +97,6 @@ void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, Sca
    Shuffle(ctx, inst, value, index, clamp, segmentation_mask, "XOR");
 }

-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 lane) {
-    // QuadBroadcast: src = (thread_id & ~3) | (lane & 3) — SHFIDX with quad mask 0x1C03
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("AND.U RC.x,{}.threadid,~3;"
-            "AND.U RC.y,{},3;"
-            "OR.U RC.x,RC.x,RC.y;"
-            "SHFIDX.U {},{},RC.x,0x1C03;"
-            "MOV.U {}.x,{}.y;",
-            ctx.stage_name, lane, ret, value, ret, ret);
-}
-
-void EmitQuadSwap(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 direction) {
-    // QuadSwap: XOR thread_id with (direction+1) within quad — SHFXOR with quad mask 0x1C03
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("ADD.U RC.x,{},1;"
-            "SHFXOR.U {},{},RC.x,0x1C03;"
-            "MOV.U {}.x,{}.y;",
-            direction, ret, value, ret, ret);
-}
-
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a, ScalarF32 op_b,
                     ScalarU32 swizzle) {
    const auto ret{ctx.reg_alloc.Define(inst)};
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -743,10 +743,6 @@ void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
 void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view value,
                          std::string_view index, std::string_view clamp,
                          std::string_view segmentation_mask);
-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                       std::string_view lane);
-void EmitQuadSwap(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                  std::string_view direction);
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, std::string_view op_a, std::string_view op_b,
                     std::string_view swizzle);
 void EmitDPdxFine(EmitContext& ctx, IR::Inst& inst, std::string_view op_a);
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -203,20 +200,6 @@ void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view val
    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
 }

-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                       std::string_view lane) {
-    // QuadBroadcast: read from (thread_id & ~3) | (lane & 3) within the subgroup
-    const auto src_thread_id{fmt::format("(({}&~3)|({}& 3))", THREAD_ID, lane)};
-    ctx.AddU32("{}=readInvocationARB({},{});", inst, value, src_thread_id);
-}
-
-void EmitQuadSwap(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                  std::string_view direction) {
-    // QuadSwap: XOR thread_id with (direction+1) — maps directions 0/1/2 to XOR 1/2/3
-    const auto src_thread_id{fmt::format("({}^({}+1))", THREAD_ID, direction)};
-    ctx.AddU32("{}=readInvocationARB({},{});", inst, value, src_thread_id);
-}
-
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, std::string_view op_a, std::string_view op_b,
                     std::string_view swizzle) {
    const auto mask{fmt::format("({}>>((gl_SubGroupInvocationARB&3)<<1))&3", swizzle)};
@@ -322,12 +322,6 @@ void DefineEntryPoint(const IR::Program& program, EmitContext& ctx, Id main) {
        if (ctx.runtime_info.force_early_z) {
            ctx.AddExecutionMode(main, spv::ExecutionMode::EarlyFragmentTests);
        }
-        if (ctx.profile.support_shader_quad_control &&
-            (program.info.uses_derivatives || program.info.uses_quad_shuffles)) {
-            ctx.AddExtension("SPV_KHR_quad_control");
-            ctx.AddCapability(spv::Capability::QuadControlKHR);
-            ctx.AddExecutionMode(main, spv::ExecutionMode::RequireFullQuadsKHR);
-        }
        break;
    default:
        throw NotImplementedException("Stage {}", program.stage);
@@ -409,6 +403,9 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
    if (info.uses_sampled_1d) {
        ctx.AddCapability(spv::Capability::Sampled1D);
    }
+    if (info.uses_image_1d) {
+        ctx.AddCapability(spv::Capability::Image1D);
+    }
    if (info.uses_sparse_residency) {
        ctx.AddCapability(spv::Capability::SparseResidency);
    }
@@ -438,7 +435,7 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
    }
    if ((info.uses_subgroup_vote || info.uses_subgroup_invocation_id ||
         info.uses_subgroup_shuffles) &&
-        profile.support_vote) {
+        profile.support_vote && profile.SupportsSubgroupStage(ctx.stage)) {
        ctx.AddCapability(spv::Capability::GroupNonUniformBallot);
        ctx.AddCapability(spv::Capability::GroupNonUniformShuffle);
        if (!profile.warp_size_potentially_larger_than_guest) {
@@ -446,12 +443,6 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
            ctx.AddCapability(spv::Capability::GroupNonUniformVote);
        }
    }
-    if (info.uses_quad_shuffles) {
-        if (profile.support_quad_shuffles) {
-            ctx.AddCapability(spv::Capability::GroupNonUniformQuad);
-        }
-        ctx.AddCapability(spv::Capability::GroupNonUniformShuffle);
-    }
    if (info.uses_int64_bit_atomics && profile.support_int64_atomics) {
        ctx.AddCapability(spv::Capability::Int64Atomics);
    }
@@ -202,7 +202,8 @@ void EmitGetIndirectBranchVariable(EmitContext&) {
 }

 Id EmitGetCbufU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int8) {
+    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int8 &&
+        ctx.profile.support_uniform_and_storage_buffer_8bit) {
        const Id load{GetCbuf(ctx, ctx.U8, &UniformDefinitions::U8, sizeof(u8), binding, offset,
                              ctx.load_const_func_u8)};
        return ctx.OpUConvert(ctx.U32[1], load);
@@ -219,7 +220,8 @@ Id EmitGetCbufU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& of
 }

 Id EmitGetCbufS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int8) {
+    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int8 &&
+        ctx.profile.support_uniform_and_storage_buffer_8bit) {
        const Id load{GetCbuf(ctx, ctx.S8, &UniformDefinitions::S8, sizeof(s8), binding, offset,
                              ctx.load_const_func_u8)};
        return ctx.OpSConvert(ctx.U32[1], load);
@@ -236,7 +238,8 @@ Id EmitGetCbufS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& of
 }

 Id EmitGetCbufU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int16) {
+    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int16 &&
+        ctx.profile.support_uniform_and_storage_buffer_16bit) {
        const Id load{GetCbuf(ctx, ctx.U16, &UniformDefinitions::U16, sizeof(u16), binding, offset,
                              ctx.load_const_func_u16)};
        return ctx.OpUConvert(ctx.U32[1], load);
@@ -253,7 +256,8 @@ Id EmitGetCbufU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& o
 }

 Id EmitGetCbufS16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int16) {
+    if (ctx.profile.support_descriptor_aliasing && ctx.profile.support_int16 &&
+        ctx.profile.support_uniform_and_storage_buffer_16bit) {
        const Id load{GetCbuf(ctx, ctx.S16, &UniformDefinitions::S16, sizeof(s16), binding, offset,
                              ctx.load_const_func_u16)};
        return ctx.OpSConvert(ctx.U32[1], load);
@@ -260,6 +260,13 @@ bool IsTextureMsaa(EmitContext& ctx, const IR::TextureInstInfo& info) {
    return ctx.textures.at(info.descriptor_index).is_multisample;
 }

+bool IsTextureInteger(EmitContext& ctx, const IR::TextureInstInfo& info) {
+    if (info.type == TextureType::Buffer) {
+        return false;
+    }
+    return ctx.textures.at(info.descriptor_index).is_integer;
+}
+
 Id Decorate(EmitContext& ctx, IR::Inst* inst, Id sample) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
    if (info.relaxed_precision != 0) {
@@ -480,11 +487,14 @@ Id EmitBoundImageWrite(EmitContext&) {
 Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id bias_lc, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
+    Id color;
    if (ctx.stage == Stage::Fragment) {
        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                     bias_lc, offset);
-        return Emit(&EmitContext::OpImageSparseSampleImplicitLod,
-                    &EmitContext::OpImageSampleImplicitLod, ctx, inst, ctx.F32[4],
+        color = Emit(&EmitContext::OpImageSparseSampleImplicitLod,
+                    &EmitContext::OpImageSampleImplicitLod, ctx, inst, result_type,
                    Texture(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
    } else {
        // We can't use implicit lods on non-fragment stages on SPIR-V. Maxwell hardware behaves as
@@ -492,26 +502,29 @@ Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
        // derivatives
        const Id lod{ctx.Const(0.0f)};
        const ImageOperands operands(ctx, false, true, info.has_lod_clamp != 0, lod, offset);
-        return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                    &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+        color = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                    &EmitContext::OpImageSampleExplicitLod, ctx, inst, result_type,
                    Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
    }
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], color) : color;
 }

 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id lod, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
    const ImageOperands operands(ctx, false, true, false, lod, offset);

    Id result = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                     &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                     &EmitContext::OpImageSampleExplicitLod, ctx, inst, result_type,
                     Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
 #ifdef __ANDROID__
-    if (Settings::values.fix_bloom_effects.GetValue()) {
+    if (!is_integer && Settings::values.fix_bloom_effects.GetValue()) {
        result = ctx.OpVectorTimesScalar(ctx.F32[4], result, ctx.Const(0.98f));
    }
 #endif
-    return result;
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], result) : result;
 }

 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
@@ -547,30 +560,39 @@ Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                   const IR::Value& offset, const IR::Value& offset2) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
    const ImageOperands operands(ctx, offset, offset2);
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
    }
-    return Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst,
-                ctx.F32[4], Texture(ctx, info, index), coords, ctx.Const(info.gather_component),
-                operands.MaskOptional(), operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst,
+                        result_type, Texture(ctx, info, index), coords,
+                        ctx.Const(info.gather_component), operands.MaskOptional(),
+                        operands.Span())};
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], color) : color;
 }

 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                       const IR::Value& offset, const IR::Value& offset2, Id dref) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
    const ImageOperands operands(ctx, offset, offset2);
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
    }
-    return Emit(&EmitContext::OpImageSparseDrefGather, &EmitContext::OpImageDrefGather, ctx, inst,
-                ctx.F32[4], Texture(ctx, info, index), coords, dref, operands.MaskOptional(),
-                operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseDrefGather, &EmitContext::OpImageDrefGather,
+                        ctx, inst, result_type, Texture(ctx, info, index), coords, dref,
+                        operands.MaskOptional(), operands.Span())};
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], color) : color;
 }

 Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset,
                  Id lod, Id ms) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
    AddOffsetToCoordinates(ctx, info, coords, offset);
    if (info.type == TextureType::Buffer) {
        lod = Id{};
@@ -580,8 +602,10 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
        lod = Id{};
    }
    const ImageOperands operands(lod, ms);
-    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
-                TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst,
+                        result_type, TextureImage(ctx, info, index), coords,
+                        operands.MaskOptional(), operands.Span())};
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], color) : color;
 }

 Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod,
@@ -626,14 +650,17 @@ Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                     Id derivatives, const IR::Value& offset, Id lod_clamp) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    const bool is_integer{IsTextureInteger(ctx, info)};
+    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
    const auto operands = info.num_derivatives == 3
                              ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              ctx.Def(offset), {}, lod_clamp)
                              : ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              info.num_derivatives, offset, lod_clamp);
-    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
-                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
+    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, result_type,
+                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
+    return is_integer ? ctx.OpBitcast(ctx.F32[4], color) : color;
 }

 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -622,8 +622,6 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam
                   Id segmentation_mask);
 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                        Id segmentation_mask);
-Id EmitQuadBroadcast(EmitContext& ctx, Id value, Id lane);
-Id EmitQuadSwap(EmitContext& ctx, Id value, Id direction);
 Id EmitFSwizzleAdd(EmitContext& ctx, Id op_a, Id op_b, Id swizzle);
 Id EmitDPdxFine(EmitContext& ctx, Id op_a);
 Id EmitDPdyFine(EmitContext& ctx, Id op_a);
@@ -13,7 +13,14 @@ Id SubgroupScope(EmitContext& ctx) {
    return ctx.Const(static_cast<u32>(spv::Scope::Subgroup));
 }

+bool StageSupportsSubgroups(EmitContext& ctx) {
+    return ctx.profile.SupportsSubgroupStage(ctx.stage);
+}
+
 Id GetThreadId(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.u32_zero_value;
+    }
    return ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id);
 }

@@ -71,6 +78,9 @@ Id GetMaxThreadId(EmitContext& ctx, Id thread_id, Id clamp, Id segmentation_mask
 }

 Id SelectValue(EmitContext& ctx, Id in_range, Id value, Id src_thread_id) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return value;
+    }
    return ctx.OpSelect(
        ctx.U32[1], in_range,
        ctx.OpGroupNonUniformShuffle(ctx.U32[1], SubgroupScope(ctx), value, src_thread_id), value);
@@ -92,6 +102,9 @@ Id EmitLaneId(EmitContext& ctx) {
 }

 Id EmitVoteAll(EmitContext& ctx, Id pred) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return pred;
+    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAll(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -105,6 +118,9 @@ Id EmitVoteAll(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteAny(EmitContext& ctx, Id pred) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return pred;
+    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAny(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -118,6 +134,9 @@ Id EmitVoteAny(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteEqual(EmitContext& ctx, Id pred) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.true_value;
+    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAllEqual(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -132,6 +151,9 @@ Id EmitVoteEqual(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.OpSelect(ctx.U32[1], pred, ctx.Const(1u), ctx.u32_zero_value);
+    }
    const Id ballot{ctx.OpGroupNonUniformBallot(ctx.U32[4], SubgroupScope(ctx), pred)};
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpCompositeExtract(ctx.U32[1], ballot, 0U);
@@ -140,22 +162,37 @@ Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupEqMask(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.Const(1u);
+    }
    return LoadMask(ctx, ctx.subgroup_mask_eq);
 }

 Id EmitSubgroupLtMask(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.u32_zero_value;
+    }
    return LoadMask(ctx, ctx.subgroup_mask_lt);
 }

 Id EmitSubgroupLeMask(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.Const(1u);
+    }
    return LoadMask(ctx, ctx.subgroup_mask_le);
 }

 Id EmitSubgroupGtMask(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.u32_zero_value;
+    }
    return LoadMask(ctx, ctx.subgroup_mask_gt);
 }

 Id EmitSubgroupGeMask(EmitContext& ctx) {
+    if (!StageSupportsSubgroups(ctx)) {
+        return ctx.Const(1u);
+    }
    return LoadMask(ctx, ctx.subgroup_mask_ge);
 }

@@ -223,24 +260,9 @@ Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id
    return SelectValue(ctx, in_range, value, src_thread_id);
 }

-Id EmitQuadBroadcast(EmitContext& ctx, Id value, Id lane) {
-    if (ctx.profile.support_quad_shuffles) {
-        return ctx.OpGroupNonUniformQuadBroadcast(ctx.U32[1], SubgroupScope(ctx), value, lane);
-    }
-    const Id base{ctx.OpBitwiseAnd(ctx.U32[1], GetThreadId(ctx), ctx.Const(~3u))};
-    const Id local_lane{ctx.OpBitwiseAnd(ctx.U32[1], lane, ctx.Const(3u))};
-    const Id src_thread_id{ctx.OpBitwiseOr(ctx.U32[1], base, local_lane)};
-    return ctx.OpGroupNonUniformShuffle(ctx.U32[1], SubgroupScope(ctx), value, src_thread_id);
-}
-
-Id EmitQuadSwap(EmitContext& ctx, Id value, Id direction) {
-    const Id xor_mask{ctx.OpIAdd(ctx.U32[1], direction, ctx.Const(1u))};
-    return ctx.OpGroupNonUniformShuffleXor(ctx.U32[1], SubgroupScope(ctx), value, xor_mask);
-}
-
 Id EmitFSwizzleAdd(EmitContext& ctx, Id op_a, Id op_b, Id swizzle) {
    const Id three{ctx.Const(3U)};
-    Id mask{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    Id mask{GetThreadId(ctx)};
    mask = ctx.OpBitwiseAnd(ctx.U32[1], mask, three);
    mask = ctx.OpShiftLeftLogical(ctx.U32[1], mask, ctx.Const(1U));
    mask = ctx.OpShiftRightLogical(ctx.U32[1], swizzle, mask);
@@ -30,7 +30,7 @@ enum class Operation {

 Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
    const spv::ImageFormat format{spv::ImageFormat::Unknown};
-    const Id type{ctx.F32[1]};
+    const Id type{desc.is_integer ? ctx.U32[1] : ctx.F32[1]};
    const bool depth{desc.is_depth};
    const bool ms{desc.is_multisample};
    switch (desc.type) {
@@ -1126,7 +1126,7 @@ void EmitContext::DefineConstantBuffers(const Info& info, u32& binding) {
    }
    IR::Type types{info.used_constant_buffer_types | info.used_indirect_cbuf_types};
    if (True(types & IR::Type::U8)) {
-        if (profile.support_int8) {
+        if (profile.support_int8 && profile.support_uniform_and_storage_buffer_8bit) {
            DefineConstBuffers(*this, info, &UniformDefinitions::U8, binding, U8, 'u', sizeof(u8));
            DefineConstBuffers(*this, info, &UniformDefinitions::S8, binding, S8, 's', sizeof(s8));
        } else {
@@ -1134,7 +1134,7 @@ void EmitContext::DefineConstantBuffers(const Info& info, u32& binding) {
        }
    }
    if (True(types & IR::Type::U16)) {
-        if (profile.support_int16) {
+        if (profile.support_int16 && profile.support_uniform_and_storage_buffer_16bit) {
            DefineConstBuffers(*this, info, &UniformDefinitions::U16, binding, U16, 'u',
                               sizeof(u16));
            DefineConstBuffers(*this, info, &UniformDefinitions::S16, binding, S16, 's',
@@ -1196,10 +1196,18 @@ void EmitContext::DefineConstantBufferIndirectFunctions(const Info& info) {
    IR::Type types{info.used_indirect_cbuf_types};
    bool supports_aliasing = profile.support_descriptor_aliasing;
    if (supports_aliasing && True(types & IR::Type::U8)) {
-        load_const_func_u8 = make_accessor(U8, &UniformDefinitions::U8);
+        if (profile.support_int8 && profile.support_uniform_and_storage_buffer_8bit) {
+            load_const_func_u8 = make_accessor(U8, &UniformDefinitions::U8);
+        } else {
+            types |= IR::Type::U32;
+        }
    }
    if (supports_aliasing && True(types & IR::Type::U16)) {
-        load_const_func_u16 = make_accessor(U16, &UniformDefinitions::U16);
+        if (profile.support_int16 && profile.support_uniform_and_storage_buffer_16bit) {
+            load_const_func_u16 = make_accessor(U16, &UniformDefinitions::U16);
+        } else {
+            types |= IR::Type::U32;
+        }
    }
    if (supports_aliasing && True(types & IR::Type::F32)) {
        load_const_func_f32 = make_accessor(F32[1], &UniformDefinitions::F32);
@@ -1375,6 +1383,7 @@ void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_in
            .image_type = image_type,
            .count = desc.count,
            .is_multisample = desc.is_multisample,
+            .is_integer = desc.is_integer,
        });
        if (profile.supported_spirv >= 0x00010400) {
            interfaces.push_back(id);
@@ -1438,7 +1447,7 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    if (info.uses_is_helper_invocation) {
        is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
    }
-    if (info.uses_subgroup_mask) {
+    if (info.uses_subgroup_mask && profile.SupportsSubgroupStage(stage)) {
        subgroup_mask_eq = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupEqMaskKHR);
        subgroup_mask_lt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLtMaskKHR);
        subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
@@ -1452,9 +1461,10 @@ void EmitContext::DefineInputs(const IR::Program& program) {
            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
        }
    }
-    if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
-        (profile.warp_size_potentially_larger_than_guest &&
-         (info.uses_subgroup_vote || info.uses_subgroup_mask))) {
+    if ((info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
+         (profile.warp_size_potentially_larger_than_guest &&
+          (info.uses_subgroup_vote || info.uses_subgroup_mask))) &&
+        profile.SupportsSubgroupStage(stage)) {
        AddCapability(spv::Capability::GroupNonUniform);
        subgroup_local_invocation_id =
            DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
@@ -42,6 +42,7 @@ struct TextureDefinition {
    Id image_type;
    u32 count;
    bool is_multisample;
+    bool is_integer;
 };

 struct TextureBufferDefinition {
@@ -38,11 +38,10 @@ struct CbufWordKeyHash {
 struct HandleKey {
    u32 index, offset, shift_left;
    u32 sec_index, sec_offset, sec_shift_left;
-    u32 count;
    bool has_secondary;
    constexpr bool operator==(const HandleKey& o) const noexcept {
-        return std::tie(index, offset, shift_left, sec_index, sec_offset, sec_shift_left, count, has_secondary)
-            == std::tie(o.index, o.offset, o.shift_left, o.sec_index, o.sec_offset, o.sec_shift_left, o.count, o.has_secondary);
+        return std::tie(index, offset, shift_left, sec_index, sec_offset, sec_shift_left, has_secondary)
+            == std::tie(o.index, o.offset, o.shift_left, o.sec_index, o.sec_offset, o.sec_shift_left, o.has_secondary);
    }
 };
 struct HandleKeyHash {
@@ -51,8 +50,8 @@ struct HandleKeyHash {
        h ^= (size_t(k.shift_left) << 1);
        h ^= (size_t(k.sec_index) << 33) ^ (size_t(k.sec_offset) << 2);
        h ^= (size_t(k.sec_shift_left) << 3);
-        h ^= (size_t(k.count) << 7);
-        return h ^ (k.has_secondary ? 0x9e3779b97f4a7c15ULL : 0ULL);
+        h ^= k.has_secondary ? 0x9e3779b97f4a7c15ULL : 0ULL;
+        return h;
    }
 };

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -2100,14 +2100,6 @@ U32 IREmitter::ShuffleButterfly(const IR::U32& value, const IR::U32& index, cons
    return Inst<U32>(Opcode::ShuffleButterfly, value, index, clamp, seg_mask);
 }

-U32 IREmitter::QuadBroadcast(const IR::U32& value, const IR::U32& lane) {
-    return Inst<U32>(Opcode::QuadBroadcast, value, lane);
-}
-
-U32 IREmitter::QuadSwap(const IR::U32& value, const IR::U32& direction) {
-    return Inst<U32>(Opcode::QuadSwap, value, direction);
-}
-
 F32 IREmitter::FSwizzleAdd(const F32& a, const F32& b, const U32& swizzle, FpControl control) {
    return Inst<F32>(Opcode::FSwizzleAdd, Flags{control}, a, b, swizzle);
 }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -394,8 +394,6 @@ public:
                                  const IR::U32& seg_mask);
    [[nodiscard]] U32 ShuffleButterfly(const IR::U32& value, const IR::U32& index,
                                       const IR::U32& clamp, const IR::U32& seg_mask);
-    [[nodiscard]] U32 QuadBroadcast(const IR::U32& value, const IR::U32& lane);
-    [[nodiscard]] U32 QuadSwap(const IR::U32& value, const IR::U32& direction);
    [[nodiscard]] F32 FSwizzleAdd(const F32& a, const F32& b, const U32& swizzle,
                                  FpControl control = {});

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -43,6 +46,10 @@ union TextureInstInfo {
    BitField<25, 2, u32> num_derivatives;
    BitField<27, 3, ImageFormat> image_format;
    BitField<30, 1, u32> ndv_is_active;
+    /// Only meaningful for the sampled-texture family (ImageSampleImplicitLod, ImageFetch,
+    /// ImageGather, etc.); unused/zero for storage-image opcodes, which carry their own
+    /// is_integer via ImageDescriptor/ImageBufferDescriptor instead.
+    BitField<31, 1, u32> is_integer;
 };
 static_assert(sizeof(TextureInstInfo) <= sizeof(u32));

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -8,27 +5,6 @@

 namespace Shader::IR {

-namespace Detail {
-
-OpcodeMeta META_TABLE[532] = {
-#define OPCODE(name_token, type_token, ...)                                                        \
-    {                                                                                              \
-        .name{#name_token},                                                                        \
-        .type = type_token,                                                                        \
-        .arg_types{__VA_ARGS__},                                                                   \
-    },
-#include "opcodes.inc"
-#undef OPCODE
-};
-
-u8 NUM_ARGS[532] = {
-#define OPCODE(name_token, type_token, ...) u8(CalculateNumArgsOf(Opcode::name_token)),
-#include "opcodes.inc"
-#undef OPCODE
-};
-
-}
-
 std::string_view NameOf(Opcode op) {
    return Detail::META_TABLE[static_cast<size_t>(op)].name;
 }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -30,54 +30,69 @@ struct OpcodeMeta {
 };

 // using enum Type;
-static constexpr Type Void{Type::Void};
-static constexpr Type Opaque{Type::Opaque};
-static constexpr Type Reg{Type::Reg};
-static constexpr Type Pred{Type::Pred};
-static constexpr Type Attribute{Type::Attribute};
-static constexpr Type Patch{Type::Patch};
-static constexpr Type U1{Type::U1};
-static constexpr Type U8{Type::U8};
-static constexpr Type U16{Type::U16};
-static constexpr Type U32{Type::U32};
-static constexpr Type U64{Type::U64};
-static constexpr Type F16{Type::F16};
-static constexpr Type F32{Type::F32};
-static constexpr Type F64{Type::F64};
-static constexpr Type U32x2{Type::U32x2};
-static constexpr Type U32x3{Type::U32x3};
-static constexpr Type U32x4{Type::U32x4};
-static constexpr Type F16x2{Type::F16x2};
-static constexpr Type F16x3{Type::F16x3};
-static constexpr Type F16x4{Type::F16x4};
-static constexpr Type F32x2{Type::F32x2};
-static constexpr Type F32x3{Type::F32x3};
-static constexpr Type F32x4{Type::F32x4};
-static constexpr Type F64x2{Type::F64x2};
-static constexpr Type F64x3{Type::F64x3};
-static constexpr Type F64x4{Type::F64x4};
+constexpr Type Void{Type::Void};
+constexpr Type Opaque{Type::Opaque};
+constexpr Type Reg{Type::Reg};
+constexpr Type Pred{Type::Pred};
+constexpr Type Attribute{Type::Attribute};
+constexpr Type Patch{Type::Patch};
+constexpr Type U1{Type::U1};
+constexpr Type U8{Type::U8};
+constexpr Type U16{Type::U16};
+constexpr Type U32{Type::U32};
+constexpr Type U64{Type::U64};
+constexpr Type F16{Type::F16};
+constexpr Type F32{Type::F32};
+constexpr Type F64{Type::F64};
+constexpr Type U32x2{Type::U32x2};
+constexpr Type U32x3{Type::U32x3};
+constexpr Type U32x4{Type::U32x4};
+constexpr Type F16x2{Type::F16x2};
+constexpr Type F16x3{Type::F16x3};
+constexpr Type F16x4{Type::F16x4};
+constexpr Type F32x2{Type::F32x2};
+constexpr Type F32x3{Type::F32x3};
+constexpr Type F32x4{Type::F32x4};
+constexpr Type F64x2{Type::F64x2};
+constexpr Type F64x3{Type::F64x3};
+constexpr Type F64x4{Type::F64x4};

-extern OpcodeMeta META_TABLE[532];
-constexpr size_t CalculateNumArgsOf(Opcode op) noexcept {
-    const auto& arg_types = META_TABLE[size_t(op)].arg_types;
-    return size_t(std::distance(arg_types.begin(), std::ranges::find(arg_types, Type::Void)));
+constexpr OpcodeMeta META_TABLE[]{
+#define OPCODE(name_token, type_token, ...)                                                        \
+    {                                                                                              \
+        .name{#name_token},                                                                        \
+        .type = type_token,                                                                        \
+        .arg_types{__VA_ARGS__},                                                                   \
+    },
+#include "opcodes.inc"
+#undef OPCODE
+};
+constexpr size_t CalculateNumArgsOf(Opcode op) {
+    const auto& arg_types{META_TABLE[static_cast<size_t>(op)].arg_types};
+    return static_cast<size_t>(
+        std::distance(arg_types.begin(), std::ranges::find(arg_types, Type::Void)));
 }
-extern u8 NUM_ARGS[532];
+
+constexpr u8 NUM_ARGS[]{
+#define OPCODE(name_token, type_token, ...) static_cast<u8>(CalculateNumArgsOf(Opcode::name_token)),
+#include "opcodes.inc"
+#undef OPCODE
+};
 } // namespace Detail

 /// Get return type of an opcode
 [[nodiscard]] inline Type TypeOf(Opcode op) noexcept {
-    return Detail::META_TABLE[size_t(op)].type;
+    return Detail::META_TABLE[static_cast<size_t>(op)].type;
 }

 /// Get the number of arguments an opcode accepts
 [[nodiscard]] inline size_t NumArgsOf(Opcode op) noexcept {
-    return size_t(Detail::NUM_ARGS[size_t(op)]);
+    return static_cast<size_t>(Detail::NUM_ARGS[static_cast<size_t>(op)]);
 }

 /// Get the required type of an argument of an opcode
 [[nodiscard]] inline Type ArgTypeOf(Opcode op, size_t arg_index) noexcept {
-    return Detail::META_TABLE[size_t(op)].arg_types[arg_index];
+    return Detail::META_TABLE[static_cast<size_t>(op)].arg_types[arg_index];
 }

 /// Get the name of an opcode
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -582,8 +579,6 @@ OPCODE(ShuffleIndex,                                        U32,            U32,
 OPCODE(ShuffleUp,                                           U32,            U32,            U32,            U32,            U32,                            )
 OPCODE(ShuffleDown,                                         U32,            U32,            U32,            U32,            U32,                            )
 OPCODE(ShuffleButterfly,                                    U32,            U32,            U32,            U32,            U32,                            )
-OPCODE(QuadBroadcast,                                       U32,            U32,            U32,                                                                    )
-OPCODE(QuadSwap,                                            U32,            U32,            U32,                                                                    )
 OPCODE(FSwizzleAdd,                                         F32,            F32,            F32,            U32,                                            )
 OPCODE(DPdxFine,                                            F32,            F32,                                                                            )
 OPCODE(DPdyFine,                                            F32,            F32,                                                                            )
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -36,10 +36,7 @@ enum class ShuffleMode : u64 {
    }
 }

-constexpr u32 QUAD_MASK = (28u << 8) | 3u;
-
-void Shuffle(TranslatorVisitor& v, u64 insn, const IR::U32& index, const IR::U32& mask,
-             bool index_is_imm, u32 index_imm, bool mask_is_imm, u32 mask_imm) {
+void Shuffle(TranslatorVisitor& v, u64 insn, const IR::U32& index, const IR::U32& mask) {
    union {
        u64 insn;
        BitField<0, 8, IR::Reg> dest_reg;
@@ -48,21 +45,6 @@ void Shuffle(TranslatorVisitor& v, u64 insn, const IR::U32& index, const IR::U32
        BitField<48, 3, IR::Pred> pred;
    } const shfl{insn};

-    const bool is_quad_candidate{mask_is_imm && mask_imm == QUAD_MASK && index_is_imm &&
-                                  v.env.ShaderStage() == Stage::Fragment};
-    if (is_quad_candidate) {
-        if (shfl.mode == ShuffleMode::IDX && index_imm <= 3) {
-            v.X(shfl.dest_reg, v.ir.QuadBroadcast(v.X(shfl.src_reg), v.ir.Imm32(index_imm)));
-            v.ir.SetPred(shfl.pred, v.ir.Imm1(true));
-            return;
-        }
-        if (shfl.mode == ShuffleMode::BFLY && index_imm >= 1 && index_imm <= 3) {
-            v.X(shfl.dest_reg, v.ir.QuadSwap(v.X(shfl.src_reg), v.ir.Imm32(index_imm - 1)));
-            v.ir.SetPred(shfl.pred, v.ir.Imm1(true));
-            return;
-        }
-    }
-
    const IR::U32 result{ShuffleOperation(v.ir, v.X(shfl.src_reg), index, mask, shfl.mode)};
    v.ir.SetPred(shfl.pred, v.ir.GetInBoundsFromOp(result));
    v.X(shfl.dest_reg, result);
@@ -77,14 +59,11 @@ void TranslatorVisitor::SHFL(u64 insn) {
        BitField<29, 1, u64> src_b_flag;
        BitField<34, 13, u64> src_b_imm;
    } const flags{insn};
-    const bool index_is_imm{flags.src_a_flag != 0};
-    const bool mask_is_imm{flags.src_b_flag != 0};
-    const IR::U32 src_a{index_is_imm ? ir.Imm32(static_cast<u32>(flags.src_a_imm))
-                                     : GetReg20(insn)};
-    const IR::U32 src_b{mask_is_imm ? ir.Imm32(static_cast<u32>(flags.src_b_imm))
-                                    : GetReg39(insn)};
-    Shuffle(*this, insn, src_a, src_b, index_is_imm, static_cast<u32>(flags.src_a_imm),
-            mask_is_imm, static_cast<u32>(flags.src_b_imm));
+    const IR::U32 src_a{flags.src_a_flag != 0 ? ir.Imm32(static_cast<u32>(flags.src_a_imm))
+                                              : GetReg20(insn)};
+    const IR::U32 src_b{flags.src_b_flag != 0 ? ir.Imm32(static_cast<u32>(flags.src_b_imm))
+                                              : GetReg39(insn)};
+    Shuffle(*this, insn, src_a, src_b);
 }

 } // namespace Shader::Maxwell
@@ -498,10 +498,6 @@ void VisitUsages(Info& info, IR::Inst& inst) {
    case IR::Opcode::ShuffleButterfly:
        info.uses_subgroup_shuffles = true;
        break;
-    case IR::Opcode::QuadBroadcast:
-    case IR::Opcode::QuadSwap:
-        info.uses_quad_shuffles = true;
-        break;
    case IR::Opcode::GetCbufU8:
    case IR::Opcode::GetCbufS8:
    case IR::Opcode::GetCbufU16:
@@ -573,6 +569,8 @@ void VisitUsages(Info& info, IR::Inst& inst) {
    case IR::Opcode::ImageRead: {
        const auto flags{inst.Flags<IR::TextureInstInfo>()};
        info.uses_typeless_image_reads |= flags.image_format == ImageFormat::Typeless;
+        info.uses_image_1d |=
+            flags.type == TextureType::Color1D || flags.type == TextureType::ColorArray1D;
        info.uses_sparse_residency |=
            inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp) != nullptr;
        break;
@@ -581,6 +579,8 @@ void VisitUsages(Info& info, IR::Inst& inst) {
        const auto flags{inst.Flags<IR::TextureInstInfo>()};
        info.uses_typeless_image_writes |= flags.image_format == ImageFormat::Typeless;
        info.uses_image_buffers |= flags.type == TextureType::Buffer;
+        info.uses_image_1d |=
+            flags.type == TextureType::Color1D || flags.type == TextureType::ColorArray1D;
        break;
    }
    case IR::Opcode::SubgroupEqMask:
@@ -765,9 +765,13 @@ void VisitUsages(Info& info, IR::Inst& inst) {
    case IR::Opcode::ImageAtomicAnd32:
    case IR::Opcode::ImageAtomicOr32:
    case IR::Opcode::ImageAtomicXor32:
-    case IR::Opcode::ImageAtomicExchange32:
+    case IR::Opcode::ImageAtomicExchange32: {
+        const auto flags{inst.Flags<IR::TextureInstInfo>()};
        info.uses_atomic_image_u32 = true;
+        info.uses_image_1d |=
+            flags.type == TextureType::Color1D || flags.type == TextureType::ColorArray1D;
        break;
+    }
    default:
        break;
    }
@@ -261,25 +261,21 @@ bool IsTextureInstruction(const IR::Inst& inst) {

 static inline u32 ReadCbufCached(Environment& env, u32 index, u32 offset) {
    const CbufWordKey k{index, offset};
-    if (auto it = env.cbuf_word_cache.find(k); it != env.cbuf_word_cache.end())
-        return it->second;
+    if (auto it = env.cbuf_word_cache.find(k); it != env.cbuf_word_cache.end()) return it->second;
    const u32 v = env.ReadCbufValue(index, offset);
    env.cbuf_word_cache.emplace(k, v);
    return v;
 }

 static inline u32 GetTextureHandleCached(Environment& env, const ConstBufferAddr& cbuf) {
-    // Must all be uniquely different variables
-    // If has secondary, then it will be cbuf.secondary_{index|offset}, else its 0.
-    // So we can just hand it out the raw variable without using sec_idx or sec_off
-    // because comparing 0 against 0 will yield true.
-    const HandleKey hk{cbuf.index, cbuf.offset, cbuf.shift_left, cbuf.secondary_index, cbuf.secondary_offset, cbuf.secondary_shift_left, cbuf.count, cbuf.has_secondary};
-    if (auto it = env.handle_cache.find(hk); it != env.handle_cache.end())
-        return it->second;
-    const u32 sec_idx = cbuf.has_secondary ? cbuf.secondary_index  : cbuf.index;
-    const u32 sec_off = cbuf.has_secondary ? cbuf.secondary_offset : cbuf.offset;
+    const u32 sec_idx  = cbuf.has_secondary ? cbuf.secondary_index  : cbuf.index;
+    const u32 sec_off  = cbuf.has_secondary ? cbuf.secondary_offset : cbuf.offset;
+    const HandleKey hk{cbuf.index, cbuf.offset, cbuf.shift_left,
+                        sec_idx, sec_off, cbuf.secondary_shift_left, cbuf.has_secondary};
+    if (auto it = env.handle_cache.find(hk); it != env.handle_cache.end()) return it->second;
+
    const u32 lhs = ReadCbufCached(env, cbuf.index, cbuf.offset) << cbuf.shift_left;
-    const u32 rhs = ReadCbufCached(env, sec_idx, sec_off) << cbuf.secondary_shift_left;
+    const u32 rhs = ReadCbufCached(env, sec_idx,   sec_off)      << cbuf.secondary_shift_left;
    const u32 handle = lhs | rhs;
    env.handle_cache.emplace(hk, handle);
    return handle;
@@ -566,6 +562,7 @@ public:
        })};
        // TODO: Read this from TIC
        texture_descriptors[index].is_multisample |= desc.is_multisample;
+        texture_descriptors[index].is_integer |= desc.is_integer;
        return index;
    }

@@ -689,6 +686,21 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
        program.info.image_descriptors,
    };
    const u32 sampled_dynamic_cap = DynamicSampledTextureCap(program.info, host_info, DynamicSampledTextureArrayCount(to_replace));
+    bool has_last_is_integer{false};
+    u32 last_cbuf_index{};
+    u32 last_cbuf_offset{};
+    bool last_is_integer{false};
+    const auto is_texture_pixel_format_integer{[&](const ConstBufferAddr& cbuf_addr) {
+        if (has_last_is_integer && last_cbuf_index == cbuf_addr.index &&
+            last_cbuf_offset == cbuf_addr.offset) {
+            return last_is_integer;
+        }
+        last_is_integer = IsTexturePixelFormatIntegerCached(env, cbuf_addr);
+        last_cbuf_index = cbuf_addr.index;
+        last_cbuf_offset = cbuf_addr.offset;
+        has_last_is_integer = true;
+        return last_is_integer;
+    }};
    for (TextureInst& texture_inst : to_replace) {
        // TODO: Handle arrays
        IR::Inst* const inst{texture_inst.inst};
@@ -753,7 +765,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
            }
            const bool is_written{inst->GetOpcode() != IR::Opcode::ImageRead};
            const bool is_read{inst->GetOpcode() != IR::Opcode::ImageWrite};
-            const bool is_integer{IsTexturePixelFormatIntegerCached(env, cbuf)};
+            const bool is_integer{is_texture_pixel_format_integer(cbuf)};
            if (flags.type == TextureType::Buffer) {
                index = descriptors.Add(ImageBufferDescriptor{
                    .format = flags.image_format,
@@ -795,10 +807,12 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                });
            } else {
                count = std::min(count, sampled_dynamic_cap);
+                const bool is_integer{is_texture_pixel_format_integer(cbuf)};
                index = descriptors.Add(TextureDescriptor{
                    .type = flags.type,
                    .is_depth = flags.is_depth != 0,
                    .is_multisample = is_multisample,
+                    .is_integer = is_integer,
                    .has_secondary = cbuf.has_secondary,
                    .cbuf_index = cbuf.index,
                    .cbuf_offset = cbuf.offset,
@@ -809,6 +823,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                    .count = count,
                    .size_shift = size_shift,
                });
+                flags.is_integer.Assign(is_integer ? 1 : 0);
            }
            break;
        }
@@ -10,12 +10,16 @@

 namespace Shader {

+enum class Stage : u32;
+
 struct Profile {
    u32 supported_spirv{0x00010000};
    bool unified_descriptor_binding{};
    bool support_descriptor_aliasing{};
    bool support_int8{};
+    bool support_uniform_and_storage_buffer_8bit{};
    bool support_int16{};
+    bool support_uniform_and_storage_buffer_16bit{};
    bool support_int64{};
    bool support_vertex_instance_id{};
    bool support_float_controls{};
@@ -29,9 +33,8 @@ struct Profile {
    bool support_fp32_signed_zero_nan_preserve{};
    bool support_fp64_signed_zero_nan_preserve{};
    bool support_explicit_workgroup_layout{};
-    bool support_shader_quad_control{};
-    bool support_quad_shuffles{};
    bool support_vote{};
+    u32 supported_subgroup_stages{0x7F};
    bool support_viewport_index_layer_non_geometry{};
    bool support_viewport_mask{};
    bool support_typeless_image_loads{};
@@ -95,6 +98,10 @@ struct Profile {

    u64 min_ssbo_alignment{};
    u32 max_user_clip_distances{};
+
+    bool SupportsSubgroupStage(Stage stage) const {
+        return (supported_subgroup_stages & (1u << static_cast<u32>(stage))) != 0;
+    }
 };

 } // namespace Shader
@@ -209,6 +209,7 @@ struct TextureDescriptor {
    TextureType type;
    bool is_depth;
    bool is_multisample;
+    bool is_integer;
    bool has_secondary;
    u32 cbuf_index;
    u32 cbuf_offset;
@@ -251,7 +252,6 @@ struct Info {
    bool uses_is_helper_invocation{};
    bool uses_subgroup_invocation_id{};
    bool uses_subgroup_shuffles{};
-    bool uses_quad_shuffles{};
    std::array<bool, 30> uses_patches{};

    std::array<Interpolation, 32> interpolation{};
@@ -20,58 +20,54 @@ Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::Nv

 Decoder::~Decoder() = default;

+void Decoder::SetFrameDimensions(s32 width, s32 height) {
+    if (width <= 0 || height <= 0) {
+        frame_dimensions.reset();
+        return;
+    }
+    frame_dimensions = FFmpeg::FrameDimensions{width, height};
+}
+
 void Decoder::Decode() {
    if (!initialized) {
        return;
    }

    const auto packet_data = ComposeFrame();
-    // Send assembled bitstream to decoder.
-    if (!decode_api.SendPacket(packet_data)) {
-        return;
-    }
-
-    // Only receive/store visible frames.
-    if (vp9_hidden_frame) {
-        return;
-    }
-
-    // Receive output frames from decoder.
-    auto frame = decode_api.ReceiveFrame();
-
-    if (!frame) {
-        return;
-    }
-
-    if (IsInterlaced()) {
-        auto [luma_top, luma_bottom, chroma_top, chroma_bottom] = GetInterlacedOffsets();
-        auto frame_copy = frame;
-
-        if (!frame.get()) {
-            LOG_ERROR(HW_GPU,
-                      "Nvdec {} failed to decode interlaced frame for top {:#X} bottom 0x{:X}", id,
-                      luma_top, luma_bottom);
-        }
-
-        if (UsingDecodeOrder()) {
-            host1x.frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
-            host1x.frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
-        } else {
-            host1x.frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
-            host1x.frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
-        }
+    FFmpeg::FrameOffsets offsets{};
+    offsets.hidden = vp9_hidden_frame;
+    offsets.interlaced = IsInterlaced();
+    if (offsets.interlaced) {
+        std::tie(offsets.luma, offsets.luma_bottom, std::ignore, std::ignore) =
+            GetInterlacedOffsets();
    } else {
-        auto [luma_offset, chroma_offset] = GetProgressiveOffsets();
+        std::tie(offsets.luma, std::ignore) = GetProgressiveOffsets();
+    }

-        if (!frame.get()) {
-            LOG_ERROR(HW_GPU, "Nvdec {} failed to decode progressive frame for luma {:#X}", id,
-                      luma_offset);
-        }
+    // Send assembled bitstream to decoder.
+    if (!decode_api.SendPacket(packet_data, offsets, GetFrameDimensions())) {
+        return;
+    }

+    auto push = [&](u64 luma, std::shared_ptr<FFmpeg::Frame> frame) {
        if (UsingDecodeOrder()) {
-            host1x.frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
+            host1x.frame_queue.PushDecodeOrder(id, luma, std::move(frame));
        } else {
-            host1x.frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
+            host1x.frame_queue.PushPresentOrder(id, luma, std::move(frame));
+        }
+    };
+
+    while (auto result = decode_api.ReceiveFrame()) {
+        auto& [frame, frame_offsets] = *result;
+        if (!frame) {
+            continue;
+        }
+        if (frame_offsets.interlaced) {
+            auto frame_copy = frame;
+            push(frame_offsets.luma, std::move(frame));
+            push(frame_offsets.luma_bottom, std::move(frame_copy));
+        } else {
+            push(frame_offsets.luma, std::move(frame));
        }
    }
 }
@@ -10,6 +10,7 @@
 #include <mutex>
 #include <optional>
 #include <string_view>
+#include <tuple>
 #include <ankerl/unordered_dense.h>
 #include <queue>

@@ -46,12 +47,19 @@ protected:
    virtual std::tuple<u64, u64, u64, u64> GetInterlacedOffsets() = 0;
    virtual bool IsInterlaced() = 0;

+    void SetFrameDimensions(s32 width, s32 height);
+
+    std::optional<FFmpeg::FrameDimensions> GetFrameDimensions() const {
+        return frame_dimensions;
+    }
+
    FFmpeg::DecodeApi decode_api;
    Host1x::Host1x& host1x;
    const Host1x::NvdecCommon::NvdecRegisters& regs;
    s32 id;
    bool initialized : 1 = false;
    bool vp9_hidden_frame : 1 = false;
+    std::optional<FFmpeg::FrameDimensions> frame_dimensions;
 };

 } // namespace Tegra
@@ -52,6 +52,10 @@ bool H264::IsInterlaced() {

 std::span<const u8> H264::ComposeFrame() {
    host1x.gmmu_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context, sizeof(H264DecoderContext));
+    const auto& params = current_context.h264_parameter_set;
+    SetFrameDimensions(static_cast<s32>(params.pic_width_in_mbs) * 16,
+                       static_cast<s32>(params.frame_height_in_mbs) * 16);
+
    const s64 frame_number = current_context.h264_parameter_set.frame_number.Value();
    if (!is_first_frame && frame_number != 0) {
        frame_scratch.resize_destructive(current_context.stream_len);
@@ -35,6 +35,7 @@ std::tuple<u64, u64, u64, u64> VP8::GetInterlacedOffsets() {

 std::span<const u8> VP8::ComposeFrame() {
    host1x.gmmu_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context, sizeof(VP8PictureInfo));
+    SetFrameDimensions(current_context.frame_width, current_context.frame_height);

    const bool is_key_frame = current_context.key_frame == 1u;
    const auto bitstream_size = size_t(current_context.vld_buffer_size);
@@ -841,6 +841,7 @@ std::span<const u8> VP9::ComposeFrame() {
    {
        Vp9FrameContainer curr_frame = GetCurrentFrame();
        current_frame_info = curr_frame.info;
+        SetFrameDimensions(current_frame_info.frame_size.width, current_frame_info.frame_size.height);
        bitstream = std::move(curr_frame.bit_stream);
    }
    // The uncompressed header routine sets PrevProb parameters needed for the compressed header
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CamilleLaVey	a8c6189d53	[vulkan] Restored Presync + ConditionalRendering workaround for QCOM drivers	2026-07-07 23:26:53 -04:00
CamilleLaVey	940cc8caef	[vulkan] Add EAC formats on the query format table	2026-07-07 23:21:41 -04:00
CamilleLaVey	c57fdebdf0	[vic] Update logging for codec used	2026-07-07 22:27:19 -04:00
CamilleLaVey	059d902ca3	[android] Fix on missing transfer frames	2026-07-07 20:39:28 -04:00
CamilleLaVey	6df0089950	[vic] Quick change on VP9 offsets + ifdef encoding flags for Android	2026-07-07 20:13:56 -04:00
CamilleLaVey	d1f41a91ec	[android] Verifying the actual flag required on hardware access	2026-07-07 20:08:10 -04:00
CamilleLaVey	a1b7cd51b4	[android] Initial implementation for MediaCodec	2026-07-07 19:01:42 -04:00
CamilleLaVey	6a3f885e46	[vulkan] 2D-Array (StorageView) mistmatch handling	2026-07-07 18:41:45 -04:00
CamilleLaVey	18a9d0762b	Revert "[TEST] Return of early compute shader change"	2026-07-07 18:30:31 -04:00
CamilleLaVey	eb1060381a	[TEST] Return of early compute shader change	2026-07-07 17:21:20 -04:00
CamilleLaVey	b270bae970	[TEST] Late catch on accelerated image upload path	2026-07-07 16:02:35 -04:00
CamilleLaVey	b54be98731	[TEST] Returned shaderFloat16 to QCOM	2026-07-07 15:49:29 -04:00
CamilleLaVey	0e1e0d5664	Fix build	2026-07-06 21:29:23 -04:00
CamilleLaVey	0b17ea1804	[TEST] Remove fp16 from qcom drivers	2026-07-06 20:47:56 -04:00
CamilleLaVey	06580cc6f9	[vulkan, qcom] Updated list of removed features on QCOM drivers	2026-07-06 19:55:19 -04:00
CamilleLaVey	bb63996182	[vulkan] Subgroups gating correction	2026-07-06 15:57:53 -04:00
CamilleLaVey	83e1a676c5	[vulkan, qcom] Removed border color swizzle from QCOM drivers	2026-07-06 03:28:53 -04:00
CamilleLaVey	21fa6b5805	[vulkan] Added checks for 8/16bits on storage buffer access	2026-07-06 03:26:03 -04:00
CamilleLaVey	62e8666eee	Revert "[TEST] Debugger GPU unswizzle shaders"	2026-07-06 03:19:32 -04:00
CamilleLaVey	ca9ff1642f	Revert "[TEST] Force checks on subgroups"	2026-07-06 03:16:54 -04:00
CamilleLaVey	ace66343ce	[TEST] Force checks on subgroups	2026-07-06 03:07:48 -04:00
CamilleLaVey	4bf8828df1	[TEST] Debugger GPU unswizzle shaders	2026-07-06 02:10:21 -04:00
CamilleLaVey	7307518e44	[vulkan] Re-wiring older ASTC decoding path + new helper function on wider ASTC textures	2026-07-05 23:47:22 -04:00
CamilleLaVey	8890b8eb2a	[TEST] Removal of the 7 push constant + fixated value	2026-07-05 23:07:57 -04:00
CamilleLaVey	a7d274e5bd	[TEST] Adjusting sRGB formula	2026-07-05 20:46:33 -04:00
CamilleLaVey	bfdc50ee76	[TEST] Refactored SRGBToLinear function	2026-07-05 07:20:59 -04:00
CamilleLaVey	b0ccfb2c2a	[TEST] Remove sRGB curve convertion	2026-07-05 07:10:41 -04:00
CamilleLaVey	f191d7a0b7	Revert "[TEST] Removing AMD/Nvidia from HDR on ASTC decoded formats"	2026-07-05 06:59:15 -04:00
CamilleLaVey	0a0156a484	[TEST] Removing AMD/Nvidia from HDR on ASTC decoded formats	2026-07-05 06:53:33 -04:00
CamilleLaVey	e48a8d3ff4	Revert "[TEST] Test for RefreshParametter actual concurrency"	2026-07-05 06:36:31 -04:00
CamilleLaVey	811ee522e0	Revert "[TEST] Diagnosis for corrupted HDR consumed views"	2026-07-05 06:36:06 -04:00
CamilleLaVey	7cb8ae0c0d	[TEST] Diagnosis for corrupted HDR consumed views	2026-07-05 06:31:42 -04:00
CamilleLaVey	dbb48c4e4e	[TEST] Format swap	2026-07-05 06:24:17 -04:00
CamilleLaVey	8cc658e5be	[vulkan] Updated Typeless format structure for ASTC decoding	2026-07-05 05:26:47 -04:00
CamilleLaVey	785461a26c	[vulkan] Verify actual format of ASTC before decode	2026-07-05 05:06:16 -04:00
CamilleLaVey	7bf0e49a91	[vulkan] Plumbing ASTC decoding capabilities for HDR	2026-07-05 03:45:32 -04:00
CamilleLaVey	55627c3896	[video_core] Initial implementation on HDR endpoints for ASTC decoding	2026-07-05 02:53:52 -04:00
CamilleLaVey	1987384dec	[TEST] Test for RefreshParametter actual concurrency	2026-07-05 01:35:12 -04:00
CamilleLaVey	3b617a6733	[TEST] Add B10G11R11 as target format	2026-07-05 01:31:51 -04:00
CamilleLaVey	963e1f633b	[TEST] Add preliminary/ missing formats based on driver reports for Switch	2026-07-05 00:36:26 -04:00
CamilleLaVey	6eec277428	[vulkan] Silence unimplemented format entry	2026-07-05 00:07:41 -04:00
CamilleLaVey	dbd59bd119	[vulkan] Override default behavior on rasterizer channel	2026-07-04 23:21:46 -04:00
CamilleLaVey	3dc15a4f96	Smolio Gidolardo	2026-07-04 22:10:02 -04:00
CamilleLaVey	4900fee536	[TEST] Re-test removed features from QCOM	2026-07-04 22:05:28 -04:00
CamilleLaVey	34df1b4a16	[vulkan] Another approach for queries reset	2026-07-04 22:03:22 -04:00
CamilleLaVey	f5560deab7	[vulkan] Added tracker for reused uploads	2026-07-04 21:41:00 -04:00
CamilleLaVey	307a32f9a0	[vulkan, qcom] Updated list of features removed for QCOM stock drivers	2026-07-04 20:44:25 -04:00
CamilleLaVey	7bb4991edd	[vulkan] Refactored dual blending/ dual source attachments	2026-07-04 19:03:27 -04:00
CamilleLaVey	f5720663c2	[vulkan] Adjust blend targets from texture types	2026-07-04 18:55:00 -04:00
CamilleLaVey	53927e175e	[vulkan] Adjustments on previous TFB barrier added	2026-07-04 18:26:29 -04:00
CamilleLaVey	20a68e1e9d	[vulkan, qcom] Returned custom border color and derivates to QCOM drivers	2026-07-04 17:59:07 -04:00
CamilleLaVey	c7668fd43e	[vulkan] Adjusted checks for 8 - 16bits UBO's iteration	2026-07-04 16:40:15 -04:00
CamilleLaVey	eb7f950322	[spir-v] Workaorund for 1D sampled images	2026-07-04 16:24:22 -04:00
CamilleLaVey	80609ee974	[TEST] Remove border color swizzle from qcom	2026-07-04 16:17:01 -04:00
CamilleLaVey	28630ff109	[vulkan] Sampled linear images fallback to nearest	2026-07-04 13:47:44 -04:00
CamilleLaVey	b049f7d273	[texture_cache] Relaxed TIC's lookup for integer type image formats	2026-07-04 12:57:20 -04:00
CamilleLaVey	f6ccf2c368	[shader_recompiler] Added texture type functions	2026-07-04 01:31:25 -04:00
CamilleLaVey	27a0010b6e	[vulkan] Verify UniformAndStorage capabilities on device	2026-07-04 00:32:36 -04:00
CamilleLaVey	b06b9cc7a2	[vulkan] Pixel format handling for formats	2026-07-04 00:16:01 -04:00
CamilleLaVey	943f91cf0b	[texture_cache] Added typeless storage form	2026-07-04 00:01:31 -04:00
CamilleLaVey	bd8caa5294	[texture_cache] Added b5g6r5 pixel format to depth blit resolves	2026-07-03 23:36:05 -04:00
CamilleLaVey	3ddf349ca1	[buffer_cache] Force offsets to 0 on descriptors and use VK_WHOLE_SIZE instead	2026-07-03 23:01:13 -04:00
CamilleLaVey	d707d241fc	[host_shaders] Corrections on mismatchs for SINT on depth formats	2026-07-03 22:28:42 -04:00
CamilleLaVey	aa5d2cf9d7	[qcom] Removal custom border color from QCOM drivers	2026-07-03 22:10:12 -04:00
CamilleLaVey	decf41a3cb	Fix build	2026-07-03 21:21:14 -04:00
CamilleLaVey	d7dc4f2143	[vulkan] Correction on mislead of BindVertexBuffer entries	2026-07-03 20:58:34 -04:00
CamilleLaVey	fbd94e4237	[vulkan] Implementation color write enable + color border swizzle	2026-07-03 20:35:45 -04:00
CamilleLaVey	48cc8f4c8c	[vulkan] XFB memory barrier added	2026-07-03 02:29:06 -04:00
CamilleLaVey	e1721012d8	[vulkan] Set actual dynamic state handling for topology	2026-07-03 01:49:56 -04:00
CamilleLaVey	5af01bef9f	[vulkan] Initial implementation Synchronization2	2026-07-03 00:58:40 -04:00