Formatting

Signed-off-by: crueter <crueter@eden-emu.dev>
Fix common build
2026-08-14 12:56:09 +00:00 · 2026-07-10 00:57:36 -04:00 · 2026-07-09 23:44:58 -04:00 · 2026-07-09 19:37:50 -04:00
186 changed files with 23151 additions and 23504 deletions
@@ -1,13 +0,0 @@
-diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
-index d49f2ec..a9bdb80 100644
--- a/libs/cobalt/include/boost/cobalt/concepts.hpp
-+++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
-@@ -62,7 +62,7 @@ struct enable_awaitables
- template <typename T>
- concept with_get_executor = requires (T& t)
- {
-  {t.get_executor()} -> asio::execution::executor;
-+  t.get_executor();
- };
- 
- 
@@ -112,6 +112,11 @@ Files: src/yuzu/*.ui
 Copyright: 2018-2022 yuzu Emulator Project
 License: GPL-2.0-or-later

+Files: src/yuzu/compatdb.ui
+       src/yuzu/main.ui
+Copyright: 2014-2017 Citra Emulator Project
+License: GPL-2.0-or-later
+
 Files: src/yuzu/loading_screen.ui
 Copyright: 2019 James Rowe <jroweboy@gmail.com>
 License: GPL-2.0-or-later
@@ -281,6 +281,25 @@ if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE
    endif()
 endif()

+set(compat_base dist/compatibility_list/compatibility_list)
+set(compat_qrc ${compat_base}.qrc)
+set(compat_json ${compat_base}.json)
+
+configure_file(${PROJECT_SOURCE_DIR}/${compat_qrc}
+    ${PROJECT_BINARY_DIR}/${compat_qrc}
+    COPYONLY)
+
+if (EXISTS ${PROJECT_SOURCE_DIR}/${compat_json})
+    configure_file("${PROJECT_SOURCE_DIR}/${compat_json}"
+        "${PROJECT_BINARY_DIR}/${compat_json}"
+        COPYONLY)
+endif()
+
+# TODO: Compat list download
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/${compat_json})
+    file(WRITE ${PROJECT_BINARY_DIR}/${compat_json} "")
+endif()
+
 if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
    set(HAS_NCE 1)
    add_compile_definitions(HAS_NCE=1)
@@ -398,12 +417,9 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})

 if (Boost_ADDED)
-    if (MSVC OR ANDROID)
-        add_compile_definitions(YUZU_BOOST_v1)
-    endif()
-
+    add_compile_definitions(YUZU_BOOST_v1)
    if (NOT MSVC OR CXX_CLANG)
-        # boost sucks
+        # solaris sucks
        if (PLATFORM_SUN)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
        endif()
@@ -412,8 +428,7 @@ if (Boost_ADDED)
        target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
        target_compile_options(boost_asio INTERFACE
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
-        )
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
    endif()
 endif()

@@ -6,22 +6,19 @@
        "version": "v0.19.0"
    },
    "boost": {
-        "artifact": "%VERSION%-cmake.tar.xz",
+        "artifact": "boost-%VERSION%.tar.zst",
        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
+        "hash": "077ad58b3d336041c05ad5f2b1de7db9fe1d35af3da85cd99496c35ddeca080ecd0ae5c8058319077bda892361b38624d89f70bc9bfec6713aae2aabc17f2a43",
        "min_version": "1.57",
        "package": "Boost",
-        "patches": [
-            "0001-clang-cl.patch"
-        ],
-        "repo": "boostorg/boost",
-        "version": "boost-1.90.0"
+        "repo": "eden-emulator/ext-boost",
+        "version": "1.91.0-1"
    },
    "boost_headers": {
        "bundled": true,
-        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
+        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
        "repo": "boostorg/headers",
-        "version": "boost-1.90.0"
+        "version": "boost-1.91.0"
    },
    "catch2": {
        "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",
@@ -0,0 +1,354 @@
+[
+  {
+    "compatibility": 0,
+    "directory": "the-legend-of-zelda-breath-of-the-wild",
+    "releases": [
+      {"id": "01007EF00011E000"}
+    ],
+    "title": "The Legend of Zelda: Breath of the Wild"
+  },
+  {
+    "compatibility": 1,
+    "directory": "super-mario-odyssey",
+    "releases": [
+      {"id": "0100000000010000"}
+    ],
+    "title": "Super Mario Odyssey"
+  },
+  {
+    "compatibility": 0,
+    "directory": "animal-crossing-new-horizons",
+    "releases": [
+      {"id": "01006F8002326000"}
+    ],
+    "title": "Animal Crossing: New Horizons"
+  },
+  {
+    "compatibility": 1,
+    "directory": "pokemon-legends-z-a",
+    "releases": [
+      {"id": "0100F43008C44000"}
+    ],
+    "title": "Pokémon Legends: Z-A"
+  },
+  {
+    "compatibility": 1,
+    "directory": "the-legend-of-zelda-tears-of-the-kingdom",
+    "releases": [
+      {"id": "0100F2C0115B6000"}
+    ],
+    "title": "The Legend of Zelda: Tears of the Kingdom"
+  },
+  {
+    "compatibility": 0,
+    "directory": "super-mario-galaxy",
+    "releases": [
+      {"id": "010099C022B96000"}
+    ],
+    "title": "Super Mario Galaxy"
+  },
+  {
+    "compatibility": 3,
+    "directory": "star-wars-republic-commando",
+    "releases": [
+      {"id": "0100FA10115F8000"}
+    ],
+    "title": "Star Wars: Republic Commando"
+  },
+  {
+    "compatibility": 0,
+    "directory": "doki-doki-literature-club-plus",
+    "releases": [
+      {"id": "010086901543E000"}
+    ],
+    "title": "Doki Doki Literature Club Plus"
+  },
+  {
+    "compatibility": 1,
+    "directory": "pokemon-scarlet",
+    "releases": [
+      {"id": "0100A3D008C5C000"}
+    ],
+    "title": "Pokémon Scarlet"
+  },
+    {
+    "compatibility": 1,
+    "directory": "pokemon-violet",
+    "releases": [
+      {"id": "01008F6008C5E000"}
+    ],
+    "title": "Pokémon Violet"
+  },
+  {
+    "compatibility": 2,
+    "directory": "pokemon-legends-arceus",
+    "releases": [
+      {"id": "01001E300D162000"}
+    ],
+    "title": "Pokémon Legends: Arceus"
+  },
+  {
+    "compatibility": 0,
+    "directory": "splatoon-2",
+    "releases": [
+      {"id": "01003BC0000A0000"}
+    ],
+    "title": "Splatoon 2"
+  },
+  {
+    "compatibility": 1,
+    "directory": "super-smash-bros-ultimate",
+    "releases": [
+      {"id": "01006A800016E000"}
+    ],
+    "title": "Super Smash Bros. Ultimate"
+  },
+  {
+    "compatibility": 0,
+    "directory": "mario-kart-8-deluxe",
+    "releases": [
+      {"id": "0100152000022000"}
+    ],
+    "title": "Mario Kart 8 Deluxe"
+  },
+  {
+    "compatibility": 0,
+    "directory": "splatoon-3",
+    "releases": [
+      {"id": "0100C2500FC20000"}
+    ],
+    "title": "Splatoon 3"
+  },
+  {
+    "compatibility": 0,
+    "directory": "new-super-mario-bros-u-deluxe",
+    "releases": [
+      {"id": "0100EA80032EA000"}
+    ],
+    "title": "New Super Mario Bros. U Deluxe"
+  },
+  {
+    "compatibility": 0,
+    "directory": "hyrule-warriors-age-of-calamity",
+    "releases": [
+      {"id": "01002B00111A2000"}
+    ],
+    "title": "Hyrule Warriors: Age of Calamity"
+  },
+  {
+    "compatibility": 2,
+    "directory": "luigis-mansion-3",
+    "releases": [
+      {"id": "0100DCA0064A6000"}
+    ],
+    "title": "Luigi's Mansion 3"
+  },
+  {
+    "compatibility": 2,
+    "directory": "pokemon-brilliant-diamond",
+    "releases": [
+      {"id": "0100000011D90000"}
+    ],
+    "title": "Pokémon Brilliant Diamond"
+  },
+  {
+    "compatibility": 2,
+    "directory": "pokemon-shining-pearl",
+    "releases": [
+      {"id": "010018E011D92000"}
+    ],
+    "title": "Pokémon Shining Pearl"
+  },
+  {
+    "compatibility": 1,
+    "directory": "super-mario-3d-world-bowsers-fury",
+    "releases": [
+      {"id": "010028600EBDA000"}
+    ],
+    "title": "Super Mario 3D World + Bowser's Fury"
+  },
+  {
+    "compatibility": 0,
+    "directory": "the-legend-of-zelda-links-awakening",
+    "releases": [
+      {"id": "01006BB00C6F0000"}
+    ],
+    "title": "The Legend of Zelda: Link's Awakening"
+  },
+  {
+    "compatibility": 1,
+    "directory": "fire-emblem-three-houses",
+    "releases": [
+      {"id": "010055D009F78000"}
+    ],
+    "title": "Fire Emblem: Three Houses"
+  },
+  {
+    "compatibility": 2,
+    "directory": "metroid-dread",
+    "releases": [
+      {"id": "010093801237C000"}
+    ],
+    "title": "Metroid Dread"
+  },
+  {
+    "compatibility": 0,
+    "directory": "paper-mario-the-origami-king",
+    "releases": [
+      {"id": "0100A3900C3E2000"}
+    ],
+    "title": "Paper Mario: The Origami King"
+  },
+  {
+    "compatibility": 1,
+    "directory": "xenoblade-chronicles-definitive-edition",
+    "releases": [
+      {"id": "0100FF500E34A000"}
+    ],
+    "title": "Xenoblade Chronicles: Definitive Edition"
+  },
+  {
+    "compatibility": 2,
+    "directory": "xenoblade-chronicles-3",
+    "releases": [
+      {"id": "010074F013262000"}
+    ],
+    "title": "Xenoblade Chronicles 3"
+  },
+  {
+    "compatibility": 1,
+    "directory": "pikmin-3-deluxe",
+    "releases": [
+      {"id": "0100F8600D4B0000"}
+    ],
+    "title": "Pikmin 3 Deluxe"
+  },
+  {
+    "compatibility": 0,
+    "directory": "donkey-kong-country-tropical-freeze",
+    "releases": [
+      {"id": "0100C1F0054B6000"}
+    ],
+    "title": "Donkey Kong Country: Tropical Freeze"
+  },
+  {
+    "compatibility": 1,
+    "directory": "kirby-and-the-forgotten-land",
+    "releases": [
+      {"id": "01004D300C5AE000"}
+    ],
+    "title": "Kirby and the Forgotten Land"
+  },
+  {
+    "compatibility": 2,
+    "directory": "mario-party-superstars",
+    "releases": [
+      {"id": "01006B400D8B2000"}
+    ],
+    "title": "Mario Party Superstars"
+  },
+  {
+    "compatibility": 0,
+    "directory": "clubhouse-games-51-worldwide-classics",
+    "releases": [
+      {"id": "0100F8600D4B0000"}
+    ],
+    "title": "Clubhouse Games: 51 Worldwide Classics"
+  },
+  {
+    "compatibility": 1,
+    "directory": "ring-fit-adventure",
+    "releases": [
+      {"id": "01006B300BAF8000"}
+    ],
+    "title": "Ring Fit Adventure"
+  },
+  {
+    "compatibility": 2,
+    "directory": "arms",
+    "releases": [
+      {"id": "01009B500007C000"}
+    ],
+    "title": "ARMS"
+  },
+  {
+    "compatibility": 0,
+    "directory": "super-mario-maker-2",
+    "releases": [
+      {"id": "01009B90006DC000"}
+    ],
+    "title": "Super Mario Maker 2"
+  },
+  {
+    "compatibility": 0,
+    "directory": "pokemon-lets-go-pikachu",
+    "releases": [
+      {"id": "010003F003A34000"}
+    ],
+    "title": "Pokémon: Let's Go, Pikachu!"
+  },
+  {
+    "compatibility": 1,
+    "directory": "pokemon-lets-go-eevee",
+    "releases": [
+      {"id": "0100187003A36000"}
+    ],
+    "title": "Pokémon: Let's Go, Eevee!"
+  },
+  {
+    "compatibility": 2,
+    "directory": "pokemon-sword",
+    "releases": [
+      {"id": "0100ABF008968000"}
+    ],
+    "title": "Pokémon Sword"
+  },
+  {
+    "compatibility": 2,
+    "directory": "pokemon-shield",
+    "releases": [
+      {"id": "01008DB008C2C000"}
+    ],
+    "title": "Pokémon Shield"
+  },
+  {
+    "compatibility": 1,
+    "directory": "new-pokemon-snap",
+    "releases": [
+      {"id": "0100F4300C182000"}
+    ],
+    "title": "New Pokémon Snap"
+  },
+  {
+    "compatibility": 0,
+    "directory": "mario-golf-super-rush",
+    "releases": [
+      {"id": "0100C9C00E25C000"}
+    ],
+    "title": "Mario Golf: Super Rush"
+  },
+  {
+    "compatibility": 1,
+    "directory": "mario-tennis-aces",
+    "releases": [
+      {"id": "0100BDE00862A000"}
+    ],
+    "title": "Mario Tennis Aces"
+  },
+  {
+    "compatibility": 2,
+    "directory": "wario-ware-get-it-together",
+    "releases": [
+      {"id": "0100563010F22000"}
+    ],
+    "title": "WarioWare: Get It Together!"
+  },
+  {
+    "compatibility": 0,
+    "directory": "big-brain-academy-brain-vs-brain",
+    "releases": [
+      {"id": "0100190010F24000"}
+    ],
+    "title": "Big Brain Academy: Brain vs. Brain"
+  }
+]
@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="compatibility_list">
+      <file>compatibility_list.json</file>
+  </qresource>
+</RCC>
@@ -65,7 +65,7 @@ android {

    defaultConfig {
        applicationId = "dev.eden.eden_emulator"
-        minSdk = 33
+        minSdk = 24
        targetSdk = 36
        versionName = getGitVersion()
        versionCode = autoVersion
@@ -16,6 +16,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_USE_SPEED_LIMIT("use_speed_limit"),
    USE_CUSTOM_CPU_TICKS("use_custom_cpu_ticks"),
    SKIP_CPU_INNER_INVALIDATION("skip_cpu_inner_invalidation"),
+    ANTIFLICKER("antiflicker"),
    FIX_BLOOM_EFFECTS("fix_bloom_effects"),
    EMULATE_BGR565("emulate_bgr565"),
    RESCALE_HACK("rescale_hack"),
@@ -27,7 +28,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
    RENDERER_ASYNC_PRESENTATION("async_presentation"),
    RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
-    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
@@ -37,8 +37,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_DEBUG("debug"),
    RENDERER_PATCH_OLD_QCOM_DRIVERS("patch_old_qcom_drivers"),
    RENDERER_VERTEX_INPUT_DYNAMIC_STATE("vertex_input_dynamic_state"),
-    RENDERER_DYNAMIC_RENDERING("dynamic_rendering"),
-    RENDERER_WORKGROUP_MEMORY_EXPLICIT_LAYOUT("workgroup_memory_explicit_layout"),
    RENDERER_SAMPLE_SHADING("sample_shading"),
    GPU_UNSWIZZLE_ENABLED("gpu_unswizzle_enabled"),
    PICTURE_IN_PICTURE("picture_in_picture"),
@@ -27,7 +27,6 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {

    RENDERER_DYNA_STATE("dyna_state"),
    DMA_ACCURACY("dma_accuracy"),
-    GPU_FENCE_BEHAVIOR("gpu_fence_behavior"),
    FRAME_PACING_MODE("frame_pacing_mode"),
    AUDIO_OUTPUT_ENGINE("output_engine"),
    MAX_ANISOTROPY("max_anisotropy"),
@@ -155,20 +155,6 @@ abstract class SettingsItem(
                    descriptionId = R.string.vertex_input_dynamic_state_description
                )
            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_DYNAMIC_RENDERING,
-                    titleId = R.string.dynamic_rendering,
-                    descriptionId = R.string.dynamic_rendering_description
-                )
-            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_WORKGROUP_MEMORY_EXPLICIT_LAYOUT,
-                    titleId = R.string.workgroup_memory_explicit_layout,
-                    descriptionId = R.string.workgroup_memory_explicit_layout_description
-                )
-            )
            put(
                SliderSetting(
                    IntSetting.RENDERER_SAMPLE_SHADING,
@@ -608,7 +594,7 @@ abstract class SettingsItem(
                    IntSetting.ANDROID_PIPELINE_WORKERS,
                    titleId = R.string.pipeline_worker_cores,
                    descriptionId = R.string.pipeline_worker_cores_description,
-                    min = 2,
+                    min = 4,
                    max = 8,
                    units = "cores"
                )
@@ -683,15 +669,6 @@ abstract class SettingsItem(
                    valuesId = R.array.dmaAccuracyValues
                )
            )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.GPU_FENCE_BEHAVIOR,
-                    titleId = R.string.gpu_fence_behavior,
-                    descriptionId = R.string.gpu_fence_behavior_description,
-                    choicesId = R.array.gpuFenceBehaviorNames,
-                    valuesId = R.array.gpuFenceBehaviorValues
-                )
-            )
            put(
                SwitchSetting(
                    BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS,
@@ -699,13 +676,6 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_asynchronous_shaders_description
                )
            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
-                    titleId = R.string.renderer_unified_memory,
-                    descriptionId = R.string.renderer_unified_memory_description
-                )
-            )
            put(
                SingleChoiceSetting(
                    IntSetting.FAST_GPU_TIME,
@@ -787,6 +757,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.skip_cpu_inner_invalidation_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.ANTIFLICKER,
+                    titleId = R.string.antiflicker,
+                    descriptionId = R.string.antiflicker_description
+                )
+            )
            put(
                SwitchSetting(
                    BooleanSetting.FIX_BLOOM_EFFECTS,
@@ -283,7 +283,6 @@ class SettingsFragmentPresenter(

            add(IntSetting.RENDERER_ACCURACY.key)
            add(IntSetting.DMA_ACCURACY.key)
-            add(IntSetting.GPU_FENCE_BEHAVIOR.key)
            add(IntSetting.MAX_ANISOTROPY.key)
            add(IntSetting.RENDERER_VRAM_USAGE_MODE.key)
            add(IntSetting.RENDERER_ASTC_DECODE_METHOD.key)
@@ -300,11 +299,11 @@ class SettingsFragmentPresenter(

            add(IntSetting.FAST_GPU_TIME.key)
            add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
+            add(BooleanSetting.ANTIFLICKER.key)
            add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
            add(BooleanSetting.EMULATE_BGR565.key)
            add(BooleanSetting.RESCALE_HACK.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
-            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
            add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
            add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)
@@ -314,8 +313,6 @@ class SettingsFragmentPresenter(

            add(IntSetting.RENDERER_DYNA_STATE.key)
            add(BooleanSetting.RENDERER_VERTEX_INPUT_DYNAMIC_STATE.key)
-            add(BooleanSetting.RENDERER_DYNAMIC_RENDERING.key)
-            add(BooleanSetting.RENDERER_WORKGROUP_MEMORY_EXPLICIT_LAYOUT.key)
            add(IntSetting.RENDERER_SAMPLE_SHADING.key)

            add(HeaderSetting(R.string.display))
@@ -147,6 +147,13 @@ namespace AndroidSettings {
                                                      &show_performance_overlay};


+        Settings::Setting<s32> pipeline_worker_count{linkage, 4, "pipeline_worker_count",
+                                 Settings::Category::Android,
+                                 Settings::Specialization::Default,
+                                 true,
+                                 true};
+
+
        Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay",
                                                   Settings::Category::Overlay};
        Settings::Setting<bool> overlay_snap_to_grid{linkage, false, "overlay_snap_to_grid",
@@ -476,8 +476,6 @@
    <string name="renderer_accuracy_description">يتحكم في وضع محاكاة وحدة معالجة الرسومات. تعمل معظم الألعاب بشكل جيد مع وضعي سريع أو متوازن، لكن الوضع الدقيق لا يزال مطلوبًا لبعض الألعاب. تميل الجسيمات إلى العرض بشكل صحيح فقط عند استخدام الوضع الدقيق.</string>
    <string name="dma_accuracy">دقة DMA</string>
    <string name="dma_accuracy_description">يتحكم في دقة DMA. يمكن أن تؤدي الدقة الآمنة إلى حل المشكلات في بعض الألعاب، ولكنها قد تؤثر أيضًا على الأداء في بعض الحالات. إذا لم تكن متأكدًا، فاترك هذا الخيار على الإعداد الافتراضي.</string>
-    <string name="gpu_fence_behavior">سلوك حاجز وحدة معالجة الرسومات</string>
-    <string name="gpu_fence_behavior_description">يتحكم في سلوك تزامن حاجز وحدة معالجة الرسوميات. الخيار الفوري هو الأسرع، لكنه قد يسبب بعض المشاكل. الخيار المتوازن يقدم توافقًا أفضل وقد يصلح مشاكل في بعض الألعاب. الخيار الدقيق يحسن التوافق أكثر لكنه قد يقلل الأداء قليلاً. الخيار الصارم هو الأبطأ، لكنه قد يصلح المشاكل التي تتطلب تزامنًا أكثر صرامة. الإعداد الافتراضي يتبع إعداد دقة وحدة معالجة الرسوميات.</string>
    <string name="anisotropic_filtering">تصفية متباينة الخواص</string>
    <string name="anisotropic_filtering_description">يحسن جودة الأنسجة عند عرضها بزوايا مائلة</string>
    <string name="vram_usage_mode">وضع استخدام ذاكرة VRAM</string>
@@ -499,8 +497,6 @@
    <string name="renderer_reactive_flushing_description">يحسن دقة العرض في بعض الألعاب على حساب الأداء.</string>
    <string name="enable_buffer_history">تمكين سجل التخزين المؤقت</string>
    <string name="enable_buffer_history_description">يُتيح هذا الخيار الوصول إلى حالات التخزين المؤقت السابقة. وقد يُحسّن جودة العرض وثبات الأداء في بعض الألعاب.</string>
-    <string name="enable_gpu_buffer_readback">تفعيل قراءة مخزن وحدة معالجة الرسومات</string>
-    <string name="enable_gpu_buffer_readback_description">يحافظ هذا النظام على بيانات المخزن المؤقت المُعدّلة بواسطة وحدة معالجة الرسومات عن طريق قراءتها مرة أخرى قبل التحميل. تتطلب بعض الألعاب ذلك لعرض بعض التأثيرات بشكل صحيح. قد يُسبب ذلك مشاكل إذا لم يتمكن الجهاز من التعامل مع عبء العمل الإضافي.</string>
    <string name="use_optimized_vertex_buffers">مخازن الرؤوس المُحسّنة</string>
    <string name="use_optimized_vertex_buffers_description">يُتيح ربطًا مُحسَّنًا لمخازن الرؤوس لتحسين الأداء. يتطلب برامج تشغيل Mesa 26.0+ Turnip/ برامج تشغيل QCOM. قد يتعطل على برامج تشغيل Turnip القديمة (25.3 وما دون).</string>

@@ -510,6 +506,8 @@
    <string name="fast_gpu_time_description">يُجبر هذا الخيار معظم الألعاب على العمل بأعلى دقة عرض أصلية. استخدم 256 للحصول على أقصى أداء و512 للحصول على أعلى جودة رسومات.</string>
    <string name="skip_cpu_inner_invalidation">تخطي إبطال صلاحية وحدة المعالجة المركزية الداخلية</string>
    <string name="skip_cpu_inner_invalidation_description">يتخطى بعض عمليات إبطال ذاكرة التخزين المؤقتة من جانب وحدة المعالجة المركزية أثناء تحديثات الذاكرة، مما يقلل من استخدام وحدة المعالجة المركزية ويحسن أداءها. قد يتسبب ذلك في حدوث أعطال أو تعطل في بعض الألعاب.</string>
+    <string name="antiflicker">مضاد الوميض</string>
+    <string name="antiflicker_description">يُجبر هذا الوضع وظائف وحدة معالجة الرسومات على الانتظار حتى يتم إرسال العمل إليها. استخدمه مع وضع وحدة معالجة الرسومات السريع لتجنب الوميض مع تأثير أقل على الأداء.</string>
    <string name="fix_bloom_effects">إصلاح تأثيرات التوهج</string>
    <string name="fix_bloom_effects_description">يقلل من ضبابية التوهج في LA/EOW  (Adreno A6XX - A7XX/ Turnip)، ويزيل التوهج في Burnout. تحذير: قد يسبب تشوهات رسومية في ألعاب أخرى.</string>
    <string name="emulate_bgr565">محاكاة BGR565</string>
@@ -575,12 +573,6 @@
    <string name="gpu_log_level_description">مستوى التفاصيل لسجلات وحدة معالجة الرسومات (كلما زاد المستوى، زادت التفاصيل وزادت التكاليف الإضافية)</string>
    <string name="gpu_log_vulkan_calls">تسجيل استدعاءات واجهة برمجة تطبيقات Vulkan</string>
    <string name="gpu_log_vulkan_calls_description">تتبع جميع استدعاءات واجهة برمجة تطبيقات Vulkan في المخزن المؤقت الحلقي</string>
-    <string name="gpu_log_shader_dumps">تفريغ مظللات SPIR-V</string>
-    <string name="gpu_log_shader_dumps_description">احفظ ملفات SPIR-V الثنائية المُعاد تجميعها (.spv) في مجلد التفريغ. افحصها باستخدام spirv-dis/spirv-cross/spirv-val.</string>
-    <string name="dump_guest_shaders">تظليلات ضيف التفريغ (ماكسويل)</string>
-    <string name="dump_guest_shaders_description">احفظ ملفات بايت كود برنامج التظليل الضيف الخاص بـ «ماكسويل» (*.ash) في مجلد «dump». افحصها باستخدام nvdisasm.</string>
-    <string name="dump_macros">تفريغ ماكرو ماكسويل</string>
-    <string name="dump_macros_description">احفظ ملفات برامج ماكرو ماكسويل (*.macro) في مجلد «dump». افحصها باستخدام برنامج «envydis».</string>
    <string name="gpu_log_memory_tracking">تتبع ذاكرة وحدة معالجة الرسومات</string>
    <string name="gpu_log_memory_tracking_description">مراقبة تخصيصات ذاكرة وحدة معالجة الرسومات وإلغاء تخصيصها</string>
    <string name="gpu_log_driver_debug">معلومات تصحيح أخطاء برنامج التشغيل</string>
@@ -1008,13 +1000,6 @@
    <string name="dma_accuracy_unsafe">غير آمن</string>
    <string name="dma_accuracy_safe">آمن</string>

-    <!-- GPU Fence Behavior -->
-    <string name="gpu_fence_behavior_default">افتراضي</string>
-    <string name="gpu_fence_behavior_immediate">فوري</string>
-    <string name="gpu_fence_behavior_balanced">متوازن</string>
-    <string name="gpu_fence_behavior_accurate">دقيق</string>
-    <string name="gpu_fence_behavior_strict">صارم</string>
-
    <string name="vram_usage_conservative">محافظ</string>
    <string name="vram_usage_aggressive">عدواني</string>

@@ -470,7 +470,6 @@
    <string name="renderer_accuracy_description">Controla el modo de la emulación de la GPU. La mayoría de los juegos se renderizan correctamente en los modos Rápido o Equilibrado, pero algunos requieren Preciso. Las partículas tienden a renderizarse correctamente solo con el modo Preciso.</string>
    <string name="dma_accuracy">Precisión de DMA</string>
    <string name="dma_accuracy_description">Controla la precisión de DMA. La precisión segura puede solucionar problemas en algunos juegos, pero también puede afectar al rendimiento en algunos casos. Si no está seguro, déjelo en Predeterminado.</string>
-    <string name="gpu_fence_behavior">Comportamiento de vallado de la GPU</string>
    <string name="anisotropic_filtering">Filtrado anisotrópico</string>
    <string name="anisotropic_filtering_description">Mejora la calidad de las texturas al ser observadas desde ángulos oblicuos</string>
    <string name="vram_usage_mode">Modo de uso de VRAM</string>
@@ -503,6 +502,8 @@
    <string name="fast_gpu_time_description">Fuerza a la mayoría de los juegos a ejecutarse a su resolución nativa más alta. Usa 256 para un máximo rendimiento y 512 para una fidelidad gráfica óptima.</string>
    <string name="skip_cpu_inner_invalidation">Omitir invalidación interna de la CPU</string>
    <string name="skip_cpu_inner_invalidation_description">Omite ciertas invalidaciones de caché de la CPU durante las actualizaciones de memoria, lo que reduce el uso de la CPU y mejora su rendimiento. Esto puede causar fallos o bloqueos en algunos juegos.</string>
+    <string name="antiflicker">Antiparpadeo</string>
+    <string name="antiflicker_description">Fuerza a las funciones de devolución de llamada de la GPU a esperar a que se envíen las tareas a la GPU.\nÚsalo con el modo de GPU rápida para evitar el parpadeo con un menor impacto en el rendimiento.</string>
    <string name="fix_bloom_effects">Arreglar los efectos de resplandor</string>
    <string name="fix_bloom_effects_description">Reduce el efecto de resplandor en LA/EOW (Adreno A6XX - A7XX/ Turnip), elimina el resplandor en Burnout. Advertencia: puede causar artefactos gráficos en otros juegos.</string>
    <string name="emulate_bgr565">Emular BGR565</string>
@@ -1001,13 +1002,6 @@
    <string name="dma_accuracy_unsafe">Inseguro</string>
    <string name="dma_accuracy_safe">Seguro</string>

-    <!-- GPU Fence Behavior -->
-    <string name="gpu_fence_behavior_default">Predeterminado</string>
-    <string name="gpu_fence_behavior_immediate">Inmediato</string>
-    <string name="gpu_fence_behavior_balanced">Equilibrado</string>
-    <string name="gpu_fence_behavior_accurate">Preciso</string>
-    <string name="gpu_fence_behavior_strict">Estricto</string>
-
    <string name="vram_usage_conservative">Conservador</string>
    <string name="vram_usage_aggressive">Agresivo</string>

@@ -499,6 +499,8 @@
    <string name="fast_gpu_time_description">Принудительно запускает большинство игр в их максимальном нативном разрешении. Используйте значение 256 для максимальной производительности и 512 для максимального качества графики.</string>
    <string name="skip_cpu_inner_invalidation">Пропустить внутреннюю инвалидацию ЦП</string>
    <string name="skip_cpu_inner_invalidation_description">Пропускает некоторые инвалидации кэша на стороне ЦП при обновлениях памяти, уменьшая нагрузку на процессор и повышая производительность. Может вызывать сбои в некоторых играх.</string>
+    <string name="antiflicker">Анти-мерцание</string>
+    <string name="antiflicker_description">Принудительно заставляет обратные вызовы ГПУ-фильтра ожидать выполнения отправленных задач на ГПУ. Используйте с Быстрым режимом ГПУ, что бы избежать мерцаний с меньшим влиянием на производительность.</string>
    <string name="fix_bloom_effects">Исправить эффекты размытия</string>
    <string name="fix_bloom_effects_description">Частично убирает размытие в LA/EOW (Adreno A6XX - A7XX/ Turnip), полностью отключает его в Burnout. Внимание: может вызывать графические артефакты в других играх.</string>
    <string name="emulate_bgr565">Эмулировать BGR565</string>
@@ -502,6 +502,8 @@
    <string name="fast_gpu_time_description">Примушує більшість ігор працювати на їхній максимальній нативній роздільності. Використовуйте 256 для максимальної продуктивності та 512 для найкращої якості.</string>
    <string name="skip_cpu_inner_invalidation">Пропустити внутрішнє інвалідування CPU</string>
    <string name="skip_cpu_inner_invalidation_description">Пропускає деякі інвалідації кешу на стороні CPU під час оновлення пам\'яті, зменшуючи навантаження на процесор і покращуючи продуктивність. Може спричинити збої в деяких іграх.</string>
+    <string name="antiflicker">Антимерехтіння</string>
+    <string name="antiflicker_description">Змушує механізм синхронізації чекати, доки ГП завершить подані завдання. Використовуйте з режимом ГП «Швидко», щоб уникнути мерехтіння з меншими втратами продуктивності.</string>
    <string name="fix_bloom_effects">Виправити ефекти світіння</string>
    <string name="fix_bloom_effects_description">Зменшує розмиття світіння в LA/EOW (Adreno A6XX–A7XX / Turnip), прибирає світіння в Burnout. Увага: може спричинити графічні артефакти в інших іграх.</string>
    <string name="emulate_bgr565">Емулювати BGR565</string>
@@ -67,7 +67,7 @@
    <string name="show_shaders_building">显示着色器编译信息</string>
    <string name="show_shaders_building_description">显示当前正在编译的着色器数量</string>
    <string name="pipeline_worker_cores">管线工作线程</string>
-    <string name="pipeline_worker_cores_description">管理用于构建 Vulkan 管线的核心数量，较高的值可提升管线编译性能，但温度也会随之升高。</string>
+    <string name="pipeline_worker_cores_description">管理用于构建 Vulkan 管线的核心数量，数值越高则管线编译性能越好，但温度也会随之升高。</string>
    <string name="overlay_position">叠加层位置</string>
    <string name="overlay_position_description">选择叠加层在屏幕上显示的位置</string>
    <string name="overlay_position_top_left">左上</string>
@@ -185,7 +185,7 @@
    <string name="multiplayer_preferred_game_name">首选游戏</string>
    <string name="multiplayer_lobby_type">游戏大厅类型</string>
    <string name="multiplayer_room_name_error">长度需为3-20个字符</string>
-    <string name="multiplayer_required">需要</string>
+    <string name="multiplayer_required">必填</string>
    <string name="multiplayer_token_required">需要Web令牌，请前往高级设置 -> 系统 -> 网络</string>
    <string name="multiplayer_ip_error">IP格式无效</string>
    <string name="multiplayer_username_error">必须为4至20个字符，且仅包含字母、数字、点号、连字符、下划线和空格</string>
@@ -287,7 +287,7 @@
    <string name="warning_skip">跳过</string>
    <string name="warning_cancel">取消</string>
    <string name="install_amiibo_keys">安装 Amiibo 密钥文件</string>
-    <string name="install_amiibo_keys_description">在遊戏中使用 Amiibo 时需要</string>
+    <string name="install_amiibo_keys_description">在遊戏中使用 Amiibo 时必需</string>
    <string name="gpu_driver_fetcher">GPU驱动获取器</string>
    <string name="gpu_driver_manager">GPU 驱动管理器</string>
    <string name="install_gpu_driver_description">安装替代的驱动程序以获得更好的性能和精度</string>
@@ -463,13 +463,11 @@
    <string name="advanced">高级</string>

    <string name="renderer_accuracy">GPU 模式</string>
-    <string name="renderer_accuracy_description">控制 GPU 模拟模式。大多数游戏在“快速”或“均衡”模式下都能获得良好的渲染，但有些游戏仍需使用“精确”模式。粒子效果通常只有在“精确”模式下才能正确渲染。</string>
+    <string name="renderer_accuracy_description">控制 GPU 模拟模式。大多数游戏在“快速”或“平衡”模式下都能正常渲染，但有些游戏仍需使用“精确”模式。粒子效果通常只有在“精确”模式下才能正确渲染。</string>
    <string name="dma_accuracy">DMA 精度</string>
    <string name="dma_accuracy_description">控制 DMA 的精准度。安全精度可以修复存在于某些游戏中的问题，但在某些情况下也会对性能造成影响。如不确定，请保持“默认”。</string>
-    <string name="gpu_fence_behavior">GPU 围栏行为</string>
-    <string name="gpu_fence_behavior_description">控制 GPU 围栏同步行为。“即时”是速度最快的选项，但可能会引入一些问题。“均衡”提供了更好的兼容性，可能修复某些游戏中的问题。“精确”在牺牲部分性能的前提下进一步提升兼容性。“严格”是速度最慢的选项，但可以修复那些要求更严格同步的问题。默认遵循 GPU “精确”设定。</string>
    <string name="anisotropic_filtering">各向异性过滤</string>
-    <string name="anisotropic_filtering_description">提升斜视角下的纹理质量</string>
+    <string name="anisotropic_filtering_description">提高斜角的纹理质量</string>
    <string name="vram_usage_mode">显存使用模式</string>
    <string name="vram_usage_mode_description">控制显存分配与释放策略</string>
    <string name="accelerate_astc">ASTC解码方式</string>
@@ -490,7 +488,7 @@
    <string name="enable_buffer_history">启用缓冲区历史</string>
    <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
    <string name="enable_gpu_buffer_readback">启用 GPU 缓冲区回读</string>
-    <string name="enable_gpu_buffer_readback_description">在上传前回读经由 GPU 修改过的缓冲区数据，以将其保留。一些游戏会用到这项设定以正确渲染某些效果。如果硬件无法处理额外的工作负载，则可能会导致问题。</string>
+    <string name="enable_gpu_buffer_readback_description">在上传前回读经由 GPU 修改过的缓冲区数据，以将其保留。一些游戏需要这样做才能正确渲染某些效果。如果硬件无法处理额外的工作负载，则可能会导致问题。</string>
    <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
    <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 或 QCOM 驱动程序。若使用较旧版本的 Turnip 驱动 (25.3 及以下版本) 则会导致崩溃。</string>

@@ -500,6 +498,8 @@
    <string name="fast_gpu_time_description">强制大多数游戏以其最高原生分辨率运行。设置为 256 可获得最佳性能，设置为 512 可获得最佳画面保真度。</string>
    <string name="skip_cpu_inner_invalidation">跳过CPU内部无效化</string>
    <string name="skip_cpu_inner_invalidation_description">在更新内存时跳过某些 CPU 端的缓存失效操作，从而降低 CPU 占用率并提升性能。可能会在某些游戏中引发故障点或崩溃。</string>
+    <string name="antiflicker">防闪烁</string>
+    <string name="antiflicker_description">强制 GPU 围栏回调等待已提交的 GPU 任务。配合“快速 GPU 模式”一起使用，以牺牲少量性能为代价来避免画面闪烁现象。</string>
    <string name="fix_bloom_effects">修复 Bloom 效果</string>
    <string name="fix_bloom_effects_description">减少《智慧的再现》和《众神的三角力量2》（Adreno A6XX - A7XX/ Turnip）中的 bloom 模糊，并移除《Burnout》中的 bloom 效果。警告：可能会导致在其他游戏中出现图形异常。</string>
    <string name="emulate_bgr565">模拟 BGR565</string>
@@ -513,7 +513,7 @@
    <string name="gpu_unswizzle_enable">启用 GPU Unswizzle</string>
    <string name="gpu_unswizzle_disabled">禁用</string>
    <string name="gpu_unswizzle_texture_size">GPU Unswizzle 最大纹理尺寸</string>
-    <string name="gpu_unswizzle_texture_size_description">设置基于 GPU 的纹理 unswizzling 的最大尺寸（MB）。虽然 GPU 处理中等和大型纹理的速度更快，但对于非常小的纹理，CPU 可能更为高效。通过调节此项设置，以平衡GPU 加速与 CPU 开销。</string>
+    <string name="gpu_unswizzle_texture_size_description">设置基于 GPU 的纹理 unswizzling 的最大尺寸（MB）。虽然 GPU 处理中等和大型纹理的速度更快，但对于非常小的纹理，CPU 可能更为高效。通过调节此项设置，以尝试在 GPU 加速与 CPU 开销之间找到平衡。</string>
    <string name="gpu_unswizzle_stream_size">GPU Unswizzle 流大小</string>
    <string name="gpu_unswizzle_stream_size_description">设置用于 unswizzling 大型纹理时的每帧数据限制。较高的数值可以加速纹理的加载过程，但会带来更高的帧延迟。而较低的数值则可以降低 GPU 的开销，但也可能会导致可见的纹理闪现。</string>
    <string name="gpu_unswizzle_chunk_size">GPU Unswizzle 块大小</string>
@@ -990,7 +990,7 @@

    <!-- Renderer Accuracy -->
    <string name="renderer_accuracy_low">快速</string>
-    <string name="renderer_accuracy_medium">均衡</string>
+    <string name="renderer_accuracy_medium">平衡</string>
    <string name="renderer_accuracy_high">精确</string>

    <!-- DMA Accuracy -->
@@ -998,13 +998,6 @@
    <string name="dma_accuracy_unsafe">不安全</string>
    <string name="dma_accuracy_safe">安全</string>

-    <!-- GPU Fence Behavior -->
-    <string name="gpu_fence_behavior_default">默认</string>
-    <string name="gpu_fence_behavior_immediate">即时</string>
-    <string name="gpu_fence_behavior_balanced">均衡</string>
-    <string name="gpu_fence_behavior_accurate">精确</string>
-    <string name="gpu_fence_behavior_strict">严格</string>
-
    <string name="vram_usage_conservative">保守式</string>
    <string name="vram_usage_aggressive">主动式</string>

@@ -1028,7 +1021,7 @@
    <string name="ratio_stretch">拉伸窗口</string>

    <!-- CPU Accuracy -->
-    <string name="cpu_accuracy_accurate">精确</string>
+    <string name="cpu_accuracy_accurate">精准</string>
    <string name="cpu_accuracy_unsafe">不安全</string>
    <string name="cpu_accuracy_paranoid">极致</string>
    <string name="cpu_accuracy_debugging">调试</string>
@@ -522,21 +522,6 @@
        <item>2</item>
    </integer-array>

-    <string-array name="gpuFenceBehaviorNames">
-        <item>@string/gpu_fence_behavior_default</item>
-        <item>@string/gpu_fence_behavior_immediate</item>
-        <item>@string/gpu_fence_behavior_balanced</item>
-        <item>@string/gpu_fence_behavior_accurate</item>
-        <item>@string/gpu_fence_behavior_strict</item>
-    </string-array>
-    <integer-array name="gpuFenceBehaviorValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
-        <item>3</item>
-        <item>4</item>
-    </integer-array>
-

    <string-array name="appletEntries">
        <item>@string/applet_hle</item>
@@ -482,8 +482,6 @@
    <string name="renderer_accuracy_description">Controls the GPU emulation mode. Most games render fine with Fast or Balanced modes, but Accurate is still required for some. Particles tend to only render correctly with Accurate mode.</string>
    <string name="dma_accuracy">DMA Accuracy</string>
    <string name="dma_accuracy_description">Controls the DMA precision accuracy. Safe precision can fix issues in some games, but it can also impact performance in some cases. If unsure, leave this on Default.</string>
-    <string name="gpu_fence_behavior">GPU Fence Behavior</string>
-    <string name="gpu_fence_behavior_description">Controls the GPU fence synchronization behavior. Immediate is the fastest option, but can introduce some issues. Balanced offers better compatibility and may fix issues in some games. Accurate further improves compatibility at the cost of some performance. Strict is the slowest option, but can fix issues that require stricter synchronization. Default follows the GPU Accuracy setting.</string>
    <string name="anisotropic_filtering">Anisotropic filtering</string>
    <string name="anisotropic_filtering_description">Improves the quality of textures when viewed at oblique angles</string>
    <string name="vram_usage_mode">VRAM Usage Mode</string>
@@ -516,6 +514,8 @@
    <string name="fast_gpu_time_description">Forces most games to run at their highest native resolution. Use 256 for maximal performance and 512 for maximal graphics fidelity.</string>
    <string name="skip_cpu_inner_invalidation">Skip CPU Inner Invalidation</string>
    <string name="skip_cpu_inner_invalidation_description">Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and improving it\'s performance. This may cause glitches or crashes on some games.</string>
+    <string name="antiflicker">Anti-Flicker</string>
+    <string name="antiflicker_description">Forces GPU fence callbacks to wait for submitted GPU work. Use with Fast GPU mode, to avoid flicker with lower performance impact.</string>
    <string name="fix_bloom_effects">Fix Bloom Effects</string>
    <string name="fix_bloom_effects_description">Reduces bloom blur in LA/EOW (Adreno A6XX - A7XX/ Turnip), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</string>
    <string name="emulate_bgr565">Emulate BGR565</string>
@@ -524,8 +524,6 @@
    <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
    <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
    <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
-    <string name="renderer_unified_memory">Unified memory access (UMA)</string>
-    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
    <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
    <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
    <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
@@ -546,10 +544,6 @@
    <string name="disabled">Disabled</string>
    <string name="vertex_input_dynamic_state">Vertex Input Dynamic State</string>
    <string name="vertex_input_dynamic_state_description">Enabling this feature allows for more flexible vertex input handling, potentially reducing pipeline compilation time in vertex/buffer.</string>
-    <string name="dynamic_rendering">Dynamic Rendering</string>
-    <string name="dynamic_rendering_description">Render without render pass and framebuffer objects. Results vary by driver: some gain performance, others lose it.</string>
-    <string name="workgroup_memory_explicit_layout">Workgroup Memory Explicit Layout</string>
-    <string name="workgroup_memory_explicit_layout_description">Let shaders declare explicit layouts for workgroup memory. Disabled by default: some Qualcomm drivers are unstable with it.</string>
    <string name="sample_shading_fraction">Sample Shading</string>
    <string name="sample_shading_fraction_description">Allows the fragment shader to execute per sample in a multi-sampled fragment instead once per fragment. Improves graphics quality at the cost of some performance.</string>

@@ -1053,13 +1047,6 @@
    <string name="dma_accuracy_unsafe">Unsafe</string>
    <string name="dma_accuracy_safe">Safe</string>

-    <!-- GPU Fence Behavior -->
-    <string name="gpu_fence_behavior_default">Default</string>
-    <string name="gpu_fence_behavior_immediate">Immediate</string>
-    <string name="gpu_fence_behavior_balanced">Balanced</string>
-    <string name="gpu_fence_behavior_accurate">Accurate</string>
-    <string name="gpu_fence_behavior_strict">Strict</string>
-
    <!-- ASTC Decoding Method Choices -->
    <string name="accelerate_astc_cpu" translatable="false">CPU</string>
    <string name="accelerate_astc_gpu" translatable="false">GPU</string>
@@ -51,60 +51,14 @@

 #endif // ^^^ POSIX ^^^

-#include <atomic>
 #include <mutex>
 #include <random>
-#include <vector>

 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
-#include "common/memory_detect.h"
-#include "common/settings.h"
-
-#ifdef __ANDROID__
-#include <dlfcn.h>
-#include <android/hardware_buffer.h>
-
-namespace {
-
-struct NativeHandle {
-    int version;
-    int numFds;
-    int numInts;
-    int data[1];
-};
-
-using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
-using PFN_AHardwareBuffer_isSupported = int (*)(const AHardwareBuffer_Desc*);
-
-void* NativeWindowLibrary() {
-    static void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
-    return lib;
-}
-
-PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
-    void* const lib = NativeWindowLibrary();
-    if (lib == nullptr) {
-        return nullptr;
-    }
-    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
-        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
-}
-
-PFN_AHardwareBuffer_isSupported ResolveIsSupported() {
-    void* const lib = NativeWindowLibrary();
-    if (lib == nullptr) {
-        return nullptr;
-    }
-    return reinterpret_cast<PFN_AHardwareBuffer_isSupported>(
-        dlsym(lib, "AHardwareBuffer_isSupported"));
-}
-
-} // namespace
-#endif

 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -121,12 +75,6 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;

-static std::atomic<u64> committed_backing_size{};
-
-u64 GetCommittedBackingSize() noexcept {
-    return committed_backing_size.load(std::memory_order_relaxed);
-}
-
 #ifdef _WIN32

 // Manually imported for MinGW compatibility
@@ -561,11 +509,6 @@ public:
    bool Init() {
        long page_size = sysconf(_SC_PAGESIZE);
        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging", page_size);
-#ifdef __ANDROID__
-        if (InitAhbBacking()) {
-            return InitVirtual();
-        }
-#endif
        // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
        fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -611,10 +554,7 @@ public:
            return false;
        }

-        return InitVirtual();
-    }
-
-    bool InitVirtual() {
+        // Virtual memory initialization
        virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
        if (virtual_base == MAP_FAILED) {
            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -627,180 +567,6 @@ public:
        return true;
    }

-#ifdef __ANDROID__
-    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
-        return AHardwareBuffer_Desc{
-            .width = static_cast<u32>(len),
-            .height = 1,
-            .layers = 1,
-            .format = AHARDWAREBUFFER_FORMAT_BLOB,
-            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
-            .stride = 0,
-            .rfu0 = 0,
-            .rfu1 = 0,
-        };
-    }
-
-    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
-        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
-        AHardwareBuffer* buffer{};
-        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-            LOG_WARNING(HW_Memory, "Hardware buffer probe allocation failed");
-            return false;
-        }
-        const NativeHandle* const handle = get_native_handle(buffer);
-        if (handle == nullptr || handle->numFds < 1) {
-            LOG_WARNING(HW_Memory, "Hardware buffer has no mappable file descriptor");
-            AHardwareBuffer_release(buffer);
-            return false;
-        }
-        const int probe_fd = handle->data[0];
-        bool ok = true;
-        const auto try_map = [&](int prot, off_t offset, const char* what) {
-            if (!ok) {
-                return;
-            }
-            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
-            if (ptr == MAP_FAILED) {
-                LOG_WARNING(HW_Memory, "Hardware buffer backing rejects {}: {}", what,
-                            strerror(errno));
-                ok = false;
-                return;
-            }
-            munmap(ptr, PageAlignment);
-        };
-        try_map(PROT_READ | PROT_WRITE, 0, "shared mappings");
-        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment), "mappings at an offset");
-#ifdef ARCHITECTURE_arm64
-        try_map(PROT_READ | PROT_EXEC, 0, "executable mappings");
-#endif
-        AHardwareBuffer_release(buffer);
-        return ok;
-    }
-
-    bool InitAhbBacking() {
-        if (!Settings::values.use_unified_memory.GetValue()) {
-            return false;
-        }
-        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
-            ResolveGetNativeHandle();
-        if (get_native_handle == nullptr) {
-            LOG_WARNING(HW_Memory, "AHardwareBuffer_getNativeHandle is not available");
-            return false;
-        }
-        static const PFN_AHardwareBuffer_isSupported is_supported = ResolveIsSupported();
-        if (is_supported == nullptr) {
-            LOG_WARNING(HW_Memory, "AHardwareBuffer_isSupported is not available");
-            return false;
-        }
-        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
-        if (total_physical != 0 && backing_size > total_physical / 2) {
-            LOG_WARNING(HW_Memory,
-                        "Hardware buffer backing would commit {} MiB on a {} MiB system, keeping "
-                        "lazily committed memory",
-                        backing_size >> 20, total_physical >> 20);
-            return false;
-        }
-        if (!ProbeAhbBacking(get_native_handle)) {
-            return false;
-        }
-        const auto try_window_size = [&](size_t window_size) -> bool {
-            const size_t num_windows = (backing_size + window_size - 1) / window_size;
-            std::vector<AHardwareBuffer*> buffers;
-            std::vector<int> buffer_fds;
-            const auto cleanup = [&] {
-                for (AHardwareBuffer* buffer : buffers) {
-                    AHardwareBuffer_release(buffer);
-                }
-                buffers.clear();
-                buffer_fds.clear();
-            };
-            for (size_t i = 0; i < num_windows; ++i) {
-                const size_t len = (std::min)(window_size, backing_size - i * window_size);
-                const AHardwareBuffer_Desc desc = MakeBlobDesc(len);
-                AHardwareBuffer* buffer{};
-                if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer allocation failed for window {}", i);
-                    cleanup();
-                    return false;
-                }
-                buffers.push_back(buffer);
-                const NativeHandle* const handle = get_native_handle(buffer);
-                if (handle == nullptr || handle->numFds < 1) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer has no mappable file descriptor");
-                    cleanup();
-                    return false;
-                }
-                const int buffer_fd = handle->data[0];
-                const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
-                if (buffer_len < static_cast<off_t>(len)) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer descriptor smaller than requested");
-                    cleanup();
-                    return false;
-                }
-                buffer_fds.push_back(buffer_fd);
-            }
-            u8* const base =
-                static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
-                                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
-            if (base == MAP_FAILED) {
-                cleanup();
-                return false;
-            }
-            for (size_t i = 0; i < num_windows; ++i) {
-                const size_t len = (std::min)(window_size, backing_size - i * window_size);
-                if (mmap(base + i * window_size, len, PROT_READ | PROT_WRITE,
-                         MAP_SHARED | MAP_FIXED, buffer_fds[i], 0) == MAP_FAILED) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer mmap failed: {}", strerror(errno));
-                    munmap(base, backing_size);
-                    cleanup();
-                    return false;
-                }
-            }
-            backing_base = base;
-            ahb_windows = std::move(buffers);
-            ahb_fds = std::move(buffer_fds);
-            ahb_window_size = window_size;
-            ahb_backing = true;
-            committed_backing_size.store(backing_size, std::memory_order_relaxed);
-            LOG_INFO(HW_Memory,
-                     "Guest memory backed by {} hardware buffer windows of {} MiB, {} MiB committed",
-                     ahb_windows.size(), window_size >> 20, backing_size >> 20);
-            return true;
-        };
-        static constexpr size_t candidate_window_sizes[] = {
-            1024ULL << 20,
-            512ULL << 20,
-            256ULL << 20,
-            128ULL << 20,
-        };
-        for (const size_t candidate : candidate_window_sizes) {
-            const AHardwareBuffer_Desc window_desc = MakeBlobDesc(candidate);
-            if (is_supported(&window_desc) == 0) {
-                LOG_DEBUG(HW_Memory, "Allocator rejects {} MiB hardware buffer windows",
-                          candidate >> 20);
-                continue;
-            }
-            if (try_window_size(candidate)) {
-                return true;
-            }
-            LOG_WARNING(HW_Memory, "Could not back guest memory with {} MiB windows",
-                        candidate >> 20);
-        }
-        return false;
-    }
-
-    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t AhbWindowSize() const noexcept {
-        return ahb_backing ? ahb_window_size : 0;
-    }
-#endif
-
    ~Impl() {
        Release();
    }
@@ -821,26 +587,6 @@ public:
 #ifdef ARCHITECTURE_arm64
        if (True(perms & MemoryPermission::Execute))
            prot_flags |= PROT_EXEC;
-#endif
-#ifdef __ANDROID__
-        if (ahb_backing) {
-            size_t voff = virtual_offset;
-            size_t hoff = host_offset;
-            size_t remaining = length;
-            while (remaining > 0) {
-                const size_t window = hoff / ahb_window_size;
-                const size_t local = hoff % ahb_window_size;
-                const size_t chunk = (std::min)(remaining, ahb_window_size - local);
-                void* const ret =
-                    mmap(virtual_base + voff, chunk, prot_flags, MAP_SHARED | MAP_FIXED,
-                         ahb_fds[window], static_cast<off_t>(local));
-                ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
-                voff += chunk;
-                hoff += chunk;
-                remaining -= chunk;
-            }
-            return;
-        }
 #endif
        int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -910,18 +656,6 @@ private:
            int ret = close(fd);
            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
        }
-
-#ifdef __ANDROID__
-        for (AHardwareBuffer* buffer : ahb_windows) {
-            AHardwareBuffer_release(buffer);
-        }
-        ahb_windows.clear();
-        ahb_fds.clear();
-        if (ahb_backing) {
-            committed_backing_size.store(0, std::memory_order_relaxed);
-            ahb_backing = false;
-        }
-#endif
    }

    void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -947,13 +681,6 @@ private:

    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
    FreeRegionManager free_manager{};
-
-#ifdef __ANDROID__
-    bool ahb_backing{};
-    std::vector<AHardwareBuffer*> ahb_windows;
-    std::vector<int> ahb_fds;
-    size_t ahb_window_size{};
-#endif
 };

 #endif // ^^^ POSIX ^^^
@@ -1040,22 +767,6 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
    std::memset(backing_base + physical_offset, fill_value, length);
 }

-std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
-#else
-    return {};
-#endif
-}
-
-size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindowSize() : 0;
-#else
-    return 0;
-#endif
-}
-
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
    if (impl) {
@@ -8,17 +8,12 @@

 #include <memory>
 #include <optional>
-#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"

-struct AHardwareBuffer;
-
 namespace Common {

-[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
-
 enum class MemoryPermission : u32 {
    Read = 1 << 0,
    Write = 1 << 1,
@@ -67,14 +62,6 @@ public:
        return backing_base;
    }

-    [[nodiscard]] size_t BackingSize() const noexcept {
-        return backing_size;
-    }
-
-    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
-
-    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
-
    [[nodiscard]] u8* VirtualBasePointer() noexcept {
        return virtual_base;
    }
@@ -156,6 +156,14 @@ void UpdateGPUAccuracy() {
    values.current_gpu_accuracy = values.gpu_accuracy.GetValue();
 }

+bool IsGPULevelLow() {
+    return values.current_gpu_accuracy == GpuAccuracy::Low;
+}
+
+bool IsGPULevelMedium() {
+    return values.current_gpu_accuracy == GpuAccuracy::Medium;
+}
+
 bool IsGPULevelHigh() {
    return values.current_gpu_accuracy == GpuAccuracy::High;
 }
@@ -168,22 +176,6 @@ bool IsDMALevelSafe() {
    return values.dma_accuracy.GetValue() == DmaAccuracy::Safe;
 }

-bool IsGPUFenceBehaviorDefault() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Default;
-}
-
-bool IsGPUFenceBehaviorBalanced() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Balanced;
-}
-
-bool IsGPUFenceBehaviorAccurate() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Accurate;
-}
-
-bool IsGPUFenceBehaviorStrict() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Strict;
-}
-
 bool IsFastmemEnabled() {
    if (values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Debugging)
        return bool(values.cpuopt_fastmem);
@@ -420,7 +420,7 @@ struct Values {
 #ifdef __ANDROID__
                                                      GpuAccuracy::Low,
 #else
-                                                      GpuAccuracy::High,
+                                                      GpuAccuracy::Medium,
 #endif
                                                      "gpu_accuracy",
                                                      Category::RendererAdvanced,
@@ -428,7 +428,7 @@ struct Values {
                                                      true,
                                                      true};

-    GpuAccuracy current_gpu_accuracy{GpuAccuracy::High};
+    GpuAccuracy current_gpu_accuracy{GpuAccuracy::Medium};

    SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
                                                      DmaAccuracy::Default,
@@ -438,16 +438,6 @@ struct Values {
                                                      true,
                                                      true};

-    SwitchableSetting<GpuFenceBehavior, true> gpu_fence_behavior{linkage,
-                                                                 GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Strict,
-                                                                 "gpu_fence_behavior",
-                                                                 Category::RendererAdvanced,
-                                                                 Specialization::Default,
-                                                                 true,
-                                                                 true};
-
    SwitchableSetting<VramUsageMode, true> vram_usage_mode{linkage,
                                                           VramUsageMode::Conservative,
                                                           "vram_usage_mode",
@@ -555,6 +545,13 @@ struct Values {
                                                        Specialization::Default,
                                                        true,
                                                        true};
+    SwitchableSetting<bool> antiflicker{linkage,
+                                        false,
+                                        "antiflicker",
+                                        Category::RendererHacks,
+                                        Specialization::Default,
+                                        true,
+                                        true};
    SwitchableSetting<bool> async_presentation{linkage,
 #ifdef __ANDROID__
                                               false,
@@ -587,9 +584,6 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};

-    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
-                                               Category::RendererHacks};
-
    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                  GpuUnswizzleSize::Large,
                                                  "gpu_unswizzle_texture_size",
@@ -638,16 +632,6 @@ struct Values {
 #endif
                                                       "vertex_input_dynamic_state", Category::RendererExtensions};

-    SwitchableSetting<bool> dynamic_rendering{linkage, true, "dynamic_rendering",
-                                              Category::RendererExtensions};
-
-    SwitchableSetting<bool> workgroup_memory_explicit_layout{
-        linkage, false, "workgroup_memory_explicit_layout", Category::RendererExtensions};
-
-    SwitchableSetting<s32, true> pipeline_worker_count{
-        linkage, 2, 2, 8, "pipeline_worker_count", Category::RendererAdvanced,
-        Specialization::Scalar};
-
    Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
    Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
                                           Category::RendererDebug};
@@ -887,16 +871,13 @@ extern Values values;
 bool getDebugKnobAt(u8 i);

 void UpdateGPUAccuracy();
+bool IsGPULevelLow();
+bool IsGPULevelMedium();
 bool IsGPULevelHigh();

 bool IsDMALevelDefault();
 bool IsDMALevelSafe();

-bool IsGPUFenceBehaviorDefault();
-bool IsGPUFenceBehaviorBalanced();
-bool IsGPUFenceBehaviorAccurate();
-bool IsGPUFenceBehaviorStrict();
-
 bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);
 bool IsNceEnabled();
@@ -135,9 +135,8 @@ ENUM(FramePacingMode, Target_Auto, Target_30, Target_60, Target_90, Target_120);
 ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
 ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL_GLSL, Vulkan, Null, OpenGL_GLASM, OpenGL_SPIRV);
-ENUM(GpuAccuracy, Low, High);
+ENUM(GpuAccuracy, Low, Medium, High);
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);
 ENUM(CpuClock, Off, Boost, Fast)
@@ -1,6 +1,5 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -40,110 +39,6 @@
 #include <unistd.h>
 #endif

-#ifdef __ANDROID__
-#include <sys/resource.h>
-#include <algorithm>
-#include <fstream>
-#include <utility>
-#include <vector>
-
-namespace {
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_URGENT_AUDIO = -19;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_AUDIO = -16;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_URGENT_DISPLAY = -8;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_DISPLAY = -4;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_FOREGROUND = -2;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_MORE_FAVORABLE = -1;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_DEFAULT = 0;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_LESS_FAVORABLE = 1;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_BACKGROUND = 10;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_LOWEST = 19;
-
-constexpr size_t ANDROID_MINIMUM_PERFORMANCE_CORES = 4;
-
-cpu_set_t ComputePerformanceCoreMask() {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-
-    cpu_set_t allowed;
-    CPU_ZERO(&allowed);
-    if (sched_getaffinity(gettid(), sizeof(allowed), &allowed) != 0) {
-        return mask;
-    }
-
-    std::vector<std::pair<long, int>> cores;
-    const int total = static_cast<int>(std::thread::hardware_concurrency());
-    for (int cpu = 0; cpu < total; ++cpu) {
-        if (!CPU_ISSET(cpu, &allowed)) {
-            continue;
-        }
-        long max_frequency = 0;
-        std::ifstream file("/sys/devices/system/cpu/cpu" + std::to_string(cpu) +
-                           "/cpufreq/cpuinfo_max_freq");
-        if (!file || !(file >> max_frequency) || max_frequency <= 0) {
-            CPU_ZERO(&mask);
-            return mask;
-        }
-        cores.emplace_back(max_frequency, cpu);
-    }
-    if (cores.empty()) {
-        return mask;
-    }
-
-    std::sort(cores.begin(), cores.end(),
-              [](const auto& lhs, const auto& rhs) { return lhs.first > rhs.first; });
-
-    size_t taken = 0;
-    long cluster_frequency = cores.front().first;
-    for (const auto& [frequency, cpu] : cores) {
-        if (frequency != cluster_frequency) {
-            if (taken >= ANDROID_MINIMUM_PERFORMANCE_CORES) {
-                break;
-            }
-            cluster_frequency = frequency;
-        }
-        CPU_SET(cpu, &mask);
-        ++taken;
-    }
-    return mask;
-}
-
-const cpu_set_t& PerformanceCoreMask() {
-    static const cpu_set_t mask = ComputePerformanceCoreMask();
-    return mask;
-}
-
-cpu_set_t ComputeEfficiencyCoreMask() {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-
-    const cpu_set_t& performance = PerformanceCoreMask();
-    if (CPU_COUNT(&performance) == 0) {
-        return mask;
-    }
-
-    cpu_set_t allowed;
-    CPU_ZERO(&allowed);
-    if (sched_getaffinity(gettid(), sizeof(allowed), &allowed) != 0) {
-        return mask;
-    }
-
-    const int total = static_cast<int>(std::thread::hardware_concurrency());
-    for (int cpu = 0; cpu < total; ++cpu) {
-        if (CPU_ISSET(cpu, &allowed) && !CPU_ISSET(cpu, &performance)) {
-            CPU_SET(cpu, &mask);
-        }
-    }
-    return mask;
-}
-
-const cpu_set_t& EfficiencyCoreMask() {
-    static const cpu_set_t mask = ComputeEfficiencyCoreMask();
-    return mask;
-}
-} // Anonymous namespace
-#endif
-
 #include "common/cpu_features.h"
 #ifdef ARCHITECTURE_x86_64
 #ifdef _MSC_VER
@@ -183,21 +78,6 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
        }
    }();
    set_thread_priority(find_thread(NULL), priority);
-#elif defined(__ANDROID__)
-    const int nice_value = [&]() {
-        switch (new_priority) {
-        case ThreadPriority::Low: return ANDROID_THREAD_PRIORITY_BACKGROUND;
-        case ThreadPriority::Normal: return ANDROID_THREAD_PRIORITY_DEFAULT;
-        case ThreadPriority::High: return ANDROID_THREAD_PRIORITY_DISPLAY;
-        case ThreadPriority::VeryHigh: return ANDROID_THREAD_PRIORITY_URGENT_DISPLAY;
-        case ThreadPriority::Critical: return ANDROID_THREAD_PRIORITY_AUDIO;
-        default: return ANDROID_THREAD_PRIORITY_DEFAULT;
-        }
-    }();
-    if (setpriority(PRIO_PROCESS, static_cast<id_t>(gettid()), nice_value) != 0) {
-        LOG_DEBUG(Common, "Could not set thread nice value to {}: {}", nice_value,
-                  GetLastErrorMsg());
-    }
 #else
    pthread_t this_thread = pthread_self();
    const auto scheduling_type = SCHED_OTHER;
@@ -252,28 +132,29 @@ void SetCurrentThreadName(const char* name) {
 #endif
 }

-void SetCurrentThreadToPerformanceCores() {
+void PinCurrentThreadToPerformanceCore(size_t core_id) {
+    ASSERT(core_id < 4);
+    // If we set a flag for a CPU that doesn't exist, the thread may not be allowed to
+    // run in ANY processor!
+    auto const total_cores = std::thread::hardware_concurrency();
+    if (core_id < total_cores) {
 #if defined(__ANDROID__)
-    const cpu_set_t& mask = PerformanceCoreMask();
-    if (CPU_COUNT(&mask) == 0) {
-        return;
-    }
-    if (sched_setaffinity(gettid(), sizeof(mask), &mask) != 0) {
-        LOG_DEBUG(Common, "Could not restrict thread to performance cores: {}", GetLastErrorMsg());
-    }
+        cpu_set_t set;
+        CPU_ZERO(&set);
+        CPU_SET(core_id, &set);
+        sched_setaffinity(pthread_self(), sizeof(set), &set);
+#elif defined(__linux__) || defined(__FreeBSD__)
+        cpu_set_t set;
+        CPU_ZERO(&set);
+        CPU_SET(core_id, &set);
+        pthread_setaffinity_np(pthread_self(), sizeof(set), &set);
+#elif defined(_WIN32)
+        DWORD set = 1UL << core_id;
+        SetThreadAffinityMask(GetCurrentThread(), set);
+#else
+        // No pin functionality implemented
 #endif
-}
-
-void SetCurrentThreadToEfficiencyCores() {
-#if defined(__ANDROID__)
-    const cpu_set_t& mask = EfficiencyCoreMask();
-    if (CPU_COUNT(&mask) == 0) {
-        return;
    }
-    if (sched_setaffinity(gettid(), sizeof(mask), &mask) != 0) {
-        LOG_DEBUG(Common, "Could not restrict thread to efficiency cores: {}", GetLastErrorMsg());
-    }
-#endif
 }

 #ifdef ARCHITECTURE_x86_64
@@ -99,14 +99,8 @@ enum class ThreadPriority : u32 {
    Critical = 4,
 };

-enum class ThreadPlacement : u32 {
-    Default = 0,
-    Background = 1,
-};
-
 void SetCurrentThreadPriority(ThreadPriority new_priority);
 void SetCurrentThreadName(const char* name);
-void SetCurrentThreadToPerformanceCores();
-void SetCurrentThreadToEfficiencyCores();
+void PinCurrentThreadToPerformanceCore(size_t core_id);

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

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -37,15 +37,10 @@ class StatefulThreadWorker {
    using StateMaker = std::conditional_t<with_state, std::function<StateType()>, DummyCallable>;

 public:
-    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {},
-                                  ThreadPlacement placement = ThreadPlacement::Default)
+    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})
        : workers_queued{num_workers}, thread_name{std::move(name)} {
-        const auto lambda = [this, func, placement](std::stop_token stop_token) {
+        const auto lambda = [this, func](std::stop_token stop_token) {
            Common::SetCurrentThreadName(thread_name.c_str());
-            if (placement == ThreadPlacement::Background) {
-                Common::SetCurrentThreadPriority(ThreadPriority::Low);
-                Common::SetCurrentThreadToEfficiencyCores();
-            }
            {
                [[maybe_unused]] std::conditional_t<with_state, StateType, int> state{func()};
                while (!stop_token.stop_requested()) {
@@ -157,8 +157,6 @@ bool ArmNce::HandleGuestAlignmentFault(GuestContext* guest_ctx, void* raw_info,
    return HandleFailedGuestFault(guest_ctx, raw_info, raw_context);
 }

-constexpr size_t NCE_WRITE_FAULT_CLUSTER_PAGES = 4;
-
 bool ArmNce::HandleGuestAccessFault(GuestContext* guest_ctx, void* raw_info, void* raw_context) {
    auto* info = static_cast<siginfo_t*>(raw_info);

@@ -167,7 +165,7 @@ bool ArmNce::HandleGuestAccessFault(GuestContext* guest_ctx, void* raw_info, voi
    const Common::ProcessAddress addr =
        (reinterpret_cast<u64>(info->si_addr) & ~Memory::YUZU_PAGEMASK);
    auto& memory = guest_ctx->parent->m_running_thread->GetOwnerProcess()->GetMemory();
-    if (memory.InvalidateNCE(addr, Memory::YUZU_PAGESIZE * NCE_WRITE_FAULT_CLUSTER_PAGES)) {
+    if (memory.InvalidateNCE(addr, Memory::YUZU_PAGESIZE)) {
        // We handled the access successfully and are returning to guest code.
        return true;
    }
@@ -118,7 +118,6 @@ struct System::Impl {

        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();

        core_timing.SetMulticore(is_multicore);
        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -146,8 +145,7 @@ struct System::Impl {
            !device_memory.has_value() ||
            is_multicore != Settings::values.use_multi_core.GetValue() ||
            extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb) ||
-            unified_memory != Settings::values.use_unified_memory.GetValue();
+                                       Settings::MemoryLayout::Memory_4Gb);

        if (!must_reinitialize) {
            return;
@@ -158,7 +156,6 @@ struct System::Impl {
        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout =
            Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();

        Initialize(system);
    }
@@ -506,7 +503,6 @@ struct System::Impl {
    std::atomic_bool is_powered_on{};
    bool is_multicore : 1 = false;
    bool extended_memory_layout : 1 = false;
-    bool unified_memory : 1 = false;
    bool exit_locked : 1 = false;
    bool exit_requested : 1 = false;
    bool nvdec_active : 1 = false;
@@ -174,7 +174,12 @@ void CpuManager::RunThread(std::stop_token token, std::size_t core) {
    std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"};
    Common::SetCurrentThreadName(name.c_str());
    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
-    Common::SetCurrentThreadToPerformanceCores();
+#ifdef __ANDROID__
+    // Aimed specifically for Snapdragon 8 Elite devices
+    // This kills performance on desktop, but boosts perf for UMA devices
+    // like the S8E. Mediatek and Mali likely won't suffer.
+    Common::PinCurrentThreadToPerformanceCore(core);
+#endif
    auto& data = core_data[core];
    data.host_context = Common::Fiber::ThreadToFiber();

@@ -20,8 +20,6 @@
 #include "common/scratch_buffer.h"
 #include "common/virtual_buffer.h"

-struct AHardwareBuffer;
-
 namespace Core {

 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -97,26 +95,6 @@ public:
        ApplyOpOnPAddr(address, buffer, operation);
    }

-    u8* GetPhysicalBase() noexcept {
-        return reinterpret_cast<u8*>(physical_base);
-    }
-
-    const u8* GetPhysicalBase() const noexcept {
-        return reinterpret_cast<const u8*>(physical_base);
-    }
-
-    size_t GetPhysicalSize() const noexcept {
-        return physical_size;
-    }
-
-    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t GetBackingHardwareBufferWindowSize() const noexcept {
-        return ahb_window_size;
-    }
-
    PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
        PAddr subbits = PAddr(address & page_mask);
        auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -148,10 +126,6 @@ public:
    // New batch API to update multiple ranges with a single lock acquisition.
    void UpdatePagesCachedBatch(std::span<const std::pair<DAddr, size_t>> ranges, s32 delta);

-    void UpdateTexturePagesCount(DAddr addr, size_t size, s32 delta);
-
-    [[nodiscard]] bool IsRegionTextureCached(DAddr addr, size_t size) const noexcept;
-
 private:
    struct TranslationEntry {
        DAddr guest_page{};
@@ -197,9 +171,6 @@ private:
    std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;

    const uintptr_t physical_base;
-    const size_t physical_size;
-    const std::span<AHardwareBuffer* const> ahb_windows;
-    const size_t ahb_window_size;
    DeviceInterface* device_inter;

    struct TrackedEntry {
@@ -263,7 +234,6 @@ private:
        (1ULL << (device_virtual_bits - page_bits)) / subentries;
    using CachedPages = std::array<CounterEntry, num_counter_entries>;
    std::unique_ptr<CachedPages> cached_pages;
-    std::unique_ptr<CachedPages> texture_cached_pages;
    Common::RangeMutex counter_guard;
    std::mutex mapping_guard;

@@ -171,16 +171,12 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
-    , physical_size{device_memory_.buffer.BackingSize()}
-    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
-    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
    , device_inter{nullptr}
    , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
    , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)
 {
    impl = std::make_unique<DeviceMemoryManagerAllocator<Traits>>();
    cached_pages = std::make_unique<CachedPages>();
-    texture_cached_pages = std::make_unique<CachedPages>();

    const size_t total_virtual = device_as_size >> Memory::YUZU_PAGEBITS;
    for (size_t i = 0; i < total_virtual; i++) {
@@ -629,28 +625,6 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
    UpdatePagesCachedCountNoLock(addr, size, delta);
 }

-template <typename Traits>
-void DeviceMemoryManager<Traits>::UpdateTexturePagesCount(DAddr addr, size_t size, s32 delta) {
-    Common::ScopedRangeLock lk(counter_guard, addr, size);
-    const size_t page_end = Common::DivCeil(addr + size, Memory::YUZU_PAGESIZE);
-    for (size_t page = addr >> Memory::YUZU_PAGEBITS; page != page_end; ++page) {
-        CounterAtomicType& count = texture_cached_pages->at(page >> subentries_shift).Count(page);
-        count.fetch_add(static_cast<CounterType>(delta), std::memory_order_release);
-    }
-}
-
-template <typename Traits>
-bool DeviceMemoryManager<Traits>::IsRegionTextureCached(DAddr addr, size_t size) const noexcept {
-    const size_t page_end = Common::DivCeil(addr + size, Memory::YUZU_PAGESIZE);
-    for (size_t page = addr >> Memory::YUZU_PAGEBITS; page != page_end; ++page) {
-        if (texture_cached_pages->at(page >> subentries_shift).Count(page).load(
-                std::memory_order_acquire) != 0) {
-            return true;
-        }
-    }
-    return false;
-}
-
 template <typename Traits>
 void DeviceMemoryManager<Traits>::UpdatePagesCachedBatch(std::span<const std::pair<DAddr, size_t>> ranges, s32 delta) {
    if (ranges.empty()) {
@@ -140,7 +140,7 @@ void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address
 }

 bool ProgramMetadata::Is64BitProgram() const {
-    return bool(npdm_header.has_64_bit_instructions);
+    return npdm_header.has_64_bit_instructions;
 }

 ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {
@@ -1662,17 +1662,17 @@ bool EmulatedController::IsControllerFullkey(bool use_temporary_value) const {
 bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
    const auto type = is_configuring.load() && use_temporary_value ? tmp_npad_type.load() : npad_type.load();
    switch (type) {
-    case NpadStyleIndex::Fullkey:     return bool(supported_style_tag.fullkey);
-    case NpadStyleIndex::Handheld:    return bool(supported_style_tag.handheld);
-    case NpadStyleIndex::JoyconDual:  return bool(supported_style_tag.joycon_dual);
-    case NpadStyleIndex::JoyconLeft:  return bool(supported_style_tag.joycon_left);
-    case NpadStyleIndex::JoyconRight: return bool(supported_style_tag.joycon_right);
-    case NpadStyleIndex::GameCube:    return bool(supported_style_tag.gamecube);
-    case NpadStyleIndex::Pokeball:    return bool(supported_style_tag.palma);
-    case NpadStyleIndex::NES:         return bool(supported_style_tag.lark);
-    case NpadStyleIndex::SNES:        return bool(supported_style_tag.lucia);
-    case NpadStyleIndex::N64:         return bool(supported_style_tag.lagoon);
-    case NpadStyleIndex::SegaGenesis: return bool(supported_style_tag.lager);
+    case NpadStyleIndex::Fullkey: return supported_style_tag.fullkey;
+    case NpadStyleIndex::Handheld: return supported_style_tag.handheld;
+    case NpadStyleIndex::JoyconDual: return supported_style_tag.joycon_dual;
+    case NpadStyleIndex::JoyconLeft: return supported_style_tag.joycon_left;
+    case NpadStyleIndex::JoyconRight: return supported_style_tag.joycon_right;
+    case NpadStyleIndex::GameCube: return supported_style_tag.gamecube;
+    case NpadStyleIndex::Pokeball: return supported_style_tag.palma;
+    case NpadStyleIndex::NES: return supported_style_tag.lark;
+    case NpadStyleIndex::SNES: return supported_style_tag.lucia;
+    case NpadStyleIndex::N64: return supported_style_tag.lagoon;
+    case NpadStyleIndex::SegaGenesis: return supported_style_tag.lager;
    default: return false;
    }
 }
@@ -66,7 +66,7 @@ Result NpadAbstractSixAxisHandler::UpdateSixAxisState() {
            continue;
        }
        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateSixaxisInternalState(npad_entry, data->aruid, bool(data->flag.enable_six_axis_sensor));
+        UpdateSixaxisInternalState(npad_entry, data->aruid, data->flag.enable_six_axis_sensor);
    }
    return ResultSuccess;
 }
@@ -78,7 +78,7 @@ Result NpadAbstractSixAxisHandler::UpdateSixAxisState(u64 aruid) {
        return ResultSuccess;
    }
    auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-    UpdateSixaxisInternalState(npad_entry, data->aruid, bool(data->flag.enable_six_axis_sensor));
+    UpdateSixaxisInternalState(npad_entry, data->aruid, data->flag.enable_six_axis_sensor);
    return ResultSuccess;
 }

@@ -89,7 +89,7 @@ Result NpadAbstractSixAxisHandler::UpdateSixAxisState2(u64 aruid) {
        return ResultSuccess;
    }
    auto& npad_internal_state = aruid_data->shared_memory_format->npad.npad_entry[npad_index];
-    UpdateSixaxisInternalState(npad_internal_state, aruid, bool(aruid_data->flag.enable_six_axis_sensor));
+    UpdateSixaxisInternalState(npad_internal_state, aruid, aruid_data->flag.enable_six_axis_sensor);
    return ResultSuccess;
 }

@@ -24,7 +24,7 @@ void NPadData::SetNpadAnalogStickUseCenterClamp(bool is_enabled) {
 }

 bool NPadData::GetNpadAnalogStickUseCenterClamp() const {
-    return bool(status.use_center_clamp);
+    return status.use_center_clamp;
 }

 void NPadData::SetNpadSystemExtStateEnabled(bool is_enabled) {
@@ -32,7 +32,7 @@ void NPadData::SetNpadSystemExtStateEnabled(bool is_enabled) {
 }

 bool NPadData::GetNpadSystemExtState() const {
-    return bool(status.system_ext_state);
+    return status.system_ext_state;
 }

 Result NPadData::SetSupportedNpadIdType(std::span<const Core::HID::NpadIdType> list) {
@@ -42,14 +42,18 @@ Result NPadData::SetSupportedNpadIdType(std::span<const Core::HID::NpadIdType> l
    }

    supported_npad_id_types_count = list.size();
-    std::memcpy(supported_npad_id_types.data(), list.data(), list.size() * sizeof(Core::HID::NpadIdType));
+    memcpy(supported_npad_id_types.data(), list.data(),
+           list.size() * sizeof(Core::HID::NpadIdType));
+
    return ResultSuccess;
 }

 std::size_t NPadData::GetSupportedNpadIdType(std::span<Core::HID::NpadIdType> out_list) const {
    std::size_t out_size = (std::min)(supported_npad_id_types_count, out_list.size());

-    std::memcpy(out_list.data(), supported_npad_id_types.data(), out_size * sizeof(Core::HID::NpadIdType));
+    memcpy(out_list.data(), supported_npad_id_types.data(),
+           out_size * sizeof(Core::HID::NpadIdType));
+
    return out_size;
 }

@@ -150,27 +154,27 @@ bool NPadData::IsNpadStyleIndexSupported(Core::HID::NpadStyleIndex style_index)
    Core::HID::NpadStyleTag style = {supported_npad_style_set};
    switch (style_index) {
    case Core::HID::NpadStyleIndex::Fullkey:
-        return bool(style.fullkey);
+        return style.fullkey;
    case Core::HID::NpadStyleIndex::Handheld:
-        return bool(style.handheld);
+        return style.handheld;
    case Core::HID::NpadStyleIndex::JoyconDual:
-        return bool(style.joycon_dual);
+        return style.joycon_dual;
    case Core::HID::NpadStyleIndex::JoyconLeft:
-        return bool(style.joycon_left);
+        return style.joycon_left;
    case Core::HID::NpadStyleIndex::JoyconRight:
-        return bool(style.joycon_right);
+        return style.joycon_right;
    case Core::HID::NpadStyleIndex::GameCube:
-        return bool(style.gamecube);
+        return style.gamecube;
    case Core::HID::NpadStyleIndex::Pokeball:
-        return bool(style.palma);
+        return style.palma;
    case Core::HID::NpadStyleIndex::NES:
-        return bool(style.lark);
+        return style.lark;
    case Core::HID::NpadStyleIndex::SNES:
-        return bool(style.lucia);
+        return style.lucia;
    case Core::HID::NpadStyleIndex::N64:
-        return bool(style.lagoon);
+        return style.lagoon;
    case Core::HID::NpadStyleIndex::SegaGenesis:
-        return bool(style.lager);
+        return style.lager;
    default:
        return false;
    }
@@ -181,7 +185,7 @@ void NPadData::SetLrAssignmentMode(bool is_enabled) {
 }

 bool NPadData::GetLrAssignmentMode() const {
-    return bool(status.lr_assignment_mode);
+    return status.lr_assignment_mode;
 }

 void NPadData::SetAssigningSingleOnSlSrPress(bool is_enabled) {
@@ -189,7 +193,7 @@ void NPadData::SetAssigningSingleOnSlSrPress(bool is_enabled) {
 }

 bool NPadData::GetAssigningSingleOnSlSrPress() const {
-    return bool(status.assigning_single_on_sl_sr_press);
+    return status.assigning_single_on_sl_sr_press;
 }

 void NPadData::SetHomeProtectionEnabled(bool is_enabled, Core::HID::NpadIdType npad_id) {
@@ -548,7 +548,7 @@ void TouchResource::OnTouchUpdate(s64 timestamp) {
            }

            auto& touch_shared = applet_data->shared_memory_format->touch_screen;
-            StorePreviousTouchState(previous_touch_state, data.finger_map, current_touch_state, bool(applet_data->flag.enable_touchscreen));
+            StorePreviousTouchState(previous_touch_state, data.finger_map, current_touch_state, applet_data->flag.enable_touchscreen);
            touch_shared.touch_screen_lifo.WriteNextEntry(current_touch_state);
        }
    }
@@ -193,6 +193,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
    INSERT(Settings, skip_cpu_inner_invalidation, tr("Skip CPU Inner Invalidation"),
           tr("Skips certain cache invalidations during memory updates, reducing CPU usage and "
              "improving latency. This may cause soft-crashes."));
+    INSERT(Settings, antiflicker, tr("Anti-Flicker"),
+           tr("Forces GPU fence callbacks to wait for submitted GPU work.\n"
+              "Use with Fast GPU mode, to avoid flicker with lower performance impact."));
    INSERT(Settings, vsync_mode, tr("VSync Mode:"),
           tr("FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
              "refresh rate.\nFIFO Relaxed allows tearing as it recovers from a slow down.\n"
@@ -220,21 +223,16 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
           tr("Controls the quality of texture rendering at oblique angles.\nSafe to set at 16x on "
              "most GPUs."));
    INSERT(Settings, gpu_accuracy, tr("GPU Mode:"),
-           tr("Controls the GPU emulation mode.\nMost games render fine with Fast, but Accurate is still "
+           tr("Controls the GPU emulation mode.\nMost games render fine with Fast or Balanced "
+              "modes, but Accurate is still "
              "required for some.\nParticles tend to only render correctly with Accurate mode."));
    INSERT(Settings, dma_accuracy, tr("DMA Accuracy:"),
-           tr("Controls the DMA read mode.\nUnsafe is faster, while Safe is more stable and can fix issues in some games.\nDefault follows the GPU Accuracy setting."));
-    INSERT(Settings, gpu_fence_behavior, tr("GPU Fence Behavior:"),
-           tr("Controls the GPU fence synchronization behavior.\nImmediate is the fastest option, but can introduce some issues.\nBalanced offers better compatibility and may fix issues in some games.\nAccurate further improves compatibility at the cost of some performance.\nStrict is the slowest option, but can fix issues that require stricter synchronization.\nDefault follows the GPU Accuracy setting."));
+           tr("Controls the DMA precision accuracy. Safe precision fixes issues in some games but "
+              "may degrade performance."));
    INSERT(Settings, enable_gpu_buffer_readback, tr("Enable GPU buffer readback"),
-           tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
+           tr("Preserves GPU-modified buffer data by reading it back before uploads.\nSome games require this to render certain effects properly.\nMay cause issues if the hardware cannot handle the additional workload."));
    INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
           tr("May reduce shader stutter."));
-    INSERT(Settings, use_unified_memory, tr("Enable unified memory access (UMA)"),
-           tr("Lets the GPU write buffer readbacks directly into guest memory."));
-    INSERT(Settings, pipeline_worker_count, tr("Pipeline Worker Threads"),
-           tr("Number of threads used to build Vulkan pipelines.\n"
-              "Higher values speed up compilation at the cost of heat and power."));
    INSERT(Settings, fast_gpu_time, tr("Fast GPU Time"),
           tr("Overclocks the emulated GPU to increase dynamic resolution and render "
              "distance.\nUse 256 for maximal performance and 512 for maximal graphics fidelity."));
@@ -292,12 +290,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
    INSERT(Settings, vertex_input_dynamic_state, tr("Vertex Input Dynamic State"),
           tr("Enables vertex input dynamic state feature for better quality and performance."));

-    INSERT(Settings, dynamic_rendering, tr("Dynamic Rendering"),
-           tr("Renders without render pass and framebuffer objects.\n"
-              "Results vary by driver: some gain performance, others lose it."));
-
-    INSERT(Settings, workgroup_memory_explicit_layout, QString(), QString());
-
    INSERT(
        Settings, sample_shading, tr("Sample Shading"),
        tr("Allows the fragment shader to execute per sample in a multi-sampled fragment "
@@ -438,6 +430,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
    translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(),
                          {
                              PAIR(GpuAccuracy, Low, tr("Fast")),
+                              PAIR(GpuAccuracy, Medium, tr("Balanced")),
                              PAIR(GpuAccuracy, High, tr("Accurate")),
                          }});
    translations->insert({Settings::EnumMetadata<Settings::DmaAccuracy>::Index(),
@@ -446,14 +439,6 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                              PAIR(DmaAccuracy, Unsafe, tr("Unsafe (fast)")),
                              PAIR(DmaAccuracy, Safe, tr("Safe (stable)")),
                          }});
-    translations->insert({Settings::EnumMetadata<Settings::GpuFenceBehavior>::Index(),
-                          {
-                              PAIR(GpuFenceBehavior, Default, tr("Default")),
-                              PAIR(GpuFenceBehavior, Immediate, tr("Immediate")),
-                              PAIR(GpuFenceBehavior, Balanced, tr("Balanced")),
-                              PAIR(GpuFenceBehavior, Accurate, tr("Accurate")),
-                              PAIR(GpuFenceBehavior, Strict, tr("Strict")),
-                          }});
    translations->insert(
        {Settings::EnumMetadata<Settings::CpuAccuracy>::Index(),
         {
@@ -64,6 +64,7 @@ static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map

 static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map = {
    {Settings::GpuAccuracy::Low, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Fast"))},
+    {Settings::GpuAccuracy::Medium, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Balanced"))},
    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Accurate"))},
 };

@@ -223,6 +223,9 @@ struct Values {
    // perf overlay
    Setting<bool> show_perf_overlay{linkage, false, "show_perf_overlay", Category::UiGameList};

+    // Compatibility List
+    Setting<bool> show_compat{linkage, true, "show_compat", Category::UiGameList};
+
    // Size & File Types Column
    Setting<bool> show_size{linkage, true, "show_size", Category::UiGameList};
    Setting<bool> show_types{linkage, true, "show_types", Category::UiGameList};
@@ -52,7 +52,7 @@ void GameListModel::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
    current_worker.reset();
    removeRows(0, rowCount());

-    current_worker = std::make_unique<GameListWorker>(vfs, provider, game_dirs,
+    current_worker = std::make_unique<GameListWorker>(vfs, provider, game_dirs, compatibility_list,
                                                      play_time_manager, system);

    connect(current_worker.get(), &GameListWorker::DataAvailable, this, &GameListModel::WorkerEvent,
@@ -157,6 +157,50 @@ void GameListModel::RemoveFavorite(u64 program_id) {
    }
 }

+void GameListModel::LoadCompatibilityList() {
+    QFile compat_list{QStringLiteral(":compatibility_list/compatibility_list.json")};
+
+    if (!compat_list.open(QFile::ReadOnly | QFile::Text)) {
+        LOG_ERROR(Frontend, "Unable to open game compatibility list");
+        return;
+    }
+
+    if (compat_list.size() == 0) {
+        LOG_WARNING(Frontend, "Game compatibility list is empty");
+        return;
+    }
+
+    const QByteArray content = compat_list.readAll();
+    if (content.isEmpty()) {
+        LOG_ERROR(Frontend, "Unable to completely read game compatibility list");
+        return;
+    }
+
+    const QJsonDocument json = QJsonDocument::fromJson(content);
+    const QJsonArray arr = json.array();
+
+    for (const QJsonValue& value : arr) {
+        const QJsonObject game = value.toObject();
+        const QString compatibility_key = QStringLiteral("compatibility");
+
+        if (!game.contains(compatibility_key) || !game[compatibility_key].isDouble()) {
+            continue;
+        }
+
+        const int compatibility = game[compatibility_key].toInt();
+        const QString directory = game[QStringLiteral("directory")].toString();
+        const QJsonArray ids = game[QStringLiteral("releases")].toArray();
+
+        for (const QJsonValue& id_ref : ids) {
+            const QJsonObject id_object = id_ref.toObject();
+            const QString id = id_object[QStringLiteral("id")].toString();
+
+            compatibility_list.emplace(id.toUpper().toStdString(),
+                                       std::make_pair(QString::number(compatibility), directory));
+        }
+    }
+}
+
 void GameListModel::Repopulate() {
    current_worker.reset();
    QtCommon::system->GetFileSystemController().CreateFactories(*QtCommon::vfs);
@@ -192,6 +236,7 @@ void GameListModel::ResetExternalWatcher() {

 void GameListModel::RetranslateUI() {
    setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
    setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
    setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
    setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
@@ -202,6 +247,10 @@ QFileSystemWatcher* GameListModel::GetWatcher() const {
    return watcher;
 }

+const CompatibilityList& GameListModel::GetCompatibilityList() const {
+    return compatibility_list;
+}
+
 void GameListModel::SetFlat(bool flat) {
    m_flat = flat;
 }
@@ -12,6 +12,7 @@
 #include "common/common_types.h"
 #include "frontend_common/play_time_manager.h"
 #include "qt_common/config/uisettings.h"
+#include "yuzu/compatibility_list.h"

 namespace Core {
 class System;
@@ -36,6 +37,7 @@ public:
        COLUMN_SIZE,
        COLUMN_PLAY_TIME,
        COLUMN_ADD_ONS,
+        COLUMN_COMPATIBILITY,
        COLUMN_COUNT,
    };

@@ -60,10 +62,14 @@ public:
    void RefreshExternalContent();
    void ResetExternalWatcher();

+    void LoadCompatibilityList();
+
    void RetranslateUI();

    QFileSystemWatcher* GetWatcher() const;

+    const CompatibilityList& GetCompatibilityList() const;
+
    void SetFlat(bool flat);

 signals:
@@ -83,6 +89,7 @@ private:

    std::shared_ptr<FileSys::VfsFilesystem> vfs;
    FileSys::ManualContentProvider* provider;
+    CompatibilityList compatibility_list;
    const PlayTime::PlayTimeManager& play_time_manager;
    Core::System& system;

@@ -33,6 +33,7 @@
 #include "qt_common/qt_common.h"

 #include "qt_common/game_list/game_list_p.h"
+#include "yuzu/compatibility_list.h"

 #include "qt_common/game_list/model.h"
 #include "qt_common/game_list/worker.h"
@@ -202,8 +203,14 @@ QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager,
 QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::string& name,
                                        const std::size_t size, const std::vector<u8>& icon,
                                        Loader::AppLoader& loader, u64 program_id,
+                                        const CompatibilityList& compatibility_list,
                                        const PlayTime::PlayTimeManager& play_time_manager,
                                        const FileSys::PatchManager& patch) {
+    auto const it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
+    // The game list uses 99 as compatibility number for untested games
+    QString compatibility =
+        it != compatibility_list.end() ? it->second.first : QStringLiteral("99");
+
    auto const file_type = loader.GetFileType();
    auto const file_type_string = QString::fromStdString(Loader::GetFileTypeString(file_type));

@@ -220,6 +227,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
        new GameListItemSize(size),
        new GameListItemPlayTime(play_time),
        new GameListItem(patch_versions),
+        new GameListItemCompat(compatibility),
    };
 }
 } // Anonymous namespace
@@ -227,10 +235,11 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
 GameListWorker::GameListWorker(FileSys::VirtualFilesystem vfs_,
                               FileSys::ManualContentProvider* provider_,
                               QVector<UISettings::GameDir>& game_dirs_,
+                               const CompatibilityList& compatibility_list_,
                               const PlayTime::PlayTimeManager& play_time_manager_,
                               Core::System& system_)
    : vfs{std::move(vfs_)}, provider{provider_}, game_dirs{game_dirs_},
-      play_time_manager{play_time_manager_},
+      compatibility_list{compatibility_list_}, play_time_manager{play_time_manager_},
      system{system_} {
    // We want the game list to manage our lifetime.
    setAutoDelete(false);
@@ -326,7 +335,7 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
        }

        auto entry = MakeGameListEntry(file->GetFullPath(), name, file->GetSize(), icon, *loader,
-                                       program_id, play_time_manager, patch);
+                                       program_id, compatibility_list, play_time_manager, patch);
        RecordEvent([=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
    }
 }
@@ -396,7 +405,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa

                    auto entry = MakeGameListEntry(
                        physical_name, name, Common::FS::GetSize(physical_name), icon, *app_loader,
-                        id, play_time_manager, patch);
+                        id, compatibility_list, play_time_manager, patch);

                    RecordEvent([=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
                };
@@ -20,6 +20,7 @@
 #include "core/file_sys/registered_cache.h"
 #include "frontend_common/play_time_manager.h"
 #include "qt_common/config/uisettings.h"
+#include "yuzu/compatibility_list.h"

 namespace Core {
 class System;
@@ -45,6 +46,7 @@ public:
    explicit GameListWorker(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
                            FileSys::ManualContentProvider* provider_,
                            QVector<UISettings::GameDir>& game_dirs_,
+                            const CompatibilityList& compatibility_list_,
                            const PlayTime::PlayTimeManager& play_time_manager_,
                            Core::System& system_);
    ~GameListWorker() override;
@@ -83,6 +85,7 @@ private:
    std::shared_ptr<FileSys::VfsFilesystem> vfs;
    FileSys::ManualContentProvider* provider;
    QVector<UISettings::GameDir>& game_dirs;
+    const CompatibilityList& compatibility_list;
    const PlayTime::PlayTimeManager& play_time_manager;

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

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

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

-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 lane) {
-    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) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("ADD.U RC.x,{},1;"
-            "SHFXOR.U {},{},RC.x,0x1C03;"
-            "MOV.U {}.x,{}.y;",
-            direction, ret, value, ret, ret);
-}
-
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a, ScalarF32 op_b,
                     ScalarU32 swizzle) {
    const auto ret{ctx.reg_alloc.Define(inst)};
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

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

-void EmitQuadBroadcast(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                       std::string_view lane) {
-    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) {
-    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,11 +322,6 @@ void DefineEntryPoint(const IR::Program& program, EmitContext& ctx, Id main) {
        if (ctx.runtime_info.force_early_z) {
            ctx.AddExecutionMode(main, spv::ExecutionMode::EarlyFragmentTests);
        }
-        if (ctx.profile.support_shader_quad_control && program.info.uses_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);
@@ -448,12 +443,6 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
            ctx.AddCapability(spv::Capability::GroupNonUniformVote);
        }
    }
-    if (info.uses_quad_shuffles) {
-        if (profile.support_quad_shuffles) {
-            ctx.AddCapability(spv::Capability::GroupNonUniformQuad);
-        }
-        ctx.AddCapability(spv::Capability::GroupNonUniformShuffle);
-    }
    if (info.uses_int64_bit_atomics && profile.support_int64_atomics) {
        ctx.AddCapability(spv::Capability::Int64Atomics);
    }
@@ -476,22 +465,12 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
    ctx.AddCapability(spv::Capability::ImageGatherExtended);
    ctx.AddCapability(spv::Capability::ImageQuery);
    ctx.AddCapability(spv::Capability::SampledBuffer);
-    if (!ctx.non_uniform_ids.empty()) {
-        if (ctx.profile.supported_spirv < 0x00010500)
+    // TODO: this usage needs to be tracked properly
+    if (ctx.profile.support_sampled_image_array_nonuniform_indexing) {
+        if (ctx.profile.supported_spirv < 0x00010400)
            ctx.AddExtension("SPV_EXT_descriptor_indexing");
        ctx.AddCapability(spv::Capability::ShaderNonUniform);
-        if (ctx.uses_nonuniform_sampled_image) {
-            ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);
-        }
-        if (ctx.uses_nonuniform_storage_image) {
-            ctx.AddCapability(spv::Capability::StorageImageArrayNonUniformIndexing);
-        }
-        if (ctx.uses_nonuniform_uniform_texel_buffer) {
-            ctx.AddCapability(spv::Capability::UniformTexelBufferArrayNonUniformIndexing);
-        }
-        if (ctx.uses_nonuniform_storage_texel_buffer) {
-            ctx.AddCapability(spv::Capability::StorageTexelBufferArrayNonUniformIndexing);
-        }
+        ctx.AddCapability(spv::Capability::SampledImageArrayNonUniformIndexing);
    }
 }

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

@@ -18,7 +15,7 @@ Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
    if (index_offset > 0) {
        index = ctx.OpIAdd(ctx.U32[1], index, ctx.Const(index_offset));
    }
-    return ctx.uses_explicit_workgroup_layout
+    return ctx.profile.support_explicit_workgroup_layout
               ? ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, ctx.u32_zero_value, index)
               : ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, index);
 }
@@ -158,7 +155,7 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 }

 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
-    if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_int64_atomics && ctx.profile.support_explicit_workgroup_layout) {
        const Id shift_id{ctx.Const(3U)};
        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
        const Id pointer{
@@ -624,14 +624,12 @@ Id EmitRenderArea(EmitContext& ctx) {
 }

 Id EmitLoadLocal(EmitContext& ctx, Id word_offset) {
-    const Id pointer{
-        ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset, ctx.Const(0U))};
+    const Id pointer{ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset)};
    return ctx.OpLoad(ctx.U32[1], pointer);
 }

 void EmitWriteLocal(EmitContext& ctx, Id word_offset, Id value) {
-    const Id pointer{
-        ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset, ctx.Const(0U))};
+    const Id pointer{ctx.OpAccessChain(ctx.private_u32, ctx.local_memory, word_offset)};
    ctx.OpStore(pointer, value);
 }

@@ -15,56 +15,8 @@
 namespace Shader::Backend::SPIRV {
 namespace {

-enum class NonUniformKind {
-    SampledImage,
-    StorageImage,
-    UniformTexelBuffer,
-    StorageTexelBuffer,
-};
-
-[[nodiscard]] bool IsNonUniformSupported(const Profile& profile, NonUniformKind kind) noexcept {
-    switch (kind) {
-    case NonUniformKind::SampledImage:
-        return profile.support_sampled_image_array_nonuniform_indexing;
-    case NonUniformKind::StorageImage:
-        return profile.support_storage_image_array_nonuniform_indexing;
-    case NonUniformKind::UniformTexelBuffer:
-        return profile.support_uniform_texel_buffer_array_nonuniform_indexing;
-    case NonUniformKind::StorageTexelBuffer:
-        return profile.support_storage_texel_buffer_array_nonuniform_indexing;
-    }
-    return false;
-}
-
-void DecorateNonUniform(EmitContext& ctx, Id object) {
-    if (ctx.non_uniform_ids.contains(object.value)) {
-        return;
-    }
-    ctx.Decorate(object, spv::Decoration::NonUniform);
-    ctx.non_uniform_ids.insert(object.value);
-}
-
-[[nodiscard]] bool MarkNonUniform(EmitContext& ctx, Id idx, const IR::Value& index,
-                                  NonUniformKind kind) {
-    if (index.IsImmediate() || !IsNonUniformSupported(ctx.profile, kind)) {
-        return false;
-    }
-    DecorateNonUniform(ctx, idx);
-    switch (kind) {
-    case NonUniformKind::SampledImage:
-        ctx.uses_nonuniform_sampled_image = true;
-        break;
-    case NonUniformKind::StorageImage:
-        ctx.uses_nonuniform_storage_image = true;
-        break;
-    case NonUniformKind::UniformTexelBuffer:
-        ctx.uses_nonuniform_uniform_texel_buffer = true;
-        break;
-    case NonUniformKind::StorageTexelBuffer:
-        ctx.uses_nonuniform_storage_texel_buffer = true;
-        break;
-    }
-    return true;
+[[nodiscard]] bool IsNonUniformDescriptor(EmitContext& ctx, const IR::Value& index) noexcept {
+    return ctx.profile.support_sampled_image_array_nonuniform_indexing && !index.IsImmediate();
 }

 class ImageOperands {
@@ -243,13 +195,12 @@ Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IR
    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
    if (def.count > 1) {
        auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);
-        const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::SampledImage)};
+        if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {
+            ctx.Decorate(idx, spv::Decoration::NonUniform);
+            ctx.non_uniform_ids.insert(idx.value);
+        }
        const Id pointer{ctx.OpAccessChain(def.pointer_type, def.id, idx)};
        const Id object{ctx.OpLoad(def.sampled_type, pointer)};
-        if (non_uniform) {
-            DecorateNonUniform(ctx, pointer);
-            DecorateNonUniform(ctx, object);
-        }
        return object;
    } else {
        return ctx.OpLoad(def.sampled_type, def.id);
@@ -261,30 +212,21 @@ Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& ind
        const TextureBufferDefinition& def{ctx.texture_buffers.at(info.descriptor_index)};
        if (def.count > 1) {
            const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};
-            const bool non_uniform{
-                MarkNonUniform(ctx, idx, index, NonUniformKind::UniformTexelBuffer)};
            const Id ptr{ctx.OpAccessChain(ctx.image_buffer_type, def.id, idx)};
-            const Id object{ctx.OpLoad(ctx.image_buffer_type, ptr)};
-            if (non_uniform) {
-                DecorateNonUniform(ctx, ptr);
-                DecorateNonUniform(ctx, object);
-            }
-            return object;
+            return ctx.OpLoad(ctx.image_buffer_type, ptr);
        }
        return ctx.OpLoad(ctx.image_buffer_type, def.id);
    } else {
        const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
        if (def.count > 1) {
            auto const idx = index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index);
-            const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::SampledImage)};
+            if (!ctx.non_uniform_ids.contains(idx.value) && IsNonUniformDescriptor(ctx, index)) {
+                ctx.Decorate(idx, spv::Decoration::NonUniform);
+                ctx.non_uniform_ids.insert(idx.value);
+            }
            const Id ptr = ctx.OpAccessChain(def.pointer_type, def.id, idx);
            const Id object = ctx.OpLoad(def.sampled_type, ptr);
            const Id image = ctx.OpImage(def.image_type, object);
-            if (non_uniform) {
-                DecorateNonUniform(ctx, ptr);
-                DecorateNonUniform(ctx, object);
-                DecorateNonUniform(ctx, image);
-            }
            return image;
        }
        return ctx.OpImage(def.image_type, ctx.OpLoad(def.sampled_type, def.id));
@@ -296,29 +238,16 @@ std::pair<Id, bool> Image(EmitContext& ctx, const IR::Value& index, IR::TextureI
        const ImageBufferDefinition def{ctx.image_buffers.at(info.descriptor_index)};
        if (def.count > 1) {
            const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};
-            const bool non_uniform{
-                MarkNonUniform(ctx, idx, index, NonUniformKind::StorageTexelBuffer)};
            const Id ptr{ctx.OpAccessChain(def.pointer_type, def.id, idx)};
-            const Id image{ctx.OpLoad(def.image_type, ptr)};
-            if (non_uniform) {
-                DecorateNonUniform(ctx, ptr);
-                DecorateNonUniform(ctx, image);
-            }
-            return {image, def.is_integer};
+            return {ctx.OpLoad(def.image_type, ptr), def.is_integer};
        }
        return {ctx.OpLoad(def.image_type, def.id), def.is_integer};
    } else {
        const ImageDefinition def{ctx.images.at(info.descriptor_index)};
        if (def.count > 1) {
            const Id idx{index.IsImmediate() ? ctx.Const(index.U32()) : ctx.Def(index)};
-            const bool non_uniform{MarkNonUniform(ctx, idx, index, NonUniformKind::StorageImage)};
            const Id ptr{ctx.OpAccessChain(def.pointer_type, def.id, idx)};
-            const Id image{ctx.OpLoad(def.image_type, ptr)};
-            if (non_uniform) {
-                DecorateNonUniform(ctx, ptr);
-                DecorateNonUniform(ctx, image);
-            }
-            return {image, def.is_integer};
+            return {ctx.OpLoad(def.image_type, ptr), def.is_integer};
        }
        return {ctx.OpLoad(def.image_type, def.id), def.is_integer};
    }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -622,8 +622,6 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam
                   Id segmentation_mask);
 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                        Id segmentation_mask);
-Id EmitQuadBroadcast(EmitContext& ctx, Id value, Id lane);
-Id EmitQuadSwap(EmitContext& ctx, Id value, Id direction);
 Id EmitFSwizzleAdd(EmitContext& ctx, Id op_a, Id op_b, Id swizzle);
 Id EmitDPdxFine(EmitContext& ctx, Id op_a);
 Id EmitDPdyFine(EmitContext& ctx, Id op_a);
@@ -159,7 +159,7 @@ void EmitWriteGlobal128(EmitContext& ctx, Id address, Id value) {
 }

 Id EmitLoadStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&
+    if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit &&
        ctx.profile.support_descriptor_aliasing) {
        return ctx.OpUConvert(ctx.U32[1],
                              LoadStorage(ctx, binding, offset, ctx.U8, ctx.storage_types.U8,
@@ -171,7 +171,7 @@ Id EmitLoadStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value
 }

 Id EmitLoadStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&
+    if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit &&
        ctx.profile.support_descriptor_aliasing) {
        return ctx.OpSConvert(ctx.U32[1],
                              LoadStorage(ctx, binding, offset, ctx.S8, ctx.storage_types.S8,
@@ -183,7 +183,7 @@ Id EmitLoadStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value
 }

 Id EmitLoadStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&
+    if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit &&
        ctx.profile.support_descriptor_aliasing) {
        return ctx.OpUConvert(ctx.U32[1],
                              LoadStorage(ctx, binding, offset, ctx.U16, ctx.storage_types.U16,
@@ -195,7 +195,7 @@ Id EmitLoadStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Valu
 }

 Id EmitLoadStorageS16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
-    if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&
+    if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit &&
        ctx.profile.support_descriptor_aliasing) {
        return ctx.OpSConvert(ctx.U32[1],
                              LoadStorage(ctx, binding, offset, ctx.S16, ctx.storage_types.S16,
@@ -234,8 +234,7 @@ Id EmitLoadStorage128(EmitContext& ctx, const IR::Value& binding, const IR::Valu

 void EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                        Id value) {
-    if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&
-        ctx.profile.support_descriptor_aliasing) {
+    if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit) {
        WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.U8, value), ctx.storage_types.U8,
                     sizeof(u8), &StorageDefinitions::U8);
    } else {
@@ -245,8 +244,7 @@ void EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Va

 void EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                        Id value) {
-    if (ctx.profile.support_int8 && ctx.profile.support_storage_buffer_8bit &&
-        ctx.profile.support_descriptor_aliasing) {
+    if (ctx.profile.support_int8 && ctx.profile.support_uniform_and_storage_buffer_8bit) {
        WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.S8, value), ctx.storage_types.S8,
                     sizeof(s8), &StorageDefinitions::S8);
    } else {
@@ -256,8 +254,7 @@ void EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, const IR::Va

 void EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                         Id value) {
-    if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&
-        ctx.profile.support_descriptor_aliasing) {
+    if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit) {
        WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.U16, value), ctx.storage_types.U16,
                     sizeof(u16), &StorageDefinitions::U16);
    } else {
@@ -267,8 +264,7 @@ void EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, const IR::V

 void EmitWriteStorageS16(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                         Id value) {
-    if (ctx.profile.support_int16 && ctx.profile.support_storage_buffer_16bit &&
-        ctx.profile.support_descriptor_aliasing) {
+    if (ctx.profile.support_int16 && ctx.profile.support_uniform_and_storage_buffer_16bit) {
        WriteStorage(ctx, binding, offset, ctx.OpSConvert(ctx.S16, value), ctx.storage_types.S16,
                     sizeof(s16), &StorageDefinitions::S16);
    } else {
@@ -31,7 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace

 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
        return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U8, pointer));
@@ -42,7 +42,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
        return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U8, pointer));
@@ -53,7 +53,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
    } else {
@@ -63,7 +63,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
    } else {
@@ -73,7 +73,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
        return ctx.OpLoad(ctx.U32[1], pointer);
    } else {
@@ -82,7 +82,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        return ctx.OpLoad(ctx.U32[2], pointer);
    } else {
@@ -97,7 +97,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        return ctx.OpLoad(ctx.U32[4], pointer);
    }
@@ -113,7 +113,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }

 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
        ctx.OpStore(pointer, ctx.OpUConvert(ctx.U8, value));
@@ -123,7 +123,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
    } else {
@@ -133,7 +133,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {

 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
    Id pointer{};
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
    } else {
        const Id shift{ctx.Const(2U)};
@@ -144,7 +144,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        ctx.OpStore(pointer, value);
        return;
@@ -159,7 +159,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
-    if (ctx.uses_explicit_workgroup_layout) {
+    if (ctx.profile.support_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        ctx.OpStore(pointer, value);
        return;
@@ -260,21 +260,6 @@ 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{GetThreadId(ctx)};
@@ -371,7 +371,7 @@ Id CasFunction(EmitContext& ctx, Operation operation, Id value_type) {
 Id CasLoop(EmitContext& ctx, Operation operation, Id array_pointer, Id element_pointer,
           Id value_type, Id memory_type, spv::Scope scope) {
    const bool is_shared{scope == spv::Scope::Workgroup};
-    const bool is_struct{!is_shared || ctx.uses_explicit_workgroup_layout};
+    const bool is_struct{!is_shared || ctx.profile.support_explicit_workgroup_layout};
    const Id cas_func{CasFunction(ctx, operation, value_type)};
    const Id zero{ctx.u32_zero_value};
    const Id scope_id{ctx.Const(static_cast<u32>(scope))};
@@ -591,8 +591,7 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
        return;
    }
    const u32 num_elements{Common::DivCeil(program.local_memory_size, 4U)};
-    const Id element_type{TypeStruct(U32[1])};
-    const Id type{TypeArray(element_type, Const(num_elements))};
+    const Id type{TypeArray(U32[1], Const(num_elements))};
    const Id pointer{TypePointer(spv::StorageClass::Private, type)};
    local_memory = AddGlobalVariable(pointer, spv::StorageClass::Private);
    if (profile.supported_spirv >= 0x00010400) {
@@ -601,10 +600,6 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
 }

 void EmitContext::DefineSharedMemory(const IR::Program& program) {
-    uses_explicit_workgroup_layout =
-        profile.support_explicit_workgroup_layout &&
-        (!program.info.uses_int8 || profile.support_workgroup_layout_8bit_access) &&
-        (!program.info.uses_int16 || profile.support_workgroup_layout_16bit_access);
    if (program.shared_memory_size == 0) {
        return;
    }
@@ -625,18 +620,18 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {

        return std::make_tuple(variable, element_pointer, pointer);
    }};
-    if (uses_explicit_workgroup_layout) {
+    if (profile.support_explicit_workgroup_layout) {
        AddExtension("SPV_KHR_workgroup_memory_explicit_layout");
        AddCapability(spv::Capability::WorkgroupMemoryExplicitLayoutKHR);
-        if (program.info.uses_int8 && profile.support_int8) {
+        if (program.info.uses_int8) {
            AddCapability(spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR);
            std::tie(shared_memory_u8, shared_u8, std::ignore) = make(U8, 1);
        }
-        if (program.info.uses_int16 && profile.support_int16) {
+        if (program.info.uses_int16) {
            AddCapability(spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR);
            std::tie(shared_memory_u16, shared_u16, std::ignore) = make(U16, 2);
        }
-        if (program.info.uses_int64 && profile.support_int64) {
+        if (program.info.uses_int64) {
            std::tie(shared_memory_u64, shared_u64, std::ignore) = make(U64, 8);
        }
        std::tie(shared_memory_u32, shared_u32, shared_memory_u32_type) = make(U32[1], 4);
@@ -1234,17 +1229,16 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
    }
    AddExtension("SPV_KHR_storage_buffer_storage_class");

-    IR::Type used_types{profile.support_descriptor_aliasing ? info.used_storage_buffer_types
-                                                            : IR::Type::U32};
-    used_types |= IR::Type::U32;
-    if (profile.support_int8 && profile.support_storage_buffer_8bit &&
+    const IR::Type used_types{profile.support_descriptor_aliasing ? info.used_storage_buffer_types
+                                                                  : IR::Type::U32};
+    if (profile.support_int8 && profile.support_uniform_and_storage_buffer_8bit &&
        True(used_types & IR::Type::U8)) {
        DefineSsbos(*this, storage_types.U8, &StorageDefinitions::U8, info, binding, U8,
                    sizeof(u8));
        DefineSsbos(*this, storage_types.S8, &StorageDefinitions::S8, info, binding, S8,
                    sizeof(u8));
    }
-    if (profile.support_int16 && profile.support_storage_buffer_16bit &&
+    if (profile.support_int16 && profile.support_uniform_and_storage_buffer_16bit &&
        True(used_types & IR::Type::U16)) {
        DefineSsbos(*this, storage_types.U16, &StorageDefinitions::U16, info, binding, U16,
                    sizeof(u16));
@@ -311,7 +311,6 @@ public:

    Id local_memory{};

-    bool uses_explicit_workgroup_layout{};
    Id shared_memory_u8{};
    Id shared_memory_u16{};
    Id shared_memory_u32{};
@@ -372,11 +371,6 @@ public:
    // Sirit::Id doesn't play nice with *::set<>
    ankerl::unordered_dense::set<u32> non_uniform_ids;

-    bool uses_nonuniform_sampled_image{};
-    bool uses_nonuniform_storage_image{};
-    bool uses_nonuniform_uniform_texel_buffer{};
-    bool uses_nonuniform_storage_texel_buffer{};
-
 private:
    void DefineCommonTypes(const Info& info);
    void DefineCommonConstants();
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

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

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

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

@@ -10,7 +10,7 @@ namespace Shader::IR {

 namespace Detail {

-OpcodeMeta META_TABLE[] = {
+OpcodeMeta META_TABLE[532] = {
 #define OPCODE(name_token, type_token, ...)                                                        \
    {                                                                                              \
        .name{#name_token},                                                                        \
@@ -21,7 +21,7 @@ OpcodeMeta META_TABLE[] = {
 #undef OPCODE
 };

-u8 NUM_ARGS[] = {
+u8 NUM_ARGS[532] = {
 #define OPCODE(name_token, type_token, ...) u8(CalculateNumArgsOf(Opcode::name_token)),
 #include "opcodes.inc"
 #undef OPCODE
@@ -57,12 +57,12 @@ static constexpr Type F64x2{Type::F64x2};
 static constexpr Type F64x3{Type::F64x3};
 static constexpr Type F64x4{Type::F64x4};

-extern OpcodeMeta META_TABLE[];
+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)));
 }
-extern u8 NUM_ARGS[];
+extern u8 NUM_ARGS[532];
 } // namespace Detail

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

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

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -39,6 +39,17 @@ IR::U32 scaleIndex(IR::IREmitter& ir, IR::U32 index, Shift shift) {
    }
 }

+IR::U32 skewBytes(IR::IREmitter& ir, SZ sizeRead) {
+    const IR::U32 lane = ir.LaneId();
+    switch (sizeRead) {
+        case SZ::U8:  return lane;
+        case SZ::U16: return ir.ShiftLeftLogical(lane, ir.Imm32(1));
+        case SZ::U32:
+        case SZ::F32: return ir.ShiftLeftLogical(lane, ir.Imm32(2));
+        default: UNREACHABLE();
+    }
+}
+
 } // Anonymous namespace

 void TranslatorVisitor::ISBERD(u64 insn) {
@@ -57,41 +68,61 @@ void TranslatorVisitor::ISBERD(u64 insn) {
        BitField<47, 2, Shift> shift;
    } const isberd{insn};

-    if (isberd.skew != 0) {
-        throw NotImplementedException("ISBERD SKEW");
-    }
-    if (isberd.o != 0) {
-        throw NotImplementedException("ISBERD O");
-    }
-    if (isberd.sz.Value() > SZ::F32) {
-        throw NotImplementedException("ISBERD SZ {}",
-                                      static_cast<u64>(isberd.sz.Value()));
-    }
-    if (isberd.shift.Value() > Shift::B32) {
-        throw NotImplementedException("ISBERD Shift {}",
-                                      static_cast<u64>(isberd.shift.Value()));
+    IR::U32 index{};
+    if (isberd.src_reg_num.Value() == 0xFF) {
+        index = ir.Imm32(isberd.imm.Value());
+    } else {
+        const IR::U32 scaledIndex = scaleIndex(ir, X(isberd.src_reg.Value()), isberd.shift.Value());
+        index = ir.IAdd(scaledIndex, ir.Imm32(isberd.imm.Value()));
    }

-    switch (isberd.mode.Value()) {
-    case Mode::Default:
-        X(isberd.dest_reg.Value(), X(isberd.src_reg.Value()));
-        return;
-    case Mode::Attr: {
-        IR::U32 offset{};
-        if (isberd.src_reg_num.Value() == 0xFF) {
-            offset = ir.Imm32(isberd.imm.Value());
-        } else {
-            const IR::U32 index{
-                scaleIndex(ir, X(isberd.src_reg.Value()), isberd.shift.Value())};
-            offset = ir.IAdd(index, ir.Imm32(isberd.imm.Value()));
+    if (isberd.o.Value()) {
+        if (isberd.skew.Value()) {
+            index = ir.IAdd(index, skewBytes(ir, isberd.sz.Value()));
        }
-        X(isberd.dest_reg.Value(), ir.BitCast<IR::U32>(ir.GetAttributeIndexed(offset)));
+
+        const IR::U64 index64 = ir.UConvert(64, index);
+        IR::U32 globalLoaded{};
+        switch (isberd.sz.Value()) {
+        case SZ::U8:  globalLoaded = ir.LoadGlobalU8 (index64); break;
+        case SZ::U16: globalLoaded = ir.LoadGlobalU16(index64); break;
+        case SZ::U32:
+        case SZ::F32: globalLoaded = ir.LoadGlobal32(index64);  break;
+        default: UNREACHABLE();
+        }
+        X(isberd.dest_reg.Value(), globalLoaded);
+
        return;
    }
-    default:
-        throw NotImplementedException("ISBERD Mode {}",
-                                      static_cast<u64>(isberd.mode.Value()));
+
+    if (isberd.mode.Value() != Mode::Default) {
+        if (isberd.skew.Value()) {
+            index = ir.IAdd(index, skewBytes(ir, SZ::U32));
+        }
+
+        IR::F32 float_index{};
+        switch (isberd.mode.Value()) {
+        case Mode::Patch: float_index = ir.GetPatch(index.Patch());
+            break;
+        case Mode::Prim:  float_index = ir.GetAttribute(index.Attribute());
+            break;
+        case Mode::Attr:  float_index = ir.GetAttributeIndexed(index);
+            break;
+        default: UNREACHABLE();
+        }
+        X(isberd.dest_reg.Value(), ir.BitCast<IR::U32>(float_index));
+
+        return;
    }
+
+    if (isberd.skew.Value()) {
+        X(isberd.dest_reg.Value(), ir.IAdd(X(isberd.src_reg.Value()), ir.LaneId()));
+
+        return;
+    }
+
+    // Fallback copy
+    X(isberd.dest_reg.Value(), X(isberd.src_reg.Value()));
 }

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

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

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

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

 } // namespace Shader::Maxwell
@@ -498,10 +498,6 @@ void VisitUsages(Info& info, IR::Inst& inst) {
    case IR::Opcode::ShuffleButterfly:
        info.uses_subgroup_shuffles = true;
        break;
-    case IR::Opcode::QuadBroadcast:
-    case IR::Opcode::QuadSwap:
-        info.uses_quad_shuffles = true;
-        break;
    case IR::Opcode::GetCbufU8:
    case IR::Opcode::GetCbufS8:
    case IR::Opcode::GetCbufU16:
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

@@ -184,72 +181,6 @@ void ShiftRightArithmetic64To32(IR::Block& block, IR::Inst& inst) {
    inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));
 }

-void IAbs64To32(IR::Block& block, IR::Inst& inst) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    const auto [lo, hi]{Unpack(ir, inst.Arg(0))};
-
-    const IR::U32 neg_lo{ir.IAdd(ir.BitwiseNot(lo), ir.Imm32(1))};
-    const IR::U32 carry{IR::U32{ir.Select(ir.GetCarryFromOp(neg_lo), ir.Imm32(1u), ir.Imm32(0u))}};
-    const IR::U32 neg_hi{ir.IAdd(ir.BitwiseNot(hi), carry)};
-
-    const IR::U1 is_negative{ir.INotEqual(ir.BitwiseAnd(hi, ir.Imm32(0x80000000u)), ir.Imm32(0u))};
-    const IR::U32 ret_lo{IR::U32{ir.Select(is_negative, neg_lo, lo)}};
-    const IR::U32 ret_hi{IR::U32{ir.Select(is_negative, neg_hi, hi)}};
-    inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));
-}
-
-void SelectU64To32(IR::Block& block, IR::Inst& inst) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    const IR::U1 condition{inst.Arg(0)};
-    const auto [true_lo, true_hi]{Unpack(ir, inst.Arg(1))};
-    const auto [false_lo, false_hi]{Unpack(ir, inst.Arg(2))};
-
-    const IR::U32 ret_lo{IR::U32{ir.Select(condition, true_lo, false_lo)}};
-    const IR::U32 ret_hi{IR::U32{ir.Select(condition, true_hi, false_hi)}};
-    inst.ReplaceUsesWith(ir.CompositeConstruct(ret_lo, ret_hi));
-}
-
-void UndefU64To32(IR::Block& block, IR::Inst& inst) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    inst.ReplaceUsesWith(ir.CompositeConstruct(ir.Imm32(0u), ir.Imm32(0u)));
-}
-
-void ConvertU64U32To32(IR::Block& block, IR::Inst& inst) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    inst.ReplaceUsesWith(ir.CompositeConstruct(IR::U32{inst.Arg(0)}, ir.Imm32(0u)));
-}
-
-void ConvertU32U64To32(IR::Block& block, IR::Inst& inst) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    inst.ReplaceUsesWith(Unpack(ir, inst.Arg(0)).first);
-}
-
-void IntToFloat64To32(IR::Block& block, IR::Inst& inst, bool is_signed, size_t dest_bitsize) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    const auto [lo, hi]{Unpack(ir, inst.Arg(0))};
-    const IR::F32 low{ir.ConvertUToF(32, 32, lo)};
-    const IR::F32 high{is_signed ? IR::F32{ir.ConvertSToF(32, 32, hi)}
-                                 : IR::F32{ir.ConvertUToF(32, 32, hi)}};
-    const IR::F32 combined{ir.FPFma(high, ir.Imm32(4294967296.0f), low)};
-    if (dest_bitsize == 32) {
-        inst.ReplaceUsesWith(combined);
-    } else {
-        inst.ReplaceUsesWith(ir.FPConvert(dest_bitsize, combined));
-    }
-}
-
-void FloatToInt64To32(IR::Block& block, IR::Inst& inst, bool is_signed, size_t src_bitsize) {
-    IR::IREmitter ir(block, IR::Block::InstructionList::s_iterator_to(inst));
-    const IR::F32 value{src_bitsize == 32 ? IR::F32{inst.Arg(0)}
-                                          : IR::F32{ir.FPConvert(32, IR::F16F32F64{inst.Arg(0)})}};
-    const IR::F32 high_f{ir.FPFloor(ir.FPMul(value, ir.Imm32(1.0f / 4294967296.0f)))};
-    const IR::U32 hi{is_signed ? IR::U32{ir.ConvertFToS(32, high_f)}
-                               : IR::U32{ir.ConvertFToU(32, high_f)}};
-    const IR::F32 low_f{ir.FPFma(high_f, ir.FPNeg(ir.Imm32(4294967296.0f)), value)};
-    const IR::U32 lo{IR::U32{ir.ConvertFToU(32, low_f)}};
-    inst.ReplaceUsesWith(ir.CompositeConstruct(lo, hi));
-}
-
 void Lower(IR::Block& block, IR::Inst& inst) {
    switch (inst.GetOpcode()) {
    case IR::Opcode::PackUint2x32:
@@ -287,62 +218,6 @@ void Lower(IR::Block& block, IR::Inst& inst) {
        return inst.ReplaceOpcode(IR::Opcode::GlobalAtomicXor32x2);
    case IR::Opcode::GlobalAtomicExchange64:
        return inst.ReplaceOpcode(IR::Opcode::GlobalAtomicExchange32x2);
-    case IR::Opcode::StorageAtomicIAdd64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicIAdd32x2);
-    case IR::Opcode::StorageAtomicSMin64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicSMin32x2);
-    case IR::Opcode::StorageAtomicUMin64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicUMin32x2);
-    case IR::Opcode::StorageAtomicSMax64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicSMax32x2);
-    case IR::Opcode::StorageAtomicUMax64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicUMax32x2);
-    case IR::Opcode::StorageAtomicAnd64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicAnd32x2);
-    case IR::Opcode::StorageAtomicOr64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicOr32x2);
-    case IR::Opcode::StorageAtomicXor64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicXor32x2);
-    case IR::Opcode::StorageAtomicExchange64:
-        return inst.ReplaceOpcode(IR::Opcode::StorageAtomicExchange32x2);
-    case IR::Opcode::BitCastU64F64:
-        return inst.ReplaceOpcode(IR::Opcode::UnpackDouble2x32);
-    case IR::Opcode::BitCastF64U64:
-        return inst.ReplaceOpcode(IR::Opcode::PackDouble2x32);
-    case IR::Opcode::UndefU64:
-        return UndefU64To32(block, inst);
-    case IR::Opcode::SelectU64:
-        return SelectU64To32(block, inst);
-    case IR::Opcode::IAbs64:
-        return IAbs64To32(block, inst);
-    case IR::Opcode::ConvertU64U32:
-        return ConvertU64U32To32(block, inst);
-    case IR::Opcode::ConvertU32U64:
-        return ConvertU32U64To32(block, inst);
-    case IR::Opcode::ConvertS64F16:
-        return FloatToInt64To32(block, inst, true, 16);
-    case IR::Opcode::ConvertS64F32:
-        return FloatToInt64To32(block, inst, true, 32);
-    case IR::Opcode::ConvertS64F64:
-        return FloatToInt64To32(block, inst, true, 64);
-    case IR::Opcode::ConvertU64F16:
-        return FloatToInt64To32(block, inst, false, 16);
-    case IR::Opcode::ConvertU64F32:
-        return FloatToInt64To32(block, inst, false, 32);
-    case IR::Opcode::ConvertU64F64:
-        return FloatToInt64To32(block, inst, false, 64);
-    case IR::Opcode::ConvertF16S64:
-        return IntToFloat64To32(block, inst, true, 16);
-    case IR::Opcode::ConvertF32S64:
-        return IntToFloat64To32(block, inst, true, 32);
-    case IR::Opcode::ConvertF64S64:
-        return IntToFloat64To32(block, inst, true, 64);
-    case IR::Opcode::ConvertF16U64:
-        return IntToFloat64To32(block, inst, false, 16);
-    case IR::Opcode::ConvertF32U64:
-        return IntToFloat64To32(block, inst, false, 32);
-    case IR::Opcode::ConvertF64U64:
-        return IntToFloat64To32(block, inst, false, 64);
    default:
        break;
    }
@@ -18,10 +18,8 @@ struct Profile {
    bool support_descriptor_aliasing{};
    bool support_int8{};
    bool support_uniform_and_storage_buffer_8bit{};
-    bool support_storage_buffer_8bit{};
    bool support_int16{};
    bool support_uniform_and_storage_buffer_16bit{};
-    bool support_storage_buffer_16bit{};
    bool support_int64{};
    bool support_vertex_instance_id{};
    bool support_float_controls{};
@@ -35,10 +33,6 @@ struct Profile {
    bool support_fp32_signed_zero_nan_preserve{};
    bool support_fp64_signed_zero_nan_preserve{};
    bool support_explicit_workgroup_layout{};
-    bool support_workgroup_layout_8bit_access{};
-    bool support_workgroup_layout_16bit_access{};
-    bool support_shader_quad_control{};
-    bool support_quad_shuffles{};
    bool support_vote{};
    u32 supported_subgroup_stages{0x7F};
    bool support_viewport_index_layer_non_geometry{};
@@ -46,7 +40,6 @@ struct Profile {
    bool support_typeless_image_loads{};
    bool support_demote_to_helper_invocation{};
    bool support_int64_atomics{};
-    bool support_shared_int64_atomics{};
    bool support_derivative_control{};
    bool support_geometry_shader_passthrough{};
    bool support_native_ndc{};
@@ -61,9 +54,6 @@ struct Profile {
    bool support_multi_viewport{};
    bool support_geometry_streams{};
    bool support_sampled_image_array_nonuniform_indexing{};
-    bool support_storage_image_array_nonuniform_indexing{};
-    bool support_uniform_texel_buffer_array_nonuniform_indexing{};
-    bool support_storage_texel_buffer_array_nonuniform_indexing{};

    bool warp_size_potentially_larger_than_guest{};

@@ -252,7 +252,6 @@ struct Info {
    bool uses_is_helper_invocation{};
    bool uses_subgroup_invocation_id{};
    bool uses_subgroup_shuffles{};
-    bool uses_quad_shuffles{};
    std::array<bool, 30> uses_patches{};

    std::array<Interpolation, 32> interpolation{};
@@ -33,7 +33,7 @@ add_library(video_core STATIC
    control/channel_state_cache.h
    control/scheduler.cpp
    control/scheduler.h
-    deferred_destruction_queue.h
+    delayed_destruction_ring.h
    dirty_flags.cpp
    dirty_flags.h
    dma_pusher.cpp
@@ -158,8 +158,6 @@ add_library(video_core STATIC
    renderer_vulkan/vk_compute_pass.h
    renderer_vulkan/vk_compute_pipeline.cpp
    renderer_vulkan/vk_compute_pipeline.h
-    renderer_vulkan/vk_descriptor_buffer.cpp
-    renderer_vulkan/vk_descriptor_buffer.h
    renderer_vulkan/vk_descriptor_pool.cpp
    renderer_vulkan/vk_descriptor_pool.h
    renderer_vulkan/vk_fence_manager.cpp
@@ -121,21 +121,12 @@ public:
        return size_bytes;
    }

-    u64 getWriteTick() const noexcept {
-        return write_tick;
-    }
-
-    void setWriteTick(u64 write_tick_) {
-        write_tick = write_tick_;
-    }
-
 private:
    VAddr cpu_addr = 0;
    BufferFlagBits flags{};
    int stream_score = 0;
    size_t lru_id = SIZE_MAX;
    size_t size_bytes = 0;
-    u64 write_tick = 0;
 };

 } // namespace VideoCommon
@@ -7,7 +7,6 @@
 #pragma once

 #include <algorithm>
-#include <bit>
 #include <memory>
 #include <numeric>

@@ -32,84 +31,44 @@ BufferCache<P>::BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, R
    immediately_free = (Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Aggressive);
 #endif
    if (!runtime.CanReportMemoryUsage()) {
-        memory_budget = FALLBACK_MEMORY_BUDGET;
+        minimum_memory = DEFAULT_EXPECTED_MEMORY;
+        critical_memory = DEFAULT_CRITICAL_MEMORY;
        return;
    }

-    memory_budget = runtime.GetDeviceLocalMemory();
+    const s64 device_local_memory = static_cast<s64>(runtime.GetDeviceLocalMemory());
+    const s64 min_spacing_expected = device_local_memory - 1_GiB;
+    const s64 min_spacing_critical = device_local_memory - 512_MiB;
+    const s64 mem_threshold = (std::min)(device_local_memory, TARGET_THRESHOLD);
+    const s64 min_vacancy_expected = (6 * mem_threshold) / 10;
+    const s64 min_vacancy_critical = (2 * mem_threshold) / 10;
+    minimum_memory = static_cast<u64>(
+        (std::max)((std::min)(device_local_memory - min_vacancy_expected, min_spacing_expected),
+                 DEFAULT_EXPECTED_MEMORY));
+    critical_memory = static_cast<u64>(
+        (std::max)((std::min)(device_local_memory - min_vacancy_critical, min_spacing_critical),
+                 DEFAULT_CRITICAL_MEMORY));
 }

 template <class P>
 BufferCache<P>::~BufferCache() = default;

 template <class P>
-u64 BufferCache<P>::DeviceUsage(bool force_refresh) {
-    if (!runtime.CanReportMemoryUsage()) {
-        return total_used_memory;
-    }
-    if (force_refresh || usage_refresh_countdown == 0) {
-        cached_device_usage = runtime.GetDeviceAllocationUsage();
-        usage_refresh_countdown = USAGE_REFRESH_INTERVAL;
-    } else {
-        --usage_refresh_countdown;
-    }
-    return cached_device_usage;
-}
-
-template <class P>
-u64 BufferCache<P>::ReclaimMemory(u64 target_bytes, bool allow_download) {
-    if (target_bytes == 0 || in_reclaim) {
-        return 0;
-    }
-    in_reclaim = true;
-    u64 freed = 0;
-    const auto clean_up = [&](BufferId buffer_id) {
-        if (freed >= target_bytes) {
+void BufferCache<P>::RunGarbageCollector() {
+    const bool aggressive_gc = total_used_memory >= critical_memory;
+    const u64 ticks_to_destroy = aggressive_gc ? 60 : 120;
+    int num_iterations = aggressive_gc ? 64 : 32;
+    const auto clean_up = [this, &num_iterations](BufferId buffer_id) {
+        if (num_iterations == 0) {
            return true;
        }
+        --num_iterations;
        auto& buffer = slot_buffers[buffer_id];
-        if (!allow_download && IsRegionGpuModified(buffer.CpuAddr(), buffer.SizeBytes())) {
-            return false;
-        }
-        const u64 buffer_bytes = Common::AlignUp(buffer.SizeBytes(), 1024);
        DownloadBufferMemory(buffer);
        DeleteBuffer(buffer_id);
-        freed += buffer_bytes;
        return false;
    };
-    const u64 cold_tick =
-        frame_tick > RECLAIM_GUARD_FRAMES ? frame_tick - RECLAIM_GUARD_FRAMES : 0;
-    lru_cache.ForEachItemBelow(cold_tick, clean_up);
-    if (freed == 0) {
-        lru_cache.ForEachItemBelow(frame_tick > 0 ? frame_tick - 1 : 0, clean_up);
-    }
-    in_reclaim = false;
-    usage_refresh_countdown = 0;
-    reclaim_stalled = freed == 0;
-    if (freed > 0) {
-        reclaim_wait_sync_point = runtime.CurrentSyncPoint();
-    }
-    return freed;
-}
-
-template <class P>
-void BufferCache<P>::EnsureHeadroom(bool allow_download) {
-    if (reclaim_stalled) {
-        return;
-    }
-    if (runtime.CompletedSyncPoint() < reclaim_wait_sync_point) {
-        return;
-    }
-    const u64 limit = memory_budget > RECLAIM_HEADROOM ? memory_budget - RECLAIM_HEADROOM : 0;
-    const u64 usage = DeviceUsage(false);
-    if (usage <= limit) {
-        return;
-    }
-    const u64 target = (limit / 100) * RECLAIM_TARGET_PERCENT;
-    const u64 excess = usage - target;
-    const u64 usage_mib = (std::max)(usage >> 20, u64{1});
-    const u64 share = (((excess >> 20) * (total_used_memory >> 20)) / usage_mib) << 20;
-    ReclaimMemory((std::min)(share, total_used_memory), allow_download);
+    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, clean_up);
 }

 template <class P>
@@ -137,11 +96,15 @@ void BufferCache<P>::TickFrame() {
    const bool skip_preferred = hits * 256 < shots * 251;
    channel_state->uniform_buffer_skip_cache_size = skip_preferred ? DEFAULT_SKIP_CACHE_SIZE : 0;

-    usage_refresh_countdown = 0;
-    reclaim_stalled = false;
-    EnsureHeadroom(true);
+    // If we can obtain the memory info, use it instead of the estimate.
+    if (runtime.CanReportMemoryUsage()) {
+        total_used_memory = runtime.GetDeviceMemoryUsage();
+    }
+    if (total_used_memory >= minimum_memory) {
+        RunGarbageCollector();
+    }
    ++frame_tick;
-    sentenced_buffers.Reclaim(runtime.CompletedSyncPoint());
+    delayed_destruction_ring.Tick();

    for (auto& buffer : async_buffers_death_ring) {
        runtime.FreeDeferredStagingBuffer(buffer);
@@ -212,71 +175,9 @@ std::optional<VideoCore::RasterizerDownloadArea> BufferCache<P>::GetFlushArea(DA

 template <class P>
 void BufferCache<P>::DownloadMemory(DAddr device_addr, u64 size) {
-    if constexpr (!USE_MEMORY_MAPS) {
-        std::scoped_lock lock{mutex};
-        ForEachBufferInRange(device_addr, size, [&](BufferId, Buffer& buffer) {
-            DownloadBufferMemory(buffer, device_addr, size);
-        });
-        return;
-    }
-
-    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 8> downloads;
-    u64 total_size_bytes = 0;
-    u64 largest_copy = 0;
-
-    std::unique_lock lock{mutex};
-    ForEachBufferInRange(device_addr, size, [&](BufferId buffer_id, Buffer& buffer) {
-        memory_tracker.ForEachDownloadRangeAndClear(
-            device_addr, size, [&](u64 device_addr_out, u64 range_size) {
-                const DAddr buffer_addr = buffer.CpuAddr();
-                const auto add_download = [&](DAddr start, DAddr end) {
-                    const u64 new_offset = start - buffer_addr;
-                    const u64 new_size = end - start;
-                    downloads.push_back({
-                        BufferCopy{
-                            .src_offset = new_offset,
-                            .dst_offset = total_size_bytes,
-                            .size = new_size,
-                        },
-                        buffer_id,
-                    });
-                    constexpr u64 align = 64ULL;
-                    constexpr u64 mask = ~(align - 1ULL);
-                    total_size_bytes += (new_size + align - 1) & mask;
-                    largest_copy = (std::max)(largest_copy, new_size);
-                };
-                gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, add_download);
-                ClearDownload(device_addr_out, range_size);
-                gpu_modified_ranges.Subtract(device_addr_out, range_size);
-            });
+    ForEachBufferInRange(device_addr, size, [&](BufferId, Buffer& buffer) {
+        DownloadBufferMemory(buffer, device_addr, size);
    });
-    if (total_size_bytes == 0) {
-        return;
-    }
-
-    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
-    boost::container::small_vector<BufferCopy, 8> writebacks;
-    runtime.PreCopyBarrier();
-    for (auto& [copy, buffer_id] : downloads) {
-        copy.dst_offset += download_staging.offset;
-        Buffer& buffer = slot_buffers[buffer_id];
-        buffer.MarkUsage(copy.src_offset, copy.size);
-        const std::array copies{copy};
-        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
-        BufferCopy writeback{copy};
-        writeback.src_offset = static_cast<u64>(buffer.CpuAddr()) + copy.src_offset;
-        writebacks.push_back(writeback);
-    }
-    runtime.PostCopyBarrier();
-    lock.unlock();
-
-    runtime.Finish();
-    const u8* const base = download_staging.mapped_span.data();
-    for (const BufferCopy& writeback : writebacks) {
-        const u64 staging_offset = writeback.dst_offset - download_staging.offset;
-        device_memory.WriteBlockUnsafe(static_cast<DAddr>(writeback.src_offset),
-                                       base + staging_offset, writeback.size);
-    }
 }

 template <class P>
@@ -313,7 +214,7 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
    auto& src_buffer = slot_buffers[buffer_a];
    auto& dest_buffer = slot_buffers[buffer_b];
    SynchronizeBuffer(src_buffer, *cpu_src_address, static_cast<u32>(amount));
-    memory_tracker.UnmarkRegionAsCpuModified(*cpu_dest_address, static_cast<u32>(amount));
+    SynchronizeBuffer(dest_buffer, *cpu_dest_address, static_cast<u32>(amount));
    std::array copies{BufferCopy{
        .src_offset = src_buffer.Offset(*cpu_src_address),
        .dst_offset = dest_buffer.Offset(*cpu_dest_address),
@@ -772,44 +673,32 @@ void BufferCache<P>::PopAsyncFlushes() {

 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
-    struct Writeback {
-        DAddr addr;
-        const u8* src;
-        u64 size;
-    };
-    boost::container::small_vector<Writeback, 8> writebacks;
-    {
-        std::scoped_lock lock{mutex};
-        if (async_buffers.empty()) {
-            return;
-        }
-        if (!async_buffers.front().has_value()) {
-            async_buffers.pop_front();
-            return;
-        }
-        auto& downloads = pending_downloads.front();
-        auto& async_buffer = async_buffers.front();
-        const u8* base = async_buffer->mapped_span.data();
-        const size_t base_offset = async_buffer->offset;
-        for (const auto& copy : downloads) {
-            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-            const u64 dst_offset = copy.dst_offset - base_offset;
-            const u8* read_mapped_memory = base + dst_offset;
-            async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-                writebacks.push_back(
-                    {start, &read_mapped_memory[start - device_addr], end - start});
-            });
-            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-                gpu_modified_ranges.Subtract(start, end - start);
-            });
-        }
-        async_buffers_death_ring.emplace_back(*async_buffer);
+    if (async_buffers.empty()) {
+        return;
+    }
+    if (!async_buffers.front().has_value()) {
        async_buffers.pop_front();
-        pending_downloads.pop_front();
+        return;
    }
-    for (const auto& wb : writebacks) {
-        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
+    auto& downloads = pending_downloads.front();
+    auto& async_buffer = async_buffers.front();
+    u8* base = async_buffer->mapped_span.data();
+    const size_t base_offset = async_buffer->offset;
+    for (const auto& copy : downloads) {
+        const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+        const u64 dst_offset = copy.dst_offset - base_offset;
+        const u8* read_mapped_memory = base + dst_offset;
+        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
+                                           end - start);
+        });
+        async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+            gpu_modified_ranges.Subtract(start, end - start);
+        });
    }
+    async_buffers_death_ring.emplace_back(*async_buffer);
+    async_buffers.pop_front();
+    pending_downloads.pop_front();
 }

 template <class P>
@@ -920,46 +809,46 @@ void BufferCache<P>::BindHostVertexBuffers() {

    if (use_optimized_vertex_buffers) {
        auto& flags = maxwell3d->dirty.flags;
-        const u32 enabled_mask = enabled_vertex_buffers_mask;
-        bool any_dirty = false;
-        u32 pending_mask = enabled_mask;
-        while (pending_mask != 0) {
-            const u32 index = std::countr_zero(pending_mask);
-            pending_mask &= (pending_mask - 1);
+        u32 enabled_mask = enabled_vertex_buffers_mask;
+        HostBindings<Buffer> bindings{};
+        u32 last_index = (std::numeric_limits<u32>::max)();
+        const auto flush_bindings = [&]() {
+            if (bindings.buffers.empty()) {
+                return;
+            }
+            bindings.max_index = bindings.min_index + static_cast<u32>(bindings.buffers.size());
+            runtime.BindVertexBuffers(bindings);
+            bindings = HostBindings<Buffer>{};
+            last_index = (std::numeric_limits<u32>::max)();
+        };
+        while (enabled_mask != 0) {
+            const u32 index = std::countr_zero(enabled_mask);
+            enabled_mask &= (enabled_mask - 1);
            const Binding& binding = VertexBufferSlot(index);
            Buffer& buffer = slot_buffers[binding.buffer_id];
            TouchBuffer(buffer, binding.buffer_id);
            SynchronizeBuffer(buffer, binding.device_addr, binding.size);
-            any_dirty |= flags[Dirty::VertexBuffer0 + index];
-        }
-        if (enabled_mask == 0 || !any_dirty) {
-            return;
-        }
-        const u32 min_index = static_cast<u32>(std::countr_zero(enabled_mask));
-        const u32 max_index = 32u - static_cast<u32>(std::countl_zero(enabled_mask));
-        HostBindings<Buffer> bindings{};
-        bindings.min_index = min_index;
-        bindings.max_index = max_index;
-        for (u32 index = min_index; index < max_index; ++index) {
-            flags[Dirty::VertexBuffer0 + index] = false;
-            const u32 stride = maxwell3d->regs.vertex_streams[index].stride;
-            if ((enabled_mask & (1u << index)) == 0) {
-                bindings.buffers.push_back(&slot_buffers[NULL_BUFFER_ID]);
-                bindings.offsets.push_back(0);
-                bindings.sizes.push_back(0);
-                bindings.strides.push_back(stride);
+            if (!flags[Dirty::VertexBuffer0 + index]) {
+                flush_bindings();
                continue;
            }
-            const Binding& binding = VertexBufferSlot(index);
-            Buffer& buffer = slot_buffers[binding.buffer_id];
+            flags[Dirty::VertexBuffer0 + index] = false;
+            const u32 stride = maxwell3d->regs.vertex_streams[index].stride;
            const u32 offset = buffer.Offset(binding.device_addr);
            buffer.MarkUsage(offset, binding.size);
+            if (!bindings.buffers.empty() && index != last_index + 1) {
+                flush_bindings();
+            }
+            if (bindings.buffers.empty()) {
+                bindings.min_index = index;
+            }
            bindings.buffers.push_back(&buffer);
            bindings.offsets.push_back(offset);
            bindings.sizes.push_back(binding.size);
            bindings.strides.push_back(stride);
+            last_index = index;
        }
-        runtime.BindVertexBuffers(bindings);
+        flush_bindings();
    } else {
        HostBindings<typename P::Buffer> host_bindings;
        bool any_valid{false};
@@ -1032,6 +921,7 @@ void BufferCache<P>::BindHostGraphicsUniformBuffers(size_t stage) {

 template <class P>
 void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32 binding_index, bool needs_bind) {
+    ++channel_state->uniform_cache_shots[0];
    const Binding& binding = channel_state->uniform_buffers[stage][index];
    const DAddr device_addr = binding.device_addr;
    const u32 size = (std::min)(binding.size, (*channel_state->uniform_buffer_sizes)[stage][index]);
@@ -1050,12 +940,8 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
            return alignment > 1 && (offset % alignment) != 0;
        }
    }();
-
-    const bool cached_buffer_is_current =
-        has_host_buffer && !memory_tracker.IsRegionCpuModified(device_addr, size);
    const bool use_fast_buffer = needs_alignment_stream
-        || (has_host_buffer && !cached_buffer_is_current
-            && size <= channel_state->uniform_buffer_skip_cache_size
+        || (has_host_buffer && size <= channel_state->uniform_buffer_skip_cache_size
            && !memory_tracker.IsRegionGpuModified(device_addr, size));
    if (use_fast_buffer) {
        if constexpr (IS_OPENGL) {
@@ -1082,7 +968,7 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
        device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
        return;
    }
-    ++channel_state->uniform_cache_shots[0];
+    // Classic cached path
    if (SynchronizeBuffer(buffer, device_addr, size)) {
        ++channel_state->uniform_cache_hits[0];
    }
@@ -1544,10 +1430,6 @@ void BufferCache<P>::UpdateComputeTextureBuffers() {

 template <class P>
 void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) {
-    if constexpr (!IS_OPENGL) {
-        Buffer& buffer = slot_buffers[buffer_id];
-        buffer.setWriteTick(runtime.CurrentTick());
-    }
    memory_tracker.MarkRegionAsGpuModified(device_addr, size);
    gpu_modified_ranges.Add(device_addr, size);
    uncommitted_gpu_modified_ranges.Add(device_addr, size);
@@ -1560,32 +1442,16 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size) {
    }
    const u64 page = device_addr >> CACHING_PAGEBITS;
    const BufferId buffer_id = page_table[page];
-    if (buffer_id) {
-        Buffer& buffer = slot_buffers[buffer_id];
-        WaitForGpuFenceIfNeeded(buffer);
-        if (buffer.IsInBounds(device_addr, size)) {
-            return buffer_id;
-        }
+    if (!buffer_id) {
+        return CreateBuffer(device_addr, size);
+    }
+    const Buffer& buffer = slot_buffers[buffer_id];
+    if (buffer.IsInBounds(device_addr, size)) {
+        return buffer_id;
    }
    return CreateBuffer(device_addr, size);
 }

-template <class P>
-void BufferCache<P>::WaitForGpuFenceIfNeeded(Buffer& buffer) {
-    if constexpr (!IS_OPENGL) {
-        const bool gpu_fence_accurate = Settings::IsGPUFenceBehaviorAccurate();
-        const bool gpu_fence_strict = Settings::IsGPUFenceBehaviorStrict();
-        if (gpu_fence_accurate || gpu_fence_strict) {
-            const u64 gpu_tick_delay = gpu_fence_strict ? 0 : 3;
-            const u64 buffer_tick = buffer.getWriteTick();
-            const u64 gpu_tick = runtime.KnownGpuTick();
-            if (buffer_tick > gpu_tick + gpu_tick_delay) {
-                runtime.Wait(buffer_tick);
-            }
-        }
-    }
-}
-
 template <class P>
 typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(DAddr device_addr,
                                                                       u32 wanted_size) {
@@ -1690,7 +1556,6 @@ void BufferCache<P>::JoinOverlap(BufferId new_buffer_id, BufferId overlap_id,

 template <class P>
 BufferId BufferCache<P>::CreateBuffer(DAddr device_addr, u32 wanted_size) {
-    EnsureHeadroom(false);
    DAddr device_addr_end = Common::AlignUp(device_addr + wanted_size, CACHING_PAGESIZE);
    device_addr = Common::AlignDown(device_addr, CACHING_PAGESIZE);
    wanted_size = static_cast<u32>(device_addr_end - device_addr);
@@ -1728,7 +1593,7 @@ void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
        total_used_memory += Common::AlignUp(size, 1024);
        buffer.setLRUID(lru_cache.Insert(buffer_id, frame_tick));
    } else {
-        total_used_memory -= std::min<u64>(total_used_memory, Common::AlignUp(size, 1024));
+        total_used_memory -= Common::AlignUp(size, 1024);
        lru_cache.Free(buffer.getLRUID());
    }
    const DAddr device_addr_begin = buffer.CpuAddr();
@@ -1769,6 +1634,17 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
    if (total_size_bytes == 0) {
        return true;
    }
+    if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
+        u64 min_offset = (std::numeric_limits<u64>::max)();
+        u64 max_offset = 0;
+        for (const auto& copy : upload_copies) {
+            min_offset = (std::min)(min_offset, copy.dst_offset);
+            max_offset = (std::max)(max_offset, copy.dst_offset + copy.size);
+        }
+        const DAddr sync_addr = buffer.CpuAddr() + min_offset;
+        const u64 sync_size = max_offset - min_offset;
+        DownloadBufferMemory(buffer, sync_addr, sync_size);
+    }
    const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
    UploadMemory(buffer, total_size_bytes, largest_copy, copies_span);
    any_buffer_uploaded = true;
@@ -1803,9 +1679,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
                if (immediate_buffer.empty()) {
                    immediate_buffer = ImmediateBuffer(largest_copy);
                }
-                if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                    DownloadBufferMemory(buffer, device_addr, copy.size);
-                }
                device_memory.ReadBlockUnsafe(device_addr, immediate_buffer.data(), copy.size);
                upload_span = immediate_buffer.subspan(0, copy.size);
            }
@@ -1814,80 +1687,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
    }
 }

-template <class P>
-bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
-                                              [[maybe_unused]] std::span<BufferCopy> copies) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        const u8* const physical_base = device_memory.GetPhysicalBase();
-        const u64 unified_size = runtime.UnifiedMemorySize();
-        const u64 window_size = runtime.UnifiedMemoryWindowSize();
-        if (window_size == 0) {
-            return false;
-        }
-        boost::container::small_vector<u64, 4> window_ids;
-        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4> groups;
-        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
-            for (size_t i = 0; i < window_ids.size(); ++i) {
-                if (window_ids[i] == window) {
-                    return groups[i];
-                }
-            }
-            window_ids.push_back(window);
-            groups.emplace_back();
-            return groups.back();
-        };
-        for (const BufferCopy& copy : copies) {
-            const DAddr device_addr = buffer.CpuAddr() + copy.src_offset;
-            u64 downloaded = 0;
-            while (downloaded < copy.size) {
-                const DAddr page_addr = device_addr + downloaded;
-                const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
-                if (ptr == nullptr) {
-                    return false;
-                }
-                const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
-                u64 chunk = (std::min)(copy.size - downloaded,
-                                       static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
-                const u64 phys_offset = static_cast<u64>(ptr - physical_base);
-                if (phys_offset + chunk > unified_size) {
-                    return false;
-                }
-                const u64 window = phys_offset / window_size;
-                const u64 local_offset = phys_offset % window_size;
-                chunk = (std::min)(chunk, window_size - local_offset);
-                auto& group = group_for(window);
-                if (!group.empty()) {
-                    BufferCopy& last = group.back();
-                    if (last.src_offset + last.size == copy.src_offset + downloaded &&
-                        last.dst_offset + last.size == local_offset) {
-                        last.size += chunk;
-                        downloaded += chunk;
-                        continue;
-                    }
-                }
-                group.push_back(BufferCopy{
-                    .src_offset = copy.src_offset + downloaded,
-                    .dst_offset = local_offset,
-                    .size = chunk,
-                });
-                downloaded += chunk;
-            }
-        }
-        for (const BufferCopy& copy : copies) {
-            buffer.MarkUsage(copy.src_offset, copy.size);
-        }
-        for (size_t i = 0; i < window_ids.size(); ++i) {
-            const std::span<BufferCopy> group_span(groups[i].data(), groups[i].size());
-            runtime.CopyBuffer(runtime.UnifiedMemoryWindowBuffer(window_ids[i]), buffer,
-                               group_span, true);
-        }
-        runtime.Finish();
-        return true;
-    } else {
-        return false;
-    }
-}
-
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                        [[maybe_unused]] u64 total_size_bytes,
@@ -1898,9 +1697,6 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
        for (BufferCopy& copy : copies) {
            u8* const src_pointer = staging_pointer.data() + copy.src_offset;
            const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
-            if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                DownloadBufferMemory(buffer, device_addr, copy.size);
-            }
            device_memory.ReadBlockUnsafe(device_addr, src_pointer, copy.size);
            // Apply the staging offset
            copy.src_offset += upload_staging.offset;
@@ -1991,12 +1787,6 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
    }

    if constexpr (USE_MEMORY_MAPS) {
-        if constexpr (USE_UNIFIED_MEMORY) {
-            if (runtime.HasUnifiedMemory() &&
-                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
-                return;
-            }
-        }
        auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
        const u8* const mapped_memory = download_staging.mapped_span.data();
        const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
@@ -2067,7 +1857,7 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
 #ifdef YUZU_LEGACY
    if (!do_not_mark || !immediately_free)
 #endif
-        sentenced_buffers.Push(std::move(slot_buffers[buffer_id]), runtime.CurrentSyncPoint());
+        delayed_destruction_ring.Push(std::move(slot_buffers[buffer_id]));

    slot_buffers.erase(buffer_id);

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
crueter	b79f2d0d1c	Formatting Signed-off-by: crueter <crueter@eden-emu.dev>	2026-07-10 00:57:36 -04:00
crueter	ef28a394db	Fix common build Signed-off-by: crueter <crueter@eden-emu.dev>	2026-07-09 23:44:58 -04:00
crueter	8ba132c927	WIP: [cmake] Use a debloated boost distribution Should speed up fetch time Signed-off-by: crueter <crueter@eden-emu.dev>	2026-07-09 19:37:50 -04:00