Fix license headers

[spir-v] Added fallback for unsupported quads + shader-stage checks
[spir-v] Correcting output components
2026-08-15 13:16:43 +00:00 · 2026-07-07 20:28:53 +02:00 · 2026-07-07 20:28:53 +02:00 · 2026-07-07 20:28:53 +02:00 · 2026-07-07 20:28:53 +02:00 · 2026-07-07 20:28:53 +02:00
129 changed files with 2915 additions and 3447 deletions
@@ -1,20 +0,0 @@
-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
@@ -0,0 +1,26 @@
+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 "${VVL_SOURCE_DIR}/${abi}/libVkLayer_khronos_validation.so"
+    file(COPY "${vulkan-validation-layers_SOURCE_DIR}/${abi}/libVkLayer_khronos_validation.so"
        DESTINATION "${vvl_lib_path}")
 endif()

@@ -3,11 +3,10 @@
        "hash": "1229f345b014f7ca544dedb4edb3311e41ba736f9aa9a67f88b5f26f3c983288c6bb6cdedcfb0b8a02c63088a37e6a0d7ba97d9c2a4d721b213916327cffe28a",
        "min_version": "0.9.1",
        "repo": "lioncash/biscuit",
-        "tag": "v%VERSION%",
-        "version": "0.19.0"
+        "version": "v0.19.0"
    },
    "boost": {
-        "artifact": "%TAG%-cmake.tar.xz",
+        "artifact": "%VERSION%-cmake.tar.xz",
        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
        "min_version": "1.57",
@@ -16,15 +15,13 @@
            "0001-clang-cl.patch"
        ],
        "repo": "boostorg/boost",
-        "tag": "boost-%VERSION%",
-        "version": "1.90.0"
+        "version": "boost-1.90.0"
    },
    "boost_headers": {
        "bundled": true,
        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
        "repo": "boostorg/headers",
-        "tag": "boost-%VERSION%",
-        "version": "1.90.0"
+        "version": "boost-1.90.0"
    },
    "catch2": {
        "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",
@@ -34,8 +31,7 @@
            "0001-solaris-isnan-fix.patch"
        ],
        "repo": "catchorg/Catch2",
-        "tag": "v%VERSION%",
-        "version": "3.13.0"
+        "version": "v3.13.0"
    },
    "cpp-jwt": {
        "find_args": "CONFIG",
@@ -48,8 +44,7 @@
            "0001-fix-missing-decl.patch"
        ],
        "repo": "arun11299/cpp-jwt",
-        "sha": "7f24eb4c32",
-        "version": "1.5.1"
+        "version": "7f24eb4c32"
    },
    "cubeb": {
        "find_args": "CONFIG",
@@ -61,31 +56,26 @@
            "BUNDLE_SPEEX ON"
        ],
        "repo": "mozilla/cubeb",
-        "sha": "fa02160712",
-        "version": "0.0.0"
+        "version": "fa02160712"
    },
    "discord-rpc": {
        "find_args": "MODULE",
        "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3",
        "package": "DiscordRPC",
        "repo": "eden-emulator/discord-rpc",
-        "sha": "0d8b2d6a37",
-        "version": "3.4.1"
+        "version": "0d8b2d6a37"
    },
    "enet": {
        "find_args": "MODULE",
        "hash": "a0d2fa8c957704dd49e00a726284ac5ca034b50b00d2b20a94fa1bbfbb80841467834bfdc84aa0ed0d6aab894608fd6c86c3b94eee46343f0e6d9c22e391dbf9",
        "min_version": "1.3",
        "repo": "lsalzman/enet",
-        "tag": "v%VERSION%",
-        "version": "1.3.18"
+        "version": "v1.3.18"
    },
    "ffmpeg": {
-        "bundled": true,
        "hash": "ed177621176b3961bdcaa339187d3a7688c1c8b060b79c4bb0257cbc67ad7021ae5d5adca5303b45625abbbe3d9aafdd87ce777b8690ac295290d744c875489a",
        "repo": "FFmpeg/FFmpeg",
-        "sha": "c7b5f1537d",
-        "version": "8.0.1"
+        "version": "c7b5f1537d"
    },
    "ffmpeg-ci": {
        "ci": true,
@@ -99,23 +89,20 @@
        "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
        "min_version": "8",
        "repo": "fmtlib/fmt",
-        "tag": "%VERSION%",
        "version": "12.1.0"
    },
    "frozen": {
        "hash": "b8dfe741c82bc178dfc9749d4ab5a130cee718d9ee7b71d9b547cf5f7f23027ed0152ad250012a8546399fcc1e12187efc68d89d6731256c4d2df7d04eef8d5c",
        "package": "frozen",
        "repo": "serge-sans-paille/frozen",
-        "sha": "61dce5ae18",
-        "version": "1.2.0"
+        "version": "61dce5ae18"
    },
    "gamemode": {
        "find_args": "MODULE",
        "hash": "e87ec14ed3e826d578ebf095c41580069dda603792ba91efa84f45f4571a28f4d91889675055fd6f042d7dc25b0b9443daf70963ae463e38b11bcba95f4c65a9",
        "min_version": "1.7",
        "repo": "FeralInteractive/gamemode",
-        "sha": "ce6fe122f3",
-        "version": "1.8.2"
+        "version": "ce6fe122f3"
    },
    "httplib": {
        "find_args": "MODULE GLOBAL",
@@ -128,23 +115,20 @@
            "0001-mingw.patch"
        ],
        "repo": "yhirose/cpp-httplib",
-        "tag": "v%VERSION%",
-        "version": "0.46.0"
+        "version": "v0.46.0"
    },
    "lagoon": {
        "hash": "b9380f99c6effaeccc6d8f81d4942e852c11ad28613df637e155451556ae5826f93765bee57a5c87a9740d2bd1db463ad0f55a947772fe9d57eeabae3efa373e",
        "repo": "loongson-community/lagoon",
-        "tag": "%VERSION%",
        "version": "1.0.0"
    },
    "libadrenotools": {
        "hash": "f6526620cb752876edc5ed4c0925d57b873a8218ee09ad10859ee476e9333259784f61c1dcc55a2bcba597352d18aff22cd2e4c1925ec2ae94074e09d7da2265",
        "patches": [
-            "0001-linkerns-cpm.patch"
+            "0001-use-cpmfile-def-for-linkernsbypass.patch"
        ],
        "repo": "eden-emulator/libadrenotools",
-        "sha": "8ba23b42d7",
-        "version": "1.0.0"
+        "version": "8ba23b42d7"
    },
    "libusb": {
        "find_args": "MODULE",
@@ -153,53 +137,52 @@
            "0001-netbsd-gettime.patch"
        ],
        "repo": "libusb/libusb",
-        "tag": "v%VERSION%",
-        "version": "1.0.29"
+        "version": "v1.0.29"
+    },
+    "linkernsbypass": {
+        "bundled": "true",
+        "hash": "bbe3f1f08e2bc7172b36e8f052912cc374289fc9a8e5a39ae7547a0c232de8f57ba24883451896b7a9a5d1be0e4de5c5b0f70c2022eda18d7d5a754847521800",
+        "repo": "bylaws/liblinkernsbypass",
+        "version": "aa3975893d"
    },
    "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": "1.10.0"
+        "version": "ebb370ca83"
    },
    "moltenvk": {
        "artifact": "MoltenVK-macOS.tar",
        "bundled": true,
        "hash": "5695b36ca5775819a71791557fcb40a4a5ee4495be6b8442e0b666d0c436bec02aae68cc6210183f7a5c986bdbec0e117aecfad5396e496e9c2fd5c89133a347",
        "repo": "V380-Ori/Ryujinx.MoltenVK",
-        "tag": "v%VERSION%-ryujinx",
-        "version": "1.4.1"
+        "version": "v1.4.1-ryujinx"
    },
    "nlohmann": {
        "hash": "6cc1e86261f8fac21cc17a33da3b6b3c3cd5c116755651642af3c9e99bb3538fd42c1bd50397a77c8fb6821bc62d90e6b91bcdde77a78f58f2416c62fc53b97d",
        "min_version": "3.8",
        "package": "nlohmann_json",
        "repo": "nlohmann/json",
-        "tag": "v%VERSION%",
-        "version": "3.12.0"
+        "version": "v3.12.0"
    },
    "oaknut": {
        "hash": "9697e80a7d5d9bcb3ce51051a9a24962fb90ca79d215f1f03ae6b58da8ba13a63b5dda1b4dde3d26ac6445029696b8ef2883f4e5a777b342bba01283ed293856",
        "min_version": "2.0.1",
        "repo": "eden-emulator/oaknut",
-        "tag": "v%VERSION%",
-        "version": "2.0.3"
+        "version": "v2.0.3"
    },
    "oboe": {
        "bundled": true,
        "hash": "ce4011afe7345370d4ead3b891cd69a5ef224b129535783586c0ca75051d303ed446e6c7f10bde8da31fff58d6e307f1732a3ffd03b249f9ef1fd48fd4132715",
        "repo": "google/oboe",
-        "tag": "%VERSION%",
        "version": "1.10.0"
    },
    "openssl": {
@@ -210,8 +193,7 @@
            "0001-add-bundled-cert.patch"
        ],
        "repo": "openssl/openssl",
-        "tag": "openssl-%VERSION%",
-        "version": "3.6.2"
+        "version": "openssl-3.6.2"
    },
    "openssl-ci": {
        "ci": true,
@@ -234,7 +216,6 @@
            "0004-use-shell-wrapper.patch"
        ],
        "repo": "jimmy-park/openssl-cmake",
-        "tag": "%VERSION%",
        "version": "3.6.2"
    },
    "opus": {
@@ -250,8 +231,7 @@
            "0002-no-install.patch"
        ],
        "repo": "xiph/opus",
-        "sha": "a3f0ec02b3",
-        "version": "1.5.2"
+        "version": "a3f0ec02b3"
    },
    "quazip": {
        "hash": "609c240c7f029ac26a37d8fbab51bc16284e05e128b78b9b9c0e95d083538c36047a67d682759ac990e4adb0eeb90f04f1ea7fe2253bbda7e7e3bcce32e53dd8",
@@ -264,16 +244,14 @@
        ],
        "package": "QuaZip-Qt6",
        "repo": "stachenov/quazip",
-        "sha": "2e95c9001b",
-        "version": "1.5"
+        "version": "2e95c9001b"
    },
    "sdl3": {
        "hash": "df5a323af7ac366661a3c0e887969c72584d232f3cc211419d59b0487b620b6b2859d4549c9e8df002ee489290062e466fcfddf7edc0872a37b1f2845e81c0f3",
        "min_version": "3.2.10",
        "package": "SDL3",
        "repo": "libsdl-org/SDL",
-        "tag": "release-%VERSION%",
-        "version": "3.4.8"
+        "version": "release-3.4.8"
    },
    "sdl3-ci": {
        "ci": true,
@@ -288,19 +266,16 @@
        "hash": "b937c18a7b6277d77ca7ebfb216af4984810f77af4c32d101b7685369a4bd5eb61406223f82698e167e6311a728d07415ab59639fdf19eff71ad6dc2abfda989",
        "package": "SimpleIni",
        "repo": "brofield/simpleini",
-        "tag": "v%VERSION%",
-        "version": "4.25"
+        "version": "v4.25"
    },
    "sirit": {
-        "artifact": "sirit-source-%VERSION%.tar.zst",
        "find_args": "CONFIG",
+        "hash": "b7cd6885acae3fc8698288d19febba0dd45e4a02a2b6563d2eb995a988d0847046e8d16a5dea7e0bf832b4321bcec134cdbafc553f6ede039e4cf34525c5dce5",
        "options": [
            "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
        ],
        "repo": "eden-emulator/sirit",
-        "tag": "v%VERSION%",
-        "version": "1.0.5",
-        "hash": "10b3ff60bdcad428bb4f54360ff749212333a1d24c0b3ed99e466b1bfcf99d2db6cf596c0f965854a2095dfef9b7ce4e045edb070fa9f76eb3b295ab03a4a293"
+        "version": "v1.0.5"
    },
    "sirit-ci": {
        "ci": true,
@@ -310,13 +285,13 @@
        "version": "1.0.5"
    },
    "spirv-headers": {
-        "hash": "cae8cd179c9013068876908fecc1d158168310ad6ac250398a41f0f5206ceff6469e2aaeab9c820bce9d1b08950c725c89c46e94b89a692be9805432cf749396",
+        "hash": "d624371dd455c66a300344c89812598ffe11b5eedba555779f789e85c29dc67317741858c60e0744a1e6755cc0d2759b8659f0674f4cc31479c4cb6fc25ed23b",
        "options": [
            "SPIRV_WERROR OFF"
        ],
        "package": "SPIRV-Headers",
        "repo": "KhronosGroup/SPIRV-Headers",
-        "sha": "04f10f650d"
+        "version": "vulkan-sdk-1.4.341.0"
    },
    "tzdb": {
        "artifact": "%VERSION%.tar.gz",
@@ -324,7 +299,6 @@
        "hash": "cce65a12bf90f4ead43b24a0b95dfad77ac3d9bfbaaf66c55e6701346e7a1e44ca5d2f23f47ee35ee02271eb1082bf1762af207aad9fb236f1c8476812d008ed",
        "package": "nx_tzdb",
        "repo": "eden-emu/tzdb_to_nx",
-        "tag": "%VERSION%",
        "version": "230326"
    },
    "unordered-dense": {
@@ -336,46 +310,40 @@
            "0001-avoid-memset-when-clearing-an-empty-table.patch"
        ],
        "repo": "martinus/unordered_dense",
-        "sha": "7b55cab841",
-        "version": "4.8.1"
+        "version": "7b55cab841"
    },
    "vulkan-headers": {
        "hash": "d2846ea228415772645eea4b52a9efd33e6a563043dd3de059e798be6391a8f0ca089f455ae420ff22574939ed0f48ed7c6ff3d5a9987d5231dbf3b3f89b484b",
        "min_version": "1.4.317",
        "package": "VulkanHeaders",
        "repo": "KhronosGroup/Vulkan-Headers",
-        "tag": "v%VERSION%",
-        "version": "1.4.345"
+        "version": "v1.4.345"
    },
    "vulkan-memory-allocator": {
        "find_args": "CONFIG",
        "hash": "deb5902ef8db0e329fbd5f3f4385eb0e26bdd9f14f3a2334823fb3fe18f36bc5d235d620d6e5f6fe3551ec3ea7038638899db8778c09f6d5c278f5ff95c3344b",
        "package": "VulkanMemoryAllocator",
        "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator",
-        "tag": "v%VERSION%",
-        "version": "3.3.0"
+        "version": "v3.3.0"
    },
    "vulkan-utility-libraries": {
        "hash": "114f6b237a6dcba923ccc576befb5dea3f1c9b3a30de7dc741f234a831d1c2d52d8a224afb37dd57dffca67ac0df461eaaab6a5ab5e503b393f91c166680c3e1",
        "package": "VulkanUtilityLibraries",
        "repo": "KhronosGroup/Vulkan-Utility-Libraries",
-        "tag": "v%VERSION%",
-        "version": "1.4.345"
+        "version": "v1.4.345"
    },
    "vulkan-validation-layers": {
-        "artifact": "android-binaries-%VERSION%.zip",
+        "artifact": "android-binaries-%NUMERIC_VERSION%.zip",
        "hash": "8812ae84cbe49e6a3418ade9c458d3be6d74a3dffd319d4502007b564d580998056e8190414368ec11b27bc83993c7a0dad713c31bcc3d9553b51243efee3753",
-        "package": "VVL",
+        "numeric_version": "1.4.341.0",
        "repo": "KhronosGroup/Vulkan-ValidationLayers",
-        "tag": "vulkan-sdk-%VERSION%",
-        "version": "1.4.341.0"
+        "version": "vulkan-sdk-%NUMERIC_VERSION%"
    },
    "xbyak": {
        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
        "package": "xbyak",
        "repo": "herumi/xbyak",
-        "tag": "v%VERSION%",
-        "version": "7.35.2"
+        "version": "v7.35.2"
    },
    "zlib": {
        "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
@@ -386,8 +354,7 @@
        ],
        "package": "ZLIB",
        "repo": "madler/zlib",
-        "tag": "v%VERSION%",
-        "version": "1.3.2"
+        "version": "v1.3.2"
    },
    "zstd": {
        "find_args": "MODULE",
@@ -397,8 +364,7 @@
            "ZSTD_BUILD_SHARED OFF"
        ],
        "repo": "facebook/zstd",
-        "sha": "b8d6101fba",
        "source_subdir": "build/cmake",
-        "version": "1.5.7"
+        "version": "b8d6101fba"
    }
 }
@@ -8,6 +8,7 @@ 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)
@@ -22,12 +23,18 @@ 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. NOT RECOMMENDED!
-  - You may optionally override this (section)
+- `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_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.

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

 ```json
-"fmt": {
-    "repo": "fmtlib/fmt",
-    "tag": "12.1.0",
-    "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
-    "min_version": "8",
-    "options": [
-      "FMT_TEST ON"
-    ],
-    "patches": [
-      "0001-disable-reference-copy.patch"
-    ]
+{
+  "fmt": {
+      "repo": "fmtlib/fmt",
+      "version": "12.1.0",
+      "hash": "f0da8...23f2",
+      "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
+- Searches for a system package named `fmt` of version 8 or higher (`find_package(fmt 8)`)
 - 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`
@@ -85,63 +94,82 @@ 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 to download. This is required.
- `min_version`: The minimum required version of the package, if a system package is desired.
+- `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`
 - `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.
- 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`.
+- `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.

 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. including external fragment shaders.
+- `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.
 - `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 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.
+When fetching from a Git repository, there are generally three methods of versioning:

-`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`:
+- Commit hashes
+- Git tags
+- Release artifacts

-```json
-"openssl": {
-    "repo": "openssl/openssl",
-    "version": "3.6.2",
-    "tag": "openssl-%VERSION%"
-}
-```
+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!

-`artifact` also supports `%VERSION%` replacement, and can also use `%TAG%` to be replaced by the computed tag. Take this Boost definition:
+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`:

 ```json
 "boost": {
    "repo": "boostorg/boost",
-    "tag": "boost-%VERSION%",
-    "version": "1.90.0"
+    "version": "boost-1.90.0",
+    "artifact": "%VERSION%-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:
+The artifact will then evaluate as `boost-1.90.0-cmake.tar.xz`.

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

-Future updates need only change the `version` identifier, and the artifact and tag will automatically be updated!
+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`!

 ### 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`. 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:
+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:

 ```json
 "patches": [
@@ -151,7 +179,7 @@ CPMUtil is able to apply in-place source tree patches to downloaded packages. Th
 ]
 ```

-Then, when Boost is downloaded, it will apply these patches in order to the source tree.
+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.

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

@@ -199,12 +227,9 @@ 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:
+Within these subdirectories, additional directories are created for each individual version, corresponding directly to their `version` field. CI packages use `<platform>-<architecture>-<version>` unconditionally.

- 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.
+To see the cache directory for a given package, use `tools/cpmutil.sh package dir <JSON key>`.

 ## Addendum: Making Patches

@@ -242,7 +267,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 `-DPackageName_DIR=/path/to/downloaded/dir` (e.g. shaders)
+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`.

 ### Unsandboxed

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

@@ -318,3 +341,32 @@ 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,8 +311,9 @@ 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 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.

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

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

-    if (in_params.address == 0 || in_params.size == 0 || !Common::Is4KBAligned(in_params.address) ||
-        !Common::Is4KBAligned(in_params.size)) {
+    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)) {
        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 für audio-ins
+    // update sample counts fuer audio-ins
    {
        std::scoped_lock lk{sample_count_lock};
        last_sample_count_update_time = system.CoreTiming().GetGlobalTimeNs();
@@ -1,3 +1,6 @@
+// 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

@@ -34,12 +37,6 @@ 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) {
@@ -48,9 +45,9 @@ template <typename T>

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

@@ -455,23 +455,17 @@ 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;
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
+    // MSVC should now be fixed... right... right?!?!?!
+    for (const auto& entry : fs::recursive_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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

 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,8 +1,12 @@
+// 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
-#define STB_IMAGE_RESIZE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION 1
+#define STB_IMAGE_RESIZE_IMPLEMENTATION 1
+#define STB_IMAGE_WRITE_IMPLEMENTATION 1
+#define STBI_ONLY_JPEG 1

 #include "common/stb.h"
@@ -1,8 +1,12 @@
+// 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

 SteadyClock::time_point SteadyClock::Now() noexcept {
 #if defined(_WIN32)
-    static const auto freq = WindowsQueryPerformanceFrequency();
+    static const auto timer_freq = WindowsQueryPerformanceFrequency();
    const auto counter = WindowsQueryPerformanceCounter();
-
-    // 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;
+    const auto whole = (counter / timer_freq) * period::den;
+    const auto part = (counter % timer_freq) * period::den / timer_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{system.Kernel()}, cpu_manager{system},
+        : kernel{system}, fs_controller{system}, hid_core{kernel}, cpu_manager{system},
          reporter{system}, applet_manager{system}, frontend_applets{system}, profile_manager{} {}

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

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

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

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

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

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

 struct EmptyAllocator {
@@ -619,7 +623,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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -32,14 +32,13 @@ 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::Is4KBAligned(dst_addr)) {
+Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr, u64 src_addr, u64 size) {
+    if (!Common::IsAligned(dst_addr, Core::Memory::YUZU_PAGESIZE)) {
        LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
        R_THROW(ResultInvalidAddress);
    }

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

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

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -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::Is4KBAligned(addr)) {
+    if (!Common::IsAligned(addr, Core::Memory::YUZU_PAGESIZE)) {
        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
        R_THROW(ResultInvalidAddress);
    }

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

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

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

-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0 || !Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size);
        R_THROW(ResultInvalidSize);
    }
@@ -190,6 +190,7 @@ 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));
 }

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

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

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

-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0 || !Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE)) {
        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size);
        R_THROW(ResultInvalidSize);
    }
@@ -250,6 +251,7 @@ 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,11 +23,13 @@ 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_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} {
+    : 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}
+{
    // clang-format off
    static const FunctionInfo functions[] = {
        {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
@@ -48,8 +50,7 @@ TimeZoneService::TimeZoneService(
    // clang-format on
    RegisterHandlers(functions);

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

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

    std::scoped_lock m{m_list_mutex};
    for (auto& operation_event : m_list_nodes) {
-        operation_event.m_event->Signal(m_system.Kernel());
+        operation_event.m_event->Signal(system.Kernel());
    }
    R_SUCCEED();
 }
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -77,9 +80,7 @@ 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,10 +7,12 @@
 #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,11 +32,13 @@ 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);
@@ -132,7 +134,9 @@ Result Alarms::UpdateClosestAndSignal(Kernel::KernelCore& kernel) {
 }

 IAlarmService::IAlarmService(Core::System& system_, std::shared_ptr<TimeManager> manager)
-    : ServiceFramework{system_, "time:al"}, m_system{system}, m_alarms{manager->m_alarms} {
+    : ServiceFramework{system_, "time:al"}
+    , m_alarms{manager->m_alarms}
+{
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &IAlarmService::CreateWakeupAlarm, "CreateWakeupAlarm"},
@@ -74,8 +74,7 @@ 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() {
@@ -110,21 +109,17 @@ 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,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

 IPowerStateRequestHandler::IPowerStateRequestHandler(
    Core::System& system_, PowerStateRequestManager& power_state_request_manager)
-    : ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
-                                                                 power_state_request_manager} {
+    : ServiceFramework{system_, "time:p"}
+    , m_power_state_request_manager{power_state_request_manager}
+{
    // clang-format off
        static const FunctionInfo functions[] = {
            {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -17,16 +20,13 @@ 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_system{system}, m_time{std::move(time)},
+    : ServiceFramework{system_, "time:m"}, 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{m_system}, m_network_operation{m_system}, m_ephemeral_operation{m_system} {
+      m_local_operation{system_}, m_network_operation{system_}, m_ephemeral_operation{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 = m_system.CoreTiming().GetClockTicks();
+    auto ticks = 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 = m_system.CoreTiming().GetClockTicks();
+    auto ticks = 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(m_system.Kernel());
+    m_alarms.CheckAndSignal(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>(
-                          m_system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
+                          system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
        m_server_manager.RegisterNamedService("time:p",
                                              std::make_shared<IPowerStateRequestHandler>(
-                                                  m_system, m_time->m_power_state_request_manager));
+                                                  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>(m_system, setup_info, m_time, name);
+    *out_service = std::make_shared<StaticService>(system, setup_info, m_time, name);
    R_SUCCEED();
 }

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

@@ -60,10 +63,8 @@ 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_system{system}, m_setup_info{setup_info}, m_time{time},
+    : ServiceFramework{system_, name}, 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>(m_system, m_user_system_clock,
+    *out_service = std::make_shared<SystemClock>(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>(m_system, m_network_system_clock,
+    *out_service = std::make_shared<SystemClock>(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>(m_system, m_time, m_setup_info.can_write_steady_clock,
+        std::make_shared<SteadyClock>(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>(m_system, m_time->m_standard_steady_clock, m_time_zone,
+        std::make_shared<TimeZoneService>(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>(m_system, m_local_system_clock,
+    *out_service = std::make_shared<SystemClock>(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>(m_system, m_ephemeral_network_clock,
+    *out_service = std::make_shared<SystemClock>(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{m_system.CoreTiming().GetClockTicks()};
+    auto ticks{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,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -68,8 +71,6 @@ 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -13,10 +13,11 @@ 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_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} {
+    : 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}
+{
    // clang-format off
         static const FunctionInfo functions[] = {
        {0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -32,8 +35,6 @@ 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,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

 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_system{system}, 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_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"},
@@ -72,7 +76,7 @@ Result SystemClock::GetOperationEventReadableHandle(
    LOG_DEBUG(Service_Time, "called.");

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

        m_clock_core.LinkOperationEvent(*m_operation_event);
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -18,9 +21,7 @@ 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);
@@ -30,8 +31,6 @@ 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,9 +15,11 @@ 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_system{system}, 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_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,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -56,8 +59,6 @@ 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,10 +17,14 @@ 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);
-    ir.SetTerm(IR::Term::LinkBlock{new_location});
+    // pattern match => b .
+    if (imm32 == 0) {
+        ir.SetTerm(IR::Term::LinkBlock{new_location});
+    } else {
+        ir.SetTerm(IR::Term::LinkBlockFast{new_location});
+    }
    return false;
 }

@@ -35,7 +39,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::LinkBlock{new_location});
+    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
    return false;
 }

@@ -46,7 +50,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::LinkBlock{new_location});
+    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
    return false;
 }

@@ -56,11 +56,10 @@ 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::LinkBlock{ir.current_location.AdvancePC(4).SetEFlag(E)});
+            ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location.AdvancePC(4).SetEFlag(E)});
            return false;
        }
    }
-
    return true;
 }

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

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

@@ -906,9 +906,8 @@ 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::LinkBlock{ir.current_location.AdvancePC(2).AdvanceIT()};
-        const auto branch = IR::Term::LinkBlock{ir.current_location.AdvancePC(imm + 4).AdvanceIT()};
-
+        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()};
        if (nonzero) {
            return std::make_pair(skip, branch);
        } else {
@@ -975,10 +974,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_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
-    const auto else_location = ir.current_location.AdvancePC(2).AdvanceIT();
+    const auto then_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(imm32).AdvanceIT()};
+    const auto else_ = IR::Term::LinkBlockFast{ir.current_location.AdvancePC(2).AdvanceIT()};

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

@@ -990,8 +989,12 @@ 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();
-
-    ir.SetTerm(IR::Term::LinkBlock{next_location});
+    // pattern (b +#0)
+    if (imm32 == 0) {
+        ir.SetTerm(IR::Term::LinkBlock{next_location});
+    } else {
+        ir.SetTerm(IR::Term::LinkBlockFast{next_location});
+    }
    return false;
 }

@@ -1,3 +1,6 @@
+// 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
@@ -20,10 +23,8 @@ 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);
-    const auto new_location = ir.current_location
-                                  .AdvancePC(imm32)
-                                  .AdvanceIT();
-    ir.SetTerm(IR::Term::LinkBlock{new_location});
+    auto const new_location = ir.current_location.AdvancePC(imm32).AdvanceIT();
+    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
    return false;
 }

@@ -44,11 +45,8 @@ 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::LinkBlock{new_location});
+    const auto new_location = ir.current_location.SetPC(ir.AlignPC(4) + imm32).SetTFlag(false).AdvanceIT();
+    ir.SetTerm(IR::Term::LinkBlockFast{new_location});
    return false;
 }

@@ -61,10 +59,13 @@ 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);
-    const auto new_location = ir.current_location
-                                  .AdvancePC(imm32)
-                                  .AdvanceIT();
-    ir.SetTerm(IR::Term::LinkBlock{new_location});
+    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});
+    }
    return false;
 }

@@ -75,13 +76,9 @@ 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_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}});
+    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_});
    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::LinkBlock{ir.current_location->SetPC(target)};
-    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
+    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
+    const auto cond_fail = IR::Term::LinkBlockFast{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)});
-        return false;
+    } else {
+        ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location->SetPC(target)});
    }
-    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::LinkBlock{ir.current_location->SetPC(target)};
-    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
+    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
+    const auto cond_fail = IR::Term::LinkBlockFast{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::LinkBlock{ir.current_location->AdvancePC(4)};
-    const auto cond_fail = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
+    const auto cond_pass = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
+    const auto cond_fail = IR::Term::LinkBlockFast{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::LinkBlock{ir.current_location->AdvancePC(4)};
-    const auto cond_0 = IR::Term::LinkBlock{ir.current_location->SetPC(target)};
+    const auto cond_1 = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
+    const auto cond_0 = IR::Term::LinkBlockFast{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::LinkBlock{ir.current_location->SetPC(target)};
-    const auto cond_0 = IR::Term::LinkBlock{ir.current_location->AdvancePC(4)};
+    const auto cond_1 = IR::Term::LinkBlockFast{ir.current_location->SetPC(target)};
+    const auto cond_0 = IR::Term::LinkBlockFast{ir.current_location->AdvancePC(4)};
    ir.SetTerm(IR::Term::CheckBit{cond_1, cond_0});
    return false;
 }
@@ -1,7 +1,11 @@
+// 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"

@@ -308,17 +312,15 @@ 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};
-    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);
+    auto const it = callback_list.find(key);
+    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
+    callback_list.erase(it);
 }
 } // namespace Core::HID
@@ -10,6 +10,7 @@

 #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"
@@ -1876,12 +1877,9 @@ NpadColor EmulatedController::GetNpadColor(u32 color) {

 void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
    std::unique_lock lock{callback_mutex};
-    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) {
+    for (auto const& p : callback_list) {
+        auto const& poller = p.second;
+        if (is_npad_service_update || !poller.is_npad_service) {
            poller.on_change(type);
        }
    }
@@ -1889,18 +1887,16 @@ 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};
-    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);
+    auto const it = callback_list.find(key);
+    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
+    callback_list.erase(it);
 }

 void EmulatedController::StatusUpdate() {
@@ -1,9 +1,13 @@
+// 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"

@@ -467,17 +471,15 @@ 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};
-    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);
+    auto const it = callback_list.find(key);
+    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
+    callback_list.erase(it);
 }
 } // namespace Core::HID
@@ -1,7 +1,11 @@
+// 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"
@@ -145,7 +149,7 @@ void MotionInput::UpdateOrientation(u64 elapsed_time) {
    }

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

    return {
        std::atan2(sinr_cosp, cosr_cosp),
-        2 * std::atan2(sinp, cosp) - Common::PI / 2,
+        2 * std::atan2(sinp, cosp) - float(std::numbers::pi_v<float>) / 2,
        std::atan2(siny_cosp, cosy_cosp),
    };
 }
@@ -24,7 +24,8 @@ 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,29 +45,17 @@ 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_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);
+    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);
+            }
        }
    }
 }
@@ -101,6 +89,16 @@ 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,9 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 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"

@@ -214,7 +215,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 / Common::PI;
+        next_state.rotation_angle = angle_between_two_lines * 180.0f / float(std::numbers::pi_v<float>);
    }
 }

@@ -3,6 +3,8 @@
 // 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"
@@ -146,9 +148,9 @@ public:
            break;
        }
        case SDL_SENSOR_GYRO: {
-            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);
+            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);
            break;
        }
        }
@@ -948,34 +950,39 @@ 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;
-
-    switch_to_sdl_button = GetDefaultButtonBinding(joystick);
-
+    ButtonBindings 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},
    }};
-
-    // 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);
+    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);
        }
+        return GetSingleControllerMapping(joystick, 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;
 }

 ButtonBindings SDLDriver::GetDefaultButtonBinding(
@@ -1,8 +1,12 @@
+// 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"
@@ -15,9 +19,8 @@ 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 = TAU * 0.15f;
+    static constexpr float APERTURE = float((std::numbers::pi_v<float> / 2.f)) * 0.15f;

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

@@ -66,13 +69,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 + TAU > new_angle && old_angle + TAU <= 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);
    }

    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 - TAU >= bottom_limit && old_angle - TAU < 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);
    }

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

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

    void SetGoalAngle(bool r, bool l, bool u, bool d) {
-        // 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;
-        }
+        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
    }

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

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

 namespace InputCommon {
@@ -463,8 +464,9 @@ 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) {
@@ -474,12 +476,9 @@ void InputEngine::SetMappingCallback(MappingCallback callback) {

 void InputEngine::DeleteCallback(int key) {
    std::scoped_lock lock{mutex_callback};
-    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);
+    auto const it = callback_list.find(key);
+    ASSERT_MSG(it != callback_list.end(), "Tried to delete non-existent callback {}", key);
+    callback_list.erase(it);
 }

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -665,6 +665,8 @@ 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,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

@@ -97,6 +100,26 @@ 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -743,6 +743,10 @@ 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,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

@@ -200,6 +203,20 @@ 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,6 +322,12 @@ 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);
@@ -440,6 +446,12 @@ 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);
    }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -622,6 +622,8 @@ 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);
@@ -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

@@ -220,6 +223,21 @@ 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)};
@@ -38,10 +38,11 @@ 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, has_secondary)
-            == std::tie(o.index, o.offset, o.shift_left, o.sec_index, o.sec_offset, o.sec_shift_left, o.has_secondary);
+        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);
    }
 };
 struct HandleKeyHash {
@@ -50,8 +51,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 ^= k.has_secondary ? 0x9e3779b97f4a7c15ULL : 0ULL;
-        return h;
+        h ^= (size_t(k.count) << 7);
+        return h ^ (k.has_secondary ? 0x9e3779b97f4a7c15ULL : 0ULL);
    }
 };

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -2100,6 +2100,14 @@ 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -394,6 +394,8 @@ 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

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

 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

 // using enum Type;
-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};
+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 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 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 u8 NUM_ARGS[]{
-#define OPCODE(name_token, type_token, ...) static_cast<u8>(CalculateNumArgsOf(Opcode::name_token)),
-#include "opcodes.inc"
-#undef OPCODE
-};
+extern u8 NUM_ARGS[532];
 } // namespace Detail

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

 /// Get the number of arguments an opcode accepts
 [[nodiscard]] inline size_t NumArgsOf(Opcode op) noexcept {
-    return static_cast<size_t>(Detail::NUM_ARGS[static_cast<size_t>(op)]);
+    return size_t(Detail::NUM_ARGS[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[static_cast<size_t>(op)].arg_types[arg_index];
+    return Detail::META_TABLE[size_t(op)].arg_types[arg_index];
 }

 /// Get the name of an opcode
@@ -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

@@ -579,6 +582,8 @@ 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 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

-void Shuffle(TranslatorVisitor& v, u64 insn, const IR::U32& index, const IR::U32& mask) {
+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) {
    union {
        u64 insn;
        BitField<0, 8, IR::Reg> dest_reg;
@@ -45,6 +48,21 @@ 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);
@@ -59,11 +77,14 @@ void TranslatorVisitor::SHFL(u64 insn) {
        BitField<29, 1, u64> src_b_flag;
        BitField<34, 13, u64> src_b_imm;
    } const flags{insn};
-    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);
+    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));
 }

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -498,6 +498,10 @@ 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:
@@ -261,21 +261,25 @@ 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) {
-    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;
-
+    // 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 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;
@@ -29,6 +29,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{};
    bool support_viewport_index_layer_non_geometry{};
    bool support_viewport_mask{};
@@ -251,6 +251,7 @@ 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{};
@@ -56,6 +56,9 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
    const Maxwell& regs = maxwell3d.regs;
    const auto topology_ = maxwell3d.draw_manager.draw_state.topology;

+    driver_id = features.driver_id;
+    driver_version = features.driver_version;
+
    raw1 = 0;
    extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
    extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
@@ -21,6 +21,8 @@ namespace Vulkan {
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;

 struct DynamicFeatures {
+    u32 driver_id;
+    u32 driver_version;
    bool has_extended_dynamic_state;
    bool has_extended_dynamic_state_2;
    bool has_extended_dynamic_state_2_logic_op;
@@ -228,6 +230,8 @@ struct FixedPipelineState {
    };
    std::array<u8, Maxwell::NumRenderTargets> color_formats;

+    u32 driver_id;
+    u32 driver_version;
    u32 alpha_test_ref;
    u32 point_size;

@@ -62,7 +62,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;

-constexpr u32 CACHE_VERSION = 17;
+constexpr u32 CACHE_VERSION = 18;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};

 template <typename Container>
@@ -402,6 +402,8 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .support_fp64_signed_zero_nan_preserve =
            float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
        .support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),
+        .support_shader_quad_control = device.IsKhrShaderQuadControlSupported(),
+        .support_quad_shuffles = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_QUAD_BIT),
        .support_vote = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_VOTE_BIT),
        .support_viewport_index_layer_non_geometry =
            device.IsExtShaderViewportIndexLayerSupported(),
@@ -479,6 +481,8 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
    LOG_INFO(Render_Vulkan, "DynamicState setting value: {}", u32(Settings::values.dyna_state.GetValue()));

    dynamic_features = {};
+    dynamic_features.driver_id = device.GetDriverID();
+    dynamic_features.driver_version = device.GetDriverVersion();

    // User granularity enforced in vulkan_device.cpp switch statement:
    //   Level 0: Core Dynamic States only
@@ -1330,6 +1330,11 @@ void Device::RemoveUnsuitableExtensions() {
                               VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
    }

+    // VK_KHR_shader_quad_control
+    extensions.shader_quad_control = features.shader_quad_control.shaderQuadControl;
+    RemoveExtensionFeatureIfUnsuitable(extensions.shader_quad_control, features.shader_quad_control,
+                                       VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME);
+
    // VK_KHR_workgroup_memory_explicit_layout
    extensions.workgroup_memory_explicit_layout =
        features.features.shaderInt16 &&
@@ -1518,7 +1523,7 @@ std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
 }

 void Device::InitializeGPULogging() {
-    // Get log level from settings — Off is the disable.
+    // Get log level from settings - Off is the disable.
    const auto log_level = static_cast<GPU::Logging::LogLevel>(
        static_cast<u32>(Settings::values.gpu_log_level.GetValue()));
    if (log_level == GPU::Logging::LogLevel::Off) {
@@ -68,6 +68,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
    FEATURE(KHR, Maintenance6, MAINTENANCE_6, maintenance6)                                        \
    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
            pipeline_executable_properties)                                                        \
+    FEATURE(KHR, ShaderQuadControl, SHADER_QUAD_CONTROL, shader_quad_control)                      \
    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
            workgroup_memory_explicit_layout)

@@ -483,6 +484,11 @@ FN_MAX_LIMIT_LIST
        return extensions.workgroup_memory_explicit_layout;
    }

+    /// Returns true if the device supports VK_KHR_shader_quad_control.
+    bool IsKhrShaderQuadControlSupported() const {
+        return extensions.shader_quad_control && features.shader_quad_control.shaderQuadControl;
+    }
+
    /// Returns true if the device supports VK_KHR_image_format_list.
    bool IsKhrImageFormatListSupported() const {
        return extensions.image_format_list || instance_version >= VK_API_VERSION_1_2;
@@ -1612,7 +1612,7 @@ void PlayerControlPreview::DrawGCBody(QPainter& p, const QPointF center) {
    std::array<QPointF, gc_body.size()> qbody;
    std::array<QPointF, 8> left_hex;
    std::array<QPointF, 8> right_hex;
-    constexpr float angle = 2 * 3.1415f / 8;
+    constexpr float angle = 2.f * float(M_PI) / 8.f;

    for (std::size_t point = 0; point < gc_left_body.size() / 2; ++point) {
        const float body_x = gc_left_body[point * 2 + 0];
@@ -0,0 +1,3 @@
+# CPMUtil CMake Test Scripts
+
+Testing out some CMake scripting functionality.
@@ -0,0 +1,341 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+# TODO: Account for CPMConfig.cmake
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules)
+set(CPMUTIL_ROOT ${CMAKE_SOURCE_DIR})
+
+include(CPMUtil)
+
+# Parse the JSON object for a given key.
+macro(parse_key key)
+    get_json_object(${key})
+    set(JSON_NAME ${key})
+    parse_object(${object})
+endmacro()
+
+# Get a package's effective URL, for an already parsed object
+function(get_package_url_object out)
+    if (${url})
+        set(${out} "${url}")
+    else()
+        get_package_url(URL_OUT "${out}"
+            GIT_HOST "${git_host}"
+            REPO "${repo}"
+            VERSION "${version}"
+            ARTIFACT "${artifact}"
+            PACKAGE "${package}")
+    endif()
+
+    return(PROPAGATE ${out})
+endfunction()
+
+# Fetch a package from an already-parsed object.
+function(fetch_package_object)
+    set(optionArgs FORCE)
+    cmake_parse_arguments(ARG "${optionArgs}" "" "" ${ARGN})
+
+    if (${url})
+        set(pkg_url "${url}")
+    else()
+        get_package_url(URL_OUT pkg_url
+            GIT_HOST "${git_host}"
+            REPO "${repo}"
+            VERSION "${version}"
+            ARTIFACT "${artifact}"
+            PACKAGE "${package}")
+    endif()
+
+    if (DEFINED CACHE_PATH_OVERRIDE)
+        set(cache_path ${CACHE_PATH_OVERRIDE})
+    else()
+        get_cache_path(${package} ${version} cache_path)
+    endif()
+
+    set(fetch_args
+        URL "${pkg_url}"
+        HASH "${hash}"
+        PATH "${cache_path}"
+        PATCHES ${patches})
+
+    if(ARG_FORCE)
+        list(APPEND fetch_args FORCE)
+    endif()
+
+    fetch_package(${fetch_args})
+endfunction()
+
+# Format the cpmfile. Requires one of: jq, python, perl
+# If you don't have any of those, sorry not sorry.
+# Maybe I should make a shell-based alternative.
+function(format_cpmfile)
+    # jq is the preferred formatter since it's the fastest
+    cpm_find_program(JQ_EXECUTABLE jq)
+    if (JQ_EXECUTABLE)
+        set(command ${JQ_EXECUTABLE} --indent 4 -S .)
+    else()
+        # Python is simple and works
+        find_package(Python 3.5 COMPONENTS Interpreter QUIET)
+        if (Python_FOUND)
+            set(command ${Python_EXECUTABLE} -m json.tool
+                --indent 4 --sort-keys)
+        else()
+            # json_pp (part of perl) also works well
+            cpm_find_program(JSONPP_EXECUTABLE json_pp)
+            if (JSONPP_EXECUTABLE)
+                set(json_opts "indent" "indent_length=4" "canonical"
+                    "space_after=1" "space_before=0")
+                string(JOIN "," json_opts_str ${json_opts})
+
+                set(command ${JSONPP_EXECUTABLE} -f json -t json -json_opt
+                    "${json_opts_str}")
+            else()
+                fatal("Fatal: could not find one of jq, Python, or perl"
+                    "(json_pp). Install one of these packages to use"
+                    "CPMUtil's tooling. If they ARE installed, your"
+                    "CMake installation is broken.")
+            endif()
+        endif()
+    endif()
+
+    get_cpmfile_path(file)
+    mktempdir(TMP)
+    set(tmp_file ${TMP}/cpmfile.json)
+
+    execute_process(COMMAND ${command}
+        INPUT_FILE ${file}
+        OUTPUT_FILE ${tmp_file})
+
+    # TODO: error handling, mv, cp?
+    file(COPY_FILE ${tmp_file} ${file})
+
+    file(REMOVE_RECURSE ${TMP})
+endfunction()
+
+# Computes expected SHA512 hash of a package
+function(get_package_hash url out)
+    mktempdir(TMP)
+
+    get_filename_component(filename ${url} NAME)
+    set(file ${TMP}/${filename})
+
+    cpm_download("${url}" "${file}")
+    file(SHA512 ${file} ${out})
+
+    file(REMOVE_RECURSE ${TMP})
+    return(PROPAGATE ${out})
+endfunction()
+
+# Download and put the content into a variable.
+function(cpm_download_var url out)
+    mktempdir(TMP)
+
+    set(file ${TMP}/tmp)
+    cpm_download("${url}" "${file}")
+    file(READ ${file} ${out})
+
+    file(REMOVE_RECURSE ${TMP})
+    return(PROPAGATE ${out})
+endfunction()
+
+# Check if a URL request succeeds without actually saving anything
+function(cpm_url_exists url out)
+    foreach(i RANGE 5)
+        file(DOWNLOAD "${url}" STATUS ret LOG log TIMEOUT 10)
+        list(GET ret 0 code)
+
+        if (code EQUAL 0)
+            set(${out} TRUE)
+            break()
+        else()
+            if (log MATCHES "HTTP/[0-9.]+ (429|403)")
+                sleep(5)
+                continue()
+            endif()
+
+            set(${out} FALSE)
+            break()
+        endif()
+    endforeach()
+
+    return(PROPAGATE ${out})
+endfunction()
+
+# Get latest tag for a package.
+# Requires an already-parsed object
+function(get_latest_tag out)
+    # TODO: Ci packages
+    if (NOT repo OR ci)
+        set(${out} null)
+        return(PROPAGATE ${out})
+    endif()
+
+    # first determine if this is a tag or not
+    if (git_host STREQUAL github.com)
+        set(api "https://api.github.com/repos/${repo}")
+        set(check_endpoint "/git/refs/tags")
+    else()
+        set(api "https://${git_host}/api/v1/repos/${repo}")
+        set(check_endpoint "/tags")
+    endif()
+
+    # artifacts must only check releases
+    if ("${artifact}" STREQUAL "")
+        set(json_key name)
+        set(endpoint "/tags")
+    else()
+        set(json_key tag_name)
+        set(endpoint "/releases")
+        set(check_endpoint "/releases/tags")
+    endif()
+
+    cpm_url_exists("${api}${check_endpoint}/${version}" is_tag)
+
+    if (NOT is_tag)
+        set(${out} null)
+        return(PROPAGATE ${out})
+    endif()
+
+    # strip out prefixes e.g. boost-, openssl-, v
+    # NOTE: subrels e.g. -1 at the end may cause issues.
+    string(REGEX REPLACE "[^0-9.-]" "" t_numeric_version "${version}")
+    string(REGEX REPLACE "-$|^-" "" t_numeric_version "${numeric_version}")
+
+    # now api req
+    cpm_download_var("${api}${endpoint}" tags)
+
+    string(JSON len LENGTH ${tags})
+    math(EXPR last_index "${len} - 1")
+
+    set(greatest_version_numeric ${t_numeric_version})
+    set(greatest_version ${version})
+
+    foreach(i RANGE ${last_index})
+        string(JSON tag_obj GET "${tags}" ${i})
+        string(JSON tag_name GET "${tag_obj}" ${json_key})
+
+        # same as above
+        string(REGEX REPLACE "[^0-9.-]" "" numeric_tag "${tag_name}")
+        string(REGEX REPLACE "-$|^-" "" numeric_tag "${numeric_tag}")
+
+        if (numeric_tag VERSION_GREATER_EQUAL greatest_version_numeric)
+            set(greatest_version_numeric ${numeric_tag})
+            set(greatest_version ${tag_name})
+        endif()
+    endforeach()
+
+    # numeric version replacement
+    if (numeric_version)
+        set(${out} ${greatest_version_numeric})
+    else()
+        set(${out} ${greatest_version})
+    endif()
+
+    return(PROPAGATE ${out})
+endfunction()
+
+# TODO(crueter): Combine these
+
+# Update hash and version of a package
+# Outputs the updated object
+function(modify_package object version hash out)
+    string(JSON new_object SET "${object}" hash "\"${hash}\"")
+    string(JSON new_object SET "${new_object}" version "\"${version}\"")
+
+    set(${out} "${new_object}")
+    return(PROPAGATE ${out})
+endfunction()
+
+# Update hash and numeric_version of a package
+# Outputs the updated object
+function(modify_package_numeric object version hash out)
+    string(JSON new_object SET "${object}" hash "\"${hash}\"")
+    string(JSON new_object SET "${new_object}" numeric_version "\"${version}\"")
+
+    set(${out} "${new_object}")
+    return(PROPAGATE ${out})
+endfunction()
+
+
+function(get_cpmfile_keys out)
+    get_cpmfile_content(object)
+
+    string(JSON len LENGTH ${object})
+
+    math(EXPR last_index "${len} - 1")
+    foreach(i RANGE ${last_index})
+        string(JSON key MEMBER ${object} ${i})
+        list(APPEND ${out} ${key})
+    endforeach()
+
+    return(PROPAGATE ${out})
+endfunction()
+
+function(parse_script_args out)
+    if(PRINT_USAGE)
+        usage()
+        cmake_language(EXIT 0)
+    endif()
+
+    if(NOT CMAKE_SCRIPT_MODE_FILE OR NOT CMAKE_ARGC)
+        set(${out} "" PARENT_SCOPE)
+        return()
+    endif()
+
+    set(found_script FALSE)
+    set(idx 0)
+
+    get_filename_component(script_name "${CMAKE_SCRIPT_MODE_FILE}" NAME)
+
+    while(idx LESS CMAKE_ARGC)
+        if(found_script)
+            set(arg "${CMAKE_ARGV${idx}}")
+            if(NOT arg STREQUAL "--")
+                list(APPEND positional_args ${arg})
+            endif()
+        elseif(CMAKE_ARGV${idx} STREQUAL CMAKE_SCRIPT_MODE_FILE)
+            set(found_script TRUE)
+        else()
+            get_filename_component(arg_name "${CMAKE_ARGV${idx}}" NAME)
+            if(arg_name STREQUAL script_name)
+                set(found_script TRUE)
+            endif()
+        endif()
+        math(EXPR idx "${idx} + 1")
+    endwhile()
+
+    if(ALL_PACKAGES AND NOT NO_ALL)
+        get_cpmfile_keys(all_keys)
+        if(NO_CI)
+            set(filtered_keys)
+            foreach(key ${all_keys})
+                parse_key(${key})
+                if(NOT ci)
+                    list(APPEND filtered_keys ${key})
+                endif()
+            endforeach()
+            set(positional_args ${filtered_keys})
+        else()
+            set(positional_args ${all_keys})
+        endif()
+    endif()
+
+    set(${out} ${positional_args} PARENT_SCOPE)
+endfunction()
+
+# Convert a CMake list to a JSON array
+function(list_to_array list out)
+    set(${out} "[]")
+    set(idx 0)
+    foreach(elem ${list})
+        string(JSON ${out} SET ${${out}} "${idx}" "\"${elem}\"")
+        math(EXPR idx "${idx} + 1")
+    endforeach()
+
+    return(PROPAGATE ${out})
+endfunction()
@@ -1,9 +1,11 @@
-#!/bin/sh -e
+#!/usr/bin/env -S cmake -P

 # SPDX-FileCopyrightText: Copyright 2026 crueter
 # SPDX-License-Identifier: LGPL-3.0-or-later

-jq --indent 4 -S <cpmfile.json >cpmfile.json.new
-mv cpmfile.json.new cpmfile.json
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/ScriptUtils.cmake)

 # TODO: Run some sanity checks e.g. patches exist, etc.
+format_cpmfile()
@@ -0,0 +1,24 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/ScriptUtils.cmake)
+
+set(NO_ALL TRUE)
+
+function(usage)
+    echo([=[
+Usage: cpmutil.sh ls
+
+List all packages in the cpmfile.
+]=])
+endfunction()
+
+get_cpmfile_keys(keys)
+
+foreach(key ${keys})
+    echo("${key}")
+endforeach()
@@ -0,0 +1,104 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../ScriptUtils.cmake)
+
+function(usage)
+    echo([=[
+Usage: add.cmake [OPTIONS...]
+
+Internal use only.
+]=])
+endfunction()
+
+if (NOT DEFINED KEY)
+    fatal("KEY is required")
+endif()
+
+if (NOT DEFINED REPO)
+    fatal("REPO is required")
+endif()
+
+if (NOT DEFINED VERSION)
+    fatal("VERSION is required")
+endif()
+
+
+if (NOT DEFINED CI)
+    set(CI FALSE)
+endif()
+
+# construct json
+set(object "{}")
+
+macro(add key val)
+    set(${key} ${val})
+    string(JSON object SET ${object} ${key} "\"${val}\"")
+endmacro()
+
+add(repo ${REPO})
+add(version ${VERSION})
+
+if (DEFINED GIT_HOST AND NOT "${GIT_HOST}" STREQUAL github.com)
+    add(git_host ${GIT_HOST})
+else()
+    set(git_host github.com)
+endif()
+
+if (DEFINED PACKAGE)
+    add(package ${PACKAGE})
+else()
+    set(package ${KEY})
+endif()
+
+if (DEFINED FIND_ARGS)
+    add(find_args "${FIND_ARGS}")
+endif()
+
+if (DEFINED MIN_VERSION)
+    add(min_version ${MIN_VERSION})
+endif()
+
+if (DEFINED ARTIFACT)
+    add(artifact ${ARTIFACT})
+endif()
+
+if (CI)
+    add(ci true)
+
+    if (DEFINED DISABLED_PLATFORMS)
+        list_to_array(${DISABLED_PLATFORMS} json_disabled)
+        string(JSON object SET "${object}" disabled_platforms "${json_disabled}")
+    endif()
+else()
+    if (DEFINED OPTIONS)
+        list_to_array(${OPTIONS} json_options)
+        string(JSON object SET "${object}" options "${json_options}")
+    endif()
+
+    # get hash
+    get_package_url_object(pkg_url)
+    get_package_hash("${pkg_url}" pkg_hash)
+
+    add(hash ${pkg_hash})
+
+endif()
+
+echo("\"${KEY}\": ${object}")
+
+# now write
+get_cpmfile_content(cpmfile)
+
+# update cached cpmfile content
+string(JSON cpmfile SET "${cpmfile}" "${KEY}" "${object}")
+
+# write cached cpmfile
+get_cpmfile_path(file)
+file(WRITE ${file} "${cpmfile}")
+format_cpmfile()
+
+echo("-- Added ${KEY}")
@@ -0,0 +1,33 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../ScriptUtils.cmake)
+
+function(usage)
+    echo([=[
+Usage: cpmutil.sh package dir [-a|--all] [PACKAGE]...
+
+Get the local directory for the specified packages.
+
+Options:
+    -a, --all       Operate on all packages in this project.
+]=])
+endfunction()
+
+parse_script_args(args)
+
+# TODO: CI packages.
+
+foreach(key ${args})
+    parse_key(${key})
+
+    # Guh.
+    get_cache_path(${package} ${version} cache_path)
+
+    cmake_path(ABSOLUTE_PATH cache_path NORMALIZE OUTPUT_VARIABLE abs_path)
+    echo("${key}: ${abs_path}")
+endforeach()
@@ -0,0 +1,34 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../ScriptUtils.cmake)
+
+function(usage)
+    echo([=[
+Usage: cpmutil.sh package fetch [-a|--all] [PACKAGE]...
+
+Fetch the specified package or packages from their defined download locations.
+If the package is already cached, it will not be re-fetched.
+
+Options:
+    -a, --all       Operate on all packages in this project.
+]=])
+endfunction()
+
+set(NO_CI TRUE)
+parse_script_args(args)
+
+foreach(key ${args})
+    if (ci)
+        continue()
+    endif()
+
+    parse_key(${key})
+    echo("-- ${key}")
+
+    fetch_package_object()
+endforeach()
@@ -0,0 +1,59 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../ScriptUtils.cmake)
+
+function(usage)
+    echo([=[
+Usage: cpmutil.sh package hash [-a|--all] [PACKAGE]...
+
+Check the hash of a specific package or packages.
+If a hash mismatch occurs, this script will update the package's hash.
+
+Options:
+    -a, --all       Operate on all packages in this project.
+
+Note that this procedure will usually take a long time
+depending on the number and size of dependencies.
+]=])
+endfunction()
+
+set(NO_CI TRUE)
+parse_script_args(args)
+
+get_cpmfile_content(cpmfile)
+foreach(key ${args})
+    if (ci)
+        continue()
+    endif()
+
+    parse_key("${key}")
+    echo("-- ${key}")
+
+    get_package_url_object(pkg_url)
+    get_package_hash("${pkg_url}" pkg_hash)
+
+    if (pkg_hash STREQUAL hash)
+        echo("Hashes match")
+    else()
+        echo_error("Hash mismatch")
+        echo_error("Expected: ${hash}")
+        echo_error("Got:      ${pkg_hash}")
+
+        modify_package("${object}" "${version}" "${pkg_hash}" new_object)
+
+        # update cached cpmfile content
+        string(JSON cpmfile SET "${cpmfile}" "${key}" "${new_object}")
+
+        echo("Corrected hash for ${key}")
+    endif()
+endforeach()
+
+# write cached cpmfile
+get_cpmfile_path(file)
+file(WRITE ${file} "${cpmfile}")
+format_cpmfile()
@@ -0,0 +1,155 @@
+#!/usr/bin/env -S cmake -P
+
+# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+cmake_minimum_required(VERSION 3.31)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../ScriptUtils.cmake)
+
+function(usage)
+    echo([=[
+Usage: cpmutil.sh package patch [PACKAGE]
+
+Create an in-tree patch for the specified package.
+]=])
+endfunction()
+
+set(NO_ALL TRUE)
+
+# arg parsing
+parse_script_args(args)
+
+list(LENGTH args arg_len)
+if(arg_len GREATER 0)
+    list(GET args 0 KEY)
+endif()
+
+if (NOT KEY)
+    fatal("You must provide a key")
+endif()
+
+if (NOT DEFINED DESCRIPTION)
+    fatal("No description provided")
+endif()
+
+parse_key(${KEY})
+get_cache_path(${package} ${version} local_cache)
+
+if (NOT EXISTS ${local_cache})
+    fatal("${package} is not fetched locally")
+endif()
+
+# get last patch number + 1
+list(LENGTH patches patches_len)
+math(EXPR last_index "${patches_len} - 1")
+list(GET patches ${last_index} patch)
+string(REGEX MATCH "[0-9][0-9][0-9][0-9]" number "${patch}")
+math(EXPR new_patchnum "${number} + 1")
+
+# now pad it for filename usage
+set(padded "0000${new_patchnum}")
+string(LENGTH ${padded} total_len)
+math(EXPR start_index "${total_len} - 4")
+string(SUBSTRING ${padded} ${start_index} 4 padded_patch_number)
+
+# this requires Git
+find_package(Git REQUIRED)
+
+# fetch temporary package
+mktempdir(TMP)
+
+set(CACHE_PATH_OVERRIDE ${TMP}/local)
+fetch_package_object()
+
+# make patch dir
+set(patch_dir "${CPMUTIL_PATCH_DIR}/${KEY}")
+file(MAKE_DIRECTORY "${patch_dir}")
+
+# git stuff
+macro(git_cmd out out_status)
+    echo("${GIT_EXECUTABLE} ${ARGN}")
+    # TODO: error handling
+    execute_process(COMMAND ${GIT_EXECUTABLE} ${ARGN}
+        WORKING_DIRECTORY ${CACHE_PATH_OVERRIDE}
+        OUTPUT_VARIABLE ${out}
+        RESULT_VARIABLE ${out_status})
+endmacro()
+
+# initialize
+git_cmd(_ _ init)
+git_cmd(_ _ add -A)
+git_cmd(_ _ commit -m init)
+git_cmd(_ _ "--work-tree=${local_cache}" add -A)
+
+# check for diffs
+git_cmd(_ diff_status diff --cached --quiet)
+git_cmd(out _ diff)
+
+if (diff_status EQUAL 0)
+    echo(${out})
+    echo_error("No differences found between local copy and source")
+    file(REMOVE_RECURSE ${TMP})
+    cmake_language(EXIT 1)
+endif()
+
+# prompt for patch description
+git_cmd(_ commit_status commit -m "${DESCRIPTION}")
+
+# format patch
+git_cmd(patch_content _ format-patch -1 HEAD --stdout)
+
+# now get patch name...
+
+# strip out existing numeric prefix
+string(REGEX REPLACE "^[0-9][0-9][0-9][0-9]-" "" name_part "${DESCRIPTION}")
+# spaces to dashes
+string(REPLACE " " "-" name_part "${name_part}")
+# strip out non-alphanumeric or dash characters
+string(REGEX REPLACE "[^a-zA-Z0-9-]" "" name_part "${name_part}")
+# collapse consecutive dashes
+string(REGEX REPLACE "-+" "-" name_part "${name_part}")
+# strip leading/trailing dashes
+string(REGEX REPLACE "^-|-$" "" name_part "${name_part}")
+
+if (NOT name_part)
+    set(name_part "patch")
+    echo_error("Warning: could not determine patch name")
+endif()
+
+# Truncate to 49 chars (60 - num prefix - `.patch` suffix)
+string(SUBSTRING "${name_part}" 0 49 name_part)
+
+# And remove any trailing dashes
+string(REGEX REPLACE "-$" "" name_part "${name_part}")
+
+# now construct and save patch
+set(patch_name "${padded_patch_number}-${name_part}.patch")
+
+file(WRITE "${patch_dir}/${patch_name}" "${patch_content}")
+
+echo("-- Patch created at ${patch_dir}/${patch_name}")
+file(REMOVE_RECURSE ${TMP})
+
+# Now add to cpmfile.
+get_cpmfile_content(content)
+
+# Build new patches JSON array
+set(new_patches "[")
+if(patches)
+    string(JSON existing GET "${content}" "${KEY}" "patches")
+    string(JSON len LENGTH "${existing}")
+    math(EXPR range_end "${len} - 1")
+    foreach(idx RANGE ${range_end})
+        string(JSON val GET "${existing}" ${idx})
+        string(APPEND new_patches "\"${val}\",")
+    endforeach()
+endif()
+string(APPEND new_patches "\"${patch_name}\"]")
+
+# Update the cpmfile
+string(JSON content SET "${content}" "${KEY}" patches "${new_patches}")
+get_cpmfile_path(file_path)
+file(WRITE "${file_path}" "${content}")
+format_cpmfile()
+
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CamilleLaVey	1ee7b981a6	Fix license headers	2026-07-07 20:28:53 +02:00
CamilleLaVey	2e1f4cb84b	[spir-v] Added fallback for unsupported quads + shader-stage checks	2026-07-07 20:28:53 +02:00
CamilleLaVey	baaf9a628c	[spir-v] Correcting output components	2026-07-07 20:28:53 +02:00
CamilleLaVey	bcaeece578	Another try	2026-07-07 20:28:53 +02:00
CamilleLaVey	7a3ab68439	[spir-v] Quick workaround for glasm/ glsl instructions	2026-07-07 20:28:53 +02:00
CamilleLaVey	c784f06704	[spir-v] Early stage quad control implementation	2026-07-07 20:28:53 +02:00
lizzie	e662108584	[fs] use recursive_directory_iterator since MSVC CRT no longer should bug out (#3670 ) SURELY, microslop already fixed its megaslop? basically read the comment (now gone); MSVC is evil, but it cant still be this evil right... right?!?!?! it's been 2 years surely not! mainly because this helps deep scan (in theory); android should see slight improvments for big game libraries Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3670 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:26:10 +02:00
lizzie	29f712d3b5	[core/device_memory_manager] use more pointer/iterator stable std::vector<> instead of deque<> for multi address scatter/gather (#4098 ) this SHOULD fix a specific issue where a deque can be reallocated causing spurious crashes Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4098 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-07-07 20:17:29 +02:00
lizzie	ae75ba4883	[shader_recompiler/ir] fix potential CBuf collision when count mismatches (#4097 ) this should make disjoint counts be handled as different cbufs for the cbuf cache this fixes TIC asserts on PKZA Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4097 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:16:21 +02:00
lizzie	7b750bf5bb	[hid_core, input_common] use std::numbers::pi{_v} instead of re-defining (#4160 ) don't reinvent the wheel, simple as that. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4160 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:13:33 +02:00
lizzie	94e9c2bd74	[common] remove presumed 'hot path' for QPC of 10MHz on SteadyClock::Now() (#4162 ) while this may be true, it isn't required to have this quick path for this function because: a) arm64 b) counter/freq and counter%freq is a single idiv c) 2 muls, 2 div isnt that insanely expensive d) `static_assert(period::den % TenMHz == 0)` Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4162 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:03:27 +02:00
lizzie	9677522e6c	[core/hle/kernel/svc] add missing CanContain check for {Un}MapProcessCodeMemory, remove 4KB align func (#4164 ) does what it says, adds a missing check for that specific SVC also removes that 4kb "helper" function which is just a fancy "IsAligned" Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4164 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:02:26 +02:00
lizzie	f423471cc0	[*, docs] remove UTF8 and make docs ASCII only (#4166 ) except for the AI policy doc which uses output for demonstrative purposes Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4166 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 20:01:11 +02:00
lizzie	ce043aceb9	[core/hle/service] remove duplicate Core::System& from some ServiceFramework (#4171 ) services inheriting from ServiceFramework already have an accessible system pointer from the inheritance adding an extra pointer (m_system, often) isn't required and tis entirely redundant. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4171 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:59:58 +02:00
lizzie	1643d8766f	[vk] invalidate shader cache automatically if !=driverId or !=driverVersion (#4174 ) this integrates neatly into the existing GraphicsPipelineKey system no need for extra funcs :) Signed-off-by: lizzie <lizzie@eden-emu.dev> Co-authored-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4174 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:57:45 +02:00
lizzie	fe1b8ff0ab	[input_common] Fix GetButtonMappingForDevice() when joystick doesn't have a gamepad associated with it (#4172 ) from PS4 PR - this should help fix the case where a controller doesn't have an associated gamepad and thus its not automatically configured. this should fix that :) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4172 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:54:15 +02:00
lizzie	f22fd1714b	[dynarmic] use LinkBlockFast for branches which are guarnateed to be unconditional (or conditionally unconditional) (#4177 ) CBZ is basically ```c if (thing) { jump(A); } else { jump(B); } ``` those jumps are locally unconditional so we can add the LinkBlockFast without much repercussions for a small win in JIT opts Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4177 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:53:13 +02:00
lizzie	6119e8fad2	[hid_core] fix LM2 crash due to callbacks not being removed properly (#4178 ) the function returned the key AFTER this one, which points to an invalid object basically its like "oh im returning the index AFTER Myself" off-by-1 error basically; now it returns OUR own key. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4178 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:52:22 +02:00
lizzie	bfc0e60333	[externals/stb] only include JPEG functions, disable all others (#4179 ) we use JPEG only with STB, dont need the others which are included in the final binary, after gc+lto this doesnt affect stb_dxt, which still includes all required BCn stuff Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4179 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:51:51 +02:00
lizzie	072be286d1	[shader_recompiler] fix META_TABLE/NUM_ARGS table being duplicated per TU that included opcodes.h (#4180 ) small oopsie; we dont need 6 copies of the same 22KB table (removes 5*22 = 110 KB worth of redundant stuff) this also enforces static on the types defined in the header so they arent memoized into a non-inlined value (aka. compiler just grabs value instead of well, yknow, assuming its a constant area) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4180 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-07-07 19:50:56 +02:00
crueter	66b073ab8d	[cmake] CPMUtil rewrite of the day number 852 (#4130 ) Composite PR for several changes to CPMUtil, most notably: - https://git.crueter.xyz/CMake/CPMUtil/pulls/19 - https://git.crueter.xyz/CMake/CPMUtil/pulls/22 - https://git.crueter.xyz/CMake/CPMUtil/pulls/24 - https://git.crueter.xyz/CMake/CPMUtil/pulls/25 These contain a lot of changes that generally simplify control flow and improve ease-of-use. Read those descriptions and patchsets for more info. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4130 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-07-06 23:11:39 +02:00