[shader_recompiler, spir-v] Coalesce storage emission

user doesn't need it and just wastes resources
Signed-off-by: lizzie <lizzie@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3293
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: DraVee <dravee@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

.patch/mbedtls/0002-arm64-aes-fix.patch

@@ -13,7 +13,7 @@ index 50f2a29..c60d9dc 100644
  #define MBEDTLS_HAVE_NEON_INTRINSICS
 -#elif defined(MBEDTLS_PLATFORM_IS_WINDOWS_ON_ARM64)
 -#include <arm64_neon.h>
-+#elif defined(__ANDROID__) || defined(__ARM_NEON)
++#elif (defined(__ANDROID__) && defined(__ARM_FP)) || defined(__ARM_NEON)
 +#include <arm_neon.h>
  #define MBEDTLS_HAVE_NEON_INTRINSICS
  #endif

README.md

@@ -15,8 +15,8 @@
   <br>
 </h1>
 
-<h4 align="center"><b>Eden</b> is an open-source Nintendo Switch emulator, forked from the Yuzu emulator — started by former Citron developer Camille LaVey and the Eden team.
-It is written in C++ with portability in mind, and we actively maintain builds for Windows, Linux and Android.
+<h4 align="center"><b>Eden</b> is a free and opensource (FOSS) Switch 1 emulator, derived from Yuzu and Sudachi - started by developer Camille LaVey.
+It's written in C++ with portability in mind, with builds for Windows, Linux, macOS, Android, FreeBSD and more.
 </h4>
 
 <p align="center">

dist/dev.eden_emu.eden.desktop

@@ -9,7 +9,7 @@ Version=1.0
 Type=Application
 Name=Eden
 GenericName=Switch Emulator
-Comment=Nintendo Switch video game console emulator
+Comment=Multiplatform FOSS Switch 1 emulator written in C++, derived from Yuzu and Sudachi
 Icon=dev.eden_emu.eden
 TryExec=eden
 Exec=eden %f

dist/dev.eden_emu.eden.metainfo.xml

@@ -16,7 +16,7 @@ SPDX-License-Identifier: CC0-1.0
   <name>eden</name>
   <summary>Nintendo Switch emulator</summary>
   <description>
-    <p>Nintendo Switch video game console emulator</p>
+    <p>Multiplatform FOSS Switch 1 emulator written in C++, derived from Yuzu and Sudachi</p>
   </description>
   <categories>
     <category>Game</category>

docs/build/Android.md

@@ -76,12 +76,12 @@ The APK and AAB will be output into "artifacts".
 
 Examples:
 
-* Build legacy release with update checker for ChromeOS:
-  * `.ci/android/build.sh -c -r -t legacy`
+* Build legacy release with update checker:
+  * `.ci/android/build.sh -r -t legacy`
 * Build standard release with debug info without update checker for phones:
   * `.ci/android/build.sh -b RelWithDebInfo`
-* Build optimized release with update checker:
-  * `.ci/android/build.sh -r -t optimized`
+* Build optimized release with update checker for ChromeOS:
+  * `.ci/android/build.sh -c -r -t optimized`
 
 ### Additional Resources
 

externals/cpmfile.json

@@ -71,9 +71,9 @@
         "hash": "9697e80a7d5d9bcb3ce51051a9a24962fb90ca79d215f1f03ae6b58da8ba13a63b5dda1b4dde3d26ac6445029696b8ef2883f4e5a777b342bba01283ed293856"
     },
     "libadrenotools": {
-        "repo": "bylaws/libadrenotools",
-        "sha": "8fae8ce254",
-        "hash": "db4a74ce15559c75e01d1868a90701519b655d77f2a343bbee283a42f8332dc9046960fb022dc969f205e457348a3f99cb8be6e1cd91264d2ae1235294b9f9b2",
+        "repo": "eden-emulator/libadrenotools",
+        "sha": "8ba23b42d7",
+        "hash": "f6526620cb752876edc5ed4c0925d57b873a8218ee09ad10859ee476e9333259784f61c1dcc55a2bcba597352d18aff22cd2e4c1925ec2ae94074e09d7da2265",
         "patches": [
             "0001-linkerns-cpm.patch"
         ]
@@ -180,8 +180,8 @@
     "discord-rpc": {
         "package": "DiscordRPC",
         "repo": "eden-emulator/discord-rpc",
-        "sha": "1cf7772bb6",
-        "hash": "9a6c35887dcacceb4ba1bf3141edb73b05b2abc719a8d81dad9cb9dd5b039ce203946787335d9d738af669c10cf2534638b645635a22096fc28dcae2475e0cbe",
+        "sha": "0d8b2d6a37",
+        "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3",
         "find_args": "MODULE"
     },
     "simpleini": {

src/CMakeLists.txt

@@ -7,8 +7,7 @@
 include_directories(.)
 
 # Dynarmic
-if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64))
-    set(DYNARMIC_IGNORE_ASSERTS ON)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
     add_subdirectory(dynarmic)
     add_library(dynarmic::dynarmic ALIAS dynarmic)
 endif()

src/android/app/src/main/java/org/yuzu/yuzu_emu/YuzuApplication.kt

@@ -61,6 +61,11 @@ class YuzuApplication : Application() {
         application = this
         documentsTree = DocumentsTree()
         DirectoryInitialization.start()
+
+        // Initialize Freedreno config BEFORE loading native library
+        // This ensures GPU driver environment variables are set before adrenotools initializes
+        GpuDriverHelper.initializeFreedrenoConfigEarly()
+
         NativeLibrary.playTimeManagerInit()
         GpuDriverHelper.initializeDriverParameters()
         NativeInput.reloadInputDevices()

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/FreedrenoPresetAdapter.kt

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.adapters
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import org.yuzu.yuzu_emu.utils.FreedrenoPreset
+import org.yuzu.yuzu_emu.databinding.ListItemFreedrenoPresetBinding
+
+/**
+ * Adapter for displaying Freedreno preset configurations in a horizontal list.
+ */
+class FreedrenoPresetAdapter(
+    private val onPresetClicked: (FreedrenoPreset) -> Unit
+) : ListAdapter<FreedrenoPreset, FreedrenoPresetAdapter.PresetViewHolder>(DiffCallback) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PresetViewHolder {
+        val binding = ListItemFreedrenoPresetBinding.inflate(
+            LayoutInflater.from(parent.context),
+            parent,
+            false
+        )
+        return PresetViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: PresetViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class PresetViewHolder(private val binding: ListItemFreedrenoPresetBinding) :
+        RecyclerView.ViewHolder(binding.root) {
+
+        fun bind(preset: FreedrenoPreset) {
+            binding.presetButton.apply {
+                text = preset.name
+                setOnClickListener {
+                    onPresetClicked(preset)
+                }
+                contentDescription = "${preset.name}: ${preset.description}"
+            }
+        }
+    }
+
+    companion object {
+        private val DiffCallback = object : DiffUtil.ItemCallback<FreedrenoPreset>() {
+            override fun areItemsTheSame(oldItem: FreedrenoPreset, newItem: FreedrenoPreset): Boolean =
+                oldItem.name == newItem.name
+
+            override fun areContentsTheSame(oldItem: FreedrenoPreset, newItem: FreedrenoPreset): Boolean =
+                oldItem == newItem
+        }
+    }
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/FreedrenoVariableAdapter.kt

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.adapters
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import org.yuzu.yuzu_emu.databinding.ListItemFreedrenoVariableBinding
+import org.yuzu.yuzu_emu.fragments.FreedrenoVariable
+import org.yuzu.yuzu_emu.utils.NativeFreedrenoConfig
+
+/**
+ * Adapter for displaying currently set Freedreno environment variables in a list.
+ */
+class FreedrenoVariableAdapter(
+    private val context: Context,
+    private val onItemClicked: (FreedrenoVariable, () -> Unit) -> Unit
+) : ListAdapter<FreedrenoVariable, FreedrenoVariableAdapter.VariableViewHolder>(DiffCallback) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VariableViewHolder {
+        val binding = ListItemFreedrenoVariableBinding.inflate(
+            LayoutInflater.from(parent.context),
+            parent,
+            false
+        )
+        return VariableViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: VariableViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class VariableViewHolder(private val binding: ListItemFreedrenoVariableBinding) :
+        RecyclerView.ViewHolder(binding.root) {
+
+        fun bind(variable: FreedrenoVariable) {
+            binding.variableName.text = variable.name
+            binding.variableValue.text = variable.value
+
+            binding.buttonDelete.setOnClickListener {
+                onItemClicked(variable) {
+                    NativeFreedrenoConfig.clearFreedrenoEnv(variable.name)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val DiffCallback = object : DiffUtil.ItemCallback<FreedrenoVariable>() {
+            override fun areItemsTheSame(oldItem: FreedrenoVariable, newItem: FreedrenoVariable): Boolean =
+                oldItem.name == newItem.name
+
+            override fun areContentsTheSame(oldItem: FreedrenoVariable, newItem: FreedrenoVariable): Boolean =
+                oldItem == newItem
+        }
+    }
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt

@@ -27,6 +27,7 @@ object Settings {
         SECTION_APP_SETTINGS(R.string.app_settings),
         SECTION_CUSTOM_PATHS(R.string.preferences_custom_paths),
         SECTION_DEBUG(R.string.preferences_debug),
+        SECTION_FREEDRENO(R.string.gpu_driver_settings),
         SECTION_APPLETS(R.string.applets_menu);
     }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsAdapter.kt

@@ -29,6 +29,7 @@ import org.yuzu.yuzu_emu.databinding.ListItemSettingsHeaderBinding
 import org.yuzu.yuzu_emu.features.input.NativeInput
 import org.yuzu.yuzu_emu.features.input.model.AnalogDirection
 import org.yuzu.yuzu_emu.features.settings.model.AbstractIntSetting
+import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.view.*
 import org.yuzu.yuzu_emu.features.settings.ui.viewholder.*
 import org.yuzu.yuzu_emu.utils.ParamPackage
@@ -212,8 +213,15 @@ class SettingsAdapter(
     }
 
     fun onSubmenuClick(item: SubmenuSetting) {
-        val action = SettingsNavigationDirections.actionGlobalSettingsFragment(item.menuKey, null)
-        fragment.view?.findNavController()?.navigate(action)
+        // Check if this is the Freedreno Settings submenu
+        if (item.menuKey == Settings.MenuTag.SECTION_FREEDRENO) {
+            fragment.view?.findNavController()?.navigate(
+                R.id.action_settingsFragment_to_freedrenoSettingsFragment
+            )
+        } else {
+            val action = SettingsNavigationDirections.actionGlobalSettingsFragment(item.menuKey, null)
+            fragment.view?.findNavController()?.navigate(action)
+        }
     }
 
     fun onLaunchableClick(item: LaunchableSetting) {

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -27,6 +27,7 @@ import org.yuzu.yuzu_emu.features.settings.model.Settings.MenuTag
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
 import org.yuzu.yuzu_emu.features.settings.model.view.*
+import org.yuzu.yuzu_emu.utils.GpuDriverHelper
 import org.yuzu.yuzu_emu.utils.InputHandler
 import org.yuzu.yuzu_emu.utils.NativeConfig
 import org.yuzu.yuzu_emu.utils.DirectoryInitialization
@@ -109,6 +110,7 @@ class SettingsFragmentPresenter(
             MenuTag.SECTION_INPUT_PLAYER_EIGHT -> addInputPlayer(sl, 7)
             MenuTag.SECTION_APP_SETTINGS -> addThemeSettings(sl)
             MenuTag.SECTION_DEBUG -> addDebugSettings(sl)
+            MenuTag.SECTION_FREEDRENO -> addFreedrenoSettings(sl)
             MenuTag.SECTION_APPLETS -> addAppletSettings(sl)
             MenuTag.SECTION_CUSTOM_PATHS -> addCustomPathsSettings(sl)
         }
@@ -181,6 +183,16 @@ class SettingsFragmentPresenter(
                     menuKey = MenuTag.SECTION_DEBUG
                 )
             )
+            if (GpuDriverHelper.isAdrenoGpu() && !NativeConfig.isPerGameConfigLoaded()) {
+                add(
+                    SubmenuSetting(
+                        titleId = R.string.gpu_driver_settings,
+                        descriptionId = R.string.freedreno_settings_title,
+                        iconId = R.drawable.ic_graphics,
+                        menuKey = MenuTag.SECTION_FREEDRENO
+                    )
+                )
+            }
             add(
                 SubmenuSetting(
                     titleId = R.string.applets_menu,
@@ -498,6 +510,11 @@ class SettingsFragmentPresenter(
         }
     }
 
+    private fun addFreedrenoSettings(sl: ArrayList<SettingsItem>) {
+        // No additional settings needed here - the SubmenuSetting handles navigation
+        // This method is kept for consistency with other menu sections
+    }
+
     private fun addAppletSettings(sl: ArrayList<SettingsItem>) {
         sl.apply {
             add(IntSetting.SWKBD_APPLET.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/DriverFetcherFragment.kt

@@ -45,7 +45,7 @@ class DriverFetcherFragment : Fragment() {
     private val client = OkHttpClient()
 
     private val gpuModel: String?
-        get() = GpuDriverHelper.getGpuModel()
+        get() = GpuDriverHelper.hookLibPath?.let { GpuDriverHelper.getGpuModel(hookLibPath = it) }
 
     private val adrenoModel: Int
         get() = parseAdrenoModel()

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -87,6 +87,7 @@ import org.yuzu.yuzu_emu.utils.GameIconUtils
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
 import org.yuzu.yuzu_emu.utils.Log
 import org.yuzu.yuzu_emu.utils.NativeConfig
+import org.yuzu.yuzu_emu.utils.NativeFreedrenoConfig
 import org.yuzu.yuzu_emu.utils.ViewUtils
 import org.yuzu.yuzu_emu.utils.ViewUtils.setVisible
 import org.yuzu.yuzu_emu.utils.collect
@@ -303,6 +304,18 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                 throw fallbackException
             }
         }
+        try {
+            if (GpuDriverHelper.isAdrenoGpu()) {
+                val programIdHex = game!!.programIdHex
+                if (NativeFreedrenoConfig.loadPerGameConfigWithGlobalFallback(programIdHex)) {
+                    Log.info("[EmulationFragment] Loaded per-game Freedreno config for $programIdHex")
+                } else {
+                    Log.info("[EmulationFragment] Using global Freedreno config for $programIdHex")
+                }
+            }
+        } catch (e: Exception) {
+            Log.warning("[EmulationFragment] Failed to load Freedreno config: ${e.message}")
+        }
 
         emulationState = EmulationState(game!!.path) {
             return@EmulationState driverViewModel.isInteractionAllowed.value
@@ -616,7 +629,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
         Log.info("[EmulationFragment] Starting view setup for game: ${game?.title}")
 
-        gpuModel = GpuDriverHelper.getGpuModel().toString()
+        gpuModel = GpuDriverHelper.hookLibPath?.let { GpuDriverHelper.getGpuModel(hookLibPath = it).toString() } ?: "Unknown"
         fwVersion = NativeLibrary.firmwareVersion()
 
         updateQuickOverlayMenuEntry(BooleanSetting.SHOW_INPUT_OVERLAY.getBoolean())

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/FreedrenoSettingsFragment.kt

@@ -0,0 +1,204 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.fragments
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updatePadding
+import androidx.fragment.app.Fragment
+import androidx.navigation.fragment.navArgs
+import androidx.recyclerview.widget.LinearLayoutManager
+import com.google.android.material.snackbar.Snackbar
+import com.google.android.material.transition.MaterialSharedAxis
+import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.adapters.FreedrenoPresetAdapter
+import org.yuzu.yuzu_emu.adapters.FreedrenoVariableAdapter
+import org.yuzu.yuzu_emu.databinding.FragmentFreedrenoSettingsBinding
+import org.yuzu.yuzu_emu.model.Game
+import org.yuzu.yuzu_emu.utils.NativeFreedrenoConfig
+import org.yuzu.yuzu_emu.utils.FreedrenoPresets
+
+
+class FreedrenoSettingsFragment : Fragment() {
+    private var _binding: FragmentFreedrenoSettingsBinding? = null
+    private val binding get() = _binding!!
+    private val args by navArgs<FreedrenoSettingsFragmentArgs>()
+    private val game: Game? get() = args.game
+    private val isPerGameConfig: Boolean get() = game != null
+
+    private lateinit var presetAdapter: FreedrenoPresetAdapter
+    private lateinit var settingsAdapter: FreedrenoVariableAdapter
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enterTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
+        returnTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
+        reenterTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
+        exitTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentFreedrenoSettingsBinding.inflate(layoutInflater, container, false)
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        NativeFreedrenoConfig.setFreedrenoBasePath(requireContext().cacheDir.absolutePath)
+        NativeFreedrenoConfig.initializeFreedrenoConfig()
+
+        if (isPerGameConfig) {
+            NativeFreedrenoConfig.loadPerGameConfig(game!!.programIdHex)
+        } else {
+            NativeFreedrenoConfig.reloadFreedrenoConfig()
+        }
+
+        setupToolbar()
+        setupAdapters()
+        loadCurrentSettings()
+        setupButtonListeners()
+        setupWindowInsets()
+    }
+
+    private fun setupToolbar() {
+        binding.toolbarFreedreno.setNavigationOnClickListener {
+            requireActivity().onBackPressedDispatcher.onBackPressed()
+        }
+        if (isPerGameConfig) {
+            binding.toolbarFreedreno.title = getString(R.string.freedreno_per_game_title)
+            binding.toolbarFreedreno.subtitle = game!!.title
+        }
+    }
+
+    private fun setupAdapters() {
+        // Setup presets adapter (horizontal list)
+        presetAdapter = FreedrenoPresetAdapter { preset ->
+            applyPreset(preset)
+        }
+        binding.listFreedrenoPresets.apply {
+            adapter = presetAdapter
+            layoutManager = LinearLayoutManager(requireContext(), LinearLayoutManager.HORIZONTAL, false)
+        }
+        presetAdapter.submitList(FreedrenoPresets.ALL_PRESETS)
+
+        // Setup current settings adapter (vertical list)
+        settingsAdapter = FreedrenoVariableAdapter(requireContext()) { variable, onDelete ->
+            onDelete()
+            loadCurrentSettings() // Refresh list after deletion
+        }
+        binding.listFreedrenoSettings.apply {
+            adapter = settingsAdapter
+            layoutManager = LinearLayoutManager(requireContext())
+        }
+    }
+
+    private fun loadCurrentSettings() {
+        // Load all currently set environment variables
+        val variables = mutableListOf<FreedrenoVariable>()
+
+        // Common variables to check
+        val commonVars = listOf(
+            "TU_DEBUG", "FD_MESA_DEBUG", "IR3_SHADER_DEBUG",
+            "FD_RD_DUMP", "FD_RD_DUMP_FRAMES", "FD_RD_DUMP_TESTNAME",
+            "TU_BREADCRUMBS"
+        )
+
+        for (varName in commonVars) {
+            if (NativeFreedrenoConfig.isFreedrenoEnvSet(varName)) {
+                val value = NativeFreedrenoConfig.getFreedrenoEnv(varName)
+                variables.add(FreedrenoVariable(varName, value))
+            }
+        }
+
+        settingsAdapter.submitList(variables)
+    }
+
+    private fun setupButtonListeners() {
+        binding.buttonAddVariable.setOnClickListener {
+            val varName = binding.variableNameInput.text.toString().trim()
+            val varValue = binding.variableValueInput.text.toString().trim()
+
+            if (varName.isEmpty()) {
+                showSnackbar(getString(R.string.freedreno_error_empty_name))
+                return@setOnClickListener
+            }
+
+            if (NativeFreedrenoConfig.setFreedrenoEnv(varName, varValue)) {
+                showSnackbar(getString(R.string.freedreno_variable_added, varName))
+                binding.variableNameInput.text?.clear()
+                binding.variableValueInput.text?.clear()
+                loadCurrentSettings()
+            } else {
+                showSnackbar(getString(R.string.freedreno_error_setting_variable))
+            }
+        }
+
+        binding.buttonClearAll.setOnClickListener {
+            NativeFreedrenoConfig.clearAllFreedrenoEnv()
+            showSnackbar(getString(R.string.freedreno_cleared_all))
+            loadCurrentSettings()
+        }
+
+        binding.buttonSave.setOnClickListener {
+            if (isPerGameConfig) {
+                NativeFreedrenoConfig.savePerGameConfig(game!!.programIdHex)
+                showSnackbar(getString(R.string.freedreno_per_game_saved))
+            } else {
+                NativeFreedrenoConfig.saveFreedrenoConfig()
+                showSnackbar(getString(R.string.freedreno_saved))
+            }
+        }
+    }
+
+    private fun applyPreset(preset: org.yuzu.yuzu_emu.utils.FreedrenoPreset) {
+        // Clear all first for consistency
+        NativeFreedrenoConfig.clearAllFreedrenoEnv()
+
+        // Apply all variables in the preset
+        for ((varName, varValue) in preset.variables) {
+            NativeFreedrenoConfig.setFreedrenoEnv(varName, varValue)
+        }
+
+        showSnackbar(getString(R.string.freedreno_preset_applied, preset.name))
+        loadCurrentSettings()
+    }
+
+    private fun setupWindowInsets() {
+        ViewCompat.setOnApplyWindowInsetsListener(binding.root) { _, insets ->
+            val systemInsets = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+            binding.root.updatePadding(
+                left = systemInsets.left,
+                right = systemInsets.right,
+                bottom = systemInsets.bottom
+            )
+            insets
+        }
+    }
+
+    private fun showSnackbar(message: String) {
+        Snackbar.make(binding.root, message, Snackbar.LENGTH_SHORT).show()
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+}
+
+/**
+ * Data class representing a Freedreno environment variable.
+ */
+data class FreedrenoVariable(
+    val name: String,
+    val value: String
+)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt

@@ -325,6 +325,20 @@ class GamePropertiesFragment : Fragment() {
                     )
                 )
             }
+            if (GpuDriverHelper.isAdrenoGpu()) {
+                add(
+                    SubmenuProperty(
+                        R.string.freedreno_per_game_title,
+                        R.string.freedreno_per_game_description,
+                        R.drawable.ic_graphics,
+                        action = {
+                            val action = GamePropertiesFragmentDirections
+                                .actionPerGamePropertiesFragmentToFreedrenoSettingsFragment(args.game)
+                            binding.root.findNavController().navigate(action)
+                        }
+                    )
+                )
+            }
 
             if (!args.game.isHomebrew) {
                 add(

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GpuDriverHelper.kt

@@ -23,10 +23,16 @@ object GpuDriverHelper {
     private const val META_JSON_FILENAME = "meta.json"
     private var fileRedirectionPath: String? = null
     var driverInstallationPath: String? = null
-    private var hookLibPath: String? = null
+    internal var hookLibPath: String? = null
 
     val driverStoragePath get() = DirectoryInitialization.userDirectory!! + "/gpu_drivers/"
 
+    fun initializeFreedrenoConfigEarly() {
+        NativeFreedrenoConfig.setFreedrenoBasePath(YuzuApplication.appContext.cacheDir.absolutePath)
+        NativeFreedrenoConfig.initializeFreedrenoConfig()
+        NativeFreedrenoConfig.reloadFreedrenoConfig()
+    }
+
     fun initializeDriverParameters() {
         try {
             // Initialize the file redirection directory.
@@ -40,11 +46,9 @@ object GpuDriverHelper {
             throw RuntimeException(e)
         }
 
-        // Initialize directories.
         initializeDirectories()
-
-        // Initialize hook libraries directory.
         hookLibPath = YuzuApplication.appContext.applicationInfo.nativeLibraryDir + "/"
+        NativeFreedrenoConfig.reloadFreedrenoConfig()
 
         // Initialize GPU driver.
         NativeLibrary.initializeGpuDriver(
@@ -211,9 +215,17 @@ object GpuDriverHelper {
 
     external fun getGpuModel(
         surface: Surface = Surface(SurfaceTexture(true)),
-        hookLibPath: String = GpuDriverHelper.hookLibPath!!
+        hookLibPath: String
     ): String?
 
+    fun isAdrenoGpu(): Boolean {
+        return try {
+            supportsCustomDriverLoading()
+        } catch (e: Exception) {
+            false
+        }
+    }
+
     // Parse the custom driver metadata to retrieve the name.
     val installedCustomDriverData: GpuDriverMetadata
         get() = GpuDriverMetadata(File(driverInstallationPath + META_JSON_FILENAME))

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativeFreedrenoConfig.kt

@@ -0,0 +1,164 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.utils
+
+/**
+ * Provides access to Freedreno/Turnip driver configuration through JNI bindings.
+ *
+ * This class allows Java/Kotlin code to configure Freedreno environment variables
+ * for the GPU driver (Turnip/Freedreno) that runs in the emulator on Android.
+ *
+ * Variables must be set BEFORE starting emulation for them to take effect.
+ *
+ * See https://docs.mesa3d.org/drivers/freedreno.html for documentation.
+ */
+object NativeFreedrenoConfig {
+
+    @Synchronized
+    external fun setFreedrenoBasePath(basePath: String)
+
+    @Synchronized
+    external fun initializeFreedrenoConfig()
+
+    @Synchronized
+    external fun saveFreedrenoConfig()
+
+    @Synchronized
+    external fun reloadFreedrenoConfig()
+
+    @Synchronized
+    external fun setFreedrenoEnv(varName: String, value: String): Boolean
+
+    @Synchronized
+    external fun getFreedrenoEnv(varName: String): String
+
+    @Synchronized
+    external fun isFreedrenoEnvSet(varName: String): Boolean
+
+    @Synchronized
+    external fun clearFreedrenoEnv(varName: String): Boolean
+
+    @Synchronized
+    external fun clearAllFreedrenoEnv()
+
+    @Synchronized
+    external fun getFreedrenoEnvSummary(): String
+
+    @Synchronized
+    external fun setCurrentProgramId(programId: String)
+
+    @Synchronized
+    external fun loadPerGameConfig(programId: String): Boolean
+
+    @Synchronized
+    external fun loadPerGameConfigWithGlobalFallback(programId: String): Boolean
+
+    @Synchronized
+    external fun savePerGameConfig(programId: String): Boolean
+
+    @Synchronized
+    external fun hasPerGameConfig(programId: String): Boolean
+
+    @Synchronized
+    external fun deletePerGameConfig(programId: String): Boolean
+}
+
+/**
+ * Data class representing a Freedreno preset configuration.
+ * Presets are commonly used debugging/profiling configurations.
+ */
+data class FreedrenoPreset(
+    val name: String,           // Display name (e.g., "Debug - CPU Memory")
+    val description: String,    // Description of what this preset does
+    val icon: String,           // Icon identifier
+    val variables: Map<String, String> // Map of env vars to set
+)
+
+/**
+ * Predefined Freedreno presets for quick configuration.
+ */
+object FreedrenoPresets {
+
+    val DEBUG_CPU_MEMORY = FreedrenoPreset(
+        name = "Debug - CPU Memory",
+        description = "Use CPU memory (slower but more stable)",
+        icon = "ic_debug_cpu",
+        variables = mapOf(
+            "TU_DEBUG" to "sysmem"
+        )
+    )
+
+    val DEBUG_UBWC_DISABLED = FreedrenoPreset(
+        name = "Debug - No UBWC",
+        description = "Disable UBWC compression for debugging",
+        icon = "ic_debug_ubwc",
+        variables = mapOf(
+            "TU_DEBUG" to "noubwc"
+        )
+    )
+
+    val DEBUG_NO_BINNING = FreedrenoPreset(
+        name = "Debug - No Binning",
+        description = "Disable binning optimization",
+        icon = "ic_debug_bin",
+        variables = mapOf(
+            "TU_DEBUG" to "nobin"
+        )
+    )
+
+    val CAPTURE_RENDERPASS = FreedrenoPreset(
+        name = "Capture - Renderpass",
+        description = "Capture command stream data for debugging",
+        icon = "ic_capture",
+        variables = mapOf(
+            "FD_RD_DUMP" to "enable"
+        )
+    )
+
+    val CAPTURE_FRAMES = FreedrenoPreset(
+        name = "Capture - First 100 Frames",
+        description = "Capture command stream for first 100 frames only",
+        icon = "ic_capture",
+        variables = mapOf(
+            "FD_RD_DUMP" to "enable",
+            "FD_RD_DUMP_FRAMES" to "0-100"
+        )
+    )
+
+    val SHADER_DEBUG = FreedrenoPreset(
+        name = "Shader Debug",
+        description = "Enable IR3 shader compiler debugging",
+        icon = "ic_shader",
+        variables = mapOf(
+            "IR3_SHADER_DEBUG" to "nouboopt,spillall"
+        )
+    )
+
+    val GPU_HANG_TRACE = FreedrenoPreset(
+        name = "GPU Hang Trace",
+        description = "Trace GPU progress for debugging hangs",
+        icon = "ic_hang_trace",
+        variables = mapOf(
+            "TU_BREADCRUMBS" to "1"
+        )
+    )
+
+    val PERFORMANCE_DEFAULT = FreedrenoPreset(
+        name = "Performance - Default",
+        description = "Clear all debug options for performance",
+        icon = "ic_performance",
+        variables = emptyMap()  // Clears all when applied
+    )
+
+    val ALL_PRESETS = listOf(
+        DEBUG_CPU_MEMORY,
+        DEBUG_UBWC_DISABLED,
+        DEBUG_NO_BINNING,
+        CAPTURE_RENDERPASS,
+        CAPTURE_FRAMES,
+        SHADER_DEBUG,
+        GPU_HANG_TRACE,
+        PERFORMANCE_DEFAULT
+    )
+}

src/android/app/src/main/jni/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(yuzu-android SHARED
     native.cpp
     native.h
     native_config.cpp
+    native_freedreno.cpp
     android_settings.cpp
     game_metadata.cpp
     native_log.cpp

src/android/app/src/main/jni/native.cpp

@@ -730,11 +730,28 @@ jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_doesUpdateMatchProgram(JNIEnv* en
     return false;
 }
 
-void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeGpuDriver(JNIEnv* env, jclass clazz,
+void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeGpuDriver(JNIEnv* env,
+                                                                       [[maybe_unused]] jclass clazz,
                                                                        jstring hook_lib_dir,
                                                                        jstring custom_driver_dir,
                                                                        jstring custom_driver_name,
                                                                        jstring file_redirect_dir) {
+    // Log active Freedreno environment variables
+    const char* tu_debug = getenv("TU_DEBUG");
+    const char* fd_debug = getenv("FD_MESA_DEBUG");
+    const char* ir3_debug = getenv("IR3_SHADER_DEBUG");
+    const char* fd_rd_dump = getenv("FD_RD_DUMP");
+    const char* tu_breadcrumbs = getenv("TU_BREADCRUMBS");
+
+    if (tu_debug || fd_debug || ir3_debug || fd_rd_dump || tu_breadcrumbs) {
+        LOG_INFO(Frontend, "[Freedreno] Initializing GPU driver with configuration:");
+        if (tu_debug) LOG_INFO(Frontend, "[Freedreno]   TU_DEBUG={}", tu_debug);
+        if (fd_debug) LOG_INFO(Frontend, "[Freedreno]   FD_MESA_DEBUG={}", fd_debug);
+        if (ir3_debug) LOG_INFO(Frontend, "[Freedreno]   IR3_SHADER_DEBUG={}", ir3_debug);
+        if (fd_rd_dump) LOG_INFO(Frontend, "[Freedreno]   FD_RD_DUMP={}", fd_rd_dump);
+        if (tu_breadcrumbs) LOG_INFO(Frontend, "[Freedreno]   TU_BREADCRUMBS={}", tu_breadcrumbs);
+    }
+
     EmulationSession::GetInstance().InitializeGpuDriver(
         Common::Android::GetJString(env, hook_lib_dir),
         Common::Android::GetJString(env, custom_driver_dir),

src/android/app/src/main/jni/native_freedreno.cpp

@@ -0,0 +1,477 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * @file native_freedreno.cpp
+ * @brief JNI bindings for Freedreno/Turnip GPU driver configuration.
+ *
+ * Provides runtime configuration of Mesa Freedreno environment variables
+ * for the Turnip Vulkan driver on Adreno GPUs.
+ *
+ * @see https://docs.mesa3d.org/drivers/freedreno.html
+ */
+
+#include <algorithm>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <string>
+#include <sys/stat.h>
+
+#include <jni.h>
+
+#include "common/android/android_common.h"
+#include "common/logging/log.h"
+#include "native.h"
+
+namespace {
+
+struct FreedrenoConfig {
+    std::map<std::string, std::string> env_vars;
+    std::string config_file_path;
+};
+
+std::unique_ptr<FreedrenoConfig> g_config;
+std::string g_base_path;
+std::string g_current_program_id;
+
+constexpr const char* kConfigFileName = ".freedreno.conf";
+constexpr const char* kPerGameConfigDir = "freedreno_games";
+
+void LogActiveVariables() {
+    if (!g_config || g_config->env_vars.empty()) {
+        return;
+    }
+    for (const auto& [key, value] : g_config->env_vars) {
+        LOG_INFO(Frontend, "[Freedreno] {}={}", key, value);
+    }
+}
+
+bool ApplyEnvironmentVariable(const std::string& key, const std::string& value) {
+    if (setenv(key.c_str(), value.c_str(), 1) != 0) {
+        LOG_ERROR(Frontend, "[Freedreno] Failed to set {}={} (errno: {})", key, value, errno);
+        return false;
+    }
+    return true;
+}
+
+void ClearAllEnvironmentVariables() {
+    if (!g_config) return;
+    for (const auto& [key, value] : g_config->env_vars) {
+        unsetenv(key.c_str());
+    }
+    g_config->env_vars.clear();
+}
+
+std::string GetConfigPath() {
+    return g_base_path + "/" + kConfigFileName;
+}
+
+std::string GetPerGameConfigPath(const std::string& program_id) {
+    return g_base_path + "/" + kPerGameConfigDir + "/" + program_id + ".conf";
+}
+
+void EnsurePerGameConfigDir() {
+    std::string dir_path = g_base_path + "/" + kPerGameConfigDir;
+    mkdir(dir_path.c_str(), 0755);
+}
+
+bool LoadConfigFromFile(const std::string& config_path) {
+    if (!g_config) return false;
+
+    FILE* file = fopen(config_path.c_str(), "r");
+    if (!file) {
+        return false;
+    }
+
+    char line[512];
+    int count = 0;
+    while (fgets(line, sizeof(line), file)) {
+        size_t len = strlen(line);
+        if (len > 0 && line[len - 1] == '\n') {
+            line[len - 1] = '\0';
+            len--;
+        }
+
+        if (len == 0 || line[0] == '#') {
+            continue;
+        }
+
+        const char* eq = strchr(line, '=');
+        if (!eq) {
+            continue;
+        }
+
+        std::string key(line, eq - line);
+        std::string value(eq + 1);
+
+        g_config->env_vars[key] = value;
+        ApplyEnvironmentVariable(key, value);
+        count++;
+    }
+
+    fclose(file);
+    return count > 0;
+}
+
+bool SaveConfigToFile(const std::string& config_path) {
+    if (!g_config) return false;
+
+    FILE* file = fopen(config_path.c_str(), "w");
+    if (!file) {
+        LOG_ERROR(Frontend, "[Freedreno] Failed to open {} for writing", config_path);
+        return false;
+    }
+
+    fprintf(file, "# Freedreno/Turnip Configuration\n");
+    fprintf(file, "# Auto-generated by Eden Emulator\n\n");
+
+    for (const auto& [key, value] : g_config->env_vars) {
+        fprintf(file, "%s=%s\n", key.c_str(), value.c_str());
+    }
+
+    fclose(file);
+    return true;
+}
+
+} // anonymous namespace
+
+extern "C" {
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_setFreedrenoBasePath(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jbasePath) {
+    g_base_path = Common::Android::GetJString(env, jbasePath);
+}
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_initializeFreedrenoConfig(
+    [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
+    if (!g_config) {
+        g_config = std::make_unique<FreedrenoConfig>();
+        LOG_INFO(Frontend, "[Freedreno] Configuration system initialized");
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_saveFreedrenoConfig(
+    [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
+    if (!g_config) {
+        LOG_WARNING(Frontend, "[Freedreno] Cannot save: not initialized");
+        return;
+    }
+
+    const std::string config_path = GetConfigPath();
+    FILE* file = fopen(config_path.c_str(), "w");
+    if (!file) {
+        LOG_ERROR(Frontend, "[Freedreno] Failed to open {} for writing", config_path);
+        return;
+    }
+
+    fprintf(file, "# Freedreno/Turnip Configuration\n");
+    fprintf(file, "# Auto-generated by Eden Emulator\n\n");
+
+    for (const auto& [key, value] : g_config->env_vars) {
+        fprintf(file, "%s=%s\n", key.c_str(), value.c_str());
+    }
+
+    fclose(file);
+    g_config->config_file_path = config_path;
+
+    LOG_INFO(Frontend, "[Freedreno] Saved {} variables to {}",
+             g_config->env_vars.size(), config_path);
+}
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_reloadFreedrenoConfig(
+    [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
+    if (!g_config) {
+        LOG_WARNING(Frontend, "[Freedreno] Cannot reload: not initialized");
+        return;
+    }
+
+    const std::string config_path = GetConfigPath();
+    g_config->env_vars.clear();
+
+    FILE* file = fopen(config_path.c_str(), "r");
+    if (!file) {
+        LOG_DEBUG(Frontend, "[Freedreno] No config file found at {}", config_path);
+        return;
+    }
+
+    char line[512];
+    while (fgets(line, sizeof(line), file)) {
+        // Remove trailing newline
+        size_t len = strlen(line);
+        if (len > 0 && line[len - 1] == '\n') {
+            line[len - 1] = '\0';
+            len--;
+        }
+
+        // Skip empty lines and comments
+        if (len == 0 || line[0] == '#') {
+            continue;
+        }
+
+        // Parse key=value
+        const char* eq = strchr(line, '=');
+        if (!eq) {
+            continue;
+        }
+
+        std::string key(line, eq - line);
+        std::string value(eq + 1);
+
+        g_config->env_vars[key] = value;
+        ApplyEnvironmentVariable(key, value);
+    }
+
+    fclose(file);
+    g_config->config_file_path = config_path;
+
+    if (!g_config->env_vars.empty()) {
+        LOG_INFO(Frontend, "[Freedreno] Loaded {} variables:", g_config->env_vars.size());
+        LogActiveVariables();
+    }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_setFreedrenoEnv(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jvarName, jstring jvalue) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto var_name = Common::Android::GetJString(env, jvarName);
+    auto value = Common::Android::GetJString(env, jvalue);
+
+    if (var_name.empty()) {
+        return JNI_FALSE;
+    }
+
+    g_config->env_vars[var_name] = value;
+
+    if (!ApplyEnvironmentVariable(var_name, value)) {
+        return JNI_FALSE;
+    }
+
+    LOG_INFO(Frontend, "[Freedreno] Set {}={}", var_name, value);
+    return JNI_TRUE;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_getFreedrenoEnv(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jvarName) {
+    if (!g_config) {
+        return env->NewStringUTF("");
+    }
+
+    auto var_name = Common::Android::GetJString(env, jvarName);
+    auto it = g_config->env_vars.find(var_name);
+
+    if (it != g_config->env_vars.end()) {
+        return env->NewStringUTF(it->second.c_str());
+    }
+
+    return env->NewStringUTF("");
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_isFreedrenoEnvSet(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jvarName) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto var_name = Common::Android::GetJString(env, jvarName);
+    auto it = g_config->env_vars.find(var_name);
+
+    return (it != g_config->env_vars.end() && !it->second.empty()) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_clearFreedrenoEnv(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jvarName) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto var_name = Common::Android::GetJString(env, jvarName);
+    auto it = g_config->env_vars.find(var_name);
+
+    if (it != g_config->env_vars.end()) {
+        g_config->env_vars.erase(it);
+        unsetenv(var_name.c_str());
+        LOG_INFO(Frontend, "[Freedreno] Cleared {}", var_name);
+        return JNI_TRUE;
+    }
+
+    return JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_clearAllFreedrenoEnv(
+    [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
+    if (!g_config) {
+        return;
+    }
+
+    for (const auto& [key, value] : g_config->env_vars) {
+        unsetenv(key.c_str());
+    }
+
+    size_t count = g_config->env_vars.size();
+    g_config->env_vars.clear();
+
+    if (count > 0) {
+        LOG_INFO(Frontend, "[Freedreno] Cleared all {} variables", count);
+    }
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_getFreedrenoEnvSummary(
+    JNIEnv* env, [[maybe_unused]] jobject obj) {
+    if (!g_config || g_config->env_vars.empty()) {
+        return env->NewStringUTF("");
+    }
+
+    std::string summary;
+    for (const auto& [key, value] : g_config->env_vars) {
+        if (!summary.empty()) {
+            summary += ",";
+        }
+        summary += key + "=" + value;
+    }
+
+    return env->NewStringUTF(summary.c_str());
+}
+
+JNIEXPORT void JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_setCurrentProgramId(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    g_current_program_id = Common::Android::GetJString(env, jprogramId);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_loadPerGameConfig(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto program_id = Common::Android::GetJString(env, jprogramId);
+    if (program_id.empty()) {
+        return JNI_FALSE;
+    }
+
+    // Clear current environment variables first
+    ClearAllEnvironmentVariables();
+    g_current_program_id = program_id;
+
+    // Try to load per-game config - do NOT fall back to global
+    // Per-game config should start empty if no config exists yet
+    std::string per_game_path = GetPerGameConfigPath(program_id);
+    if (LoadConfigFromFile(per_game_path)) {
+        LOG_INFO(Frontend, "[Freedreno] Loaded per-game config for {}", program_id);
+        LogActiveVariables();
+        return JNI_TRUE;
+    }
+
+    // No per-game config exists - start with empty config
+    LOG_INFO(Frontend, "[Freedreno] No per-game config for {}, starting empty", program_id);
+    return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_loadPerGameConfigWithGlobalFallback(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto program_id = Common::Android::GetJString(env, jprogramId);
+    if (program_id.empty()) {
+        return JNI_FALSE;
+    }
+
+    // Clear current environment variables first
+    ClearAllEnvironmentVariables();
+    g_current_program_id = program_id;
+
+    // Try to load per-game config first
+    std::string per_game_path = GetPerGameConfigPath(program_id);
+    if (LoadConfigFromFile(per_game_path)) {
+        LOG_INFO(Frontend, "[Freedreno] Loaded per-game config for {}", program_id);
+        LogActiveVariables();
+        return JNI_TRUE;
+    }
+
+    // Fall back to global config for emulation
+    std::string global_path = GetConfigPath();
+    if (LoadConfigFromFile(global_path)) {
+        LOG_INFO(Frontend, "[Freedreno] No per-game config for {}, using global for emulation", program_id);
+        LogActiveVariables();
+    }
+
+    return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_savePerGameConfig(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    if (!g_config) {
+        return JNI_FALSE;
+    }
+
+    auto program_id = Common::Android::GetJString(env, jprogramId);
+    if (program_id.empty()) {
+        return JNI_FALSE;
+    }
+
+    EnsurePerGameConfigDir();
+    std::string config_path = GetPerGameConfigPath(program_id);
+
+    if (SaveConfigToFile(config_path)) {
+        LOG_INFO(Frontend, "[Freedreno] Saved per-game config for {}", program_id);
+        return JNI_TRUE;
+    }
+
+    return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_hasPerGameConfig(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    auto program_id = Common::Android::GetJString(env, jprogramId);
+    if (program_id.empty()) {
+        return JNI_FALSE;
+    }
+
+    std::string config_path = GetPerGameConfigPath(program_id);
+    FILE* file = fopen(config_path.c_str(), "r");
+    if (file) {
+        fclose(file);
+        return JNI_TRUE;
+    }
+    return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_yuzu_yuzu_1emu_utils_NativeFreedrenoConfig_deletePerGameConfig(
+    JNIEnv* env, [[maybe_unused]] jobject obj, jstring jprogramId) {
+    auto program_id = Common::Android::GetJString(env, jprogramId);
+    if (program_id.empty()) {
+        return JNI_FALSE;
+    }
+
+    std::string config_path = GetPerGameConfigPath(program_id);
+    if (remove(config_path.c_str()) == 0) {
+        LOG_INFO(Frontend, "[Freedreno] Deleted per-game config for {}", program_id);
+        return JNI_TRUE;
+    }
+    return JNI_FALSE;
+}
+
+} // extern "C"

src/android/app/src/main/res/layout/fragment_freedreno_settings.xml

@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/coordinator_main"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="?attr/colorSurface">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:id="@+id/appbar_freedreno"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:fitsSystemWindows="true"
+        android:touchscreenBlocksFocus="false"
+        app:elevation="0dp">
+
+        <com.google.android.material.appbar.CollapsingToolbarLayout
+            android:id="@+id/toolbar_freedreno_layout"
+            style="?attr/collapsingToolbarLayoutMediumStyle"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/collapsingToolbarLayoutMediumSize"
+            app:layout_scrollFlags="scroll|exitUntilCollapsed|snap"
+            app:contentScrim="?attr/colorSurface"
+            app:scrimVisibleHeightTrigger="100dp">
+
+            <com.google.android.material.appbar.MaterialToolbar
+                android:id="@+id/toolbar_freedreno"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                android:touchscreenBlocksFocus="false"
+                app:layout_collapseMode="pin"
+                app:navigationIcon="@drawable/ic_back"
+                app:title="@string/gpu_driver_settings" />
+
+        </com.google.android.material.appbar.CollapsingToolbarLayout>
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <androidx.core.widget.NestedScrollView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:paddingStart="16dp"
+            android:paddingEnd="16dp"
+            android:paddingTop="8dp"
+            android:paddingBottom="16dp">
+
+            <!-- Presets Section -->
+            <com.google.android.material.textview.MaterialTextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="16dp"
+                android:layout_marginBottom="8dp"
+                android:text="@string/freedreno_presets"
+                android:textAppearance="?attr/textAppearanceTitleMedium" />
+
+            <androidx.recyclerview.widget.RecyclerView
+                android:id="@+id/list_freedreno_presets"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:scrollbars="horizontal"
+                app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager" />
+
+            <!-- Current Settings Section -->
+            <com.google.android.material.textview.MaterialTextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="24dp"
+                android:layout_marginBottom="8dp"
+                android:text="@string/freedreno_current_settings"
+                android:textAppearance="?attr/textAppearanceTitleMedium" />
+
+            <!-- Settings List -->
+            <androidx.recyclerview.widget.RecyclerView
+                android:id="@+id/list_freedreno_settings"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager" />
+
+            <!-- Debug Section -->
+            <com.google.android.material.textview.MaterialTextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="24dp"
+                android:layout_marginBottom="8dp"
+                android:text="@string/freedreno_debug"
+                android:textAppearance="?attr/textAppearanceTitleMedium" />
+
+            <!-- Manual Variable Input -->
+            <com.google.android.material.textfield.TextInputLayout
+                android:id="@+id/variable_name_input_layout"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginBottom="8dp"
+                android:hint="@string/freedreno_var_name">
+
+                <com.google.android.material.textfield.TextInputEditText
+                    android:id="@+id/variable_name_input"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:inputType="text" />
+
+            </com.google.android.material.textfield.TextInputLayout>
+
+            <com.google.android.material.textfield.TextInputLayout
+                android:id="@+id/variable_value_input_layout"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginBottom="8dp"
+                android:hint="@string/freedreno_var_value">
+
+                <com.google.android.material.textfield.TextInputEditText
+                    android:id="@+id/variable_value_input"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:inputType="text" />
+
+            </com.google.android.material.textfield.TextInputLayout>
+
+            <Button
+                android:id="@+id/button_add_variable"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginBottom="8dp"
+                android:text="@string/freedreno_add_variable" />
+
+            <!-- Action Buttons -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:layout_marginTop="16dp"
+                android:spacing="8dp">
+
+                <Button
+                    android:id="@+id/button_clear_all"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/freedreno_clear_all"
+                    style="?attr/materialButtonOutlinedStyle" />
+
+                <Button
+                    android:id="@+id/button_save"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/save" />
+
+            </LinearLayout>
+
+            <!-- Info Section -->
+            <com.google.android.material.card.MaterialCardView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="24dp"
+                app:cardElevation="0dp"
+                app:strokeWidth="1dp"
+                app:strokeColor="?attr/colorOutline">
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="vertical"
+                    android:padding="12dp">
+
+                    <com.google.android.material.textview.MaterialTextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:text="@string/freedreno_info_title"
+                        android:textAppearance="?attr/textAppearanceTitleSmall" />
+
+                    <com.google.android.material.textview.MaterialTextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:text="@string/freedreno_info_description"
+                        android:textAppearance="?attr/textAppearanceBodySmall"
+                        android:textColor="?attr/colorOnSurfaceVariant" />
+
+                </LinearLayout>
+
+            </com.google.android.material.card.MaterialCardView>
+
+        </LinearLayout>
+
+    </androidx.core.widget.NestedScrollView>
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

src/android/app/src/main/res/layout/list_item_freedreno_preset.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:paddingStart="4dp"
+    android:paddingEnd="4dp">
+
+    <com.google.android.material.button.MaterialButton
+        android:id="@+id/preset_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:minWidth="100dp"
+        android:text="Preset"
+        style="?attr/materialButtonOutlinedStyle" />
+
+</LinearLayout>

src/android/app/src/main/res/layout/list_item_freedreno_variable.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<com.google.android.material.card.MaterialCardView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_marginStart="0dp"
+    android:layout_marginEnd="0dp"
+    android:layout_marginTop="4dp"
+    android:layout_marginBottom="4dp"
+    app:cardElevation="0dp"
+    app:strokeWidth="1dp"
+    app:strokeColor="?attr/colorOutline">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:padding="12dp"
+        android:gravity="center_vertical">
+
+        <LinearLayout
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:orientation="vertical">
+
+            <com.google.android.material.textview.MaterialTextView
+                android:id="@+id/variable_name"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="VARIABLE_NAME"
+                android:textAppearance="?attr/textAppearanceTitleSmall"
+                android:textColor="?attr/colorOnSurface" />
+
+            <com.google.android.material.textview.MaterialTextView
+                android:id="@+id/variable_value"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="4dp"
+                android:text="variable_value"
+                android:textAppearance="?attr/textAppearanceBodySmall"
+                android:textColor="?attr/colorOnSurfaceVariant"
+                android:maxLines="1"
+                android:ellipsize="end" />
+
+        </LinearLayout>
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/button_delete"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="8dp"
+            android:text="@string/delete"
+            android:minWidth="0dp"
+            android:minHeight="36dp"
+            android:paddingStart="8dp"
+            android:paddingEnd="8dp"
+            style="?attr/materialButtonOutlinedStyle" />
+
+    </LinearLayout>
+
+</com.google.android.material.card.MaterialCardView>

src/android/app/src/main/res/navigation/home_navigation.xml

@@ -148,6 +148,9 @@
         <action
             android:id="@+id/action_perGamePropertiesFragment_to_driverManagerFragment"
             app:destination="@id/driverManagerFragment" />
+        <action
+            android:id="@+id/action_perGamePropertiesFragment_to_freedrenoSettingsFragment"
+            app:destination="@id/freedrenoSettingsFragment" />
     </fragment>
     <action
         android:id="@+id/action_global_perGamePropertiesFragment"
@@ -173,5 +176,15 @@
         android:name="org.yuzu.yuzu_emu.fragments.DriverFetcherFragment"
         android:label="fragment_driver_fetcher"
         tools:layout="@layout/fragment_driver_fetcher" />
+    <fragment
+        android:id="@+id/freedrenoSettingsFragment"
+        android:name="org.yuzu.yuzu_emu.fragments.FreedrenoSettingsFragment"
+        android:label="@string/freedreno_settings_title">
+        <argument
+            android:name="game"
+            app:argType="org.yuzu.yuzu_emu.model.Game"
+            app:nullable="true"
+            android:defaultValue="@null" />
+    </fragment>
 
 </navigation>

src/android/app/src/main/res/navigation/settings_navigation.xml

@@ -29,4 +29,19 @@
         android:name="org.yuzu.yuzu_emu.features.settings.ui.SettingsSearchFragment"
         android:label="SettingsSearchFragment" />
 
+    <fragment
+        android:id="@+id/freedrenoSettingsFragment"
+        android:name="org.yuzu.yuzu_emu.fragments.FreedrenoSettingsFragment"
+        android:label="@string/freedreno_settings_title">
+        <argument
+            android:name="game"
+            app:argType="org.yuzu.yuzu_emu.model.Game"
+            app:nullable="true"
+            android:defaultValue="@null" />
+    </fragment>
+
+    <action
+        android:id="@+id/action_settingsFragment_to_freedrenoSettingsFragment"
+        app:destination="@id/freedrenoSettingsFragment" />
+
 </navigation>

src/android/app/src/main/res/values/strings.xml

@@ -1051,6 +1051,28 @@
     <string name="cpu_accuracy_paranoid">Paranoid</string>
     <string name="cpu_accuracy_debugging">Debugging</string>
 
+    <!-- Freedreno Settings -->
+    <string name="freedreno_settings_title">Freedreno Settings</string>
+    <string name="gpu_driver_settings">GPU Driver Settings</string>
+    <string name="freedreno_presets">Quick Presets</string>
+    <string name="freedreno_current_settings">Current Settings</string>
+    <string name="freedreno_debug">Advanced Settings</string>
+    <string name="freedreno_var_name">Variable Name (e.g., TU_DEBUG)</string>
+    <string name="freedreno_var_value">Variable Value</string>
+    <string name="freedreno_add_variable">Add Variable</string>
+    <string name="freedreno_clear_all">Clear All</string>
+    <string name="freedreno_saved">Freedreno configuration saved</string>
+    <string name="freedreno_cleared_all">All Freedreno variables cleared</string>
+    <string name="freedreno_variable_added">Variable %1$s added</string>
+    <string name="freedreno_preset_applied">Preset \'%1$s\' applied</string>
+    <string name="freedreno_error_empty_name">Variable name cannot be empty</string>
+    <string name="freedreno_error_setting_variable">Failed to set variable</string>
+    <string name="freedreno_info_title">About Freedreno Configuration</string>
+    <string name="freedreno_info_description">Configure Freedreno/Turnip GPU driver options for debugging, profiling, and performance optimization. Changes are saved automatically. See https://docs.mesa3d.org/drivers/freedreno.html for detailed documentation.</string>
+    <string name="freedreno_per_game_title">Freedreno Settings</string>
+    <string name="freedreno_per_game_description">Configure GPU driver settings for this game</string>
+    <string name="freedreno_per_game_saved">Freedreno configuration saved</string>
+
     <!-- Gamepad Buttons -->
     <string name="gamepad_d_pad">D-pad</string>
     <string name="gamepad_left_stick">Left stick</string>

src/common/settings.h

@@ -536,7 +536,13 @@ struct Values {
                                                 Category::RendererExtensions,
                                                 Specialization::Scalar};
 
-    SwitchableSetting<bool> vertex_input_dynamic_state{linkage, true, "vertex_input_dynamic_state", Category::RendererExtensions};
+    SwitchableSetting<bool> vertex_input_dynamic_state{linkage,
+#if defined (ANDROID)
+                                                       false,
+#else
+                                                       true,
+#endif
+                                                       "vertex_input_dynamic_state", Category::RendererExtensions};
     SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex", Category::RendererExtensions};
     SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing", Category::RendererExtensions};
 

src/core/hle/kernel/kernel.cpp

@@ -50,13 +50,38 @@
 
 namespace Kernel {
 
+// Can only be used by a single implementation PER THREAD
+struct ThreadLocalData {
+    std::optional<KThread> raw_thread;
+    KThread* current_thread = nullptr;
+    KThread* thread = nullptr;
+    u8 host_thread_id = UINT8_MAX;
+    bool is_phantom_mode_for_singlecore = false;
+    bool lock = false;
+};
+
 struct KernelCore::Impl {
     static constexpr size_t ApplicationMemoryBlockSlabHeapSize = 20000;
     static constexpr size_t SystemMemoryBlockSlabHeapSize = 10000;
     static constexpr size_t BlockInfoSlabHeapSize = 4000;
     static constexpr size_t ReservedDynamicPageCount = 64;
+    // Be very careful when handling TLS data
+    // We do not want to concern ourselves with the appropriate way to manage them
+    // across **all** threads, we just need these for a few spare threads (+host/guest threads)
+    //
+    // Do not just read straight from here, use a reference beforehand, the cost of reading
+    // from TLS is greater than the cost of reading normal variables.
+    // But account that this Impl() is instanced once per program, and shared across threads
+    // so we can't use a reference for now.
+    //
+    // And we have the guarantee that the data won't move out of the way so we can safely
+    // take a reference to it. This isn't always universally true but this is "global" data
+    // so it will be statically given a TLS slot anyways.
+    static inline thread_local ThreadLocalData tls_data = {};
 
-    explicit Impl(Core::System& system_, KernelCore& kernel_) : system{system_} {}
+    explicit Impl(Core::System& system_, KernelCore& kernel_) : system{system_} {
+        tls_data.lock = true;
+    }
 
     void SetMulticore(bool is_multi) {
         is_multicore = is_multi;
@@ -69,8 +94,6 @@ struct KernelCore::Impl {
         global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
         global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
 
-        is_phantom_mode_for_singlecore = false;
-
         // Derive the initial memory layout from the emulated board
         Init::InitializeSlabResourceCounts(kernel);
         DeriveInitialMemoryLayout();
@@ -88,9 +111,7 @@ struct KernelCore::Impl {
         {
             const auto& pt_heap_region = memory_layout->GetPageTableHeapRegion();
             ASSERT(pt_heap_region.GetEndAddress() != 0);
-
-            InitializeResourceManagers(kernel, pt_heap_region.GetAddress(),
-                                       pt_heap_region.GetSize());
+            InitializeResourceManagers(kernel, pt_heap_region.GetAddress(), pt_heap_region.GetSize());
         }
 
         InitializeHackSharedMemory(kernel);
@@ -222,17 +243,11 @@ struct KernelCore::Impl {
         const auto kernel_size{sizes.second};
 
         // If setting the default system values fails, then something seriously wrong has occurred.
-        ASSERT(
-            system_resource_limit->SetLimitValue(LimitableResource::PhysicalMemoryMax, total_size)
-                .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::ThreadCountMax, 800)
-                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::EventCountMax, 900)
-                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::TransferMemoryCountMax, 200)
-                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::SessionCountMax, 1133)
-                   .IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::PhysicalMemoryMax, total_size).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::ThreadCountMax, 800).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::EventCountMax, 900).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::TransferMemoryCountMax, 200).IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::SessionCountMax, 1133).IsSuccess());
         system_resource_limit->Reserve(LimitableResource::PhysicalMemoryMax, kernel_size);
 
         // Reserve secure applet memory, introduced in firmware 5.0.0
@@ -242,16 +257,13 @@ struct KernelCore::Impl {
     }
 
     void InitializePreemption(KernelCore& kernel) {
-        preemption_event = Core::Timing::CreateEvent(
-            "PreemptionCallback",
-            [this, &kernel](s64 time,
-                            std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
-                {
-                    KScopedSchedulerLock lock(kernel);
-                    global_scheduler_context->PreemptThreads();
-                }
-                return std::nullopt;
-            });
+        preemption_event = Core::Timing::CreateEvent("PreemptionCallback", [this, &kernel](s64 time, std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
+            {
+                KScopedSchedulerLock lock(kernel);
+                global_scheduler_context->PreemptThreads();
+            }
+            return std::nullopt;
+        });
 
         const auto time_interval = std::chrono::nanoseconds{std::chrono::milliseconds(10)};
         system.CoreTiming().ScheduleLoopingEvent(time_interval, time_interval, preemption_event);
@@ -263,15 +275,13 @@ struct KernelCore::Impl {
         ASSERT(Common::IsAligned(size, PageSize));
 
         // Ensure that we have space for our reference counts.
-        const size_t rc_size =
-            Common::AlignUp(KPageTableSlabHeap::CalculateReferenceCountSize(size), PageSize);
+        const size_t rc_size = Common::AlignUp(KPageTableSlabHeap::CalculateReferenceCountSize(size), PageSize);
         ASSERT(rc_size < size);
         size -= rc_size;
 
         // Initialize the resource managers' shared page manager.
         resource_manager_page_manager = std::make_unique<KDynamicPageManager>();
-        resource_manager_page_manager->Initialize(
-            address, size, std::max<size_t>(PageSize, KPageBufferSlabHeap::BufferSize));
+        resource_manager_page_manager->Initialize(address, size, std::max<size_t>(PageSize, KPageBufferSlabHeap::BufferSize));
 
         // Initialize the KPageBuffer slab heap.
         page_buffer_slab_heap.Initialize(system);
@@ -280,16 +290,12 @@ struct KernelCore::Impl {
         app_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();
         sys_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();
         block_info_heap = std::make_unique<KBlockInfoSlabHeap>();
-        app_memory_block_heap->Initialize(resource_manager_page_manager.get(),
-                                          ApplicationMemoryBlockSlabHeapSize);
-        sys_memory_block_heap->Initialize(resource_manager_page_manager.get(),
-                                          SystemMemoryBlockSlabHeapSize);
+        app_memory_block_heap->Initialize(resource_manager_page_manager.get(), ApplicationMemoryBlockSlabHeapSize);
+        sys_memory_block_heap->Initialize(resource_manager_page_manager.get(), SystemMemoryBlockSlabHeapSize);
         block_info_heap->Initialize(resource_manager_page_manager.get(), BlockInfoSlabHeapSize);
 
         // Reserve all but a fixed number of remaining pages for the page table heap.
-        const size_t num_pt_pages = resource_manager_page_manager->GetCount() -
-                                    resource_manager_page_manager->GetUsed() -
-                                    ReservedDynamicPageCount;
+        const size_t num_pt_pages = resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() - ReservedDynamicPageCount;
         page_table_heap = std::make_unique<KPageTableSlabHeap>();
 
         // TODO(bunnei): Pass in address once we support kernel virtual memory allocations.
@@ -301,8 +307,8 @@ struct KernelCore::Impl {
         KDynamicPageManager* const app_dynamic_page_manager = nullptr;
         KDynamicPageManager* const sys_dynamic_page_manager =
             /*KTargetSystem::IsDynamicResourceLimitsEnabled()*/ true
-                ? resource_manager_page_manager.get()
-                : nullptr;
+            ? resource_manager_page_manager.get()
+            : nullptr;
         app_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>();
         sys_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>();
         app_block_info_manager = std::make_unique<KBlockInfoManager>();
@@ -320,9 +326,7 @@ struct KernelCore::Impl {
         sys_page_table_manager->Initialize(sys_dynamic_page_manager, page_table_heap.get());
 
         // Check that we have the correct number of dynamic pages available.
-        ASSERT(resource_manager_page_manager->GetCount() -
-                   resource_manager_page_manager->GetUsed() ==
-               ReservedDynamicPageCount);
+        ASSERT(resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() == ReservedDynamicPageCount);
 
         // Create the system page table managers.
         app_system_resource = std::make_unique<KSystemResource>(kernel);
@@ -331,18 +335,15 @@ struct KernelCore::Impl {
         KAutoObject::Create(std::addressof(*sys_system_resource));
 
         // Set the managers for the system resources.
-        app_system_resource->SetManagers(*app_memory_block_manager, *app_block_info_manager,
-                                         *app_page_table_manager);
-        sys_system_resource->SetManagers(*sys_memory_block_manager, *sys_block_info_manager,
-                                         *sys_page_table_manager);
+        app_system_resource->SetManagers(*app_memory_block_manager, *app_block_info_manager, *app_page_table_manager);
+        sys_system_resource->SetManagers(*sys_memory_block_manager, *sys_block_info_manager, *sys_page_table_manager);
     }
 
     void InitializeShutdownThreads() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
             shutdown_threads[core_id] = KThread::Create(system.Kernel());
-            ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {},
-                                                         core_id)
-                       .IsSuccess());
+            ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {}, core_id)
+                .IsSuccess());
             KThread::Register(system.Kernel(), shutdown_threads[core_id]);
         }
     }
@@ -356,83 +357,77 @@ struct KernelCore::Impl {
         application_process->Open();
     }
 
-    static inline thread_local u8 host_thread_id = UINT8_MAX;
-
     /// Sets the host thread ID for the caller.
     u32 SetHostThreadId(std::size_t core_id) {
         // This should only be called during core init.
-        ASSERT(host_thread_id == UINT8_MAX);
+        ASSERT(tls_data.host_thread_id == UINT8_MAX);
 
         // The first four slots are reserved for CPU core threads
         ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
-        host_thread_id = static_cast<u8>(core_id);
-        return host_thread_id;
+        tls_data.host_thread_id = u8(core_id);
+        return tls_data.host_thread_id;
     }
 
     /// Gets the host thread ID for the caller
     u32 GetHostThreadId() const {
-        return host_thread_id;
+        return tls_data.host_thread_id;
     }
 
     // Gets the dummy KThread for the caller, allocating a new one if this is the first time
     KThread* GetHostDummyThread(KThread* existing_thread) {
-        const auto initialize{[](KThread* thread) {
-            ASSERT(KThread::InitializeDummyThread(thread, nullptr).IsSuccess());
-            return thread;
-        }};
-        thread_local KThread raw_thread{system.Kernel()};
-        thread_local KThread* thread = existing_thread ? existing_thread : initialize(&raw_thread);
-        return thread;
+        if (tls_data.thread == nullptr) {
+            auto const initialize{[](KThread* thread) {
+                ASSERT(KThread::InitializeDummyThread(thread, nullptr).IsSuccess());
+                return thread;
+            }};
+            tls_data.raw_thread.emplace(system.Kernel());
+            tls_data.thread = existing_thread ? existing_thread : initialize(&*tls_data.raw_thread);
+            ASSERT(tls_data.thread != nullptr);
+        }
+        return tls_data.thread;
     }
 
     /// Registers a CPU core thread by allocating a host thread ID for it
     void RegisterCoreThread(std::size_t core_id) {
         ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
         const auto this_id = SetHostThreadId(core_id);
-        if (!is_multicore) {
+        if (!is_multicore)
             single_core_thread_id = this_id;
-        }
     }
 
     /// Registers a new host thread by allocating a host thread ID for it
     void RegisterHostThread(KThread* existing_thread) {
-        [[maybe_unused]] const auto dummy_thread = GetHostDummyThread(existing_thread);
+        (void)GetHostDummyThread(existing_thread);
     }
 
     [[nodiscard]] u32 GetCurrentHostThreadID() {
-        const auto this_id = GetHostThreadId();
-        if (!is_multicore && single_core_thread_id == this_id) {
-            return static_cast<u32>(system.GetCpuManager().CurrentCore());
-        }
+        auto const this_id = GetHostThreadId();
+        if (!is_multicore && single_core_thread_id == this_id)
+            return u32(system.GetCpuManager().CurrentCore());
         return this_id;
     }
 
-    static inline thread_local bool is_phantom_mode_for_singlecore{false};
-
+    // Forces singlecore
     bool IsPhantomModeForSingleCore() const {
-        return is_phantom_mode_for_singlecore;
+        return tls_data.is_phantom_mode_for_singlecore;
     }
-
     void SetIsPhantomModeForSingleCore(bool value) {
         ASSERT(!is_multicore);
-        is_phantom_mode_for_singlecore = value;
+        tls_data.is_phantom_mode_for_singlecore = value;
     }
 
     bool IsShuttingDown() const {
         return is_shutting_down.load(std::memory_order_relaxed);
     }
 
-    static inline thread_local KThread* current_thread{nullptr};
-
     KThread* GetCurrentEmuThread() {
-        if (!current_thread) {
-            current_thread = GetHostDummyThread(nullptr);
-        }
-        return current_thread;
+        if (!tls_data.current_thread)
+            tls_data.current_thread = GetHostDummyThread(nullptr);
+        return tls_data.current_thread;
     }
 
     void SetCurrentEmuThread(KThread* thread) {
-        current_thread = thread;
+        tls_data.current_thread = thread;
     }
 
     void DeriveInitialMemoryLayout() {

src/core/hle/result.h

@@ -12,7 +12,7 @@
 #include "common/common_types.h"
 #include "common/expected.h"
 
-// All the constants in this file come from <https://switchbrew.org/wiki/Error_codes>
+// All the constants in this file come from <http://switchbrew.org/index.php?title=Error_codes>
 
 /**
  * Identifies the module which caused the error. Error codes can be propagated through a call
@@ -43,7 +43,7 @@ enum class ErrorModule : u32 {
     NCMContent = 20,
     SM = 21,
     RO = 22,
-    Gc = 23,
+    GC = 23,
     SDMMC = 24,
     OVLN = 25,
     SPL = 26,
@@ -72,7 +72,7 @@ enum class ErrorModule : u32 {
     Bluetooth = 113,
     VI = 114,
     NFP = 115,
-    TimeService = 116,
+    Time = 116,
     FGM = 117,
     OE = 118,
     BH1730FVC = 119,

src/core/hle/service/acc/acc.cpp

@@ -100,6 +100,7 @@ public:
             {133, nullptr, "GetNintendoAccountVerificationUrlCache"}, // 9.0.0+
             {134, nullptr, "RefreshNintendoAccountVerificationUrlCache"}, // 9.0.0+
             {135, nullptr, "RefreshNintendoAccountVerificationUrlCacheAsyncIfSecondsElapsed"}, // 9.0.0+
+            {136, nullptr, "GetNintendoAccountUserResourceCache"}, // 19.0.0+
             {140, nullptr, "GetNetworkServiceLicenseCache"}, // 5.0.0+
             {141, nullptr, "RefreshNetworkServiceLicenseCacheAsync"}, // 5.0.0+
             {142, nullptr, "RefreshNetworkServiceLicenseCacheAsyncIfSecondsElapsed"}, // 5.0.0+

src/core/hle/service/am/service/application_functions.cpp

@@ -90,10 +90,10 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_, std::shared_
         {200, nullptr, "GetLastApplicationExitReason"},
         {210, D<&IApplicationFunctions::GetUnknownEvent210>, "Unknown210"},
         {220, nullptr, "Unknown220"}, // [20.0.0+]
-        {300, nullptr, "Unknown300"}, // [20.0.0+]
+        {300, nullptr, "CreateMovieWriter"}, // [19.0.0+]
         {310, nullptr, "Unknown310"}, // [20.0.0+]
         {320, nullptr, "Unknown320"}, // [20.0.0+]
-        {330, nullptr, "Unknown330"}, // [20.0.0+]
+        {330, D<&IApplicationFunctions::Unknown330>, "Unknown330"}, // [20.0.0+]
         {500, nullptr, "StartContinuousRecordingFlushForDebug"},
         {1000, nullptr, "CreateMovieMaker"},
         {1001, D<&IApplicationFunctions::PrepareForJit>, "PrepareForJit"},
@@ -503,6 +503,12 @@ Result IApplicationFunctions::GetUnknownEvent210(
     R_SUCCEED();
 }
 
+Result IApplicationFunctions::Unknown330(Out<u8> out) {
+    LOG_DEBUG(Service_AM, "called");
+    *out = 0;
+    R_SUCCEED();
+}
+
 Result IApplicationFunctions::PrepareForJit() {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 

src/core/hle/service/am/service/application_functions.h

@@ -80,6 +80,7 @@ private:
     Result GetNotificationStorageChannelEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetHealthWarningDisappearedSystemEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetUnknownEvent210(OutCopyHandle<Kernel::KReadableEvent> out_event);
+    Result Unknown330(Out<u8> out);
     Result PrepareForJit();
 
     const std::shared_ptr<Applet> m_applet;

src/core/hle/service/am/service/common_state_getter.cpp

@@ -36,19 +36,20 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {11, D<&ICommonStateGetter::ReleaseSleepLock>, "ReleaseSleepLock"},
         {12, D<&ICommonStateGetter::ReleaseSleepLockTransiently>, "ReleaseSleepLockTransiently"},
         {13, D<&ICommonStateGetter::GetAcquiredSleepLockEvent>, "GetAcquiredSleepLockEvent"},
-        {14, nullptr, "GetWakeupCount"},
+        {14, nullptr, "GetWakeupCount"}, //11.0.0+
+        {15, nullptr, "Unknown15"}, //19.0.0+
         {20, D<&ICommonStateGetter::PushToGeneralChannel>, "PushToGeneralChannel"},
         {30, nullptr, "GetHomeButtonReaderLockAccessor"},
-        {31, D<&ICommonStateGetter::GetReaderLockAccessorEx>, "GetReaderLockAccessorEx"},
-        {32, D<&ICommonStateGetter::GetWriterLockAccessorEx>, "GetWriterLockAccessorEx"},
-        {40, nullptr, "GetCradleFwVersion"},
-        {50, D<&ICommonStateGetter::IsVrModeEnabled>, "IsVrModeEnabled"},
-        {51, D<&ICommonStateGetter::SetVrModeEnabled>, "SetVrModeEnabled"},
-        {52, D<&ICommonStateGetter::SetLcdBacklighOffEnabled>, "SetLcdBacklighOffEnabled"},
-        {53, D<&ICommonStateGetter::BeginVrModeEx>, "BeginVrModeEx"},
-        {54, D<&ICommonStateGetter::EndVrModeEx>, "EndVrModeEx"},
-        {55, D<&ICommonStateGetter::IsInControllerFirmwareUpdateSection>, "IsInControllerFirmwareUpdateSection"},
-        {59, nullptr, "SetVrPositionForDebug"},
+        {31, D<&ICommonStateGetter::GetReaderLockAccessorEx>, "GetReaderLockAccessorEx"}, //2.0.0+
+        {32, D<&ICommonStateGetter::GetWriterLockAccessorEx>, "GetWriterLockAccessorEx"}, //7.0.0+
+        {40, nullptr, "GetCradleFwVersion"}, //2.0.0+
+        {50, D<&ICommonStateGetter::IsVrModeEnabled>, "IsVrModeEnabled"}, //3.0.0+
+        {51, D<&ICommonStateGetter::SetVrModeEnabled>, "SetVrModeEnabled"}, //3.0.0+
+        {52, D<&ICommonStateGetter::SetLcdBacklighOffEnabled>, "SetLcdBacklighOffEnabled"}, //4.0.0+
+        {53, D<&ICommonStateGetter::BeginVrModeEx>, "BeginVrModeEx"}, //7.0.0+
+        {54, D<&ICommonStateGetter::EndVrModeEx>, "EndVrModeEx"}, //7.0.0+
+        {55, D<&ICommonStateGetter::IsInControllerFirmwareUpdateSection>, "IsInControllerFirmwareUpdateSection"}, //3.0.0+
+        {59, nullptr, "SetVrPositionForDebug"}, //1.0.0+
         {60, D<&ICommonStateGetter::GetDefaultDisplayResolution>, "GetDefaultDisplayResolution"},
         {61, D<&ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent>, "GetDefaultDisplayResolutionChangeEvent"},
         {62, D<&ICommonStateGetter::GetHdcpAuthenticationState>, "GetHdcpAuthenticationState"},
@@ -63,7 +64,8 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
         {100, D<&ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
         {110, nullptr, "OpenMyGpuErrorHandler"},
-        {120, D<&ICommonStateGetter::GetAppletLaunchedHistory>, "GetAppletLaunchedHistory"},
+        {120, D<&ICommonStateGetter::GetAppletLaunchedHistory>, "GetAppletLaunchedHistory"}, //13.0.0+
+        {130, nullptr, "Unknown130"}, //21.0.0+
         {200, D<&ICommonStateGetter::GetOperationModeSystemInfo>, "GetOperationModeSystemInfo"},
         {300, D<&ICommonStateGetter::GetSettingsPlatformRegion>, "GetSettingsPlatformRegion"},
         {400, nullptr, "ActivateMigrationService"},
@@ -72,7 +74,13 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {501, nullptr, "SuppressDisablingSleepTemporarily"},
         {502, nullptr, "IsSleepEnabled"},
         {503, nullptr, "IsDisablingSleepSuppressed"},
-        {900, D<&ICommonStateGetter::SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled>, "SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled"},
+        {600, nullptr, "Unknown600"}, //20.0.0+
+        {610, nullptr, "Unknown610"}, //21.0.0+
+        {900, D<&ICommonStateGetter::SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled>, "SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled"}, //11.0.0+
+        {910, nullptr, "GetLaunchRequiredTick"}, //17.0.0+
+        {1000, nullptr, "BeginVrMode3d"}, //19.0.0+
+        {1001, nullptr, "EndVrMode3d"}, //19.0.0+
+        {1002, nullptr, "IsVrModeEnabled3d"}, //19.0.0+
     };
     // clang-format on
 

src/core/hle/service/am/service/library_applet_accessor.cpp

@@ -27,8 +27,10 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
         {25, D<&ILibraryAppletAccessor::Terminate>, "Terminate"},
         {30, D<&ILibraryAppletAccessor::GetResult>, "GetResult"},
         {50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
-        {60, D<&ILibraryAppletAccessor::PresetLibraryAppletGpuTimeSliceZero>, "PresetLibraryAppletGpuTimeSliceZero"},
-        {90, D<&ILibraryAppletAccessor::Unknown90>, "Unknown90"},
+        {60, D<&ILibraryAppletAccessor::PresetLibraryAppletGpuTimeSliceZero>, "PresetLibraryAppletGpuTimeSliceZero"}, //10.0.0+
+        {80, nullptr, "RequestForLibraryAppletToGetForeground"}, //19.0.0+
+        {81, nullptr, "GetCurrentChildLibraryApplet"}, //19.0.0+
+        {90, D<&ILibraryAppletAccessor::Unknown90>, "Unknown90"}, //20.0.0+
         {100, D<&ILibraryAppletAccessor::PushInData>, "PushInData"},
         {101, D<&ILibraryAppletAccessor::PopOutData>, "PopOutData"},
         {102, nullptr, "PushExtraStorage"},
@@ -39,7 +41,7 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
         {110, nullptr, "NeedsToExitProcess"},
         {120, nullptr, "GetLibraryAppletInfo"},
         {150, nullptr, "RequestForAppletToGetForeground"},
-        {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"},
+        {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
     };
     // clang-format on
 

src/core/hle/service/audio/audio_renderer.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -28,10 +31,10 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
         {7, D<&IAudioRenderer::QuerySystemEvent>, "QuerySystemEvent"},
         {8, D<&IAudioRenderer::SetRenderingTimeLimit>, "SetRenderingTimeLimit"},
         {9, D<&IAudioRenderer::GetRenderingTimeLimit>, "GetRenderingTimeLimit"},
-        {10, D<&IAudioRenderer::RequestUpdateAuto>, "RequestUpdateAuto"},
-        {11, nullptr, "ExecuteAudioRendererRendering"},
-        {12, D<&IAudioRenderer::SetVoiceDropParameter>, "SetVoiceDropParameter"},
-        {13, D<&IAudioRenderer::GetVoiceDropParameter>, "GetVoiceDropParameter"},
+        {10, D<&IAudioRenderer::RequestUpdateAuto>, "RequestUpdateAuto"}, //3.0.0+
+        {11, nullptr, "ExecuteAudioRendererRendering"}, //3.0.0+
+        {12, D<&IAudioRenderer::SetVoiceDropParameter>, "SetVoiceDropParameter"}, //15.0.0+
+        {13, D<&IAudioRenderer::GetVoiceDropParameter>, "GetVoiceDropParameter"}, //15.0.0+
     };
     // clang-format on
     RegisterHandlers(functions);

src/core/hle/service/psc/time/errors.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -10,18 +7,18 @@
 
 namespace Service::PSC::Time {
 
-constexpr Result ResultPermissionDenied{ErrorModule::TimeService, 1};
-constexpr Result ResultClockMismatch{ErrorModule::TimeService, 102};
-constexpr Result ResultClockUninitialized{ErrorModule::TimeService, 103};
-constexpr Result ResultTimeNotFound{ErrorModule::TimeService, 200};
-constexpr Result ResultOverflow{ErrorModule::TimeService, 201};
-constexpr Result ResultFailed{ErrorModule::TimeService, 801};
-constexpr Result ResultInvalidArgument{ErrorModule::TimeService, 901};
-constexpr Result ResultTimeZoneOutOfRange{ErrorModule::TimeService, 902};
-constexpr Result ResultTimeZoneParseFailed{ErrorModule::TimeService, 903};
-constexpr Result ResultRtcTimeout{ErrorModule::TimeService, 988};
-constexpr Result ResultTimeZoneNotFound{ErrorModule::TimeService, 989};
-constexpr Result ResultNotImplemented{ErrorModule::TimeService, 990};
-constexpr Result ResultAlarmNotRegistered{ErrorModule::TimeService, 1502};
+constexpr Result ResultPermissionDenied{ErrorModule::Time, 1};
+constexpr Result ResultClockMismatch{ErrorModule::Time, 102};
+constexpr Result ResultClockUninitialized{ErrorModule::Time, 103};
+constexpr Result ResultTimeNotFound{ErrorModule::Time, 200};
+constexpr Result ResultOverflow{ErrorModule::Time, 201};
+constexpr Result ResultFailed{ErrorModule::Time, 801};
+constexpr Result ResultInvalidArgument{ErrorModule::Time, 901};
+constexpr Result ResultTimeZoneOutOfRange{ErrorModule::Time, 902};
+constexpr Result ResultTimeZoneParseFailed{ErrorModule::Time, 903};
+constexpr Result ResultRtcTimeout{ErrorModule::Time, 988};
+constexpr Result ResultTimeZoneNotFound{ErrorModule::Time, 989};
+constexpr Result ResultNotImplemented{ErrorModule::Time, 990};
+constexpr Result ResultAlarmNotRegistered{ErrorModule::Time, 1502};
 
 } // namespace Service::PSC::Time

src/core/hle/service/service.cpp

@@ -19,16 +19,13 @@
 namespace Service {
 
 /// @brief Creates a function string for logging, complete with the name (or header code, depending
-/// on what's passed in) the port name, and all the cmd_buff arguments.
-[[maybe_unused]] static std::string MakeFunctionString(std::string_view name, std::string_view port_name, const u32* cmd_buff) {
+/// on what's passed in) the port name, and all the cmd_buf arguments.
+[[maybe_unused]] static std::string MakeFunctionString(std::string_view name, std::string_view port_name, const u32* cmd_buf) {
     // Number of params == bits 0-5 + bits 6-11
-    int num_params = (cmd_buff[0] & 0x3F) + ((cmd_buff[0] >> 6) & 0x3F);
-
-    std::string function_string = fmt::format("function '{}': port={}", name, port_name);
-
+    int num_params = (cmd_buf[0] & 0x3F) + ((cmd_buf[0] >> 6) & 0x3F);
+    std::string function_string = fmt::format("fn '{}': port={}", name, port_name);
     for (int i = 1; i <= num_params; ++i)
-        function_string += fmt::format(", cmd_buff[{}]={:#X}", i, cmd_buff[i]);
-
+        function_string += fmt::format(", cmd_buf[{}]={:#X}", i, cmd_buf[i]);
     return function_string;
 }
 

src/core/hle/service/sm/sm_controller.cpp

@@ -119,7 +119,7 @@ Controller::Controller(Core::System& system_) : ServiceFramework{system_, "IpcCo
         {2, &Controller::CloneCurrentObject, "CloneCurrentObject"},
         {3, &Controller::QueryPointerBufferSize, "QueryPointerBufferSize"},
         {4, &Controller::CloneCurrentObjectEx, "CloneCurrentObjectEx"},
-        {5, &Controller::SetPointerBufferSize, "SetPointerBufferSize"},
+        {5, &Controller::SetPointerBufferSize, "SetPointerBufferSize"}, //TODO: where does this come from
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/sockets/bsd.cpp

@@ -1015,11 +1015,23 @@ BSD::BSD(Core::System& system_, const char* name)
         {26, &BSD::Close, "Close"},
         {27, &BSD::DuplicateSocket, "DuplicateSocket"},
         {28, nullptr, "GetResourceStatistics"},
-        {29, nullptr, "RecvMMsg"},
-        {30, nullptr, "SendMMsg"},
-        {31, &BSD::EventFd, "EventFd"},
-        {32, nullptr, "RegisterResourceStatisticsName"},
-        {33, nullptr, "Initialize2"},
+        {29, nullptr, "RecvMMsg"}, //3.0.0+
+        {30, nullptr, "SendMMsg"}, //3.0.0+
+        {31, &BSD::EventFd, "EventFd"}, //7.0.0+
+        {32, nullptr, "RegisterResourceStatisticsName"}, //7.0.0+
+        {33, nullptr, "RegisterClientShared"}, //10.0.0+
+        {34, nullptr, "GetSocketStatistics"}, //15.0.0+
+        {35, nullptr, "NifIoctl"}, //17.0.0+
+        {36, nullptr, "Unknown36"}, //18.0.0+
+        {37, nullptr, "Unknown37"}, //18.0.0+
+        {38, nullptr, "Unknown38"}, //18.0.0+
+        {39, nullptr, "Unknown39"}, //20.0.0+
+        {40, nullptr, "Unknown40"}, //20.0.0+
+        {41, nullptr, "Unknown41"}, //21.0.0+
+        {42, nullptr, "Unknown42"}, //21.0.0+
+        {43, nullptr, "Unknown43"}, //21.0.0+
+        {200, nullptr, "SetThreadCoreMask"}, //15.0.0+
+        {201, nullptr, "GetThreadCoreMask"}, //15.0.0+
     };
     // clang-format on
 

src/core/hle/service/sockets/sockets.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -82,6 +85,10 @@ enum class OptName : u32 {
     RCVTIMEO = 0x1006,
     ERROR_ = 0x1007,   // avoid name collision with Windows macro
     NOSIGPIPE = 0x800, // at least according to libnx
+    ACCEPTFILTER = 0x1000,
+    BINTIME = 0x2000,
+    NO_OFFLOAD = 0x4000,
+    NO_DDP = 0x8000,
 };
 
 enum class ShutdownHow : s32 {

src/dynarmic/CMakeLists.txt

@@ -9,6 +9,8 @@ set(dynarmic_VERSION_PATCH 0)
 
 set(dynarmic_VERSION ${dynarmic_VERSION_MAJOR}.${dynarmic_VERSION_MINOR}.${dynarmic_VERSION_PATCH})
 
+project(dynarmic LANGUAGES C CXX ASM VERSION ${dynarmic_VERSION})
+
 # Determine if we're built as a subproject (using add_subdirectory)
 # or if this is the master project.
 set(MASTER_PROJECT OFF)
@@ -30,7 +32,7 @@ else()
 endif()
 option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${REQUIRE_WX})
 
-option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" OFF)
+option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" ON)
 option(DYNARMIC_TESTS_USE_UNICORN "Enable fuzzing tests against unicorn" OFF)
 CMAKE_DEPENDENT_OPTION(DYNARMIC_USE_LLVM "Support disassembly of jitted x86_64 code using LLVM" OFF "NOT YUZU_DISABLE_LLVM" OFF)
 

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.cpp

@@ -102,9 +102,6 @@ A32EmitX64::BlockDescriptor A32EmitX64::Emit(IR::Block& block) {
     }
 
     code.EnableWriting();
-    SCOPE_EXIT {
-        code.DisableWriting();
-    };
 
     const boost::container::static_vector<HostLoc, 28> gpr_order = [this] {
         boost::container::static_vector<HostLoc, 28> gprs{any_gpr};
@@ -126,37 +123,31 @@ A32EmitX64::BlockDescriptor A32EmitX64::Emit(IR::Block& block) {
 
     EmitCondPrelude(ctx);
 
-    auto const loop_all_inst = [this, &block, &ctx](auto const func) {
-        for (auto iter = block.begin(); iter != block.end(); ++iter) [[likely]] {
-            auto* inst = &*iter;
-            // Call the relevant Emit* member function.
-            switch (inst->GetOpcode()) {
+    for (auto iter = block.begin(); iter != block.end(); ++iter) [[likely]] {
+        auto* inst = &*iter;
+        // Call the relevant Emit* member function.
+        switch (inst->GetOpcode()) {
 #define OPCODE(name, type, ...)                     \
-            case IR::Opcode::name:                  \
-                A32EmitX64::Emit##name(ctx, inst);  \
-                break;
+        case IR::Opcode::name:                  \
+            A32EmitX64::Emit##name(ctx, inst);  \
+            break;
 #define A32OPC(name, type, ...)                     \
-            case IR::Opcode::A32##name:             \
-                A32EmitX64::EmitA32##name(ctx, inst);\
-                break;
+        case IR::Opcode::A32##name:             \
+            A32EmitX64::EmitA32##name(ctx, inst);\
+            break;
 #define A64OPC(...)
 #include "dynarmic/ir/opcodes.inc"
 #undef OPCODE
 #undef A32OPC
 #undef A64OPC
-            default:
-                UNREACHABLE();
-            }
-            reg_alloc.EndOfAllocScope();
-            func(reg_alloc);
+        default:
+            UNREACHABLE();
         }
-    };
-    if (!conf.very_verbose_debugging_output) [[likely]] {
-        loop_all_inst([](auto&) { /*noop*/ });
-    } else [[unlikely]] {
-        loop_all_inst([this](auto& reg_alloc) {
+        reg_alloc.EndOfAllocScope();
+#ifndef NDEBUG
+        if (conf.very_verbose_debugging_output)
             EmitVerboseDebuggingOutput(reg_alloc);
-        });
+#endif
     }
 
     reg_alloc.AssertNoMoreUses();
@@ -172,7 +163,7 @@ A32EmitX64::BlockDescriptor A32EmitX64::Emit(IR::Block& block) {
     }
     code.int3();
 
-    const size_t size = static_cast<size_t>(code.getCurr() - entrypoint);
+    const size_t size = size_t(code.getCurr() - entrypoint);
 
     const A32::LocationDescriptor descriptor{block.Location()};
     const A32::LocationDescriptor end_location{block.EndLocation()};
@@ -180,7 +171,9 @@ A32EmitX64::BlockDescriptor A32EmitX64::Emit(IR::Block& block) {
     const auto range = boost::icl::discrete_interval<u32>::closed(descriptor.PC(), end_location.PC() - 1);
     block_ranges.AddRange(range, descriptor);
 
-    return RegisterBlock(descriptor, entrypoint, size);
+    auto const bdesc = RegisterBlock(descriptor, entrypoint, size);
+    code.DisableWriting();
+    return bdesc;
 }
 
 void A32EmitX64::ClearCache() {

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.cpp

@@ -76,10 +76,6 @@ A64EmitX64::BlockDescriptor A64EmitX64::Emit(IR::Block& block) noexcept {
     }
 
     code.EnableWriting();
-    SCOPE_EXIT {
-        code.DisableWriting();
-    };
-
     const boost::container::static_vector<HostLoc, 28> gpr_order = [this] {
         boost::container::static_vector<HostLoc, 28> gprs{any_gpr};
         if (conf.fastmem_pointer) {
@@ -141,9 +137,10 @@ a64_branch:
         (this->*a64_handlers[size_t(opcode) - std::size(opcode_handlers)])(ctx, &inst);
 finish_this_inst:
         ctx.reg_alloc.EndOfAllocScope();
-        if (conf.very_verbose_debugging_output) [[unlikely]] {
+#ifndef NDEBUG
+        if (conf.very_verbose_debugging_output)
             EmitVerboseDebuggingOutput(reg_alloc);
-        }
+#endif
     }
 
     reg_alloc.AssertNoMoreUses();
@@ -167,7 +164,9 @@ finish_this_inst:
     const auto range = boost::icl::discrete_interval<u64>::closed(descriptor.PC(), end_location.PC() - 1);
     block_ranges.AddRange(range, descriptor);
 
-    return RegisterBlock(descriptor, entrypoint, size);
+    auto bdesc = RegisterBlock(descriptor, entrypoint, size);
+    code.DisableWriting();
+    return bdesc;
 }
 
 void A64EmitX64::ClearCache() {

src/dynarmic/src/dynarmic/backend/x64/emit_x64.cpp

@@ -105,6 +105,7 @@ void EmitX64::PushRSBHelper(Xbyak::Reg64 loc_desc_reg, Xbyak::Reg64 index_reg, I
     code.mov(dword[code.ABI_JIT_PTR + code.GetJitStateInfo().offsetof_rsb_ptr], index_reg.cvt32());
 }
 
+#ifndef NDEBUG
 void EmitX64::EmitVerboseDebuggingOutput(RegAlloc& reg_alloc) {
     code.lea(rsp, ptr[rsp - sizeof(RegisterData)]);
     code.stmxcsr(dword[rsp + offsetof(RegisterData, mxcsr)]);
@@ -134,6 +135,7 @@ void EmitX64::EmitVerboseDebuggingOutput(RegAlloc& reg_alloc) {
     code.ldmxcsr(dword[rsp + offsetof(RegisterData, mxcsr)]);
     code.add(rsp, sizeof(RegisterData));
 }
+#endif
 
 void EmitX64::EmitPushRSB(EmitContext& ctx, IR::Inst* inst) {
     auto args = ctx.reg_alloc.GetArgumentInfo(inst);

src/dynarmic/src/dynarmic/backend/x64/emit_x64.h

@@ -113,7 +113,9 @@ public:
     BlockDescriptor RegisterBlock(const IR::LocationDescriptor& location_descriptor, CodePtr entrypoint, size_t size);
     void PushRSBHelper(Xbyak::Reg64 loc_desc_reg, Xbyak::Reg64 index_reg, IR::LocationDescriptor target);
 
+#ifndef NDEBUG
     void EmitVerboseDebuggingOutput(RegAlloc& reg_alloc);
+#endif
     virtual void EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept = 0;
 
     // Patching

src/dynarmic/src/dynarmic/backend/x64/hostloc.h

@@ -58,7 +58,7 @@ enum class HostLoc : std::uint8_t {
     FirstSpill,
 };
 
-constexpr size_t NonSpillHostLocCount = static_cast<size_t>(HostLoc::FirstSpill);
+constexpr size_t NonSpillHostLocCount = size_t(HostLoc::FirstSpill);
 
 constexpr bool HostLocIsGPR(HostLoc reg) {
     return reg >= HostLoc::RAX && reg <= HostLoc::R15;

src/dynarmic/src/dynarmic/backend/x64/reg_alloc.cpp

@@ -56,26 +56,23 @@ static inline bool IsValuelessType(const IR::Type type) noexcept {
 }
 
 void HostLocInfo::ReleaseOne() noexcept {
-    is_being_used_count--;
+    ASSERT(is_being_used_count > 0);
+    --is_being_used_count;
     is_scratch = false;
-
-    if (current_references == 0)
-        return;
-
-    ASSERT(size_t(accumulated_uses) + 1 < (std::numeric_limits<uint16_t>::max)());
-    accumulated_uses++;
-    current_references--;
-
-    if (current_references == 0)
-        ReleaseAll();
+    if (current_references > 0) {
+        ASSERT(size_t(accumulated_uses) + 1 < (std::numeric_limits<decltype(accumulated_uses)>::max)());
+        ++accumulated_uses;
+        --current_references;
+        if (current_references == 0)
+            ReleaseAll();
+    }
 }
 
 void HostLocInfo::ReleaseAll() noexcept {
+    ASSERT(size_t(accumulated_uses) + current_references < (std::numeric_limits<decltype(accumulated_uses)>::max)());
     accumulated_uses += current_references;
     current_references = 0;
-
     is_set_last_use = false;
-
     if (total_uses == accumulated_uses) {
         values.clear();
         accumulated_uses = 0;
@@ -87,17 +84,19 @@ void HostLocInfo::ReleaseAll() noexcept {
     is_scratch = false;
 }
 
-void HostLocInfo::AddValue(IR::Inst* inst) noexcept {
+void HostLocInfo::AddValue(HostLoc loc, IR::Inst* inst) noexcept {
     if (is_set_last_use) {
         is_set_last_use = false;
         values.clear();
     }
     values.push_back(inst);
-    ASSERT(size_t(total_uses) + inst->UseCount() < (std::numeric_limits<uint16_t>::max)());
+
+    ASSERT(size_t(total_uses) + inst->UseCount() < (std::numeric_limits<decltype(total_uses)>::max)());
     total_uses += inst->UseCount();
     max_bit_width = std::max<uint8_t>(max_bit_width, std::countr_zero(GetBitWidth(inst->GetType())));
 }
 
+#ifndef NDEBUG
 void HostLocInfo::EmitVerboseDebuggingOutput(BlockOfCode& code, size_t host_loc_index) const noexcept {
     using namespace Xbyak::util;
     for (auto const value : values) {
@@ -108,6 +107,7 @@ void HostLocInfo::EmitVerboseDebuggingOutput(BlockOfCode& code, size_t host_loc_
         code.CallFunction(PrintVerboseDebuggingOutputLine);
     }
 }
+#endif
 
 bool Argument::FitsInImmediateU32() const noexcept {
     if (!IsImmediate())
@@ -197,12 +197,13 @@ RegAlloc::ArgumentInfo RegAlloc::GetArgumentInfo(const IR::Inst* inst) noexcept
         Argument{},
         Argument{}
     };
-    for (size_t i = 0; i < inst->NumArgs(); i++) {
+    for (size_t i = 0; i < inst->NumArgs() && i < 4; i++) {
         const auto arg = inst->GetArg(i);
         ret[i].value = arg;
         if (!arg.IsImmediate() && !IsValuelessType(arg.GetType())) {
-            ASSERT(ValueLocation(arg.GetInst()) && "argument must already been defined");
-            LocInfo(*ValueLocation(arg.GetInst())).AddArgReference();
+            auto const loc = ValueLocation(arg.GetInst());
+            ASSERT(loc && "argument must already been defined");
+            LocInfo(*loc).AddArgReference();
         }
     }
     return ret;
@@ -211,9 +212,9 @@ RegAlloc::ArgumentInfo RegAlloc::GetArgumentInfo(const IR::Inst* inst) noexcept
 void RegAlloc::RegisterPseudoOperation(const IR::Inst* inst) noexcept {
     ASSERT(IsValueLive(inst) || !inst->HasUses());
     for (size_t i = 0; i < inst->NumArgs(); i++) {
-        const auto arg = inst->GetArg(i);
+        auto const arg = inst->GetArg(i);
         if (!arg.IsImmediate() && !IsValuelessType(arg.GetType())) {
-            if (const auto loc = ValueLocation(arg.GetInst())) {
+            if (auto const loc = ValueLocation(arg.GetInst())) {
                 // May not necessarily have a value (e.g. CMP variant of Sub32).
                 LocInfo(*loc).AddArgReference();
             }
@@ -262,9 +263,8 @@ HostLoc RegAlloc::UseImpl(BlockOfCode& code, IR::Value use_value, const boost::c
         return LoadImmediate(code, use_value, ScratchImpl(code, desired_locations));
     }
 
-    const auto* use_inst = use_value.GetInst();
-    const HostLoc current_location = *ValueLocation(use_inst);
-    const size_t max_bit_width = LocInfo(current_location).GetMaxBitWidth();
+    auto const* use_inst = use_value.GetInst();
+    HostLoc const current_location = *ValueLocation(use_inst);
 
     const bool can_use_current_location = std::find(desired_locations.begin(), desired_locations.end(), current_location) != desired_locations.end();
     if (can_use_current_location) {
@@ -276,7 +276,8 @@ HostLoc RegAlloc::UseImpl(BlockOfCode& code, IR::Value use_value, const boost::c
         return UseScratchImpl(code, use_value, desired_locations);
     }
 
-    const HostLoc destination_location = SelectARegister(desired_locations);
+    size_t const max_bit_width = LocInfo(current_location).GetMaxBitWidth();
+    HostLoc const destination_location = SelectARegister(desired_locations);
     if (max_bit_width > HostLocBitWidth(destination_location)) {
         return UseScratchImpl(code, use_value, desired_locations);
     } else if (CanExchange(destination_location, current_location)) {
@@ -300,10 +301,10 @@ HostLoc RegAlloc::UseScratchImpl(BlockOfCode& code, IR::Value use_value, const b
 
     const bool can_use_current_location = std::find(desired_locations.begin(), desired_locations.end(), current_location) != desired_locations.end();
     if (can_use_current_location && !LocInfo(current_location).IsLocked()) {
-        if (!LocInfo(current_location).IsLastUse()) {
-            MoveOutOfTheWay(code, current_location);
+        if (LocInfo(current_location).IsLastUse()) {
+            LocInfo(current_location).is_set_last_use = true;
         } else {
-            LocInfo(current_location).SetLastUse();
+            MoveOutOfTheWay(code, current_location);
         }
         LocInfo(current_location).WriteLock();
         return current_location;
@@ -455,29 +456,31 @@ HostLoc RegAlloc::SelectARegister(const boost::container::static_vector<HostLoc,
 
 std::optional<HostLoc> RegAlloc::ValueLocation(const IR::Inst* value) const noexcept {
     for (size_t i = 0; i < hostloc_info.size(); i++)
-        if (hostloc_info[i].ContainsValue(value))
+        if (hostloc_info[i].ContainsValue(value)) {
+            //for (size_t j = 0; j < hostloc_info.size(); ++j)
+            //    ASSERT((i == j || !hostloc_info[j].ContainsValue(value)) && "duplicate defs");
             return HostLoc(i);
+        }
     return std::nullopt;
 }
 
 void RegAlloc::DefineValueImpl(BlockOfCode& code, IR::Inst* def_inst, HostLoc host_loc) noexcept {
     ASSERT(!ValueLocation(def_inst) && "def_inst has already been defined");
-    LocInfo(host_loc).AddValue(def_inst);
+    LocInfo(host_loc).AddValue(host_loc, def_inst);
+    ASSERT(*ValueLocation(def_inst) == host_loc);
 }
 
 void RegAlloc::DefineValueImpl(BlockOfCode& code, IR::Inst* def_inst, const IR::Value& use_inst) noexcept {
     ASSERT(!ValueLocation(def_inst) && "def_inst has already been defined");
-
     if (use_inst.IsImmediate()) {
         const HostLoc location = ScratchImpl(code, gpr_order);
         DefineValueImpl(code, def_inst, location);
         LoadImmediate(code, use_inst, location);
-        return;
+    } else {
+        ASSERT(ValueLocation(use_inst.GetInst()) && "use_inst must already be defined");
+        const HostLoc location = *ValueLocation(use_inst.GetInst());
+        DefineValueImpl(code, def_inst, location);
     }
-
-    ASSERT(ValueLocation(use_inst.GetInst()) && "use_inst must already be defined");
-    const HostLoc location = *ValueLocation(use_inst.GetInst());
-    DefineValueImpl(code, def_inst, location);
 }
 
 void RegAlloc::Move(BlockOfCode& code, HostLoc to, HostLoc from) noexcept {

src/dynarmic/src/dynarmic/backend/x64/reg_alloc.h

@@ -46,61 +46,55 @@ public:
         return is_being_used_count == 0 && values.empty();
     }
     inline bool IsLastUse() const {
-        return is_being_used_count == 0 && current_references == 1 && accumulated_uses + 1 == total_uses;
-    }
-    inline void SetLastUse() noexcept {
-        ASSERT(IsLastUse());
-        is_set_last_use = true;
+        return is_being_used_count == 0 && current_references == 1 && size_t(accumulated_uses) + 1 == size_t(total_uses);
     }
     inline void ReadLock() noexcept {
-        ASSERT(size_t(is_being_used_count) + 1 < (std::numeric_limits<uint16_t>::max)());
+        ASSERT(size_t(is_being_used_count) + 1 < (std::numeric_limits<decltype(is_being_used_count)>::max)());
         ASSERT(!is_scratch);
         is_being_used_count++;
     }
     inline void WriteLock() noexcept {
-        ASSERT(size_t(is_being_used_count) + 1 < (std::numeric_limits<uint16_t>::max)());
         ASSERT(is_being_used_count == 0);
         is_being_used_count++;
         is_scratch = true;
     }
     inline void AddArgReference() noexcept {
-        ASSERT(size_t(current_references) + 1 < (std::numeric_limits<uint16_t>::max)());
-        current_references++;
-        ASSERT(accumulated_uses + current_references <= total_uses);
+        ASSERT(size_t(current_references) + 1 < (std::numeric_limits<decltype(current_references)>::max)());
+        ++current_references;
+        ASSERT(size_t(accumulated_uses) + current_references <= size_t(total_uses));
     }
     void ReleaseOne() noexcept;
     void ReleaseAll() noexcept;
-
+    constexpr size_t GetMaxBitWidth() const noexcept { return 1 << max_bit_width; }
+    void AddValue(HostLoc loc, IR::Inst* inst) noexcept;
     /// Checks if the given instruction is in our values set
     /// SAFETY: Const is casted away, irrelevant since this is only used for checking
-    inline bool ContainsValue(const IR::Inst* inst) const noexcept {
-        //return values.contains(const_cast<IR::Inst*>(inst));
+    [[nodiscard]] bool ContainsValue(const IR::Inst* inst) const noexcept {
         return std::find(values.begin(), values.end(), inst) != values.end();
     }
-    inline size_t GetMaxBitWidth() const noexcept {
-        return 1 << max_bit_width;
-    }
-    void AddValue(IR::Inst* inst) noexcept;
+#ifndef NDEBUG
     void EmitVerboseDebuggingOutput(BlockOfCode& code, size_t host_loc_index) const noexcept;
+#endif
 private:
-//non trivial
     boost::container::small_vector<IR::Inst*, 3> values; //24
-    // Block state
-    uint16_t total_uses = 0; //8
-    //sometimes zeroed
-    uint16_t accumulated_uses = 0; //8
+//non trivial
+    // Block state, the total amount of uses for this particular arg
+    uint16_t total_uses = 0; //2
+    // Sometimes zeroed, accumulated (non referenced) uses
+    uint16_t accumulated_uses = 0; //2
 //always zeroed
     // Current instruction state
-    uint16_t is_being_used_count = 0; //8
-    uint16_t current_references = 0; //8
-    // Value state
+    uint8_t current_references = 0; //1
+    uint8_t is_being_used_count = 0; //1
+    // Value state, count for LRU selection in registers
     uint8_t lru_counter : 2 = 0; //1
-    uint8_t max_bit_width : 4 = 0; //Valid values: log2(1,2,4,8,16,32,128) = (0, 1, 2, 3, 4, 5, 6)
+    // Log 2 of bit width, valid values: log2(1,2,4,8,16,32,128) = (0, 1, 2, 3, 4, 5, 6)
+    uint8_t max_bit_width : 4 = 0;
     bool is_scratch : 1 = false; //1
     bool is_set_last_use : 1 = false; //1
     friend class RegAlloc;
 };
-static_assert(sizeof(HostLocInfo) == 64);
+//static_assert(sizeof(HostLocInfo) == 64);
 
 struct Argument {
 public:
@@ -213,10 +207,12 @@ public:
     inline void AssertNoMoreUses() noexcept {
         ASSERT(std::all_of(hostloc_info.begin(), hostloc_info.end(), [](const auto& i) noexcept { return i.IsEmpty(); }));
     }
+#ifndef NDEBUG
     inline void EmitVerboseDebuggingOutput(BlockOfCode& code) noexcept {
         for (size_t i = 0; i < hostloc_info.size(); i++)
             hostloc_info[i].EmitVerboseDebuggingOutput(code, i);
     }
+#endif
 private:
     friend struct Argument;
 
@@ -238,11 +234,11 @@ private:
     HostLoc FindFreeSpill(bool is_xmm) const noexcept;
 
     inline HostLocInfo& LocInfo(const HostLoc loc) noexcept {
-        ASSERT(loc != HostLoc::RSP && loc != ABI_JIT_PTR);
+        DEBUG_ASSERT(loc != HostLoc::RSP && loc != ABI_JIT_PTR);
         return hostloc_info[size_t(loc)];
     }
     inline const HostLocInfo& LocInfo(const HostLoc loc) const noexcept {
-        ASSERT(loc != HostLoc::RSP && loc != ABI_JIT_PTR);
+        DEBUG_ASSERT(loc != HostLoc::RSP && loc != ABI_JIT_PTR);
         return hostloc_info[size_t(loc)];
     }
 
@@ -256,6 +252,6 @@ private:
     size_t reserved_stack_space = 0;
 };
 // Ensure a cache line (or less) is used, this is primordial
-static_assert(sizeof(boost::container::static_vector<HostLoc, 28>) == 40);
+static_assert(sizeof(boost::container::static_vector<HostLoc, 28>) < 64);
 
 }  // namespace Dynarmic::Backend::X64

src/dynarmic/src/dynarmic/ir/microinstruction.h

@@ -74,7 +74,6 @@ public:
     void SetName(unsigned value) { name = value; }
     unsigned GetName() const { return name; }
 
-private:
     void Use(const Value& value);
     void UndoUse(const Value& value);
 
@@ -87,6 +86,6 @@ private:
     unsigned name = 0; //4 (4)
     alignas(64) std::array<Value, max_arg_count> args; //16 * 4 = 64 (1 cache line)
 };
-static_assert(sizeof(Inst) == 128);
+//static_assert(sizeof(Inst) == 128);
 
 }  // namespace Dynarmic::IR

src/dynarmic/src/dynarmic/ir/opt_passes.cpp

@@ -1227,28 +1227,32 @@ static void DeadCodeElimination(IR::Block& block) {
 }
 
 static void IdentityRemovalPass(IR::Block& block) {
-    boost::container::small_vector<IR::Inst*, 16> to_invalidate;
-    for (auto it = block.begin(); it != block.end();) {
-        const size_t num_args = it->NumArgs();
-        for (size_t i = 0; i < num_args; ++i) {
-            IR::Value arg = it->GetArg(i);
-            if (arg.IsIdentity()) {
-                do {
-                    arg = arg.GetInst()->GetArg(0);
-                } while (arg.IsIdentity());
-                it->SetArg(i, arg);
+    boost::container::small_vector<IR::Inst*, 128> to_invalidate;
+
+    auto iter = block.begin();
+    while (iter != block.end()) {
+        IR::Inst& inst = *iter;
+
+        const size_t num_args = inst.NumArgs();
+        for (size_t i = 0; i < num_args; i++) {
+            while (true) {
+                IR::Value arg = inst.GetArg(i);
+                if (!arg.IsIdentity())
+                    break;
+                inst.SetArg(i, arg.GetInst()->GetArg(0));
             }
         }
 
-        if (it->GetOpcode() == IR::Opcode::Identity || it->GetOpcode() == IR::Opcode::Void) {
-            to_invalidate.push_back(&*it);
-            it = block.Instructions().erase(it);
+        if (inst.GetOpcode() == IR::Opcode::Identity || inst.GetOpcode() == IR::Opcode::Void) {
+            iter = block.Instructions().erase(inst);
+            to_invalidate.push_back(&inst);
         } else {
-            ++it;
+            ++iter;
         }
     }
-    for (IR::Inst* const inst : to_invalidate)
+    for (IR::Inst* inst : to_invalidate) {
         inst->Invalidate();
+    }
 }
 
 static void NamingPass(IR::Block& block) {

src/qt_common/discord/discord_impl.cpp

@@ -84,6 +84,7 @@ void DiscordImpl::UpdateGameStatus(bool use_default) {
     presence.smallImageKey = DEFAULT_DISCORD_IMAGE;
     presence.smallImageText = DEFAULT_DISCORD_TEXT;
     presence.state = game_title.c_str();
+    presence.status_display_type = DiscordStatusDisplayType_State;
     presence.details = "Currently in game";
     presence.startTimestamp = start_time;
     Discord_UpdatePresence(&presence);
@@ -123,6 +124,7 @@ void DiscordImpl::Update() {
     DiscordRichPresence presence{};
     presence.largeImageKey = DEFAULT_DISCORD_IMAGE;
     presence.largeImageText = DEFAULT_DISCORD_TEXT;
+    presence.status_display_type = DiscordStatusDisplayType_Name;
     presence.details = "Currently not in game";
     presence.startTimestamp = start_time;
     Discord_UpdatePresence(&presence);

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <array>
 #include <span>
 #include <tuple>
 #include <type_traits>
@@ -24,6 +25,120 @@ template <class Func>
 struct FuncTraits {};
     thread_local std::unique_ptr<spvtools::Optimizer> thread_optimizer;
 
+static bool TryEmitCoalescedStorage(EmitContext& ctx, IR::Block::iterator& it,
+                                    IR::Block::iterator end) {
+    IR::Inst& inst = *it;
+    const auto opcode = inst.GetOpcode();
+
+    const bool is_u8 = opcode == IR::Opcode::WriteStorageU8 || opcode == IR::Opcode::WriteStorageS8;
+    const bool is_u16 = opcode == IR::Opcode::WriteStorageU16 || opcode == IR::Opcode::WriteStorageS16;
+
+    if ((is_u8 && ctx.profile.support_int8) || (is_u16 && ctx.profile.support_int16)) {
+        return false;
+    }
+
+    if (!is_u8 && !is_u16) {
+        return false;
+    }
+
+    if (!inst.Arg(0).IsImmediate() || !inst.Arg(1).IsImmediate()) {
+        return false;
+    }
+
+    const u32 binding = inst.Arg(0).U32();
+    const u32 base_offset = inst.Arg(1).U32();
+    const u32 base_word = base_offset / 4;
+    const u32 base_byte = base_offset % 4;
+
+    const u32 step_bytes = is_u8 ? 1u : 2u;
+    const u32 max_bytes = is_u8 ? 4u : 4u;
+
+    if (is_u16 && (base_offset % 2u) != 0) {
+        return false;
+    }
+
+    std::array<IR::Inst*, 4> grouped{};
+    grouped[0] = &inst;
+    u32 grouped_bytes = step_bytes;
+    auto look_ahead = it;
+
+    while (grouped_bytes < max_bytes) {
+        auto next = std::next(look_ahead);
+        if (next == end) {
+            break;
+        }
+        const auto next_opcode = next->GetOpcode();
+        const bool next_is_u8 = next_opcode == IR::Opcode::WriteStorageU8 || next_opcode == IR::Opcode::WriteStorageS8;
+        const bool next_is_u16 = next_opcode == IR::Opcode::WriteStorageU16 || next_opcode == IR::Opcode::WriteStorageS16;
+        if (next_is_u8 != is_u8 || next_is_u16 != is_u16) {
+            break;
+        }
+        if (!next->Arg(0).IsImmediate() || !next->Arg(1).IsImmediate()) {
+            break;
+        }
+        const u32 next_binding = next->Arg(0).U32();
+        const u32 next_offset = next->Arg(1).U32();
+        if (next_binding != binding) {
+            break;
+        }
+        if (next_offset / 4 != base_word) {
+            break;
+        }
+
+        const u32 expected_offset = base_offset + grouped_bytes;
+        if (next_offset != expected_offset) {
+            break;
+        }
+
+        grouped[grouped_bytes / step_bytes] = &*next;
+        grouped_bytes += step_bytes;
+        look_ahead = next;
+    }
+
+    const u32 count = grouped_bytes / step_bytes;
+    if (count <= 1) {
+        return false;
+    }
+
+    Id combined = ctx.u32_zero_value;
+    for (u32 i = 0; i < count; ++i) {
+        IR::Inst* current = grouped[i];
+        Id raw = ctx.Def(current->Arg(2));
+        if (is_u8) {
+            raw = ctx.OpBitwiseAnd(ctx.U32[1], raw, ctx.Const(0xFFu));
+        } else {
+            raw = ctx.OpBitwiseAnd(ctx.U32[1], raw, ctx.Const(0xFFFFu));
+        }
+        const u32 shift_bits = (is_u8 ? i * 8u : i * 16u);
+        Id shifted = raw;
+        if (shift_bits != 0) {
+            shifted = ctx.OpShiftLeftLogical(ctx.U32[1], raw, ctx.Const(shift_bits));
+        }
+        if (i == 0) {
+            combined = shifted;
+        } else {
+            combined = ctx.OpBitwiseOr(ctx.U32[1], combined, shifted);
+        }
+    }
+
+    const u32 bit_offset_val = is_u8 ? base_byte * 8u : ((base_offset / 2u) % 2u) * 16u;
+    const u32 bit_count_val = grouped_bytes * 8u;
+
+    const Id ssbo = ctx.ssbos[binding].U32;
+    const Id index = ctx.Const(base_word);
+    const Id pointer = ctx.OpAccessChain(ctx.storage_types.U32.element, ssbo, ctx.u32_zero_value, index);
+
+    if (bit_count_val == 32 && bit_offset_val == 0) {
+        ctx.OpStore(pointer, combined);
+    } else {
+        ctx.OpFunctionCall(ctx.TypeVoid(), ctx.write_storage_cas_loop_func, pointer, combined,
+                           ctx.Const(bit_offset_val), ctx.Const(bit_count_val));
+    }
+
+    it = look_ahead;
+    return true;
+}
+
     spvtools::Optimizer& GetThreadOptimizer() {
         if (!thread_optimizer) {
             thread_optimizer = std::make_unique<spvtools::Optimizer>(SPV_ENV_VULKAN_1_3);
@@ -140,8 +255,11 @@ void Traverse(EmitContext& ctx, IR::Program& program) {
             }
             current_block = node.data.block;
             ctx.AddLabel(label);
-            for (IR::Inst& inst : node.data.block->Instructions()) {
-                EmitInst(ctx, &inst);
+            for (auto it = node.data.block->begin(); it != node.data.block->end(); ++it) {
+                if (TryEmitCoalescedStorage(ctx, it, node.data.block->end())) {
+                    continue;
+                }
+                EmitInst(ctx, &*it);
             }
             break;
         }

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -906,6 +906,9 @@ void EmitContext::DefineWriteStorageCasLoopFunction(const Info& info) {
     const Id continue_label{OpLabel()};
     const Id endloop_label{OpLabel()};
     const Id beginloop_label{OpLabel()};
+    const Id max_iterations{Const(16u)};
+    const Id iteration_counter{OpVariable(TypePointer(spv::StorageClass::Function, U32[1]),
+                                          spv::StorageClass::Function, u32_zero_value)};
     OpBranch(beginloop_label);
 
     AddLabel(beginloop_label);
@@ -913,11 +916,20 @@ void EmitContext::DefineWriteStorageCasLoopFunction(const Info& info) {
     OpBranch(body_label);
 
     AddLabel(body_label);
+        const Id current_iteration{OpLoad(U32[1], iteration_counter)};
+        const Id iteration_exceeded{OpUGreaterThanEqual(U1, current_iteration, max_iterations)};
+        const Id bailout_label{OpLabel()};
+        OpSelectionMerge(bailout_label, spv::SelectionControlMask::MaskNone);
+        OpBranchConditional(iteration_exceeded, bailout_label, bailout_label);
+        AddLabel(bailout_label);
+
     const Id expected_value{OpLoad(U32[1], pointer)};
     const Id desired_value{OpBitFieldInsert(U32[1], expected_value, value, bit_offset, bit_count)};
     const Id actual_value{OpAtomicCompareExchange(U32[1], pointer, scope_device, ordering_relaxed,
                                                   ordering_relaxed, desired_value, expected_value)};
     const Id store_successful{OpIEqual(U1, expected_value, actual_value)};
+    const Id next_iteration{OpIAdd(U32[1], current_iteration, Const(1u))};
+    OpStore(iteration_counter, next_iteration);
     OpBranchConditional(store_successful, endloop_label, continue_label);
 
     AddLabel(endloop_label);
@@ -1432,6 +1444,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (info.uses_sample_id) {
         sample_id = DefineInput(*this, U32[1], false, spv::BuiltIn::SampleId);
+        if (stage == Stage::Fragment) {
+            Decorate(sample_id, spv::Decoration::Flat);
+        }
     }
     if (info.uses_is_helper_invocation) {
         is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
@@ -1442,6 +1457,13 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
         subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
         subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
+            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_le, spv::Decoration::Flat);
+            Decorate(subgroup_mask_gt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
+        }
     }
     if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
         (profile.warp_size_potentially_larger_than_guest &&
@@ -1449,7 +1471,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         AddCapability(spv::Capability::GroupNonUniform);
         subgroup_local_invocation_id =
             DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+        }
     }
     if (info.uses_fswzadd) {
         const Id f32_one{Const(1.0f)};
@@ -1461,6 +1485,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (loads[IR::Attribute::PrimitiveId]) {
         primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
+        if (stage == Stage::Fragment) {
+            Decorate(primitive_id, spv::Decoration::Flat);
+        }
     }
     if (loads[IR::Attribute::Layer]) {
         AddCapability(spv::Capability::Geometry);
@@ -1552,17 +1579,21 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (stage != Stage::Fragment) {
             continue;
         }
-        switch (info.interpolation[index]) {
-        case Interpolation::Smooth:
-            // Default
-            // Decorate(id, spv::Decoration::Smooth);
-            break;
-        case Interpolation::NoPerspective:
-            Decorate(id, spv::Decoration::NoPerspective);
-            break;
-        case Interpolation::Flat:
+        const bool is_integer = input_type == AttributeType::SignedInt ||
+                                input_type == AttributeType::UnsignedInt;
+        if (is_integer) {
             Decorate(id, spv::Decoration::Flat);
-            break;
+        } else {
+            switch (info.interpolation[index]) {
+            case Interpolation::Smooth:
+                break;
+            case Interpolation::NoPerspective:
+                Decorate(id, spv::Decoration::NoPerspective);
+                break;
+            case Interpolation::Flat:
+                Decorate(id, spv::Decoration::Flat);
+                break;
+            }
         }
     }
     if (stage == Stage::TessellationEval) {

src/shader_recompiler/ir_opt/identity_removal_pass.cpp

@@ -1,11 +1,7 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <vector>
-#include <boost/container/small_vector.hpp>
 
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/value.h"
@@ -14,30 +10,28 @@
 namespace Shader::Optimization {
 
 void IdentityRemovalPass(IR::Program& program) {
-    boost::container::small_vector<IR::Inst*, 16> to_invalidate;
+    std::vector<IR::Inst*> to_invalidate;
     for (IR::Block* const block : program.blocks) {
-        for (auto it = block->begin(); it != block->end();) {
-            const size_t num_args{it->NumArgs()};
+        for (auto inst = block->begin(); inst != block->end();) {
+            const size_t num_args{inst->NumArgs()};
             for (size_t i = 0; i < num_args; ++i) {
-                IR::Value arg = it->Arg(i);
-                if (arg.IsIdentity()) {
-                    do { // Pointer chasing (3-derefs)
-                        arg = arg.Inst()->Arg(0);
-                    } while (arg.IsIdentity());
-                    it->SetArg(i, arg);
+                IR::Value arg;
+                while ((arg = inst->Arg(i)).IsIdentity()) {
+                    inst->SetArg(i, arg.Inst()->Arg(0));
                 }
             }
-
-            if (it->GetOpcode() == IR::Opcode::Identity || it->GetOpcode() == IR::Opcode::Void) {
-                to_invalidate.push_back(&*it);
-                it = block->Instructions().erase(it);
+            if (inst->GetOpcode() == IR::Opcode::Identity ||
+                inst->GetOpcode() == IR::Opcode::Void) {
+                to_invalidate.push_back(&*inst);
+                inst = block->Instructions().erase(inst);
             } else {
-                ++it;
+                ++inst;
             }
         }
     }
-    for (IR::Inst* const inst : to_invalidate)
+    for (IR::Inst* const inst : to_invalidate) {
         inst->Invalidate();
+    }
 }
 
 } // namespace Shader::Optimization

src/video_core/buffer_cache/buffer_cache.h

@@ -407,6 +407,12 @@ void BufferCache<P>::SetComputeUniformBufferState(u32 mask,
 
 template <class P>
 void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers()) {
+            channel_state->total_graphics_storage_buffers -=
+                static_cast<u32>(std::popcount(channel_state->enabled_storage_buffers[stage]));
+        }
+    }
     channel_state->enabled_storage_buffers[stage] = 0;
     channel_state->written_storage_buffers[stage] = 0;
 }
@@ -414,8 +420,26 @@ void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {
 template <class P>
 bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index,
                                                u32 cbuf_offset, bool is_written) {
+    const bool already_enabled =
+        ((channel_state->enabled_storage_buffers[stage] >> ssbo_index) & 1U) != 0;
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
+            const u32 max_bindings = runtime.GetMaxDynamicStorageBuffers();
+            if (channel_state->total_graphics_storage_buffers >= max_bindings) {
+                LOG_WARNING(HW_GPU,
+                            "Skipping graphics storage buffer {} due to driver limit {}",
+                            ssbo_index, max_bindings);
+                return false;
+            }
+        }
+    }
     channel_state->enabled_storage_buffers[stage] |= 1U << ssbo_index;
     channel_state->written_storage_buffers[stage] |= (is_written ? 1U : 0U) << ssbo_index;
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
+            ++channel_state->total_graphics_storage_buffers;
+        }
+    }
 
     const auto& cbufs = maxwell3d->state.shader_stages[stage];
     const GPUVAddr ssbo_addr = cbufs.const_buffers[cbuf_index].address + cbuf_offset;
@@ -446,6 +470,12 @@ void BufferCache<P>::BindGraphicsTextureBuffer(size_t stage, size_t tbo_index, G
 
 template <class P>
 void BufferCache<P>::UnbindComputeStorageBuffers() {
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers()) {
+            channel_state->total_compute_storage_buffers -=
+                static_cast<u32>(std::popcount(channel_state->enabled_compute_storage_buffers));
+        }
+    }
     channel_state->enabled_compute_storage_buffers = 0;
     channel_state->written_compute_storage_buffers = 0;
     channel_state->image_compute_texture_buffers = 0;
@@ -459,8 +489,26 @@ void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index,
                   ssbo_index);
         return;
     }
+    const bool already_enabled =
+        ((channel_state->enabled_compute_storage_buffers >> ssbo_index) & 1U) != 0;
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
+            const u32 max_bindings = runtime.GetMaxDynamicStorageBuffers();
+            if (channel_state->total_compute_storage_buffers >= max_bindings) {
+                LOG_WARNING(HW_GPU,
+                            "Skipping compute storage buffer {} due to driver limit {}",
+                            ssbo_index, max_bindings);
+                return;
+            }
+        }
+    }
     channel_state->enabled_compute_storage_buffers |= 1U << ssbo_index;
     channel_state->written_compute_storage_buffers |= (is_written ? 1U : 0U) << ssbo_index;
+    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
+        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
+            ++channel_state->total_compute_storage_buffers;
+        }
+    }
 
     const auto& launch_desc = kepler_compute->launch_description;
     if (((launch_desc.const_buffer_enable_mask >> cbuf_index) & 1) == 0) {
@@ -793,9 +841,23 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     const u32 size = (std::min)(binding.size, (*channel_state->uniform_buffer_sizes)[stage][index]);
     Buffer& buffer = slot_buffers[binding.buffer_id];
     TouchBuffer(buffer, binding.buffer_id);
-    const bool use_fast_buffer = binding.buffer_id != NULL_BUFFER_ID &&
-                                 size <= channel_state->uniform_buffer_skip_cache_size &&
-                                 !memory_tracker.IsRegionGpuModified(device_addr, size);
+    const bool has_host_buffer = binding.buffer_id != NULL_BUFFER_ID;
+    const u32 offset = has_host_buffer ? buffer.Offset(device_addr) : 0;
+    const bool needs_alignment_stream = [&]() {
+        if constexpr (IS_OPENGL) {
+            return false;
+        } else {
+            if (!has_host_buffer) {
+                return false;
+            }
+            const u32 alignment = runtime.GetUniformBufferAlignment();
+            return alignment > 1 && (offset % alignment) != 0;
+        }
+    }();
+    const bool use_fast_buffer = needs_alignment_stream ||
+                                 (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) {
             if (runtime.HasFastBufferSubData()) {
@@ -834,7 +896,6 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     if (!needs_bind) {
         return;
     }
-    const u32 offset = buffer.Offset(device_addr);
     if constexpr (IS_OPENGL) {
         // Mark the index as dirty if offset doesn't match
         const bool is_copy_bind = offset != 0 && !runtime.SupportsNonZeroUniformOffset();
@@ -951,9 +1012,30 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
         TouchBuffer(buffer, binding.buffer_id);
         const u32 size =
             (std::min)(binding.size, (*channel_state->compute_uniform_buffer_sizes)[index]);
+        const bool has_host_buffer = binding.buffer_id != NULL_BUFFER_ID;
+        const u32 offset = has_host_buffer ? buffer.Offset(binding.device_addr) : 0;
+        const bool needs_alignment_stream = [&]() {
+            if constexpr (IS_OPENGL) {
+                return false;
+            } else {
+                if (!has_host_buffer) {
+                    return false;
+                }
+                const u32 alignment = runtime.GetUniformBufferAlignment();
+                return alignment > 1 && (offset % alignment) != 0;
+            }
+        }();
+        if constexpr (!IS_OPENGL) {
+            if (needs_alignment_stream) {
+                const std::span<u8> span =
+                    runtime.BindMappedUniformBuffer(0, binding_index, size);
+                device_memory.ReadBlockUnsafe(binding.device_addr, span.data(), size);
+                return;
+            }
+        }
+
         SynchronizeBuffer(buffer, binding.device_addr, size);
 
-        const u32 offset = buffer.Offset(binding.device_addr);
         buffer.MarkUsage(offset, size);
         if constexpr (NEEDS_BIND_UNIFORM_INDEX) {
             runtime.BindComputeUniformBuffer(binding_index, buffer, offset, size);

src/video_core/buffer_cache/buffer_cache_base.h

@@ -8,6 +8,7 @@
 
 #include <algorithm>
 #include <array>
+#include <bit>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -132,6 +133,9 @@ public:
     u32 enabled_compute_storage_buffers = 0;
     u32 written_compute_storage_buffers = 0;
 
+    u32 total_graphics_storage_buffers = 0;
+    u32 total_compute_storage_buffers = 0;
+
     std::array<u32, NUM_STAGES> enabled_texture_buffers{};
     std::array<u32, NUM_STAGES> written_texture_buffers{};
     std::array<u32, NUM_STAGES> image_texture_buffers{};

src/video_core/host1x/vic.h

@@ -605,20 +605,20 @@ public:
         SetOutputSurfaceChromaUnusedOffset = offsetof(VicRegisters, output_surface.chroma_v)
     };
 
-    explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue);
-    ~Vic();
+    explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue) noexcept;
+    ~Vic() noexcept;
 
     /// Write to the device state.
-    void ProcessMethod(u32 method, u32 arg) override;
+    void ProcessMethod(u32 method, u32 arg) noexcept override;
 
 private:
-    void Execute();
-    void Blend(const ConfigStruct& config, const SlotStruct& slot);
-    void ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar, bool interlaced);
-    void ReadInterlacedY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar, bool top_field);
-    void ReadY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar);
-    void WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config);
-    void WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixelFormat format);
+    void Execute() noexcept;
+    void Blend(const ConfigStruct& config, const SlotStruct& slot, VideoPixelFormat format) noexcept;
+    void ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar, bool interlaced) noexcept;
+    void ReadInterlacedY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar, bool top_field) noexcept;
+    void ReadY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets, std::shared_ptr<const FFmpeg::Frame> frame, bool planar) noexcept;
+    void WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) noexcept;
+    void WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixelFormat format) noexcept;
 
     s32 id;
     s32 nvdec_id{-1};
@@ -627,11 +627,11 @@ private:
     VicRegisters regs{};
     FrameQueue& frame_queue;
 
+    Common::ScratchBuffer<u8> swizzle_scratch;
     Common::ScratchBuffer<Pixel> output_surface;
     Common::ScratchBuffer<Pixel> slot_surface;
     Common::ScratchBuffer<u8> luma_scratch;
     Common::ScratchBuffer<u8> chroma_scratch;
-    Common::ScratchBuffer<u8> swizzle_scratch;
 };
 
 } // namespace Tegra::Host1x

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -198,6 +198,10 @@ public:
         return device.CanReportMemoryUsage();
     }
 
+    u32 GetUniformBufferAlignment() const {
+        return static_cast<u32>(device.GetUniformBufferAlignment());
+    }
+
     u32 GetStorageBufferAlignment() const {
         return static_cast<u32>(device.GetShaderStorageBufferAlignment());
     }

src/video_core/renderer_opengl/present/layer.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -57,12 +54,12 @@ GLuint Layer::ConfigureDraw(std::array<GLfloat, 3 * 2>& out_matrix,
         switch (anti_aliasing) {
         case Settings::AntiAliasing::Fxaa:
             CreateFXAA();
-            texture = std::get<FXAA>(anti_alias).Draw(program_manager, info.display_texture);
+            texture = fxaa->Draw(program_manager, info.display_texture);
             break;
         case Settings::AntiAliasing::Smaa:
         default:
             CreateSMAA();
-            texture = std::get<SMAA>(anti_alias).Draw(program_manager, info.display_texture);
+            texture = smaa->Draw(program_manager, info.display_texture);
             break;
         }
     }
@@ -71,7 +68,7 @@ GLuint Layer::ConfigureDraw(std::array<GLfloat, 3 * 2>& out_matrix,
 
     if (filters.get_scaling_filter() == Settings::ScalingFilter::Fsr) {
         if (!fsr || fsr->NeedsRecreation(layout.screen)) {
-            fsr.emplace(layout.screen.GetWidth(), layout.screen.GetHeight());
+            fsr = std::make_unique<FSR>(layout.screen.GetWidth(), layout.screen.GetHeight());
         }
 
         texture = fsr->Draw(program_manager, texture, info.scaled_width, info.scaled_height, crop);
@@ -202,20 +199,23 @@ void Layer::ConfigureFramebufferTexture(const Tegra::FramebufferConfig& framebuf
     glTextureStorage2D(framebuffer_texture.resource.handle, 1, internal_format,
                        framebuffer_texture.width, framebuffer_texture.height);
 
-    anti_alias.emplace<std::monostate>();
+    fxaa.reset();
+    smaa.reset();
 }
 
 void Layer::CreateFXAA() {
-    if (!std::holds_alternative<FXAA>(anti_alias)) {
-        anti_alias.emplace<FXAA>(
+    smaa.reset();
+    if (!fxaa) {
+        fxaa = std::make_unique<FXAA>(
             Settings::values.resolution_info.ScaleUp(framebuffer_texture.width),
             Settings::values.resolution_info.ScaleUp(framebuffer_texture.height));
     }
 }
 
 void Layer::CreateSMAA() {
-    if (!std::holds_alternative<SMAA>(anti_alias)) {
-        anti_alias.emplace<SMAA>(
+    fxaa.reset();
+    if (!smaa) {
+        smaa = std::make_unique<SMAA>(
             Settings::values.resolution_info.ScaleUp(framebuffer_texture.width),
             Settings::values.resolution_info.ScaleUp(framebuffer_texture.height));
     }

src/video_core/renderer_opengl/present/layer.h

@@ -1,20 +1,13 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include <optional>
-#include <variant>
+#include <memory>
 #include <vector>
 
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/renderer_opengl/present/smaa.h"
-#include "video_core/renderer_opengl/present/fxaa.h"
-#include "video_core/renderer_opengl/present/fsr.h"
 
 namespace Layout {
 struct FramebufferLayout;
@@ -33,8 +26,11 @@ struct FramebufferConfig;
 namespace OpenGL {
 
 struct FramebufferTextureInfo;
+class FSR;
+class FXAA;
 class ProgramManager;
 class RasterizerOpenGL;
+class SMAA;
 
 /// Structure used for storing information about the textures for the Switch screen
 struct TextureInfo {
@@ -80,8 +76,9 @@ private:
     /// Display information for Switch screen
     TextureInfo framebuffer_texture;
 
-    std::optional<FSR> fsr;
-    std::variant<std::monostate, FXAA, SMAA> anti_alias;
+    std::unique_ptr<FSR> fsr;
+    std::unique_ptr<FXAA> fxaa;
+    std::unique_ptr<SMAA> smaa;
 };
 
 } // namespace OpenGL

src/video_core/renderer_vulkan/blit_image.cpp

@@ -46,7 +46,7 @@ namespace Vulkan {
 using VideoCommon::ImageViewType;
 
 namespace {
-    
+
 [[nodiscard]] VkImageAspectFlags AspectMaskFromFormat(VideoCore::Surface::PixelFormat format) {
     using VideoCore::Surface::SurfaceType;
     switch (VideoCore::Surface::GetFormatType(format)) {
@@ -525,18 +525,24 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
           nullptr, PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(float) * 4>))),
       full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),
       blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),
-      blit_depth_stencil_frag(BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)),
+      blit_depth_stencil_frag(device.IsExtShaderStencilExportSupported()
+                             ? BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)
+                             : vk::ShaderModule{}),
       clear_color_vert(BuildShader(device, VULKAN_COLOR_CLEAR_VERT_SPV)),
       clear_color_frag(BuildShader(device, VULKAN_COLOR_CLEAR_FRAG_SPV)),
       clear_stencil_frag(BuildShader(device, VULKAN_DEPTHSTENCIL_CLEAR_FRAG_SPV)),
       convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
       convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
-      convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
+      convert_abgr8_to_d24s8_frag(device.IsExtShaderStencilExportSupported()
+                                 ? BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)
+                                 : vk::ShaderModule{}),
       convert_abgr8_to_d32f_frag(BuildShader(device, CONVERT_ABGR8_TO_D32F_FRAG_SPV)),
       convert_d32f_to_abgr8_frag(BuildShader(device, CONVERT_D32F_TO_ABGR8_FRAG_SPV)),
       convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
       convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),
-      convert_abgr8_srgb_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV)),
+      convert_abgr8_srgb_to_d24s8_frag(device.IsExtShaderStencilExportSupported()
+                                      ? BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV)
+                                      : vk::ShaderModule{}),
       convert_rgba_to_bgra_frag(BuildShader(device, CONVERT_RGBA8_TO_BGRA8_FRAG_SPV)),
       convert_yuv420_to_rgb_comp(BuildShader(device, CONVERT_YUV420_TO_RGB_COMP_SPV)),
       convert_rgb_to_yuv420_comp(BuildShader(device, CONVERT_RGB_TO_YUV420_COMP_SPV)),
@@ -667,6 +673,11 @@ void BlitImageHelper::ConvertR16ToD16(const Framebuffer* dst_framebuffer,
 
 void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
                                           const ImageView& src_image_view) {
+    if (!device.IsExtShaderStencilExportSupported()) {
+        // Shader requires VK_EXT_shader_stencil_export which is not available
+        LOG_WARNING(Render_Vulkan, "ConvertABGR8ToD24S8 requires shader_stencil_export, skipping");
+        return;
+    }
     ConvertPipelineDepthTargetEx(convert_abgr8_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
                                  convert_abgr8_to_d24s8_frag);
     Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view);
@@ -702,6 +713,11 @@ void BlitImageHelper::ConvertS8D24ToABGR8(const Framebuffer* dst_framebuffer,
 
 void BlitImageHelper::ConvertABGR8SRGBToD24S8(const Framebuffer* dst_framebuffer,
                                              const ImageView& src_image_view) {
+    if (!device.IsExtShaderStencilExportSupported()) {
+        // Shader requires VK_EXT_shader_stencil_export which is not available
+        LOG_WARNING(Render_Vulkan, "ConvertABGR8SRGBToD24S8 requires shader_stencil_export, skipping");
+        return;
+    }
     ConvertPipelineDepthTargetEx(convert_abgr8_srgb_to_d24s8_pipeline,
                                 dst_framebuffer->RenderPass(),
                                 convert_abgr8_srgb_to_d24s8_frag);

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -59,7 +59,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     raw1 = 0;
     extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
     extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
-    extended_dynamic_state_2_extra.Assign(features.has_extended_dynamic_state_2_extra ? 1 : 0);
+    extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op ? 1 : 0);
     extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
     extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
@@ -157,7 +157,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
             return static_cast<u16>(array.stride.Value());
         });
     }
-    if (!extended_dynamic_state_2_extra) {
+    if (!extended_dynamic_state_2_logic_op) {
         dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
     }
     if (!extended_dynamic_state_3_blend) {

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,7 +23,8 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 struct DynamicFeatures {
     bool has_extended_dynamic_state;
     bool has_extended_dynamic_state_2;
-    bool has_extended_dynamic_state_2_extra;
+    bool has_extended_dynamic_state_2_logic_op;
+    bool has_extended_dynamic_state_2_patch_control_points;
     bool has_extended_dynamic_state_3_blend;
     bool has_extended_dynamic_state_3_enables;
     bool has_dynamic_vertex_input;
@@ -186,7 +190,7 @@ struct FixedPipelineState {
         u32 raw1;
         BitField<0, 1, u32> extended_dynamic_state;
         BitField<1, 1, u32> extended_dynamic_state_2;
-        BitField<2, 1, u32> extended_dynamic_state_2_extra;
+        BitField<2, 1, u32> extended_dynamic_state_2_logic_op;
         BitField<3, 1, u32> extended_dynamic_state_3_blend;
         BitField<4, 1, u32> extended_dynamic_state_3_enables;
         BitField<5, 1, u32> dynamic_vertex_input;

src/video_core/renderer_vulkan/present/anti_alias_pass.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -19,4 +16,10 @@ public:
                       VkImageView* inout_image_view) = 0;
 };
 
+class NoAA final : public AntiAliasPass {
+public:
+    void Draw(Scheduler& scheduler, size_t image_index, VkImage* inout_image,
+              VkImageView* inout_image_view) override {}
+};
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/filters.cpp

@@ -30,19 +30,32 @@
 
 namespace Vulkan {
 
+namespace {
+
+vk::ShaderModule SelectScaleForceShader(const Device& device) {
+    if (device.IsFloat16Supported()) {
+        return BuildShader(device, VULKAN_PRESENT_SCALEFORCE_FP16_FRAG_SPV);
+    } else {
+        return BuildShader(device, VULKAN_PRESENT_SCALEFORCE_FP32_FRAG_SPV);
+    }
+}
+
+} // Anonymous namespace
+
 std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device, VkFormat frame_format) {
-    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateNearestNeighborSampler(device),
-        BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
+    return std::make_unique<WindowAdaptPass>(device, frame_format,
+                                             CreateNearestNeighborSampler(device),
+                                             BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-        BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
+                                             BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-        BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
+                                             BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights) {
@@ -71,26 +84,22 @@ std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat fram
 
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-        BuildShader(device, PRESENT_GAUSSIAN_FRAG_SPV));
+                                             BuildShader(device, PRESENT_GAUSSIAN_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-        BuildShader(device, PRESENT_LANCZOS_FRAG_SPV));
+                                             BuildShader(device, PRESENT_LANCZOS_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format) {
-    auto const select_fn = [&]() {
-        return device.IsFloat16Supported()
-            ? BuildShader(device, VULKAN_PRESENT_SCALEFORCE_FP16_FRAG_SPV)
-            : BuildShader(device, VULKAN_PRESENT_SCALEFORCE_FP32_FRAG_SPV);
-    };
-    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device), select_fn());
+    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
+                                             SelectScaleForceShader(device));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_format) {
     return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-        BuildShader(device, PRESENT_AREA_FRAG_SPV));
+                                             BuildShader(device, PRESENT_AREA_FRAG_SPV));
 }
 
 std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device, VkFormat frame_format) {

src/video_core/renderer_vulkan/present/fsr.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -44,18 +41,25 @@ FSR::FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_c
 void FSR::CreateImages() {
     m_dynamic_images.resize(m_image_count);
     for (auto& images : m_dynamic_images) {
-        images.images[Easu] = CreateWrappedImage(m_memory_allocator, m_extent, VK_FORMAT_R16G16B16A16_SFLOAT);
-        images.images[Rcas] = CreateWrappedImage(m_memory_allocator, m_extent, VK_FORMAT_R16G16B16A16_SFLOAT);
-        images.image_views[Easu] = CreateWrappedImageView(m_device, images.images[Easu], VK_FORMAT_R16G16B16A16_SFLOAT);
-        images.image_views[Rcas] = CreateWrappedImageView(m_device, images.images[Rcas], VK_FORMAT_R16G16B16A16_SFLOAT);
+        images.images[Easu] =
+            CreateWrappedImage(m_memory_allocator, m_extent, VK_FORMAT_R16G16B16A16_SFLOAT);
+        images.images[Rcas] =
+            CreateWrappedImage(m_memory_allocator, m_extent, VK_FORMAT_R16G16B16A16_SFLOAT);
+        images.image_views[Easu] =
+            CreateWrappedImageView(m_device, images.images[Easu], VK_FORMAT_R16G16B16A16_SFLOAT);
+        images.image_views[Rcas] =
+            CreateWrappedImageView(m_device, images.images[Rcas], VK_FORMAT_R16G16B16A16_SFLOAT);
     }
 }
 
 void FSR::CreateRenderPasses() {
     m_renderpass = CreateWrappedRenderPass(m_device, VK_FORMAT_R16G16B16A16_SFLOAT);
+
     for (auto& images : m_dynamic_images) {
-        images.framebuffers[Easu] = CreateWrappedFramebuffer(m_device, m_renderpass, images.image_views[Easu], m_extent);
-        images.framebuffers[Rcas] = CreateWrappedFramebuffer(m_device, m_renderpass, images.image_views[Rcas], m_extent);
+        images.framebuffers[Easu] =
+            CreateWrappedFramebuffer(m_device, m_renderpass, images.image_views[Easu], m_extent);
+        images.framebuffers[Rcas] =
+            CreateWrappedFramebuffer(m_device, m_renderpass, images.image_views[Rcas], m_extent);
     }
 }
 
@@ -83,13 +87,16 @@ void FSR::CreateDescriptorPool() {
 }
 
 void FSR::CreateDescriptorSetLayout() {
-    m_descriptor_set_layout = CreateWrappedDescriptorSetLayout(m_device, {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER});
+    m_descriptor_set_layout =
+        CreateWrappedDescriptorSetLayout(m_device, {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER});
 }
 
 void FSR::CreateDescriptorSets() {
     std::vector<VkDescriptorSetLayout> layouts(MaxFsrStage, *m_descriptor_set_layout);
-    for (auto& images : m_dynamic_images)
+
+    for (auto& images : m_dynamic_images) {
         images.descriptor_sets = CreateWrappedDescriptorSets(m_descriptor_pool, layouts);
+    }
 }
 
 void FSR::CreatePipelineLayouts() {
@@ -121,24 +128,31 @@ void FSR::CreatePipelines() {
 void FSR::UpdateDescriptorSets(VkImageView image_view, size_t image_index) {
     Images& images = m_dynamic_images[image_index];
     std::vector<VkDescriptorImageInfo> image_infos;
-    std::vector<VkWriteDescriptorSet> updates{
-        CreateWriteDescriptorSet(image_infos, *m_sampler, image_view, images.descriptor_sets[Easu], 0),
-        CreateWriteDescriptorSet(image_infos, *m_sampler, *images.image_views[Easu], images.descriptor_sets[Rcas], 0)
-    };
+    std::vector<VkWriteDescriptorSet> updates;
+    image_infos.reserve(2);
+
+    updates.push_back(CreateWriteDescriptorSet(image_infos, *m_sampler, image_view,
+                                               images.descriptor_sets[Easu], 0));
+    updates.push_back(CreateWriteDescriptorSet(image_infos, *m_sampler, *images.image_views[Easu],
+                                               images.descriptor_sets[Rcas], 0));
+
     m_device.GetLogical().UpdateDescriptorSets(updates, {});
 }
 
 void FSR::UploadImages(Scheduler& scheduler) {
-    if (!m_images_ready) {
-        m_images_ready = true;
-        scheduler.Record([&](vk::CommandBuffer cmdbuf) {
-            for (auto& image : m_dynamic_images) {
-                ClearColorImage(cmdbuf, *image.images[Easu]);
-                ClearColorImage(cmdbuf, *image.images[Rcas]);
-            }
-        });
-        scheduler.Finish();
+    if (m_images_ready) {
+        return;
     }
+
+    scheduler.Record([&](vk::CommandBuffer cmdbuf) {
+        for (auto& image : m_dynamic_images) {
+            ClearColorImage(cmdbuf, *image.images[Easu]);
+            ClearColorImage(cmdbuf, *image.images[Rcas]);
+        }
+    });
+    scheduler.Finish();
+
+    m_images_ready = true;
 }
 
 VkImageView FSR::Draw(Scheduler& scheduler, size_t image_index, VkImage source_image,

src/video_core/renderer_vulkan/present/layer.cpp

@@ -4,12 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <variant>
 #include "video_core/present.h"
-#include "video_core/renderer_vulkan/present/anti_alias_pass.h"
-/* X11 defines */
-#undef Success
-#undef BadValue
 #include "video_core/renderer_vulkan/vk_rasterizer.h"
 
 #include "common/settings.h"
@@ -63,7 +58,7 @@ Layer::Layer(const Device& device_, MemoryAllocator& memory_allocator_, Schedule
     CreateDescriptorPool();
     CreateDescriptorSets(layout);
     if (filters.get_scaling_filter() == Settings::ScalingFilter::Fsr) {
-        fsr.emplace(device, memory_allocator, image_count, output_size);
+        CreateFSR(output_size);
     }
 }
 
@@ -102,11 +97,7 @@ void Layer::ConfigureDraw(PresentPushConstants* out_push_constants,
     VkImageView source_image_view =
         texture_info ? texture_info->image_view : *raw_image_views[image_index];
 
-    if (std::holds_alternative<FXAA>(anti_alias)) {
-        std::get<FXAA>(anti_alias).Draw(scheduler, image_index, &source_image, &source_image_view);
-    } else if (std::holds_alternative<SMAA>(anti_alias)) {
-        std::get<SMAA>(anti_alias).Draw(scheduler, image_index, &source_image, &source_image_view);
-    }
+    anti_alias->Draw(scheduler, image_index, &source_image, &source_image_view);
 
     auto crop_rect = Tegra::NormalizeCrop(framebuffer, texture_width, texture_height);
     const VkExtent2D render_extent{
@@ -165,6 +156,10 @@ void Layer::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
     }
 }
 
+void Layer::CreateFSR(VkExtent2D output_size) {
+    fsr = std::make_unique<FSR>(device, memory_allocator, image_count, output_size);
+}
+
 void Layer::RefreshResources(const Tegra::FramebufferConfig& framebuffer) {
     if (framebuffer.width == raw_width && framebuffer.height == raw_height &&
         framebuffer.pixel_format == pixel_format && !raw_images.empty()) {
@@ -174,7 +169,7 @@ void Layer::RefreshResources(const Tegra::FramebufferConfig& framebuffer) {
     raw_width = framebuffer.width;
     raw_height = framebuffer.height;
     pixel_format = framebuffer.pixel_format;
-    anti_alias.emplace<std::monostate>();
+    anti_alias.reset();
 
     ReleaseRawImages();
     CreateStagingBuffer(framebuffer);
@@ -182,8 +177,9 @@ void Layer::RefreshResources(const Tegra::FramebufferConfig& framebuffer) {
 }
 
 void Layer::SetAntiAliasPass() {
-    if (!std::holds_alternative<std::monostate>(anti_alias) && anti_alias_setting == filters.get_anti_aliasing())
+    if (anti_alias && anti_alias_setting == filters.get_anti_aliasing()) {
         return;
+    }
 
     anti_alias_setting = filters.get_anti_aliasing();
 
@@ -194,13 +190,13 @@ void Layer::SetAntiAliasPass() {
 
     switch (anti_alias_setting) {
     case Settings::AntiAliasing::Fxaa:
-        anti_alias.emplace<FXAA>(device, memory_allocator, image_count, render_area);
+        anti_alias = std::make_unique<FXAA>(device, memory_allocator, image_count, render_area);
         break;
     case Settings::AntiAliasing::Smaa:
-        anti_alias.emplace<SMAA>(device, memory_allocator, image_count, render_area);
+        anti_alias = std::make_unique<SMAA>(device, memory_allocator, image_count, render_area);
         break;
     default:
-        anti_alias.emplace<std::monostate>();
+        anti_alias = std::make_unique<NoAA>();
         break;
     }
 }

src/video_core/renderer_vulkan/present/layer.h

@@ -1,20 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include <optional>
-#include <variant>
-
 #include "common/math_util.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
-#include "video_core/renderer_vulkan/present/fsr.h"
-#include "video_core/renderer_vulkan/present/fxaa.h"
-#include "video_core/renderer_vulkan/present/smaa.h"
 
 namespace Layout {
 struct FramebufferLayout;
@@ -38,6 +29,7 @@ namespace Vulkan {
 
 class AntiAliasPass;
 class Device;
+class FSR;
 class MemoryAllocator;
 struct PresentPushConstants;
 class RasterizerVulkan;
@@ -62,6 +54,7 @@ private:
     void CreateDescriptorSets(VkDescriptorSetLayout layout);
     void CreateStagingBuffer(const Tegra::FramebufferConfig& framebuffer);
     void CreateRawImages(const Tegra::FramebufferConfig& framebuffer);
+    void CreateFSR(VkExtent2D output_size);
 
     void RefreshResources(const Tegra::FramebufferConfig& framebuffer);
     void SetAntiAliasPass();
@@ -94,8 +87,9 @@ private:
     Service::android::PixelFormat pixel_format{};
 
     Settings::AntiAliasing anti_alias_setting{};
-    std::variant<std::monostate, FXAA, SMAA> anti_alias{};
-    std::optional<FSR> fsr{};
+    std::unique_ptr<AntiAliasPass> anti_alias{};
+
+    std::unique_ptr<FSR> fsr{};
     std::vector<u64> resource_ticks{};
 };
 

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -333,16 +333,18 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
       staging_pool{staging_pool_}, guest_descriptor_queue{guest_descriptor_queue_},
       quad_index_pass(device, scheduler, descriptor_pool, staging_pool,
                       compute_pass_descriptor_queue) {
+    const VkDriverIdKHR driver_id = device.GetDriverID();
+    limit_dynamic_storage_buffers = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+                                    driver_id == VK_DRIVER_ID_MESA_TURNIP ||
+                                    driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    if (limit_dynamic_storage_buffers) {
+        max_dynamic_storage_buffers = device.GetMaxDescriptorSetStorageBuffersDynamic();
+    }
     if (device.GetDriverID() != VK_DRIVER_ID_QUALCOMM_PROPRIETARY) {
         // TODO: FixMe: Uint8Pass compute shader does not build on some Qualcomm drivers.
         uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
                                                  compute_pass_descriptor_queue);
     }
-    const u32 ubo_align = static_cast<u32>(
-            device.GetUniformBufferAlignment() //check if the device has it
-    );
-    // add the ability to change the size in settings in future
-    uniform_ring.Init(memory_allocator, 8 * 1024 * 1024 /* 8 MiB */, ubo_align ? ubo_align : 256);
     quad_array_index_buffer = std::make_shared<QuadArrayIndexBuffer>(device_, memory_allocator_,
                                                                      scheduler_, staging_pool_);
     quad_strip_index_buffer = std::make_shared<QuadStripIndexBuffer>(device_, memory_allocator_,
@@ -361,41 +363,6 @@ void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
     staging_pool.FreeDeferred(ref);
 }
 
-void BufferCacheRuntime::UniformRing::Init(MemoryAllocator& alloc, u64 bytes, u32 alignment)
-{
-    for (size_t i = 0; i < NUM_FRAMES; ++i) {
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size  = bytes,
-            .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        buffers[i] = alloc.CreateBuffer(ci, MemoryUsage::Upload);
-        mapped[i] = buffers[i].Mapped().data();
-    }
-    size   = bytes;
-    align  = alignment ? alignment : 256;
-    head   = 0;
-    current_frame = 0;
-}
-
-std::span<u8> BufferCacheRuntime::UniformRing::Alloc(u32 bytes, u32& out_offset) {
-    const u64 aligned = Common::AlignUp(head, static_cast<u64>(align));
-    u64 end = aligned + bytes;
-
-    if (end > size) {
-       return {}; // Fallback to staging pool
-    }
-
-    out_offset = static_cast<u32>(aligned);
-    head = end;
-    return {mapped[current_frame] + out_offset, bytes};
-}
-
 u64 BufferCacheRuntime::GetDeviceLocalMemory() const {
     return device.GetDeviceLocalMemory();
 }
@@ -408,6 +375,10 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
+u32 BufferCacheRuntime::GetUniformBufferAlignment() const {
+    return static_cast<u32>(device.GetUniformBufferAlignment());
+}
+
 u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
     return static_cast<u32>(device.GetStorageBufferAlignment());
 }
@@ -416,7 +387,6 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         it->ResetUsageTracking();
     }
-    uniform_ring.BeginFrame();
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <limits>
+
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
 #include "video_core/buffer_cache/usage_tracker.h"
@@ -94,6 +96,8 @@ public:
 
     bool CanReportMemoryUsage() const;
 
+    u32 GetUniformBufferAlignment() const;
+
     u32 GetStorageBufferAlignment() const;
 
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
@@ -127,15 +131,9 @@ public:
 
     void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);
 
-    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
-                                          [[maybe_unused]] u32 /*binding_index*/,
+    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t stage,
+                                          [[maybe_unused]] u32 binding_index,
                                           u32 size) {
-        u32 offset = 0;
-        if (auto span = uniform_ring.Alloc(size, offset); !span.empty()) {
-            BindBuffer(*uniform_ring.buffers[uniform_ring.current_frame], offset, size);
-            return span;
-        }
-        // Fallback for giant requests
         const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
         BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
         return ref.mapped_span;
@@ -155,6 +153,14 @@ public:
         guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format));
     }
 
+    bool ShouldLimitDynamicStorageBuffers() const {
+        return limit_dynamic_storage_buffers;
+    }
+
+    u32 GetMaxDynamicStorageBuffers() const {
+        return max_dynamic_storage_buffers;
+    }
+
 private:
     void BindBuffer(VkBuffer buffer, u32 offset, u32 size) {
         guest_descriptor_queue.AddBuffer(buffer, offset, size);
@@ -163,24 +169,6 @@ private:
     void ReserveNullBuffer();
     vk::Buffer CreateNullBuffer();
 
-    struct UniformRing {
-        static constexpr size_t NUM_FRAMES = 3;
-        std::array<vk::Buffer, NUM_FRAMES> buffers{};
-        std::array<u8*, NUM_FRAMES> mapped{};
-        u64 size = 0;
-        u64 head = 0;
-        u32 align = 256;
-        size_t current_frame = 0;
-
-        void Init(MemoryAllocator& alloc, u64 bytes, u32 alignment);
-        void BeginFrame() {
-            current_frame = (current_frame + 1) % NUM_FRAMES;
-            head = 0;
-        }
-        std::span<u8> Alloc(u32 bytes, u32& out_offset);
-    };
-    UniformRing uniform_ring;
-
     const Device& device;
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
@@ -194,6 +182,9 @@ private:
 
     std::unique_ptr<Uint8Pass> uint8_pass;
     QuadIndexedPass quad_index_pass;
+
+    bool limit_dynamic_storage_buffers = false;
+    u32 max_dynamic_storage_buffers = std::numeric_limits<u32>::max();
 };
 
 struct BufferCacheParams {

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -418,6 +418,9 @@ ConditionalRenderingResolvePass::ConditionalRenderingResolvePass(
 
 void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_buffer,
                                               u32 src_offset, bool compare_to_zero) {
+    if (!device.IsExtConditionalRendering()) {
+        return;
+    }
     const size_t compare_size = compare_to_zero ? 8 : 24;
 
     compute_pass_descriptor_queue.Acquire();
@@ -448,7 +451,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
         cmdbuf.Dispatch(1, 1, 1);
         cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                               VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0, write_barrier);
+                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
     });
 }
 
@@ -470,6 +473,14 @@ QueriesPrefixScanPass::QueriesPrefixScanPass(
 void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffer,
                                 VkBuffer src_buffer, size_t number_of_sums,
                                 size_t min_accumulation_limit, size_t max_accumulation_limit) {
+    constexpr VkAccessFlags BASE_DST_ACCESS = VK_ACCESS_SHADER_READ_BIT |
+                                              VK_ACCESS_TRANSFER_READ_BIT |
+                                              VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
+                                              VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
+                                              VK_ACCESS_INDEX_READ_BIT |
+                                              VK_ACCESS_UNIFORM_READ_BIT;
+    const VkAccessFlags conditional_access =
+        device.IsExtConditionalRendering() ? VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT : 0;
     size_t current_runs = number_of_sums;
     size_t offset = 0;
     while (current_runs != 0) {
@@ -486,22 +497,18 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
 
         scheduler.RequestOutsideRenderPassOperationContext();
         scheduler.Record([this, descriptor_data, min_accumulation_limit, max_accumulation_limit,
-                          runs_to_do, used_offset](vk::CommandBuffer cmdbuf) {
+                          runs_to_do, used_offset, conditional_access](vk::CommandBuffer cmdbuf) {
             static constexpr VkMemoryBarrier read_barrier{
                 .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                 .pNext = nullptr,
                 .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
                 .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
             };
-            static constexpr VkMemoryBarrier write_barrier{
+            const VkMemoryBarrier write_barrier{
                 .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                 .pNext = nullptr,
                 .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT |
-                                 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
-                                 VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_INDEX_READ_BIT |
-                                 VK_ACCESS_UNIFORM_READ_BIT |
-                                 VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+                .dstAccessMask = BASE_DST_ACCESS | conditional_access,
             };
             const QueriesPrefixScanPushConstants uniforms{
                 .min_accumulation_base = static_cast<u32>(min_accumulation_limit),
@@ -519,8 +526,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
             cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
             cmdbuf.Dispatch(1, 1, 1);
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                                   VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0,
-                                   write_barrier);
+                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
         });
     }
 }

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -263,6 +263,7 @@ GraphicsPipeline::GraphicsPipeline(
         std::ranges::copy(info->constant_buffer_used_sizes, uniform_buffer_sizes[stage].begin());
         num_textures += Shader::NumDescriptors(info->texture_descriptors);
     }
+    fragment_has_color0_output = stage_infos[NUM_STAGES - 1].stores_frag_color[0];
     auto func{[this, shader_notify, &render_pass_cache, &descriptor_pool, pipeline_statistics] {
         DescriptorLayoutBuilder builder{MakeBuilder(device, stage_infos)};
         uses_push_descriptor = builder.CanUsePushDescriptor();
@@ -702,13 +703,18 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .lineWidth = 1.0f,
         // TODO(alekpop): Transfer from regs
     };
+    const bool smooth_lines_supported =
+        device.IsExtLineRasterizationSupported() && device.SupportsSmoothLines();
+    const bool stippled_lines_supported =
+        device.IsExtLineRasterizationSupported() && device.SupportsStippledRectangularLines();
     VkPipelineRasterizationLineStateCreateInfoEXT line_state{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
         .pNext = nullptr,
-        .lineRasterizationMode = key.state.smooth_lines != 0
+        .lineRasterizationMode = key.state.smooth_lines != 0 && smooth_lines_supported
                                      ? VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
                                      : VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
-        .stippledLineEnable = dynamic.line_stipple_enable ? VK_TRUE : VK_FALSE,
+        .stippledLineEnable =
+            (dynamic.line_stipple_enable && stippled_lines_supported) ? VK_TRUE : VK_FALSE,
         .lineStippleFactor = key.state.line_stipple_factor,
         .lineStipplePattern = static_cast<uint16_t>(key.state.line_stipple_pattern),
     };
@@ -739,6 +745,8 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         provoking_vertex.pNext = std::exchange(rasterization_ci.pNext, &provoking_vertex);
     }
 
+    const bool supports_alpha_output = fragment_has_color0_output;
+    const bool alpha_to_one_supported = device.SupportsAlphaToOne();
     const VkPipelineMultisampleStateCreateInfo multisample_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pNext = nullptr,
@@ -747,8 +755,10 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .sampleShadingEnable = Settings::values.sample_shading.GetValue() > 0 ? VK_TRUE : VK_FALSE,
         .minSampleShading = f32(Settings::values.sample_shading.GetValue()) / 100.0f,
         .pSampleMask = nullptr,
-        .alphaToCoverageEnable = key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
-        .alphaToOneEnable = key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToCoverageEnable =
+            supports_alpha_output && key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToOneEnable = supports_alpha_output && alpha_to_one_supported &&
+                           key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
     };
     const VkPipelineDepthStencilStateCreateInfo depth_stencil_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -813,7 +823,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         VK_DYNAMIC_STATE_LINE_WIDTH,
     };
     if (key.state.extended_dynamic_state) {
-        std::vector<VkDynamicState> extended{
+        static constexpr std::array extended{
             VK_DYNAMIC_STATE_CULL_MODE_EXT,
             VK_DYNAMIC_STATE_FRONT_FACE_EXT,
             VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
@@ -823,51 +833,68 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
             VK_DYNAMIC_STATE_STENCIL_OP_EXT,
         };
-        if (!device.IsExtVertexInputDynamicStateSupported()) {
-            extended.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
-        }
-        if (key.state.dynamic_vertex_input) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
-        }
         dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
-        if (key.state.extended_dynamic_state_2) {
-            static constexpr std::array extended2{
-                VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
-                VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
+
+        // VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT is part of EDS1
+        // Only use it if VIDS is not active (VIDS replaces it with full vertex input control)
+        if (!key.state.dynamic_vertex_input) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
         }
-        if (key.state.extended_dynamic_state_2_extra) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
+    }
+
+    // VK_DYNAMIC_STATE_VERTEX_INPUT_EXT (VIDS) - Independent from EDS
+    // Provides full dynamic vertex input control, replaces VERTEX_INPUT_BINDING_STRIDE
+    if (key.state.dynamic_vertex_input) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
+    }
+
+    // EDS2 - Core (3 states)
+    if (key.state.extended_dynamic_state_2) {
+        static constexpr std::array extended2{
+            VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
+            VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
+            VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
+    }
+
+    // EDS2 - LogicOp (granular)
+    if (key.state.extended_dynamic_state_2_logic_op) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
+    }
+
+    // EDS3 - Blending (composite: 3 states)
+    if (key.state.extended_dynamic_state_3_blend) {
+        static constexpr std::array extended3{
+            VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
+            VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
+            VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+    }
+
+    // EDS3 - Enables (composite: per-feature)
+    if (key.state.extended_dynamic_state_3_enables) {
+        if (device.SupportsDynamicState3DepthClampEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT);
         }
-        if (key.state.extended_dynamic_state_3_blend) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
-                VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
-                VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
-
-                // VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+        if (device.SupportsDynamicState3LogicOpEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT);
         }
-        if (key.state.extended_dynamic_state_3_enables) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
-
-                // additional state3 extensions
-                VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
-
-                VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
-
-                VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+        if (device.SupportsDynamicState3LineRasterizationMode()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT);
+        }
+        if (device.SupportsDynamicState3ConservativeRasterizationMode()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT);
+        }
+        if (device.SupportsDynamicState3LineStippleEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT);
+        }
+        if (device.SupportsDynamicState3AlphaToCoverageEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT);
+        }
+        if (device.SupportsDynamicState3AlphaToOneEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT);
         }
     }
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -82,6 +82,17 @@ public:
         const std::array<const Shader::Info*, NUM_STAGES>& infos);
 
     bool HasDynamicVertexInput() const noexcept { return key.state.dynamic_vertex_input; }
+    bool SupportsAlphaToCoverage() const noexcept {
+        return fragment_has_color0_output;
+    }
+
+    bool SupportsAlphaToOne() const noexcept {
+        return fragment_has_color0_output;
+    }
+
+    bool UsesExtendedDynamicState() const noexcept {
+        return key.state.extended_dynamic_state != 0;
+    }
     GraphicsPipeline& operator=(GraphicsPipeline&&) noexcept = delete;
     GraphicsPipeline(GraphicsPipeline&&) noexcept = delete;
 
@@ -149,6 +160,7 @@ private:
     std::array<u32, 5> enabled_uniform_buffer_masks{};
     VideoCommon::UniformBufferSizes uniform_buffer_sizes{};
     u32 num_textures{};
+    bool fragment_has_color0_output{};
 
     vk::DescriptorSetLayout descriptor_set_layout;
     DescriptorAllocator descriptor_allocator;

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -55,7 +55,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-constexpr u32 CACHE_VERSION = 14;
+constexpr u32 CACHE_VERSION = 15;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
@@ -146,7 +146,8 @@ Shader::AttributeType AttributeType(const FixedPipelineState& state, size_t inde
 Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> programs,
                                     const GraphicsPipelineCacheKey& key,
                                     const Shader::IR::Program& program,
-                                    const Shader::IR::Program* previous_program) {
+                                    const Shader::IR::Program* previous_program,
+                                    const Vulkan::Device& device) {
     Shader::RuntimeInfo info;
     if (previous_program) {
         info.previous_stage_stores = previous_program->info.stores;
@@ -168,10 +169,14 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
                 info.fixed_state_point_size = point_size;
             }
             if (key.state.xfb_enabled) {
-                auto [varyings, count] =
-                    VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
-                info.xfb_varyings = varyings;
-                info.xfb_count = count;
+                if (device.IsExtTransformFeedbackSupported()) {
+                    auto [varyings, count] =
+                        VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
+                    info.xfb_varyings = varyings;
+                    info.xfb_count = count;
+                } else {
+                    LOG_WARNING(Render_Vulkan, "XFB requested in pipeline key but device lacks VK_EXT_transform_feedback; ignoring XFB decorations");
+                }
             }
             info.convert_depth_mode = gl_ndc;
         }
@@ -218,10 +223,14 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
             info.fixed_state_point_size = point_size;
         }
         if (key.state.xfb_enabled != 0) {
-            auto [varyings, count] =
-                VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
-            info.xfb_varyings = varyings;
-            info.xfb_count = count;
+            if (device.IsExtTransformFeedbackSupported()) {
+                auto [varyings, count] =
+                    VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
+                info.xfb_varyings = varyings;
+                info.xfb_count = count;
+            } else {
+                LOG_WARNING(Render_Vulkan, "XFB requested in pipeline key but device lacks VK_EXT_transform_feedback; ignoring XFB decorations");
+            }
         }
         info.convert_depth_mode = gl_ndc;
         break;
@@ -269,8 +278,9 @@ size_t GetTotalPipelineWorkers() {
     const size_t max_core_threads =
         std::max<size_t>(static_cast<size_t>(std::thread::hardware_concurrency()), 2ULL) - 1ULL;
 #ifdef ANDROID
-    // Leave at least a few cores free in android
-    constexpr size_t free_cores = 3ULL;
+    // Leave at least one core free on Android. Previously we reserved two, but
+    // shipping builds benefit from one extra compilation worker.
+    constexpr size_t free_cores = 1ULL;
     if (max_core_threads <= free_cores) {
         return 1ULL;
     }
@@ -404,14 +414,35 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                     device.GetMaxVertexInputBindings(), Maxwell::NumVertexArrays);
     }
 
-    dynamic_features = DynamicFeatures{
-        .has_extended_dynamic_state = device.IsExtExtendedDynamicStateSupported(),
-        .has_extended_dynamic_state_2 = device.IsExtExtendedDynamicState2Supported(),
-        .has_extended_dynamic_state_2_extra = device.IsExtExtendedDynamicState2ExtrasSupported(),
-        .has_extended_dynamic_state_3_blend = device.IsExtExtendedDynamicState3BlendingSupported(),
-        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported(),
-        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported(),
-    };
+    LOG_INFO(Render_Vulkan, "DynamicState setting value: {}", u32(Settings::values.dyna_state.GetValue()));
+
+    dynamic_features = {};
+
+    // User granularity enforced in vulkan_device.cpp switch statement:
+    //   Level 0: Core Dynamic States only
+    //   Level 1: Core + EDS1
+    //   Level 2: Core + EDS1 + EDS2 (accumulative)
+    //   Level 3: Core + EDS1 + EDS2 + EDS3 (accumulative)
+    // Here we only verify if extensions were successfully loaded by the device
+
+    dynamic_features.has_extended_dynamic_state =
+        device.IsExtExtendedDynamicStateSupported();
+
+    dynamic_features.has_extended_dynamic_state_2 =
+        device.IsExtExtendedDynamicState2Supported();
+    dynamic_features.has_extended_dynamic_state_2_logic_op =
+        device.IsExtExtendedDynamicState2ExtrasSupported();
+    dynamic_features.has_extended_dynamic_state_2_patch_control_points = false;
+
+    dynamic_features.has_extended_dynamic_state_3_blend =
+        device.IsExtExtendedDynamicState3BlendingSupported();
+    dynamic_features.has_extended_dynamic_state_3_enables =
+        device.IsExtExtendedDynamicState3EnablesSupported();
+
+    // VIDS: Independent toggle (not affected by dyna_state levels)
+    dynamic_features.has_dynamic_vertex_input =
+        device.IsExtVertexInputDynamicStateSupported() &&
+        Settings::values.vertex_input_dynamic_state.GetValue();
 }
 
 PipelineCache::~PipelineCache() {
@@ -516,8 +547,8 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
                 dynamic_features.has_extended_dynamic_state ||
             (key.state.extended_dynamic_state_2 != 0) !=
                 dynamic_features.has_extended_dynamic_state_2 ||
-            (key.state.extended_dynamic_state_2_extra != 0) !=
-                dynamic_features.has_extended_dynamic_state_2_extra ||
+            (key.state.extended_dynamic_state_2_logic_op != 0) !=
+                dynamic_features.has_extended_dynamic_state_2_logic_op ||
             (key.state.extended_dynamic_state_3_blend != 0) !=
                 dynamic_features.has_extended_dynamic_state_3_blend ||
             (key.state.extended_dynamic_state_3_enables != 0) !=
@@ -671,7 +702,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         const size_t stage_index{index - 1};
         infos[stage_index] = &program.info;
 
-        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)};
+        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage, device)};
         ConvertLegacyToGeneric(program, runtime_info);
         const std::vector<u32> code{EmitSPIRV(profile, runtime_info, program, binding, this->optimize_spirv_output)};
         device.SaveShader(code);
@@ -767,6 +798,19 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+    const VkDriverIdKHR driver_id = device.GetDriverID();
+    const bool needs_shared_mem_clamp =
+        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
+    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
+        LOG_WARNING(Render_Vulkan,
+                    "Compute shader 0x{:016x} requests {}KB shared memory but device max is {}KB - clamping",
+                    key.unique_hash,
+                    program.shared_memory_size / 1024,
+                    max_shared_memory / 1024);
+        program.shared_memory_size = max_shared_memory;
+    }
     const std::vector<u32> code{EmitSPIRV(profile, program, this->optimize_spirv_output)};
     device.SaveShader(code);
     vk::ShaderModule spv_module{BuildShader(device, code)};

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -156,19 +156,6 @@ public:
 
         ReserveHostQuery();
 
-        // Ensure outside render pass
-        scheduler.RequestOutsideRenderPassOperationContext();
-
-        // Reset query pool outside render pass
-        scheduler.Record([query_pool = current_query_pool,
-                                 query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
-            cmdbuf.ResetQueryPool(query_pool, static_cast<u32>(query_index), 1);
-        });
-
-        // Manually restart the render pass (required for vkCmdClearAttachments, etc.)
-        scheduler.RequestRenderpass(texture_cache.GetFramebuffer());
-
-        // Begin query inside the newly started render pass
         scheduler.Record([query_pool = current_query_pool,
                                  query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
             const bool use_precise = Settings::IsGPULevelHigh();
@@ -872,17 +859,18 @@ private:
             return;
         }
         has_flushed_end_pending = true;
+        // Refresh buffers state before beginning transform feedback so counters are up-to-date
+        UpdateBuffers();
         if (!has_started || buffers_count == 0) {
+            // No counter buffers available: begin without counters
             scheduler.Record([](vk::CommandBuffer cmdbuf) {
                 cmdbuf.BeginTransformFeedbackEXT(0, 0, nullptr, nullptr);
             });
-            UpdateBuffers();
             return;
         }
         scheduler.Record([this, total = static_cast<u32>(buffers_count)](vk::CommandBuffer cmdbuf) {
             cmdbuf.BeginTransformFeedbackEXT(0, total, counter_buffers.data(), offsets.data());
         });
-        UpdateBuffers();
     }
 
     void FlushEndTFB() {
@@ -892,11 +880,15 @@ private:
         }
         has_flushed_end_pending = false;
 
+        // Refresh buffer state before ending transform feedback to ensure counters_count is up-to-date.
+        UpdateBuffers();
         if (buffers_count == 0) {
+            LOG_DEBUG(Render_Vulkan, "EndTransformFeedbackEXT called with no counters (buffers_count=0)");
             scheduler.Record([](vk::CommandBuffer cmdbuf) {
                 cmdbuf.EndTransformFeedbackEXT(0, 0, nullptr, nullptr);
             });
         } else {
+            LOG_DEBUG(Render_Vulkan, "EndTransformFeedbackEXT called with counters (buffers_count={})", buffers_count);
             scheduler.Record([this,
                               total = static_cast<u32>(buffers_count)](vk::CommandBuffer cmdbuf) {
                 cmdbuf.EndTransformFeedbackEXT(0, total, counter_buffers.data(), offsets.data());
@@ -907,6 +899,7 @@ private:
     void UpdateBuffers() {
         last_queries.fill(0);
         last_queries_stride.fill(1);
+        streams_mask = 0; // reset previously recorded streams
         runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
             buffers_count = 0;
             out_topology = maxwell3d.draw_manager->GetDrawState().topology;
@@ -916,6 +909,10 @@ private:
                     continue;
                 }
                 const size_t stream = tf.controls[i].stream;
+                if (stream >= last_queries_stride.size()) {
+                    LOG_WARNING(Render_Vulkan, "TransformFeedback stream {} out of range", stream);
+                    continue;
+                }
                 last_queries_stride[stream] = tf.controls[i].stride;
                 streams_mask |= 1ULL << stream;
                 buffers_count = std::max<size_t>(buffers_count, stream + 1);
@@ -1116,16 +1113,21 @@ public:
 
             query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
             u64 num_vertices = 0;
+            // Protect against stride == 0 (avoid divide-by-zero). Use fallback stride=1 and warn.
+            u64 safe_stride = query->stride == 0 ? 1 : query->stride;
+            if (query->stride == 0) {
+                LOG_WARNING(Render_Vulkan, "TransformFeedback query has stride 0; using 1 to avoid div-by-zero (addr=0x{:x})", query->dependant_address);
+            }
             if (query->dependant_manage) {
                 auto* dependant_query = tfb_streamer.GetQuery(query->dependant_index);
-                num_vertices = dependant_query->value / query->stride;
+                num_vertices = dependant_query->value / safe_stride;
                 tfb_streamer.Free(query->dependant_index);
             } else {
                 u8* pointer = device_memory.GetPointer<u8>(query->dependant_address);
                 if (pointer != nullptr) {
                     u32 result;
                     std::memcpy(&result, pointer, sizeof(u32));
-                    num_vertices = static_cast<u64>(result) / query->stride;
+                    num_vertices = static_cast<u64>(result) / safe_stride;
                 }
             }
             query->value = [&]() -> u64 {

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -197,6 +197,11 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
+
+    // Log multi-draw support
+    if (device.IsExtMultiDrawSupported()) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_multi_draw is enabled for optimized draw calls");
+    }
 }
 
 RasterizerVulkan::~RasterizerVulkan() = default;
@@ -234,16 +239,44 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
         const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
         const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
-        scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
-            if (draw_params.is_indexed) {
-                cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
-                                   draw_params.first_index, draw_params.base_vertex,
-                                   draw_params.base_instance);
-            } else {
-                cmdbuf.Draw(draw_params.num_vertices, draw_params.num_instances,
-                            draw_params.base_vertex, draw_params.base_instance);
-            }
-        });
+
+        // Use VK_EXT_multi_draw if available (single draw becomes multi-draw with count=1)
+        if (device.IsExtMultiDrawSupported()) {
+            scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
+                if (draw_params.is_indexed) {
+                    // Use multi-draw indexed with single draw
+                    const VkMultiDrawIndexedInfoEXT multi_draw_info{
+                        .firstIndex = draw_params.first_index,
+                        .indexCount = draw_params.num_vertices,
+                    };
+                    const int32_t vertex_offset = static_cast<int32_t>(draw_params.base_vertex);
+                    cmdbuf.DrawMultiIndexedEXT(1, &multi_draw_info, draw_params.num_instances,
+                                               draw_params.base_instance,
+                                               sizeof(VkMultiDrawIndexedInfoEXT), &vertex_offset);
+                } else {
+                    // Use multi-draw with single draw
+                    const VkMultiDrawInfoEXT multi_draw_info{
+                        .firstVertex = draw_params.base_vertex,
+                        .vertexCount = draw_params.num_vertices,
+                    };
+                    cmdbuf.DrawMultiEXT(1, &multi_draw_info, draw_params.num_instances,
+                                        draw_params.base_instance,
+                                        sizeof(VkMultiDrawInfoEXT));
+                }
+            });
+        } else {
+            // Fallback to standard draw calls
+            scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
+                if (draw_params.is_indexed) {
+                    cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
+                                       draw_params.first_index, draw_params.base_vertex,
+                                       draw_params.base_instance);
+                } else {
+                    cmdbuf.Draw(draw_params.num_vertices, draw_params.num_instances,
+                                draw_params.base_vertex, draw_params.base_instance);
+                }
+            });
+        }
     });
 }
 
@@ -386,13 +419,48 @@ void RasterizerVulkan::Clear(u32 layer_count) {
         .baseArrayLayer = regs.clear_surface.layer,
         .layerCount = layer_count,
     };
-    if (clear_rect.rect.extent.width == 0 || clear_rect.rect.extent.height == 0) {
+    const auto clamp_rect_to_render_area = [render_area](VkRect2D& rect) -> bool {
+        const auto clamp_axis = [](s32& offset, u32& extent, u32 limit) {
+            auto clamp_offset = [&offset, limit]() {
+                if (limit == 0) {
+                    offset = 0;
+                    return;
+                }
+                offset = std::clamp(offset, 0, static_cast<s32>(limit));
+            };
+
+            if (extent == 0) {
+                clamp_offset();
+                return;
+            }
+            if (offset < 0) {
+                const u32 shrink = (std::min)(extent, static_cast<u32>(-offset));
+                extent -= shrink;
+                offset = 0;
+            }
+            if (limit == 0) {
+                extent = 0;
+                offset = 0;
+                return;
+            }
+            if (offset >= static_cast<s32>(limit)) {
+                offset = static_cast<s32>(limit);
+                extent = 0;
+                return;
+            }
+            const u64 end_coord = static_cast<u64>(offset) + extent;
+            if (end_coord > limit) {
+                extent = limit - static_cast<u32>(offset);
+            }
+        };
+
+        clamp_axis(rect.offset.x, rect.extent.width, render_area.width);
+        clamp_axis(rect.offset.y, rect.extent.height, render_area.height);
+        return rect.extent.width != 0 && rect.extent.height != 0;
+    };
+    if (!clamp_rect_to_render_area(clear_rect.rect)) {
         return;
     }
-    clear_rect.rect.extent = VkExtent2D{
-        .width = (std::min)(clear_rect.rect.extent.width, render_area.width),
-        .height = (std::min)(clear_rect.rect.extent.height, render_area.height),
-    };
 
     const u32 color_attachment = regs.clear_surface.RT;
     if (use_color && framebuffer->HasAspectColorBit(color_attachment)) {
@@ -839,23 +907,21 @@ void RasterizerVulkan::LoadDiskResources(u64 title_id, std::stop_token stop_load
 
 void RasterizerVulkan::FlushWork() {
 #ifdef ANDROID
-    static constexpr u32 DRAWS_TO_DISPATCH = 1024;
+    static constexpr u32 DRAWS_TO_DISPATCH = 512;
+    static constexpr u32 CHECK_MASK = 3;
 #else
     static constexpr u32 DRAWS_TO_DISPATCH = 4096;
+    static constexpr u32 CHECK_MASK = 7;
 #endif // ANDROID
 
-    // Only check multiples of 8 draws
-    static_assert(DRAWS_TO_DISPATCH % 8 == 0);
-    if ((++draw_counter & 7) != 7) {
+    static_assert(DRAWS_TO_DISPATCH % (CHECK_MASK + 1) == 0);
+    if ((++draw_counter & CHECK_MASK) != CHECK_MASK) {
         return;
     }
     if (draw_counter < DRAWS_TO_DISPATCH) {
-        // Send recorded tasks to the worker thread
         scheduler.DispatchWork();
         return;
     }
-    // Otherwise (every certain number of draws) flush execution.
-    // This submits commands to the Vulkan driver.
     scheduler.Flush();
     draw_counter = 0;
 }
@@ -921,6 +987,8 @@ bool AccelerateDMA::BufferToImage(const Tegra::DMA::ImageCopy& copy_info,
 
 void RasterizerVulkan::UpdateDynamicStates() {
     auto& regs = maxwell3d->regs;
+
+    // Core Dynamic States (Vulkan 1.0) - Always active regardless of dyna_state setting
     UpdateViewportsState(regs);
     UpdateScissorsState(regs);
     UpdateDepthBias(regs);
@@ -928,6 +996,8 @@ void RasterizerVulkan::UpdateDynamicStates() {
     UpdateDepthBounds(regs);
     UpdateStencilFaces(regs);
     UpdateLineWidth(regs);
+
+    // EDS1: CullMode, DepthCompare, FrontFace, StencilOp, DepthBoundsTest, DepthTest, DepthWrite, StencilTest
     if (device.IsExtExtendedDynamicStateSupported()) {
         UpdateCullMode(regs);
         UpdateDepthCompareOp(regs);
@@ -938,40 +1008,52 @@ void RasterizerVulkan::UpdateDynamicStates() {
             UpdateDepthTestEnable(regs);
             UpdateDepthWriteEnable(regs);
             UpdateStencilTestEnable(regs);
-            if (device.IsExtExtendedDynamicState2Supported()) {
-                UpdatePrimitiveRestartEnable(regs);
-                UpdateRasterizerDiscardEnable(regs);
-                UpdateDepthBiasEnable(regs);
-            }
-            if (device.IsExtExtendedDynamicState3EnablesSupported()) {
-                using namespace Tegra::Engines;
-                if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE || device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
-                    const auto has_float = std::any_of(
-                        regs.vertex_attrib_format.begin(),
-                        regs.vertex_attrib_format.end(),
-                        [](const auto& attrib) {
-                            return attrib.type == Maxwell3D::Regs::VertexAttribute::Type::Float;
-                        }
-                    );
-                    if (regs.logic_op.enable) {
-                        regs.logic_op.enable = static_cast<u32>(!has_float);
-                    }
-                }
-                UpdateLogicOpEnable(regs);
-                UpdateDepthClampEnable(regs);
-            }
-        }
-        if (device.IsExtExtendedDynamicState2ExtrasSupported()) {
-            UpdateLogicOp(regs);
-        }
-        if (device.IsExtExtendedDynamicState3BlendingSupported()) {
-            UpdateBlending(regs);
-        }
-        if (device.IsExtExtendedDynamicState3EnablesSupported()) {
-            UpdateLineStippleEnable(regs);
-            UpdateConservativeRasterizationMode(regs);
         }
     }
+
+    // EDS2: PrimitiveRestart, RasterizerDiscard, DepthBias enable/disable
+    if (device.IsExtExtendedDynamicState2Supported()) {
+        UpdatePrimitiveRestartEnable(regs);
+        UpdateRasterizerDiscardEnable(regs);
+        UpdateDepthBiasEnable(regs);
+    }
+
+    // EDS2 Extras: LogicOp operation selection
+    if (device.IsExtExtendedDynamicState2ExtrasSupported()) {
+        UpdateLogicOp(regs);
+    }
+
+    // EDS3 Enables: LogicOpEnable, DepthClamp, LineStipple, ConservativeRaster
+    if (device.IsExtExtendedDynamicState3EnablesSupported()) {
+        using namespace Tegra::Engines;
+        // AMD Workaround: LogicOp incompatible with float render targets
+        if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE ||
+            device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
+            const auto has_float = std::any_of(
+                regs.vertex_attrib_format.begin(), regs.vertex_attrib_format.end(),
+                [](const auto& attrib) {
+                    return attrib.type == Maxwell3D::Regs::VertexAttribute::Type::Float;
+                }
+            );
+            if (regs.logic_op.enable) {
+                regs.logic_op.enable = static_cast<u32>(!has_float);
+            }
+        }
+        UpdateLogicOpEnable(regs);
+        UpdateDepthClampEnable(regs);
+        UpdateLineRasterizationMode(regs);
+        UpdateLineStippleEnable(regs);
+        UpdateConservativeRasterizationMode(regs);
+        UpdateAlphaToCoverageEnable(regs);
+        UpdateAlphaToOneEnable(regs);
+    }
+
+    // EDS3 Blending: ColorBlendEnable, ColorBlendEquation, ColorWriteMask
+    if (device.IsExtExtendedDynamicState3BlendingSupported()) {
+        UpdateBlending(regs);
+    }
+
+    // Vertex Input Dynamic State: Independent from EDS levels
     if (device.IsExtVertexInputDynamicStateSupported()) {
         if (auto* gp = pipeline_cache.CurrentGraphicsPipeline(); gp && gp->HasDynamicVertexInput()) {
             UpdateVertexInput(regs);
@@ -984,9 +1066,16 @@ void RasterizerVulkan::HandleTransformFeedback() {
 
     const auto& regs = maxwell3d->regs;
     if (!device.IsExtTransformFeedbackSupported()) {
-        std::call_once(warn_unsupported, [&] {
-            LOG_ERROR(Render_Vulkan, "Transform feedbacks used but not supported");
-        });
+        // If the guest enabled transform feedback, warn once that the device lacks support.
+        if (regs.transform_feedback_enabled != 0) {
+            std::call_once(warn_unsupported, [&] {
+                LOG_WARNING(Render_Vulkan, "Transform feedback requested by guest but VK_EXT_transform_feedback is unavailable; queries disabled");
+            });
+        } else {
+            std::call_once(warn_unsupported, [&] {
+                LOG_INFO(Render_Vulkan, "VK_EXT_transform_feedback not available on device");
+            });
+        }
         return;
     }
     query_cache.CounterEnable(VideoCommon::QueryType::StreamingByteCount,
@@ -1324,6 +1413,10 @@ void RasterizerVulkan::UpdateConservativeRasterizationMode(Tegra::Engines::Maxwe
         return;
     }
 
+    if (!device.SupportsDynamicState3ConservativeRasterizationMode()) {
+        return;
+    }
+
     scheduler.Record([enable = regs.conservative_raster_enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetConservativeRasterizationModeEXT(
             enable ? VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
@@ -1336,23 +1429,50 @@ void RasterizerVulkan::UpdateLineStippleEnable(Tegra::Engines::Maxwell3D::Regs&
         return;
     }
 
+    if (!device.SupportsDynamicState3LineStippleEnable()) {
+        return;
+    }
+
     scheduler.Record([enable = regs.line_stipple_enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetLineStippleEnableEXT(enable);
     });
 }
 
 void RasterizerVulkan::UpdateLineRasterizationMode(Tegra::Engines::Maxwell3D::Regs& regs) {
-    // if (!state_tracker.TouchLi()) {
-    //     return;
-    // }
+    if (!device.IsExtLineRasterizationSupported()) {
+        return;
+    }
+    if (!state_tracker.TouchLineRasterizationMode()) {
+        return;
+    }
 
-    // TODO: The maxwell emulator does not capture line rasters
+    if (!device.SupportsDynamicState3LineRasterizationMode()) {
+        static std::once_flag warn_missing_rect;
+        std::call_once(warn_missing_rect, [] {
+            LOG_WARNING(Render_Vulkan,
+                        "Driver lacks rectangular line rasterization support; skipping dynamic "
+                        "line state updates");
+        });
+        return;
+    }
 
-    // scheduler.Record([enable = regs.line](vk::CommandBuffer cmdbuf) {
-    //     cmdbuf.SetConservativeRasterizationModeEXT(
-    //         enable ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
-    //                : VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT);
-    // });
+    const bool wants_smooth = regs.line_anti_alias_enable != 0;
+    VkLineRasterizationModeEXT mode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT;
+    if (wants_smooth) {
+        if (device.SupportsSmoothLines()) {
+            mode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT;
+        } else {
+            static std::once_flag warn_missing_smooth;
+            std::call_once(warn_missing_smooth, [] {
+                LOG_WARNING(Render_Vulkan,
+                            "Line anti-aliasing requested but smoothLines feature unavailable; "
+                            "using rectangular rasterization");
+            });
+        }
+    }
+    scheduler.Record([mode](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetLineRasterizationModeEXT(mode);
+    });
 }
 
 void RasterizerVulkan::UpdateDepthBiasEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
@@ -1394,6 +1514,9 @@ void RasterizerVulkan::UpdateLogicOpEnable(Tegra::Engines::Maxwell3D::Regs& regs
     if (!state_tracker.TouchLogicOpEnable()) {
         return;
     }
+    if (!device.SupportsDynamicState3LogicOpEnable()) {
+        return;
+    }
     scheduler.Record([enable = regs.logic_op.enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetLogicOpEnableEXT(enable != 0);
     });
@@ -1403,6 +1526,9 @@ void RasterizerVulkan::UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& r
     if (!state_tracker.TouchDepthClampEnable()) {
         return;
     }
+    if (!device.SupportsDynamicState3DepthClampEnable()) {
+        return;
+    }
     bool is_enabled = !(regs.viewport_clip_control.geometry_clip ==
                             Maxwell::ViewportClipControl::GeometryClip::Passthrough ||
                         regs.viewport_clip_control.geometry_clip ==
@@ -1413,6 +1539,41 @@ void RasterizerVulkan::UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& r
         [is_enabled](vk::CommandBuffer cmdbuf) { cmdbuf.SetDepthClampEnableEXT(is_enabled); });
 }
 
+void RasterizerVulkan::UpdateAlphaToCoverageEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
+    if (!state_tracker.TouchAlphaToCoverageEnable()) {
+        return;
+    }
+    if (!device.SupportsDynamicState3AlphaToCoverageEnable()) {
+        return;
+    }
+    GraphicsPipeline* const pipeline = pipeline_cache.CurrentGraphicsPipeline();
+    const bool enable = pipeline != nullptr && pipeline->SupportsAlphaToCoverage() &&
+                        regs.anti_alias_alpha_control.alpha_to_coverage != 0;
+    scheduler.Record([enable](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetAlphaToCoverageEnableEXT(enable ? VK_TRUE : VK_FALSE);
+    });
+}
+
+void RasterizerVulkan::UpdateAlphaToOneEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
+    if (!state_tracker.TouchAlphaToOneEnable()) {
+        return;
+    }
+    if (!device.SupportsDynamicState3AlphaToOneEnable()) {
+        static std::once_flag warn_alpha_to_one;
+        std::call_once(warn_alpha_to_one, [] {
+            LOG_WARNING(Render_Vulkan,
+                        "Alpha-to-one is not supported on this device; forcing it disabled");
+        });
+        return;
+    }
+    GraphicsPipeline* const pipeline = pipeline_cache.CurrentGraphicsPipeline();
+    const bool enable = pipeline != nullptr && pipeline->SupportsAlphaToOne() &&
+                        regs.anti_alias_alpha_control.alpha_to_one != 0;
+    scheduler.Record([enable](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetAlphaToOneEnableEXT(enable ? VK_TRUE : VK_FALSE);
+    });
+}
+
 void RasterizerVulkan::UpdateDepthCompareOp(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchDepthCompareOp()) {
         return;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -183,6 +183,8 @@ private:
     void UpdateDepthBiasEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateLogicOpEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& regs);
+    void UpdateAlphaToCoverageEnable(Tegra::Engines::Maxwell3D::Regs& regs);
+    void UpdateAlphaToOneEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateFrontFace(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateStencilOp(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -13,6 +13,7 @@
 
 #include "common/thread.h"
 #include "video_core/renderer_vulkan/vk_command_pool.h"
+#include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
@@ -130,9 +131,27 @@ void Scheduler::RequestOutsideRenderPassOperationContext() {
 
 bool Scheduler::UpdateGraphicsPipeline(GraphicsPipeline* pipeline) {
     if (state.graphics_pipeline == pipeline) {
+        if (pipeline && pipeline->UsesExtendedDynamicState() &&
+            state.needs_state_enable_refresh) {
+            state_tracker.InvalidateStateEnableFlag();
+            state.needs_state_enable_refresh = false;
+        }
         return false;
     }
+
     state.graphics_pipeline = pipeline;
+
+    if (!pipeline) {
+        return true;
+    }
+
+    if (!pipeline->UsesExtendedDynamicState()) {
+        state.needs_state_enable_refresh = true;
+    } else if (state.needs_state_enable_refresh) {
+        state_tracker.InvalidateStateEnableFlag();
+        state.needs_state_enable_refresh = false;
+    }
+
     return true;
 }
 
@@ -283,8 +302,6 @@ void Scheduler::EndRenderPass()
                        images = renderpass_images,
                        ranges = renderpass_image_ranges](vk::CommandBuffer cmdbuf) {
             std::array<VkImageMemoryBarrier, 9> barriers;
-            VkPipelineStageFlags src_stages = 0;
-
             for (size_t i = 0; i < num_images; ++i) {
                 const VkImageSubresourceRange& range = ranges[i];
                 const bool is_color = (range.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != 0;
@@ -293,20 +310,14 @@ void Scheduler::EndRenderPass()
                                                  | VK_IMAGE_ASPECT_STENCIL_BIT)) !=0;
 
                 VkAccessFlags src_access = 0;
-                VkPipelineStageFlags this_stage = 0;
 
-                if (is_color) {
+                if (is_color)
                     src_access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-                    this_stage |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-                }
-
-                if (is_depth_stencil) {
+                else if (is_depth_stencil)
                     src_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-                    this_stage |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
-                                  | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-                }
-
-                src_stages |= this_stage;
+                else
+                    src_access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
+                                  | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 
                 barriers[i] = VkImageMemoryBarrier{
                         .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
@@ -325,15 +336,10 @@ void Scheduler::EndRenderPass()
                         .subresourceRange = range,
                 };
             }
-
-            // Graft: ensure explicit fragment tests + color output stages are always synchronized (AMD/Windows fix)
-            src_stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
-                    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
-                    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-
             cmdbuf.EndRenderPass();
-
-            cmdbuf.PipelineBarrier(src_stages,
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
+                                   VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
+                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                    0,
                                    nullptr,

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -214,6 +217,7 @@ private:
         GraphicsPipeline* graphics_pipeline = nullptr;
         bool is_rescaling = false;
         bool rescaling_defined = false;
+        bool needs_state_enable_refresh = false;
     };
 
     void WorkerThread(std::stop_token stop_token);

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -48,6 +48,7 @@ Flags MakeInvalidationFlags() {
         FrontFace,
         StencilOp,
         StencilTestEnable,
+        RasterizerDiscardEnable,
         VertexBuffers,
         VertexInput,
         StateEnable,
@@ -55,6 +56,9 @@ Flags MakeInvalidationFlags() {
         DepthBiasEnable,
         LogicOpEnable,
         DepthClampEnable,
+        AlphaToCoverageEnable,
+        AlphaToOneEnable,
+        LineRasterizationMode,
         LogicOp,
         Blending,
         ColorMask,
@@ -148,6 +152,8 @@ void SetupDirtyStateEnable(Tables& tables) {
     setup(OFF(logic_op.enable), LogicOpEnable);
     setup(OFF(viewport_clip_control.geometry_clip), DepthClampEnable);
     setup(OFF(line_stipple_enable), LineStippleEnable);
+    setup(OFF(anti_alias_alpha_control.alpha_to_coverage), AlphaToCoverageEnable);
+    setup(OFF(anti_alias_alpha_control.alpha_to_one), AlphaToOneEnable);
 }
 
 void SetupDirtyDepthCompareOp(Tables& tables) {
@@ -226,6 +232,7 @@ void SetupRasterModes(Tables &tables) {
 
     table[OFF(line_stipple_params)] = LineStippleParams;
     table[OFF(conservative_raster_enable)] = ConservativeRasterizationMode;
+    table[OFF(line_anti_alias_enable)] = LineRasterizationMode;
 }
 } // Anonymous namespace
 

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -54,6 +54,7 @@ enum : u8 {
     PrimitiveRestartEnable,
     RasterizerDiscardEnable,
     ConservativeRasterizationMode,
+    LineRasterizationMode,
     LineStippleEnable,
     LineStippleParams,
     DepthBiasEnable,
@@ -61,6 +62,8 @@ enum : u8 {
     LogicOp,
     LogicOpEnable,
     DepthClampEnable,
+    AlphaToCoverageEnable,
+    AlphaToOneEnable,
 
     Blending,
     BlendEnable,
@@ -94,6 +97,10 @@ public:
         (*flags)[Dirty::Scissors] = true;
     }
 
+    void InvalidateStateEnableFlag() {
+        (*flags)[Dirty::StateEnable] = true;
+    }
+
     bool TouchViewports() {
         const bool dirty_viewports = Exchange(Dirty::Viewports, false);
         const bool rescale_viewports = Exchange(VideoCommon::Dirty::RescaleViewports, false);
@@ -225,6 +232,14 @@ public:
         return Exchange(Dirty::DepthClampEnable, false);
     }
 
+    bool TouchAlphaToCoverageEnable() {
+        return Exchange(Dirty::AlphaToCoverageEnable, false);
+    }
+
+    bool TouchAlphaToOneEnable() {
+        return Exchange(Dirty::AlphaToOneEnable, false);
+    }
+
     bool TouchDepthCompareOp() {
         return Exchange(Dirty::DepthCompareOp, false);
     }
@@ -261,6 +276,10 @@ public:
         return Exchange(Dirty::LogicOp, false);
     }
 
+    bool TouchLineRasterizationMode() {
+        return Exchange(Dirty::LineRasterizationMode, false);
+    }
+
     bool ChangePrimitiveTopology(Maxwell::PrimitiveTopology new_topology) {
         const bool has_changed = current_topology != new_topology;
         current_topology = new_topology;

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -306,7 +306,17 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
         swapchain_ci.queueFamilyIndexCount = static_cast<u32>(queue_indices.size());
         swapchain_ci.pQueueFamilyIndices = queue_indices.data();
     }
-    static constexpr std::array view_formats{VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SRGB};
+    // According to Vulkan spec, when using VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR,
+    // the base format (imageFormat) MUST be included in pViewFormats
+    const std::array view_formats{
+        swapchain_ci.imageFormat,  // Base format MUST be first
+        VK_FORMAT_B8G8R8A8_UNORM,
+        VK_FORMAT_B8G8R8A8_SRGB,
+#ifdef ANDROID
+        VK_FORMAT_R8G8B8A8_UNORM,  // Android may use RGBA
+        VK_FORMAT_R8G8B8A8_SRGB,
+#endif
+    };
     VkImageFormatListCreateInfo format_list{
         .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR,
         .pNext = nullptr,

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -101,7 +104,7 @@ public:
     }
 
     VkSemaphore CurrentRenderSemaphore() const {
-        return *render_semaphores[frame_index];
+        return *render_semaphores[image_index];
     }
 
     u32 GetWidth() const {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1104,6 +1104,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                 UNREACHABLE();
             }
         }();
+        // Use shader-based depth/stencil blits if hardware doesn't support the format
+        // Note: MSAA resolves (MSAA->single) use vkCmdResolveImage which works fine
         if (!can_blit_depth_stencil) {
             UNIMPLEMENTED_IF(is_src_msaa || is_dst_msaa);
             blit_image_helper.BlitDepthStencil(dst_framebuffer, src, dst_region, src_region,
@@ -1118,6 +1120,15 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
     const VkImage src_image = src.ImageHandle();
     const VkImageSubresourceLayers dst_layers = MakeSubresourceLayers(&dst);
     const VkImageSubresourceLayers src_layers = MakeSubresourceLayers(&src);
+    const bool is_msaa_to_msaa = is_src_msaa && is_dst_msaa;
+
+    // NVIDIA 510+ and Intel crash on MSAA->MSAA blits (scaling operations)
+    // Fall back to 3D helpers for MSAA scaling
+    if (is_msaa_to_msaa && device.CantBlitMSAA()) {
+        // This should be handled by NeedsScaleHelper() and use 3D helpers instead
+        UNIMPLEMENTED_MSG("MSAA to MSAA blit not supported on this driver");
+        return;
+    }
     const bool is_resolve = is_src_msaa && !is_dst_msaa;
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([filter, dst_region, src_region, dst_image, src_image, dst_layers, src_layers,
@@ -1516,6 +1527,10 @@ bool TextureCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
+std::optional<size_t> TextureCacheRuntime::GetSamplerHeapBudget() const {
+    return device.GetSamplerHeapBudget();
+}
+
 void TextureCacheRuntime::TickFrame() {}
 
 Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu_addr_,
@@ -2222,18 +2237,26 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
 
 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
     const auto& device = runtime.device;
-    const bool arbitrary_borders = runtime.device.IsExtCustomBorderColorSupported();
+    // Check if custom border colors are supported
+    const bool has_custom_border_colors = runtime.device.IsCustomBorderColorsSupported();
+    const bool has_format_undefined = runtime.device.IsCustomBorderColorWithoutFormatSupported();
     const auto color = tsc.BorderColor();
 
+    // Determine border format based on available features:
+    // - If customBorderColorWithoutFormat is available: use VK_FORMAT_UNDEFINED (most flexible)
+    // - If only customBorderColors is available: use concrete format (R8G8B8A8_UNORM)
+    // - If neither is available: use standard border colors (handled by ConvertBorderColor)
+    const VkFormat border_format = has_format_undefined ? VK_FORMAT_UNDEFINED
+                                                        : VK_FORMAT_R8G8B8A8_UNORM;
+
     const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
         .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
         .pNext = nullptr,
-        // TODO: Make use of std::bit_cast once libc++ supports it.
         .customBorderColor = std::bit_cast<VkClearColorValue>(color),
-        .format = VK_FORMAT_UNDEFINED,
+        .format = border_format,
     };
     const void* pnext = nullptr;
-    if (arbitrary_borders) {
+    if (has_custom_border_colors) {
         pnext = &border_ci;
     }
     const VkSamplerReductionModeCreateInfoEXT reduction_ci{
@@ -2267,8 +2290,8 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
             .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
             .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
             .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
-            .borderColor =
-                arbitrary_borders ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT : ConvertBorderColor(color),
+            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+                                                    : ConvertBorderColor(color),
             .unnormalizedCoordinates = VK_FALSE,
         });
     };

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -62,6 +65,8 @@ public:
 
     bool CanReportMemoryUsage() const;
 
+    std::optional<size_t> GetSamplerHeapBudget() const;
+
     void BlitImage(Framebuffer* dst_framebuffer, ImageView& dst, ImageView& src,
                    const Region2D& dst_region, const Region2D& src_region,
                    Tegra::Engines::Fermi2D::Filter filter,

src/video_core/texture_cache/texture_cache.h

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <limits>
+#include <optional>
 #include <unordered_set>
 #include <boost/container/small_vector.hpp>
 
@@ -1736,11 +1738,89 @@ SamplerId TextureCache<P>::FindSampler(const TSCEntry& config) {
     }
     const auto [pair, is_new] = channel_state->samplers.try_emplace(config);
     if (is_new) {
+        EnforceSamplerBudget();
         pair->second = slot_samplers.insert(runtime, config);
     }
     return pair->second;
 }
 
+template <class P>
+std::optional<size_t> TextureCache<P>::QuerySamplerBudget() const {
+    if constexpr (requires { runtime.GetSamplerHeapBudget(); }) {
+        return runtime.GetSamplerHeapBudget();
+    } else {
+        return std::nullopt;
+    }
+}
+
+template <class P>
+void TextureCache<P>::EnforceSamplerBudget() {
+    const auto budget = QuerySamplerBudget();
+    if (!budget) {
+        return;
+    }
+    if (slot_samplers.size() < *budget) {
+        return;
+    }
+    if (!channel_state) {
+        return;
+    }
+    if (last_sampler_gc_frame == frame_tick) {
+        return;
+    }
+    last_sampler_gc_frame = frame_tick;
+    TrimInactiveSamplers(*budget);
+}
+
+template <class P>
+void TextureCache<P>::TrimInactiveSamplers(size_t budget) {
+    if (channel_state->samplers.empty()) {
+        return;
+    }
+    static constexpr size_t SAMPLER_GC_SLACK = 1024;
+    auto mark_active = [](auto& set, SamplerId id) {
+        if (!id || id == CORRUPT_ID || id == NULL_SAMPLER_ID) {
+            return;
+        }
+        set.insert(id);
+    };
+    std::unordered_set<SamplerId> active;
+    active.reserve(channel_state->graphics_sampler_ids.size() +
+                   channel_state->compute_sampler_ids.size());
+    for (const SamplerId id : channel_state->graphics_sampler_ids) {
+        mark_active(active, id);
+    }
+    for (const SamplerId id : channel_state->compute_sampler_ids) {
+        mark_active(active, id);
+    }
+
+    size_t removed = 0;
+    auto& sampler_map = channel_state->samplers;
+    for (auto it = sampler_map.begin(); it != sampler_map.end();) {
+        const SamplerId sampler_id = it->second;
+        if (!sampler_id || sampler_id == CORRUPT_ID) {
+            it = sampler_map.erase(it);
+            continue;
+        }
+        if (active.find(sampler_id) != active.end()) {
+            ++it;
+            continue;
+        }
+        slot_samplers.erase(sampler_id);
+        it = sampler_map.erase(it);
+        ++removed;
+        if (slot_samplers.size() + SAMPLER_GC_SLACK <= budget) {
+            break;
+        }
+    }
+
+    if (removed != 0) {
+        LOG_WARNING(HW_GPU,
+                    "Sampler cache exceeded {} entries on this driver; reclaimed {} inactive samplers",
+                    budget, removed);
+    }
+}
+
 template <class P>
 ImageViewId TextureCache<P>::FindColorBuffer(size_t index) {
     const auto& regs = maxwell3d->regs;

src/video_core/texture_cache/texture_cache_base.h

@@ -429,6 +429,9 @@ private:
 
     void QueueAsyncDecode(Image& image, ImageId image_id);
     void TickAsyncDecode();
+    void EnforceSamplerBudget();
+    void TrimInactiveSamplers(size_t budget);
+    std::optional<size_t> QuerySamplerBudget() const;
 
     Runtime& runtime;
 
@@ -500,6 +503,7 @@ private:
 
     u64 modification_tick = 0;
     u64 frame_tick = 0;
+    u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();
 
     Common::ThreadWorker texture_decode_worker{1, "TextureDecoder"};
     std::vector<std::unique_ptr<AsyncDecodeContext>> async_decodes;

src/video_core/textures/decoders.cpp

@@ -18,8 +18,7 @@
 
 namespace Tegra::Texture {
 namespace {
-template <u32 mask>
-constexpr u32 pdep(u32 value) {
+constexpr u32 pdep(u32 mask, u32 value) {
     u32 result = 0;
     u32 m = mask;
     for (u32 bit = 1; m; bit += bit) {
@@ -30,15 +29,12 @@ constexpr u32 pdep(u32 value) {
     return result;
 }
 
-template <u32 mask, u32 incr_amount>
-void incrpdep(u32& value) {
-    static constexpr u32 swizzled_incr = pdep<mask>(incr_amount);
+void incrpdep(u32 mask, u32 incr_amount, u32& value) {
+    u32 swizzled_incr = pdep(mask, incr_amount);
     value = ((value | ~mask) + swizzled_incr) & mask;
 }
 
-template <bool TO_LINEAR, u32 BYTES_PER_PIXEL>
-void SwizzleImpl(std::span<u8> output, std::span<const u8> input, u32 width, u32 height, u32 depth,
-                 u32 block_height, u32 block_depth, u32 stride) {
+void SwizzleImpl(bool to_linear, u32 bytes_per_pixel, std::span<u8> output, std::span<const u8> input, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride) {
     // The origin of the transformation can be configured here, leave it as zero as the current API
     // doesn't expose it.
     static constexpr u32 origin_x = 0;
@@ -46,13 +42,12 @@ void SwizzleImpl(std::span<u8> output, std::span<const u8> input, u32 width, u32
     static constexpr u32 origin_z = 0;
 
     // We can configure here a custom pitch
-    // As it's not exposed 'width * BYTES_PER_PIXEL' will be the expected pitch.
-    const u32 pitch = width * BYTES_PER_PIXEL;
+    // As it's not exposed 'width * bytes_per_pixel' will be the expected pitch.
+    const u32 pitch = width * bytes_per_pixel;
 
     const u32 gobs_in_x = Common::DivCeilLog2(stride, GOB_SIZE_X_SHIFT);
     const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height + block_depth);
-    const u32 slice_size =
-        Common::DivCeilLog2(height, block_height + GOB_SIZE_Y_SHIFT) * block_size;
+    const u32 slice_size = Common::DivCeilLog2(height, block_height + GOB_SIZE_Y_SHIFT) * block_size;
 
     const u32 block_height_mask = (1U << block_height) - 1;
     const u32 block_depth_mask = (1U << block_depth) - 1;
@@ -64,50 +59,42 @@ void SwizzleImpl(std::span<u8> output, std::span<const u8> input, u32 width, u32
                              ((z & block_depth_mask) << (GOB_SIZE_SHIFT + block_height));
         for (u32 line = 0; line < height; ++line) {
             const u32 y = line + origin_y;
-            const u32 swizzled_y = pdep<SWIZZLE_Y_BITS>(y);
+            const u32 swizzled_y = pdep(SWIZZLE_Y_BITS, y);
 
             const u32 block_y = y >> GOB_SIZE_Y_SHIFT;
-            const u32 offset_y = (block_y >> block_height) * block_size +
-                                 ((block_y & block_height_mask) << GOB_SIZE_SHIFT);
+            const u32 offset_y = (block_y >> block_height) * block_size + ((block_y & block_height_mask) << GOB_SIZE_SHIFT);
 
-            u32 swizzled_x = pdep<SWIZZLE_X_BITS>(origin_x * BYTES_PER_PIXEL);
-            for (u32 column = 0; column < width;
-                 ++column, incrpdep<SWIZZLE_X_BITS, BYTES_PER_PIXEL>(swizzled_x)) {
-                const u32 x = (column + origin_x) * BYTES_PER_PIXEL;
+            u32 swizzled_x = pdep(SWIZZLE_X_BITS, origin_x * bytes_per_pixel);
+            for (u32 column = 0; column < width; ++column, incrpdep(SWIZZLE_X_BITS, bytes_per_pixel, swizzled_x)) {
+                const u32 x = (column + origin_x) * bytes_per_pixel;
                 const u32 offset_x = (x >> GOB_SIZE_X_SHIFT) << x_shift;
 
                 const u32 base_swizzled_offset = offset_z + offset_y + offset_x;
                 const u32 swizzled_offset = base_swizzled_offset + (swizzled_x | swizzled_y);
 
-                const u32 unswizzled_offset =
-                    slice * pitch * height + line * pitch + column * BYTES_PER_PIXEL;
+                const u32 unswizzled_offset = slice * pitch * height + line * pitch + column * bytes_per_pixel;
+                u8* const dst = &output[to_linear ? swizzled_offset : unswizzled_offset];
+                const u8* const src = &input[to_linear ? unswizzled_offset : swizzled_offset];
 
-                u8* const dst = &output[TO_LINEAR ? swizzled_offset : unswizzled_offset];
-                const u8* const src = &input[TO_LINEAR ? unswizzled_offset : swizzled_offset];
-
-                std::memcpy(dst, src, BYTES_PER_PIXEL);
+                std::memcpy(dst, src, bytes_per_pixel);
             }
         }
     }
 }
 
-template <bool TO_LINEAR, u32 BYTES_PER_PIXEL>
-void SwizzleSubrectImpl(std::span<u8> output, std::span<const u8> input, u32 width, u32 height,
-                        u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 num_lines,
-                        u32 block_height, u32 block_depth, u32 pitch_linear) {
+void SwizzleSubrectImpl(bool to_linear, u32 bytes_per_pixel, std::span<u8> output, std::span<const u8> input, u32 width, u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 num_lines, u32 block_height, u32 block_depth, u32 pitch_linear) {
     // The origin of the transformation can be configured here, leave it as zero as the current API
     // doesn't expose it.
     static constexpr u32 origin_z = 0;
 
     // We can configure here a custom pitch
-    // As it's not exposed 'width * BYTES_PER_PIXEL' will be the expected pitch.
+    // As it's not exposed 'width * bytes_per_pixel' will be the expected pitch.
     const u32 pitch = pitch_linear;
-    const u32 stride = Common::AlignUpLog2(width * BYTES_PER_PIXEL, GOB_SIZE_X_SHIFT);
+    const u32 stride = Common::AlignUpLog2(width * bytes_per_pixel, GOB_SIZE_X_SHIFT);
 
     const u32 gobs_in_x = Common::DivCeilLog2(stride, GOB_SIZE_X_SHIFT);
     const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height + block_depth);
-    const u32 slice_size =
-        Common::DivCeilLog2(height, block_height + GOB_SIZE_Y_SHIFT) * block_size;
+    const u32 slice_size = Common::DivCeilLog2(height, block_height + GOB_SIZE_Y_SHIFT) * block_size;
 
     const u32 block_height_mask = (1U << block_height) - 1;
     const u32 block_depth_mask = (1U << block_depth) - 1;
@@ -123,28 +110,25 @@ void SwizzleSubrectImpl(std::span<u8> output, std::span<const u8> input, u32 wid
         const u32 lines_in_y = (std::min)(unprocessed_lines, extent_y);
         for (u32 line = 0; line < lines_in_y; ++line) {
             const u32 y = line + origin_y;
-            const u32 swizzled_y = pdep<SWIZZLE_Y_BITS>(y);
+            const u32 swizzled_y = pdep(SWIZZLE_Y_BITS, y);
 
             const u32 block_y = y >> GOB_SIZE_Y_SHIFT;
-            const u32 offset_y = (block_y >> block_height) * block_size +
-                                 ((block_y & block_height_mask) << GOB_SIZE_SHIFT);
+            const u32 offset_y = (block_y >> block_height) * block_size + ((block_y & block_height_mask) << GOB_SIZE_SHIFT);
 
-            u32 swizzled_x = pdep<SWIZZLE_X_BITS>(origin_x * BYTES_PER_PIXEL);
-            for (u32 column = 0; column < extent_x;
-                 ++column, incrpdep<SWIZZLE_X_BITS, BYTES_PER_PIXEL>(swizzled_x)) {
-                const u32 x = (column + origin_x) * BYTES_PER_PIXEL;
+            u32 swizzled_x = pdep(SWIZZLE_X_BITS, origin_x * bytes_per_pixel);
+            for (u32 column = 0; column < extent_x; ++column, incrpdep(SWIZZLE_X_BITS, bytes_per_pixel, swizzled_x)) {
+                const u32 x = (column + origin_x) * bytes_per_pixel;
                 const u32 offset_x = (x >> GOB_SIZE_X_SHIFT) << x_shift;
 
                 const u32 base_swizzled_offset = offset_z + offset_y + offset_x;
                 const u32 swizzled_offset = base_swizzled_offset + (swizzled_x | swizzled_y);
 
-                const u32 unswizzled_offset =
-                    slice * pitch * height + line * pitch + column * BYTES_PER_PIXEL;
+                const u32 unswizzled_offset = slice * pitch * height + line * pitch + column * bytes_per_pixel;
 
-                u8* const dst = &output[TO_LINEAR ? swizzled_offset : unswizzled_offset];
-                const u8* const src = &input[TO_LINEAR ? unswizzled_offset : swizzled_offset];
+                u8* const dst = &output[to_linear ? swizzled_offset : unswizzled_offset];
+                const u8* const src = &input[to_linear ? unswizzled_offset : swizzled_offset];
 
-                std::memcpy(dst, src, BYTES_PER_PIXEL);
+                std::memcpy(dst, src, bytes_per_pixel);
             }
         }
         unprocessed_lines -= lines_in_y;
@@ -154,23 +138,17 @@ void SwizzleSubrectImpl(std::span<u8> output, std::span<const u8> input, u32 wid
     }
 }
 
-template <bool TO_LINEAR>
-void Swizzle(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width,
-             u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride_alignment) {
+void Swizzle(bool to_linear, std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride_alignment) {
     switch (bytes_per_pixel) {
-#define BPP_CASE(x)                                                                                \
-    case x:                                                                                        \
-        return SwizzleImpl<TO_LINEAR, x>(output, input, width, height, depth, block_height,        \
-                                         block_depth, stride_alignment);
-        BPP_CASE(1)
-        BPP_CASE(2)
-        BPP_CASE(3)
-        BPP_CASE(4)
-        BPP_CASE(6)
-        BPP_CASE(8)
-        BPP_CASE(12)
-        BPP_CASE(16)
-#undef BPP_CASE
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 6:
+    case 8:
+    case 12:
+    case 16:
+        return SwizzleImpl(to_linear, bytes_per_pixel, output, input, width, height, depth, block_height, block_depth, stride_alignment);
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
         break;
@@ -179,78 +157,57 @@ void Swizzle(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixe
 
 } // Anonymous namespace
 
-void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
-                      u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth,
-                      u32 stride_alignment) {
+void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride_alignment) {
     const u32 stride = Common::AlignUpLog2(width, stride_alignment) * bytes_per_pixel;
-    const u32 new_bpp = (std::min)(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
+    const u32 new_bpp = (std::min)(4U, u32(std::countr_zero(width * bytes_per_pixel)));
     width = (width * bytes_per_pixel) >> new_bpp;
     bytes_per_pixel = 1U << new_bpp;
-    Swizzle<false>(output, input, bytes_per_pixel, width, height, depth, block_height, block_depth,
-                   stride);
+    Swizzle(false, output, input, bytes_per_pixel, width, height, depth, block_height, block_depth, stride);
 }
 
-void SwizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width,
-                    u32 height, u32 depth, u32 block_height, u32 block_depth,
-                    u32 stride_alignment) {
+void SwizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride_alignment) {
     const u32 stride = Common::AlignUpLog2(width, stride_alignment) * bytes_per_pixel;
-    const u32 new_bpp = (std::min)(4U, static_cast<u32>(std::countr_zero(width * bytes_per_pixel)));
+    const u32 new_bpp = (std::min)(4U, u32(std::countr_zero(width * bytes_per_pixel)));
     width = (width * bytes_per_pixel) >> new_bpp;
     bytes_per_pixel = 1U << new_bpp;
-    Swizzle<true>(output, input, bytes_per_pixel, width, height, depth, block_height, block_depth,
-                  stride);
+    Swizzle(true, output, input, bytes_per_pixel, width, height, depth, block_height, block_depth, stride);
 }
 
-void SwizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width,
-                    u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 extent_y,
-                    u32 block_height, u32 block_depth, u32 pitch_linear) {
+void SwizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 extent_y, u32 block_height, u32 block_depth, u32 pitch_linear) {
     switch (bytes_per_pixel) {
-#define BPP_CASE(x)                                                                                \
-    case x:                                                                                        \
-        return SwizzleSubrectImpl<true, x>(output, input, width, height, depth, origin_x,          \
-                                           origin_y, extent_x, extent_y, block_height,             \
-                                           block_depth, pitch_linear);
-        BPP_CASE(1)
-        BPP_CASE(2)
-        BPP_CASE(3)
-        BPP_CASE(4)
-        BPP_CASE(6)
-        BPP_CASE(8)
-        BPP_CASE(12)
-        BPP_CASE(16)
-#undef BPP_CASE
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 6:
+    case 8:
+    case 12:
+    case 16:
+        return SwizzleSubrectImpl(true, bytes_per_pixel, output, input, width, height, depth, origin_x, origin_y, extent_x, extent_y, block_height, block_depth, pitch_linear);
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
         break;
     }
 }
 
-void UnswizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
-                      u32 width, u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x,
-                      u32 extent_y, u32 block_height, u32 block_depth, u32 pitch_linear) {
+void UnswizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 extent_y, u32 block_height, u32 block_depth, u32 pitch_linear) {
     switch (bytes_per_pixel) {
-#define BPP_CASE(x)                                                                                \
-    case x:                                                                                        \
-        return SwizzleSubrectImpl<false, x>(output, input, width, height, depth, origin_x,         \
-                                            origin_y, extent_x, extent_y, block_height,            \
-                                            block_depth, pitch_linear);
-        BPP_CASE(1)
-        BPP_CASE(2)
-        BPP_CASE(3)
-        BPP_CASE(4)
-        BPP_CASE(6)
-        BPP_CASE(8)
-        BPP_CASE(12)
-        BPP_CASE(16)
-#undef BPP_CASE
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 6:
+    case 8:
+    case 12:
+    case 16:
+        return SwizzleSubrectImpl(false, bytes_per_pixel, output, input, width, height, depth, origin_x, origin_y, extent_x, extent_y, block_height, block_depth, pitch_linear);
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
         break;
     }
 }
 
-std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
-                          u32 block_height, u32 block_depth) {
+std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth) {
     if (tiled) {
         const u32 aligned_width = Common::AlignUpLog2(width * bytes_per_pixel, GOB_SIZE_X_SHIFT);
         const u32 aligned_height = Common::AlignUpLog2(height, GOB_SIZE_Y_SHIFT + block_height);
@@ -261,8 +218,7 @@ std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height
     }
 }
 
-u64 GetGOBOffset(u32 width, u32 height, u32 dst_x, u32 dst_y, u32 block_height,
-                 u32 bytes_per_pixel) {
+u64 GetGOBOffset(u32 width, u32 height, u32 dst_x, u32 dst_y, u32 block_height, u32 bytes_per_pixel) {
     auto div_ceil = [](const u32 x, const u32 y) { return ((x + y - 1) / y); };
     const u32 gobs_in_block = 1 << block_height;
     const u32 y_blocks = GOB_SIZE_Y << block_height;

src/video_core/vulkan_common/vulkan.h

@@ -22,6 +22,17 @@
 
 #include <vulkan/vulkan.h>
 
+// Define maintenance 7-9 extension names (not yet in official Vulkan headers)
+#ifndef VK_KHR_MAINTENANCE_7_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7"
+#endif
+#ifndef VK_KHR_MAINTENANCE_8_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8"
+#endif
+#ifndef VK_KHR_MAINTENANCE_9_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9"
+#endif
+
 // Sanitize macros
 #undef CreateEvent
 #undef CreateSemaphore

src/video_core/vulkan_common/vulkan_device.cpp

@@ -294,9 +294,10 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
 void OverrideBcnFormats(std::unordered_map<VkFormat, VkFormatProperties>& format_properties) {
     // These properties are extracted from Adreno driver 512.687.0
-    constexpr VkFormatFeatureFlags tiling_features{
-                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+    constexpr VkFormatFeatureFlags tiling_features{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+                                                   VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
+                                                   VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
                                                    VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
 
     constexpr VkFormatFeatureFlags buffer_features{VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT};
@@ -418,7 +419,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     const bool is_suitable = GetSuitability(surface != nullptr);
 
     const VkDriverId driver_id = properties.driver.driverID;
-    const auto device_id = properties.properties.deviceID;
 
     const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
     const bool is_amd_driver =
@@ -432,8 +432,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
     const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
     const bool is_turnip = driver_id == VK_DRIVER_ID_MESA_TURNIP;
-    const bool is_s8gen2 = device_id == 0x43050a01;
-    //const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
 
     if (!is_suitable)
         LOG_WARNING(Render_Vulkan, "Unsuitable driver - continuing anyways");
@@ -487,8 +486,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     is_non_gpu = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_OTHER ||
                  properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
 
-    const bool is_intel_igpu = is_integrated && (is_intel_anv || is_intel_windows);
-
     supports_d24_depth =
         IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
                           VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
@@ -499,6 +496,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     CollectToolingInfo();
 
     if (is_qualcomm) {
+        // Qualcomm Adreno GPUs doesn't handle scaled vertex attributes; keep emulation enabled
+        must_emulate_scaled_formats = true;
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm drivers require scaled vertex format emulation; forcing fallback");
+
         LOG_WARNING(Render_Vulkan,
                     "Disabling shader float controls and 64-bit integer features on Qualcomm proprietary drivers");
         RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
@@ -561,35 +563,31 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         }
 
         if (nv_major_version >= 510) {
-            LOG_WARNING(Render_Vulkan, "NVIDIA Drivers >= 510 do not support MSAA image blits");
+            LOG_WARNING(Render_Vulkan,
+                        "NVIDIA Drivers >= 510 do not support MSAA->MSAA image blits. "
+                        "MSAA scaling will use 3D helpers. MSAA resolves work normally.");
             cant_blit_msaa = true;
         }
-    }
 
-    if (extensions.extended_dynamic_state3 && is_radv) {
-        LOG_WARNING(Render_Vulkan, "RADV has broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
-        dynamic_state3_blending = false;
+        // Mali/ NVIDIA proprietary drivers: Shader stencil export not supported
+        // Use hardware depth/stencil blits instead when available
+        if (!extensions.shader_stencil_export) {
+            LOG_INFO(Render_Vulkan,
+                     "NVIDIA: VK_EXT_shader_stencil_export not supported, using hardware blits "
+                     "for depth/stencil operations");
+            LOG_INFO(Render_Vulkan, "  D24S8 hardware blit support: {}",
+                     is_blit_depth24_stencil8_supported);
+            LOG_INFO(Render_Vulkan, "  D32S8 hardware blit support: {}",
+                     is_blit_depth32_stencil8_supported);
 
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 23, 1, 0)) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV versions older than 23.1.0 have broken depth clamp dynamic state");
-            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
-            dynamic_state3_enables = false;
+            if (!is_blit_depth24_stencil8_supported && !is_blit_depth32_stencil8_supported) {
+                LOG_WARNING(Render_Vulkan,
+                            "NVIDIA: Neither shader export nor hardware blits available for "
+                            "depth/stencil. Performance may be degraded.");
+            }
         }
     }
 
-    if (extensions.extended_dynamic_state3 && (is_amd_driver || driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
-        // AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation
-        LOG_WARNING(Render_Vulkan,
-                    "AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
-        dynamic_state3_blending = false;
-    }
-
     sets_per_pool = 64;
     if (is_amd_driver) {
         // AMD drivers need a higher amount of Sets per Pool in certain circumstances like in XC2.
@@ -607,6 +605,18 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         if (version < VK_MAKE_API_VERSION(0, 255, 615, 512)) {
             has_broken_parallel_compiling = true;
         }
+        const size_t sampler_limit = properties.properties.limits.maxSamplerAllocationCount;
+        if (sampler_limit > 0) {
+            constexpr size_t MIN_SAMPLER_BUDGET = 1024U;
+            const size_t reserved = sampler_limit / 4U;
+            const size_t derived_budget =
+                (std::max)(MIN_SAMPLER_BUDGET, sampler_limit - reserved);
+            sampler_heap_budget = derived_budget;
+            LOG_WARNING(Render_Vulkan,
+                        "Qualcomm driver reports max {} samplers; reserving {} (25%) and "
+                        "allowing Eden to use {} (75%) to avoid heap exhaustion",
+                        sampler_limit, reserved, sampler_heap_budget);
+        }
     }
 
     if (extensions.sampler_filter_minmax && is_amd) {
@@ -626,15 +636,27 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     }
 
     if (is_intel_windows) {
-        LOG_WARNING(Render_Vulkan, "Intel proprietary drivers do not support MSAA image blits");
+        LOG_WARNING(Render_Vulkan,
+                    "Intel proprietary drivers do not support MSAA->MSAA image blits. "
+                    "MSAA scaling will use 3D helpers. MSAA resolves work normally.");
         cant_blit_msaa = true;
     }
 
     has_broken_compute =
         CheckBrokenCompute(properties.driver.driverID, properties.properties.driverVersion) &&
         !Settings::values.enable_compute_pipelines.GetValue();
-    if (is_intel_anv || (is_qualcomm && !is_s8gen2)) {
-        LOG_WARNING(Render_Vulkan, "Driver does not support native BGR format");
+    must_emulate_bgr565 = false; // Default: assume emulation isn't required
+
+    if (is_intel_anv) {
+        LOG_WARNING(Render_Vulkan, "Intel ANV driver does not support native BGR format");
+        must_emulate_bgr565 = true;
+    } else if (is_qualcomm) {
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm driver mishandles BGR5 formats even with VK_KHR_maintenance5, forcing emulation");
+        must_emulate_bgr565 = true;
+    } else if (is_arm) {
+        LOG_WARNING(Render_Vulkan,
+                    "ARM Mali driver mishandles BGR5 formats even with VK_KHR_maintenance5, forcing emulation");
         must_emulate_bgr565 = true;
     }
 
@@ -647,53 +669,57 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             (std::min)(properties.properties.limits.maxVertexInputBindings, 16U);
     }
 
-    if (is_turnip) {
-        LOG_WARNING(Render_Vulkan, "Turnip requires higher-than-reported binding limits");
+    if (is_turnip || is_qualcomm) {
+        LOG_WARNING(Render_Vulkan, "Driver requires higher-than-reported binding limits");
         properties.properties.limits.maxVertexInputBindings = 32;
     }
 
-    if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState2 due to missing extendedDynamicState");
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-    }
+    const auto dyna_state = Settings::values.dyna_state.GetValue();
 
-    if (!extensions.extended_dynamic_state2 && extensions.extended_dynamic_state3) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState3 due to missing extendedDynamicState2");
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        dynamic_state3_blending = false;
-        dynamic_state3_enables = false;
-    }
-
-    const auto dyna_state = u32(Settings::values.dyna_state.GetValue());
-
-    // Mesa Intel drivers on UHD 620 have broken EDS causing extreme flickering - unknown if it affects other iGPUs
-    // ALSO affects ALL versions of UHD drivers on Windows 10+, seems to cause even worse issues like straight up crashing
-    // So... Yeah, UHD drivers fucking suck -- maybe one day we can work past this, maybe; some driver hacking?
-    // And then we can rest in peace by doing `< VK_MAKE_API_VERSION(26, 0, 0)` for our beloved mesa drivers... one day
-    if ((is_mvk || is_intel_igpu) && dyna_state != 0) {
-        LOG_WARNING(Render_Vulkan, "Driver has broken dynamic state, forcing to 0 to prevent graphical issues");
-        Settings::values.dyna_state.SetValue(Settings::ExtendedDynamicState::Disabled);
-    }
+    // Base dynamic states (VIEWPORT, SCISSOR, DEPTH_BIAS, etc.) are ALWAYS active in vk_graphics_pipeline.cpp
+    // This slider controls EXTENDED dynamic states with accumulative levels per Vulkan specs:
+    //   Level 0 = Core Dynamic States only (Vulkan 1.0)
+    //   Level 1 = Core + VK_EXT_extended_dynamic_state
+    //   Level 2 = Core + VK_EXT_extended_dynamic_state + VK_EXT_extended_dynamic_state2
+    //   Level 3 = Core + VK_EXT_extended_dynamic_state + VK_EXT_extended_dynamic_state2 + VK_EXT_extended_dynamic_state3
 
     switch (dyna_state) {
-    case 0:
-        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-        [[fallthrough]];
-    case 1:
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2, VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        [[fallthrough]];
-    case 2:
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+    case Settings::ExtendedDynamicState::Disabled:
+        // Level 0: Disable all extended dynamic state extensions
+        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
         dynamic_state3_blending = false;
         dynamic_state3_enables = false;
         break;
+    case Settings::ExtendedDynamicState::EDS1:
+        // Level 1: Enable EDS1, disable EDS2 and EDS3
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        break;
+    case Settings::ExtendedDynamicState::EDS2:
+        // Level 2: Enable EDS1 + EDS2, disable EDS3
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        break;
+    case Settings::ExtendedDynamicState::EDS3:
+    default:
+        // Level 3: Enable all (EDS1 + EDS2 + EDS3)
+        break;
     }
 
-    if (!Settings::values.vertex_input_dynamic_state.GetValue() || !extensions.extended_dynamic_state) {
+    // VK_EXT_vertex_input_dynamic_state is independent from EDS
+    // It can be enabled even without extended_dynamic_state
+    if (!Settings::values.vertex_input_dynamic_state.GetValue()) {
         RemoveExtensionFeature(extensions.vertex_input_dynamic_state, features.vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
     }
 
@@ -781,8 +807,8 @@ void Device::SaveShader(std::span<const u32> spirv) const {
 }
 
 bool Device::ComputeIsOptimalAstcSupported() const {
-    // Disable for now to avoid converting ASTC twice.
-    static constexpr std::array astc_formats = {
+    // Verify hardware supports all ASTC formats with optimal tiling to avoid software conversion
+    static constexpr std::array<VkFormat, 28> astc_formats = {
         VK_FORMAT_ASTC_4x4_UNORM_BLOCK,   VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
         VK_FORMAT_ASTC_5x4_UNORM_BLOCK,   VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
         VK_FORMAT_ASTC_5x5_UNORM_BLOCK,   VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
@@ -801,9 +827,10 @@ bool Device::ComputeIsOptimalAstcSupported() const {
     if (!features.features.textureCompressionASTC_LDR) {
         return false;
     }
-    const auto format_feature_usage{
-                                    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-                                    VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+    const auto format_feature_usage{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_DST_BIT |
+                                    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
                                     VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
     for (const auto format : astc_formats) {
         const auto physical_format_properties{physical.GetFormatProperties(format)};
@@ -1000,7 +1027,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
     // Set next pointer.
     void** next = &features2.pNext;
 
-    // Vulkan 1.2, 1.3 and 1.4 features
+    // Vulkan 1.2 and 1.3 features
     if (instance_version >= VK_API_VERSION_1_2) {
         features_1_2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
         features_1_3.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
@@ -1106,6 +1133,16 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
         SetNext(next, properties.transform_feedback);
     }
+    if (extensions.maintenance5) {
+        properties.maintenance5.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
+        SetNext(next, properties.maintenance5);
+    }
+    if (extensions.multi_draw) {
+        properties.multi_draw.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+        SetNext(next, properties.multi_draw);
+    }
 
     // Perform the property fetch.
     physical.GetProperties2(properties2);
@@ -1138,14 +1175,70 @@ bool Device::GetSuitability(bool requires_swapchain) {
         }
     }
 
+    // VK_DYNAMIC_STATE
+
+    // Driver detection variables for workarounds in GetSuitability
+    const VkDriverId driver_id = properties.driver.driverID;
+    const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
+
+    // VK_EXT_extended_dynamic_state2 below this will appear drivers that need workarounds.
+
+    // VK_EXT_extended_dynamic_state3 below this will appear drivers that need workarounds.
+
+    // Samsung: Broken extendedDynamicState3ColorBlendEquation
+    // Disable blend equation dynamic state, force static pipeline state
+    if (extensions.extended_dynamic_state3 &&
+        (driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
+        LOG_WARNING(Render_Vulkan,
+                    "Samsung: Disabling broken extendedDynamicState3ColorBlendEquation");
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+    }
+
+    // Intel Windows < 27.20.100.0: Broken VertexInputDynamicState
+    // Disable VertexInputDynamicState on old Intel Windows drivers
+    if (extensions.vertex_input_dynamic_state && is_intel_windows) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "Intel Windows < 27.20.100.0: Disabling broken VK_EXT_vertex_input_dynamic_state");
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        }
+    }
+
+    if (u32(Settings::values.dyna_state.GetValue()) == 0) {
+        LOG_INFO(Render_Vulkan, "Extended Dynamic State disabled by user setting, clearing all EDS features");
+        features.custom_border_color.customBorderColors = false;
+        features.custom_border_color.customBorderColorWithoutFormat = false;
+        features.extended_dynamic_state.extendedDynamicState = false;
+        features.extended_dynamic_state2.extendedDynamicState2 = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask = false;
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable = false;
+    }
+
     // Return whether we were suitable.
     return suitable;
 }
 
 void Device::RemoveUnsuitableExtensions() {
     // VK_EXT_custom_border_color
-    extensions.custom_border_color = features.custom_border_color.customBorderColors &&
-                                     features.custom_border_color.customBorderColorWithoutFormat;
+    // Enable extension if driver supports it, then check individual features
+    // - customBorderColors: Required to use VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+    // - customBorderColorWithoutFormat: Optional, allows VK_FORMAT_UNDEFINED
+    // If only customBorderColors is available, we must provide a specific format
+    if (extensions.custom_border_color) {
+        // Verify that at least customBorderColors is available
+        if (!features.custom_border_color.customBorderColors) {
+            LOG_WARNING(Render_Vulkan,
+                        "VK_EXT_custom_border_color reported but customBorderColors feature not available, disabling");
+            extensions.custom_border_color = false;
+        }
+    }
     RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color,
                                        VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
 
@@ -1174,21 +1267,79 @@ void Device::RemoveUnsuitableExtensions() {
                                        VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
 
     // VK_EXT_extended_dynamic_state3
-    dynamic_state3_blending =
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable &&
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation &&
+    const bool supports_color_blend_enable =
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable;
+    const bool supports_color_blend_equation =
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation;
+    const bool supports_color_write_mask =
         features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask;
-    dynamic_state3_enables =
-        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable &&
+    dynamic_state3_blending = supports_color_blend_enable && supports_color_blend_equation &&
+                              supports_color_write_mask;
+
+    const bool supports_depth_clamp_enable =
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable;
+    const bool supports_logic_op_enable =
         features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
+    const bool supports_line_raster_mode =
+        features.extended_dynamic_state3.extendedDynamicState3LineRasterizationMode &&
+        extensions.line_rasterization && features.line_rasterization.rectangularLines;
+    const bool supports_conservative_raster_mode =
+        features.extended_dynamic_state3.extendedDynamicState3ConservativeRasterizationMode &&
+        extensions.conservative_rasterization;
+    const bool supports_line_stipple_enable =
+        features.extended_dynamic_state3.extendedDynamicState3LineStippleEnable &&
+        extensions.line_rasterization && features.line_rasterization.stippledRectangularLines;
+    const bool supports_alpha_to_coverage =
+        features.extended_dynamic_state3.extendedDynamicState3AlphaToCoverageEnable;
+    const bool supports_alpha_to_one =
+        features.extended_dynamic_state3.extendedDynamicState3AlphaToOneEnable &&
+        features.features.alphaToOne;
+
+    dynamic_state3_depth_clamp_enable = supports_depth_clamp_enable;
+    dynamic_state3_logic_op_enable = supports_logic_op_enable;
+    dynamic_state3_line_raster_mode = supports_line_raster_mode;
+    dynamic_state3_conservative_raster_mode = supports_conservative_raster_mode;
+    dynamic_state3_line_stipple_enable = supports_line_stipple_enable;
+    dynamic_state3_alpha_to_coverage = supports_alpha_to_coverage;
+    dynamic_state3_alpha_to_one = supports_alpha_to_one;
+
+    dynamic_state3_enables = dynamic_state3_depth_clamp_enable || dynamic_state3_logic_op_enable ||
+                             dynamic_state3_line_raster_mode ||
+                             dynamic_state3_conservative_raster_mode ||
+                             dynamic_state3_line_stipple_enable ||
+                             dynamic_state3_alpha_to_coverage || dynamic_state3_alpha_to_one;
 
     extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
-    dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
-    dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
+    if (!extensions.extended_dynamic_state3) {
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        dynamic_state3_depth_clamp_enable = false;
+        dynamic_state3_logic_op_enable = false;
+        dynamic_state3_line_raster_mode = false;
+        dynamic_state3_conservative_raster_mode = false;
+        dynamic_state3_line_stipple_enable = false;
+        dynamic_state3_alpha_to_coverage = false;
+        dynamic_state3_alpha_to_one = false;
+    }
     RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state3,
                                        features.extended_dynamic_state3,
                                        VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
 
+    // VK_EXT_robustness2
+    // Enable if at least one robustness2 feature is available
+    extensions.robustness_2 = features.robustness2.robustBufferAccess2 ||
+                              features.robustness2.robustImageAccess2 ||
+                              features.robustness2.nullDescriptor;
+
+    RemoveExtensionFeatureIfUnsuitable(extensions.robustness_2, features.robustness2,
+                                       VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
+
+    // VK_EXT_image_robustness
+    // Enable if robustImageAccess is available
+    extensions.image_robustness = features.image_robustness.robustImageAccess;
+    RemoveExtensionFeatureIfUnsuitable(extensions.image_robustness, features.image_robustness,
+                                       VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME);
+
     // VK_EXT_provoking_vertex
     if (Settings::values.provoking_vertex.GetValue()) {
         extensions.provoking_vertex = features.provoking_vertex.provokingVertexLast
@@ -1226,15 +1377,21 @@ void Device::RemoveUnsuitableExtensions() {
                                        VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
 
     // VK_EXT_transform_feedback
+    // We only require the basic transformFeedback feature and at least
+    // one transform feedback buffer. We keep transformFeedbackQueries as it's used by
+    // the streaming byte count implementation. GeometryStreams and multiple streams
+    // are not strictly required since we currently support only stream 0.
     extensions.transform_feedback =
         features.transform_feedback.transformFeedback &&
-        features.transform_feedback.geometryStreams &&
-        properties.transform_feedback.maxTransformFeedbackStreams >= 4 &&
         properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
-        properties.transform_feedback.transformFeedbackQueries &&
-        properties.transform_feedback.transformFeedbackDraw;
+        properties.transform_feedback.transformFeedbackQueries;
     RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
                                        VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
+    if (extensions.transform_feedback) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_transform_feedback enabled (buffers={}, queries={})",
+                 properties.transform_feedback.maxTransformFeedbackBuffers,
+                 properties.transform_feedback.transformFeedbackQueries);
+    }
 
     // VK_EXT_vertex_input_dynamic_state
     extensions.vertex_input_dynamic_state =
@@ -1243,6 +1400,17 @@ void Device::RemoveUnsuitableExtensions() {
                                        features.vertex_input_dynamic_state,
                                        VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
 
+    // VK_EXT_multi_draw
+    extensions.multi_draw = features.multi_draw.multiDraw;
+
+    if (extensions.multi_draw) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_multi_draw: maxMultiDrawCount={}",
+                 properties.multi_draw.maxMultiDrawCount);
+    }
+
+    RemoveExtensionFeatureIfUnsuitable(extensions.multi_draw, features.multi_draw,
+                                       VK_EXT_MULTI_DRAW_EXTENSION_NAME);
+
     // VK_KHR_pipeline_executable_properties
     if (Settings::values.renderer_shader_feedback.GetValue()) {
         extensions.pipeline_executable_properties =
@@ -1266,6 +1434,76 @@ void Device::RemoveUnsuitableExtensions() {
     RemoveExtensionFeatureIfUnsuitable(extensions.workgroup_memory_explicit_layout,
                                        features.workgroup_memory_explicit_layout,
                                        VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
+
+    // VK_EXT_swapchain_maintenance1 (extension only, has features)
+    // Requires VK_EXT_surface_maintenance1 instance extension
+    extensions.swapchain_maintenance1 = features.swapchain_maintenance1.swapchainMaintenance1;
+    if (extensions.swapchain_maintenance1) {
+        // Check if VK_EXT_surface_maintenance1 instance extension is available
+        const auto instance_extensions = vk::EnumerateInstanceExtensionProperties(dld);
+        const bool has_surface_maintenance1 = instance_extensions && std::ranges::any_of(*instance_extensions,
+            [](const VkExtensionProperties& prop) {
+                return std::strcmp(prop.extensionName, VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) == 0;
+            });
+        if (!has_surface_maintenance1) {
+            LOG_WARNING(Render_Vulkan,
+                        "VK_EXT_swapchain_maintenance1 requires VK_EXT_surface_maintenance1, disabling");
+            extensions.swapchain_maintenance1 = false;
+            features.swapchain_maintenance1.swapchainMaintenance1 = false;
+        }
+    }
+    RemoveExtensionFeatureIfUnsuitable(extensions.swapchain_maintenance1, features.swapchain_maintenance1,
+                                       VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME);
+
+    // VK_KHR_maintenance1 (core in Vulkan 1.1, no features)
+    extensions.maintenance1 = loaded_extensions.contains(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance1, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
+
+    // VK_KHR_maintenance2 (core in Vulkan 1.1, no features)
+    extensions.maintenance2 = loaded_extensions.contains(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance2, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
+
+    // VK_KHR_maintenance3 (core in Vulkan 1.1, no features)
+    extensions.maintenance3 = loaded_extensions.contains(VK_KHR_MAINTENANCE_3_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance3, VK_KHR_MAINTENANCE_3_EXTENSION_NAME);
+
+    // VK_KHR_maintenance4
+    extensions.maintenance4 = features.maintenance4.maintenance4;
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance4, features.maintenance4,
+                                       VK_KHR_MAINTENANCE_4_EXTENSION_NAME);
+
+    // VK_KHR_maintenance5
+    extensions.maintenance5 = features.maintenance5.maintenance5;
+
+    if (extensions.maintenance5) {
+        LOG_INFO(Render_Vulkan, "VK_KHR_maintenance5 properties: polygonModePointSize={} "
+                                "depthStencilSwizzleOne={} earlyFragmentTests={} nonStrictWideLines={}",
+                 properties.maintenance5.polygonModePointSize,
+                 properties.maintenance5.depthStencilSwizzleOneSupport,
+                 properties.maintenance5.earlyFragmentMultisampleCoverageAfterSampleCounting &&
+                 properties.maintenance5.earlyFragmentSampleMaskTestBeforeSampleCounting,
+                 properties.maintenance5.nonStrictWideLinesUseParallelogram);
+    }
+
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance5, features.maintenance5,
+                                       VK_KHR_MAINTENANCE_5_EXTENSION_NAME);
+
+    // VK_KHR_maintenance6
+    extensions.maintenance6 = features.maintenance6.maintenance6;
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance6, features.maintenance6,
+                                       VK_KHR_MAINTENANCE_6_EXTENSION_NAME);
+
+    // VK_KHR_maintenance7 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance7 = loaded_extensions.contains(VK_KHR_MAINTENANCE_7_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance7, VK_KHR_MAINTENANCE_7_EXTENSION_NAME);
+
+    // VK_KHR_maintenance8 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance8 = loaded_extensions.contains(VK_KHR_MAINTENANCE_8_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance8, VK_KHR_MAINTENANCE_8_EXTENSION_NAME);
+
+    // VK_KHR_maintenance9 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance9 = loaded_extensions.contains(VK_KHR_MAINTENANCE_9_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance9, VK_KHR_MAINTENANCE_9_EXTENSION_NAME);
 }
 
 void Device::SetupFamilies(VkSurfaceKHR surface) {
@@ -1303,6 +1541,13 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
     }
 }
 
+std::optional<size_t> Device::GetSamplerHeapBudget() const {
+    if (sampler_heap_budget == 0) {
+        return std::nullopt;
+    }
+    return sampler_heap_budget;
+}
+
 u64 Device::GetDeviceMemoryUsage() const {
     VkPhysicalDeviceMemoryBudgetPropertiesEXT budget;
     budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;

src/video_core/vulkan_common/vulkan_device.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <optional>
 #include <set>
 #include <span>
 #include <string>
@@ -37,9 +38,13 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
 
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
+    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, image_robustness)                              \
     FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
             shader_demote_to_helper_invocation)                                                    \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)
+    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
+    FEATURE(KHR, Maintenance4, MAINTENANCE_4, maintenance4)
+
+#define FOR_EACH_VK_FEATURE_1_4(FEATURE)
 
 // Define all features which may be used by the implementation and require an extension here.
 #define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
@@ -52,12 +57,16 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(EXT, 4444Formats, 4444_FORMATS, format_a4b4g4r4)                                       \
     FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
     FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
+    FEATURE(EXT, MultiDraw, MULTI_DRAW, multi_draw)                                                \
     FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
             primitive_topology_list_restart)                                                       \
     FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
     FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
     FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
     FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
+    FEATURE(EXT, SwapchainMaintenance1, SWAPCHAIN_MAINTENANCE_1, swapchain_maintenance1)           \
+    FEATURE(KHR, Maintenance5, MAINTENANCE_5, maintenance5)                                        \
+    FEATURE(KHR, Maintenance6, MAINTENANCE_6, maintenance6)                                        \
     FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
             pipeline_executable_properties)                                                        \
     FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
@@ -84,6 +93,12 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
     EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
     EXTENSION(KHR, IMAGE_FORMAT_LIST, image_format_list)                                           \
+    EXTENSION(KHR, MAINTENANCE_1, maintenance1)                                                    \
+    EXTENSION(KHR, MAINTENANCE_2, maintenance2)                                                    \
+    EXTENSION(KHR, MAINTENANCE_3, maintenance3)                                                    \
+    EXTENSION(KHR, MAINTENANCE_7, maintenance7)                                                    \
+    EXTENSION(KHR, MAINTENANCE_8, maintenance8)                                                    \
+    EXTENSION(KHR, MAINTENANCE_9, maintenance9)                                                    \
     EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
     EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
     EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
@@ -110,6 +125,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
     EXTENSION_NAME(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME)                                     \
     EXTENSION_NAME(VK_EXT_4444_FORMATS_EXTENSION_NAME)                                             \
+    EXTENSION_NAME(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)                                         \
     EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
     EXTENSION_NAME(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)                                             \
     EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
@@ -161,6 +177,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
     FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
     FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
+    FEATURE_NAME(image_robustness, robustImageAccess)                                              \
     FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
     FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
     FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
@@ -310,6 +327,16 @@ public:
         return properties.properties.limits.maxComputeSharedMemorySize;
     }
 
+    /// Returns the maximum number of dynamic storage buffer descriptors per set.
+    u32 GetMaxDescriptorSetStorageBuffersDynamic() const {
+        return properties.properties.limits.maxDescriptorSetStorageBuffersDynamic;
+    }
+
+    /// Returns the maximum number of dynamic uniform buffer descriptors per set.
+    u32 GetMaxDescriptorSetUniformBuffersDynamic() const {
+        return properties.properties.limits.maxDescriptorSetUniformBuffersDynamic;
+    }
+
     /// Returns float control properties of the device.
     const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
         return properties.float_controls;
@@ -440,6 +467,11 @@ public:
         return extensions.swapchain_mutable_format;
     }
 
+    /// Returns true if VK_EXT_swapchain_maintenance1 is enabled.
+    bool IsExtSwapchainMaintenance1Enabled() const {
+        return extensions.swapchain_maintenance1;
+    }
+
     /// Returns true if VK_KHR_shader_float_controls is enabled.
     bool IsKhrShaderFloatControlsSupported() const {
         return extensions.shader_float_controls;
@@ -476,10 +508,18 @@ public:
     }
 
     /// Returns true if the device supports VK_EXT_shader_stencil_export.
+    /// Note: Most Mali/NVIDIA drivers don't support this. Use hardware blits as fallback.
     bool IsExtShaderStencilExportSupported() const {
         return extensions.shader_stencil_export;
     }
 
+    /// Returns true if depth/stencil operations can be performed efficiently.
+    /// Either through shader export or hardware blits.
+    bool CanPerformDepthStencilOperations() const {
+        return extensions.shader_stencil_export || is_blit_depth24_stencil8_supported ||
+               is_blit_depth32_stencil8_supported;
+    }
+
     /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
     bool IsExtDepthRangeUnrestrictedSupported() const {
         return extensions.depth_range_unrestricted;
@@ -520,6 +560,46 @@ public:
         return extensions.custom_border_color;
     }
 
+    /// Returns true if the device supports VK_EXT_image_robustness.
+    bool IsExtImageRobustnessSupported() const {
+        return extensions.image_robustness;
+    }
+
+    /// Returns true if robustImageAccess is supported.
+    bool IsRobustImageAccessSupported() const {
+        return features.image_robustness.robustImageAccess;
+    }
+
+    /// Returns true if the device supports VK_EXT_robustness2.
+    bool IsExtRobustness2Supported() const {
+        return extensions.robustness_2;
+    }
+
+    /// Returns true if robustBufferAccess2 is supported.
+    bool IsRobustBufferAccess2Supported() const {
+        return features.robustness2.robustBufferAccess2;
+    }
+
+    /// Returns true if robustImageAccess2 is supported.
+    bool IsRobustImageAccess2Supported() const {
+        return features.robustness2.robustImageAccess2;
+    }
+
+    /// Returns true if nullDescriptor is supported.
+    bool IsNullDescriptorSupported() const {
+        return features.robustness2.nullDescriptor;
+    }
+
+    /// Returns true if customBorderColors feature is available.
+    bool IsCustomBorderColorsSupported() const {
+        return features.custom_border_color.customBorderColors;
+    }
+
+    /// Returns true if customBorderColorWithoutFormat feature is available.
+    bool IsCustomBorderColorWithoutFormatSupported() const {
+        return features.custom_border_color.customBorderColorWithoutFormat;
+    }
+
     /// Returns true if the device supports VK_EXT_extended_dynamic_state.
     bool IsExtExtendedDynamicStateSupported() const {
         return extensions.extended_dynamic_state;
@@ -569,6 +649,50 @@ public:
         return extensions.line_rasterization;
     }
 
+    bool SupportsRectangularLines() const {
+        return features.line_rasterization.rectangularLines != VK_FALSE;
+    }
+
+    bool SupportsSmoothLines() const {
+        return features.line_rasterization.smoothLines != VK_FALSE;
+    }
+
+    bool SupportsStippledRectangularLines() const {
+        return features.line_rasterization.stippledRectangularLines != VK_FALSE;
+    }
+
+    bool SupportsAlphaToOne() const {
+        return features.features.alphaToOne != VK_FALSE;
+    }
+
+    bool SupportsDynamicState3DepthClampEnable() const {
+        return dynamic_state3_depth_clamp_enable;
+    }
+
+    bool SupportsDynamicState3LogicOpEnable() const {
+        return dynamic_state3_logic_op_enable;
+    }
+
+    bool SupportsDynamicState3LineRasterizationMode() const {
+        return dynamic_state3_line_raster_mode;
+    }
+
+    bool SupportsDynamicState3ConservativeRasterizationMode() const {
+        return dynamic_state3_conservative_raster_mode;
+    }
+
+    bool SupportsDynamicState3LineStippleEnable() const {
+        return dynamic_state3_line_stipple_enable;
+    }
+
+    bool SupportsDynamicState3AlphaToCoverageEnable() const {
+        return dynamic_state3_alpha_to_coverage;
+    }
+
+    bool SupportsDynamicState3AlphaToOneEnable() const {
+        return dynamic_state3_alpha_to_one;
+    }
+
     /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
     bool IsExtVertexInputDynamicStateSupported() const {
         return extensions.vertex_input_dynamic_state;
@@ -631,6 +755,8 @@ public:
         return has_broken_parallel_compiling;
     }
 
+    std::optional<size_t> GetSamplerHeapBudget() const;
+
     /// Returns the vendor name reported from Vulkan.
     std::string_view GetVendorName() const {
         return properties.driver.driverName;
@@ -703,6 +829,73 @@ public:
         return features2.features.multiViewport;
     }
 
+    /// Returns true if the device supports VK_KHR_maintenance1.
+    bool IsKhrMaintenance1Supported() const {
+        return extensions.maintenance1;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance2.
+    bool IsKhrMaintenance2Supported() const {
+        return extensions.maintenance2;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance3.
+    bool IsKhrMaintenance3Supported() const {
+        return extensions.maintenance3;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance4.
+    bool IsKhrMaintenance4Supported() const {
+        return extensions.maintenance4;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance5.
+    bool IsKhrMaintenance5Supported() const {
+        return extensions.maintenance5;
+    }
+
+    /// Returns true if polygon mode POINT supports gl_PointSize.
+    bool SupportsPolygonModePointSize() const {
+        return extensions.maintenance5 && properties.maintenance5.polygonModePointSize;
+    }
+
+    /// Returns true if depth/stencil swizzle ONE is supported.
+    bool SupportsDepthStencilSwizzleOne() const {
+        return extensions.maintenance5 && properties.maintenance5.depthStencilSwizzleOneSupport;
+    }
+
+    /// Returns true if early fragment tests optimizations are available.
+    bool SupportsEarlyFragmentTests() const {
+        return extensions.maintenance5 &&
+               properties.maintenance5.earlyFragmentMultisampleCoverageAfterSampleCounting &&
+               properties.maintenance5.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance6.
+    bool IsKhrMaintenance6Supported() const {
+        return extensions.maintenance6;
+    }
+
+    /// Returns true if the device supports VK_EXT_multi_draw.
+    bool IsExtMultiDrawSupported() const {
+        return extensions.multi_draw;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance7.
+    bool IsKhrMaintenance7Supported() const {
+        return extensions.maintenance7;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance8.
+    bool IsKhrMaintenance8Supported() const {
+        return extensions.maintenance8;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance9.
+    bool IsKhrMaintenance9Supported() const {
+        return extensions.maintenance9;
+    }
+
     [[nodiscard]] static constexpr bool CheckBrokenCompute(VkDriverId driver_id,
                                                            u32 driver_version) {
         if (driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
@@ -786,6 +979,7 @@ private:
         FOR_EACH_VK_FEATURE_1_1(FEATURE);
         FOR_EACH_VK_FEATURE_1_2(FEATURE);
         FOR_EACH_VK_FEATURE_1_3(FEATURE);
+        FOR_EACH_VK_FEATURE_1_4(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
 
@@ -802,6 +996,7 @@ private:
         FOR_EACH_VK_FEATURE_1_1(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_1_2(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_1_3(FEATURE_CORE);
+        FOR_EACH_VK_FEATURE_1_4(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE_EXT);
 
 #undef FEATURE_CORE
@@ -817,6 +1012,8 @@ private:
         VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
+        VkPhysicalDeviceMultiDrawPropertiesEXT multi_draw{};
 
         VkPhysicalDeviceProperties properties{};
     };
@@ -846,9 +1043,17 @@ private:
     bool cant_blit_msaa{};                     ///< Does not support MSAA<->MSAA blitting.
     bool must_emulate_scaled_formats{};        ///< Requires scaled vertex format emulation
     bool must_emulate_bgr565{};                ///< Emulates BGR565 by swizzling RGB565 format.
-    bool dynamic_state3_blending{};            ///< Has all blending features of dynamic_state3.
-    bool dynamic_state3_enables{};             ///< Has all enables features of dynamic_state3.
+    bool dynamic_state3_blending{};            ///< Has blending features of dynamic_state3.
+    bool dynamic_state3_enables{};             ///< Has at least one enable feature of dynamic_state3.
+    bool dynamic_state3_depth_clamp_enable{};
+    bool dynamic_state3_logic_op_enable{};
+    bool dynamic_state3_line_raster_mode{};
+    bool dynamic_state3_conservative_raster_mode{};
+    bool dynamic_state3_line_stipple_enable{};
+    bool dynamic_state3_alpha_to_coverage{};
+    bool dynamic_state3_alpha_to_one{};
     bool supports_conditional_barriers{};      ///< Allows barriers in conditional control flow.
+    size_t sampler_heap_budget{};              ///< Sampler budget for buggy drivers (0 = unlimited).
     u64 device_access_memory{};                ///< Total size of device local memory in bytes.
     u32 sets_per_pool{};                       ///< Sets per Description Pool
     NvidiaArchitecture nvidia_arch{NvidiaArchitecture::Arch_AmpereOrNewer};

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -116,10 +116,11 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdDrawIndirectCount);
     X(vkCmdDrawIndexedIndirectCount);
     X(vkCmdDrawIndirectByteCountEXT);
+    X(vkCmdDrawMultiEXT);
+    X(vkCmdDrawMultiIndexedEXT);
     X(vkCmdEndConditionalRenderingEXT);
     X(vkCmdEndQuery);
     X(vkCmdEndRenderPass);
-    X(vkCmdResetQueryPool);
     X(vkCmdEndTransformFeedbackEXT);
     X(vkCmdEndDebugUtilsLabelEXT);
     X(vkCmdFillBuffer);
@@ -145,6 +146,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdSetDepthWriteEnableEXT);
     X(vkCmdSetPrimitiveRestartEnableEXT);
     X(vkCmdSetRasterizerDiscardEnableEXT);
+    X(vkCmdSetAlphaToCoverageEnableEXT);
+    X(vkCmdSetAlphaToOneEnableEXT);
     X(vkCmdSetConservativeRasterizationModeEXT);
     X(vkCmdSetLineRasterizationModeEXT);
     X(vkCmdSetLineStippleEnableEXT);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -216,10 +216,11 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount{};
     PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount{};
     PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT{};
+    PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT{};
+    PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT{};
     PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT{};
     PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
     PFN_vkCmdEndQuery vkCmdEndQuery{};
-    PFN_vkCmdResetQueryPool vkCmdResetQueryPool{};
     PFN_vkCmdEndRenderPass vkCmdEndRenderPass{};
     PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT{};
     PFN_vkCmdFillBuffer vkCmdFillBuffer{};
@@ -238,6 +239,8 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT{};
     PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT{};
     PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT{};
+    PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT{};
+    PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT{};
     PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT{};
     PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT{};
     PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT{};
@@ -1140,9 +1143,6 @@ public:
     VkCommandBuffer operator*() const noexcept {
         return handle;
     }
-    void ResetQueryPool(VkQueryPool query_pool, uint32_t first, uint32_t count) const noexcept {
-        dld->vkCmdResetQueryPool(handle, query_pool, first, count);
-    }
     void Begin(const VkCommandBufferBeginInfo& begin_info) const {
         Check(dld->vkBeginCommandBuffer(handle, &begin_info));
     }
@@ -1239,6 +1239,19 @@ public:
                                            counter_buffer_offset, counter_offset, stride);
     }
 
+    void DrawMultiEXT(u32 draw_count, const VkMultiDrawInfoEXT* vertex_info,
+                      u32 instance_count, u32 first_instance, u32 stride) const noexcept {
+        dld->vkCmdDrawMultiEXT(handle, draw_count, vertex_info, instance_count, first_instance,
+                               stride);
+    }
+
+    void DrawMultiIndexedEXT(u32 draw_count, const VkMultiDrawIndexedInfoEXT* index_info,
+                             u32 instance_count, u32 first_instance, u32 stride,
+                             const int32_t* vertex_offset) const noexcept {
+        dld->vkCmdDrawMultiIndexedEXT(handle, draw_count, index_info, instance_count,
+                                      first_instance, stride, vertex_offset);
+    }
+
     void ClearAttachments(Span<VkClearAttachment> attachments,
                           Span<VkClearRect> rects) const noexcept {
         dld->vkCmdClearAttachments(handle, attachments.size(), attachments.data(), rects.size(),
@@ -1471,6 +1484,14 @@ public:
         dld->vkCmdSetLogicOpEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
     }
 
+    void SetAlphaToCoverageEnableEXT(bool enable) const noexcept {
+        dld->vkCmdSetAlphaToCoverageEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
+    }
+
+    void SetAlphaToOneEnableEXT(bool enable) const noexcept {
+        dld->vkCmdSetAlphaToOneEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
+    }
+
     void SetDepthClampEnableEXT(bool enable) const noexcept {
         dld->vkCmdSetDepthClampEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
     }