[vk] bump shader cache (v18)

Signed-off-by: lizzie <lizzie@eden-emu.dev>

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

@@ -31,7 +31,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
-    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
     RENDERER_DEBUG("debug"),

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

@@ -0,0 +1,89 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.features.settings.model.view
+
+import androidx.annotation.ArrayRes
+import androidx.annotation.StringRes
+import org.yuzu.yuzu_emu.features.settings.model.AbstractSetting
+import org.yuzu.yuzu_emu.features.settings.model.BooleanSetting
+import org.yuzu.yuzu_emu.features.settings.model.IntSetting
+
+class GpuUnswizzleSetting(
+    @StringRes titleId: Int = 0,
+    titleString: String = "",
+    @StringRes descriptionId: Int = 0,
+    descriptionString: String = "",
+    @ArrayRes val textureSizeChoicesId: Int,
+    @ArrayRes val textureSizeValuesId: Int,
+    @ArrayRes val streamSizeChoicesId: Int,
+    @ArrayRes val streamSizeValuesId: Int,
+    @ArrayRes val chunkSizeChoicesId: Int,
+    @ArrayRes val chunkSizeValuesId: Int
+) : SettingsItem(
+    object : AbstractSetting {
+        override val key: String = SettingsItem.GPU_UNSWIZZLE_COMBINED
+        override val defaultValue: Any = false
+        override val isSaveable = true
+        override val isRuntimeModifiable = true
+        override val isSwitchable = true
+        override val pairedSettingKey: String = ""
+        override var global: Boolean
+            get() {
+                return BooleanSetting.GPU_UNSWIZZLE_ENABLED.global &&
+                    IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.global &&
+                    IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.global &&
+                    IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.global
+            }
+            set(value) {
+                BooleanSetting.GPU_UNSWIZZLE_ENABLED.global = value
+                IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.global = value
+                IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.global = value
+                IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.global = value
+            }
+        override fun getValueAsString(needsGlobal: Boolean): String = "combined"
+        override fun reset() {
+            BooleanSetting.GPU_UNSWIZZLE_ENABLED.reset()
+            IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.reset()
+            IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.reset()
+            IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.reset()
+        }
+    },
+    titleId,
+    titleString,
+    descriptionId,
+    descriptionString
+) {
+    override val type = SettingsItem.TYPE_GPU_UNSWIZZLE
+
+    // Check if GPU unswizzle is enabled via the dedicated boolean setting
+    fun isEnabled(needsGlobal: Boolean = false): Boolean =
+        BooleanSetting.GPU_UNSWIZZLE_ENABLED.getBoolean(needsGlobal)
+
+    fun setEnabled(value: Boolean) =
+        BooleanSetting.GPU_UNSWIZZLE_ENABLED.setBoolean(value)
+
+    fun enable() = setEnabled(true)
+
+    fun disable() = setEnabled(false)
+
+    fun getTextureSize(needsGlobal: Boolean = false): Int =
+        IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.getInt(needsGlobal)
+
+    fun setTextureSize(value: Int) =
+        IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.setInt(value)
+
+    fun getStreamSize(needsGlobal: Boolean = false): Int =
+        IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.getInt(needsGlobal)
+
+    fun setStreamSize(value: Int) =
+        IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.setInt(value)
+
+    fun getChunkSize(needsGlobal: Boolean = false): Int =
+        IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.getInt(needsGlobal)
+
+    fun setChunkSize(value: Int) =
+        IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.setInt(value)
+
+    fun reset() = setting.reset()
+}

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

@@ -686,33 +686,42 @@ abstract class SettingsItem(
                 )
             )
             put(
-                SpinBoxSetting(
+                SingleChoiceSetting(
                     IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE,
                     titleId = R.string.gpu_unswizzle_texture_size,
                     descriptionId = R.string.gpu_unswizzle_texture_size_description,
-                    valueHint = R.string.gpu_unswizzle_texture_size,
-                    min = 1,
-                    max = 9
+                    choicesId = R.array.gpuTextureSizeSwizzleEntries,
+                    valuesId = R.array.gpuTextureSizeSwizzleValues
                 )
             )
             put(
-                SpinBoxSetting(
+                SingleChoiceSetting(
                     IntSetting.GPU_UNSWIZZLE_STREAM_SIZE,
                     titleId = R.string.gpu_unswizzle_stream_size,
                     descriptionId = R.string.gpu_unswizzle_stream_size_description,
-                    valueHint = R.string.gpu_unswizzle_stream_size,
-                    min = 1,
-                    max = 9
+                    choicesId = R.array.gpuSwizzleEntries,
+                    valuesId = R.array.gpuSwizzleValues
                 )
             )
             put(
-                SpinBoxSetting(
+                SingleChoiceSetting(
                     IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE,
                     titleId = R.string.gpu_unswizzle_chunk_size,
                     descriptionId = R.string.gpu_unswizzle_chunk_size_description,
-                    valueHint = R.string.gpu_unswizzle_chunk_size,
-                    min = 1,
-                    max = 9
+                    choicesId = R.array.gpuSwizzleChunkEntries,
+                    valuesId = R.array.gpuSwizzleChunkValues
+                )
+            )
+            put(
+                GpuUnswizzleSetting(
+                    titleId = R.string.gpu_unswizzle_settings,
+                    descriptionId = R.string.gpu_unswizzle_settings_description,
+                    textureSizeChoicesId = R.array.gpuTextureSizeSwizzleEntries,
+                    textureSizeValuesId = R.array.gpuTextureSizeSwizzleValues,
+                    streamSizeChoicesId = R.array.gpuSwizzleEntries,
+                    streamSizeValuesId = R.array.gpuSwizzleValues,
+                    chunkSizeChoicesId = R.array.gpuSwizzleChunkEntries,
+                    chunkSizeValuesId = R.array.gpuSwizzleChunkValues
                 )
             )
             put(
@@ -797,13 +806,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
-                    titleId = R.string.enable_gpu_buffer_readback,
-                    descriptionId = R.string.enable_gpu_buffer_readback_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,

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

@@ -0,0 +1,206 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.features.settings.ui
+
+import android.app.Dialog
+import android.content.DialogInterface
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.widget.ArrayAdapter
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.activityViewModels
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.databinding.DialogGpuUnswizzleBinding
+import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting
+
+class GpuUnswizzleDialogFragment : DialogFragment() {
+    private var position = 0
+    private val settingsViewModel: SettingsViewModel by activityViewModels()
+    private lateinit var binding: DialogGpuUnswizzleBinding
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        position = requireArguments().getInt(POSITION)
+
+        if (settingsViewModel.clickedItem == null) dismiss()
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        binding = DialogGpuUnswizzleBinding.inflate(LayoutInflater.from(requireContext()))
+        val item = settingsViewModel.clickedItem as GpuUnswizzleSetting
+
+        // Setup texture size dropdown
+        val textureSizeEntries = resources.getStringArray(item.textureSizeChoicesId)
+        val textureSizeValues = resources.getIntArray(item.textureSizeValuesId)
+        val textureSizeAdapter = ArrayAdapter(
+            requireContext(),
+            android.R.layout.simple_dropdown_item_1line,
+            textureSizeEntries.toMutableList()
+        )
+        binding.dropdownTextureSize.setAdapter(textureSizeAdapter)
+
+        // Setup stream size dropdown
+        val streamSizeEntries = resources.getStringArray(item.streamSizeChoicesId)
+        val streamSizeValues = resources.getIntArray(item.streamSizeValuesId)
+        val streamSizeAdapter = ArrayAdapter(
+            requireContext(),
+            android.R.layout.simple_dropdown_item_1line,
+            streamSizeEntries.toMutableList()
+        )
+        binding.dropdownStreamSize.setAdapter(streamSizeAdapter)
+
+        // Setup chunk size dropdown
+        val chunkSizeEntries = resources.getStringArray(item.chunkSizeChoicesId)
+        val chunkSizeValues = resources.getIntArray(item.chunkSizeValuesId)
+        val chunkSizeAdapter = ArrayAdapter(
+            requireContext(),
+            android.R.layout.simple_dropdown_item_1line,
+            chunkSizeEntries.toMutableList()
+        )
+        binding.dropdownChunkSize.setAdapter(chunkSizeAdapter)
+
+        // Load current values
+        val isEnabled = item.isEnabled()
+        binding.switchEnable.isChecked = isEnabled
+
+        if (isEnabled) {
+            val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize())
+            if (textureSizeIndex >= 0) {
+                binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false)
+            }
+
+            val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize())
+            if (streamSizeIndex >= 0) {
+                binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false)
+            }
+
+            val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize())
+            if (chunkSizeIndex >= 0) {
+                binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false)
+            }
+        } else {
+            // Set default/recommended values when disabling
+            binding.dropdownTextureSize.setText(textureSizeEntries[3], false)
+            binding.dropdownStreamSize.setText(streamSizeEntries[3], false)
+            binding.dropdownChunkSize.setText(chunkSizeEntries[3], false)
+        }
+
+        // Clear adapter filters after setText to fix rotation bug
+        textureSizeAdapter.filter.filter(null)
+        streamSizeAdapter.filter.filter(null)
+        chunkSizeAdapter.filter.filter(null)
+
+        // Enable/disable dropdowns based on switch state
+        updateDropdownsState(isEnabled)
+        binding.switchEnable.setOnCheckedChangeListener { _, checked ->
+            updateDropdownsState(checked)
+        }
+
+        val dialog = MaterialAlertDialogBuilder(requireContext())
+            .setTitle(item.title)
+            .setView(binding.root)
+            .create()
+
+        // Setup button listeners
+        binding.btnDefault.setOnClickListener {
+            // Reset to defaults
+            item.reset()
+            // Refresh values with adapters reset
+            val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize())
+            if (textureSizeIndex >= 0) {
+                binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false)
+            }
+            val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize())
+            if (streamSizeIndex >= 0) {
+                binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false)
+            }
+            val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize())
+            if (chunkSizeIndex >= 0) {
+                binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false)
+            }
+            // Clear filters
+            textureSizeAdapter.filter.filter(null)
+            streamSizeAdapter.filter.filter(null)
+            chunkSizeAdapter.filter.filter(null)
+
+            settingsViewModel.setAdapterItemChanged(position)
+            settingsViewModel.setShouldReloadSettingsList(true)
+        }
+
+        binding.btnCancel.setOnClickListener {
+            dialog.dismiss()
+        }
+
+        binding.btnOk.setOnClickListener {
+            if (binding.switchEnable.isChecked) {
+                item.enable()
+                // Save the selected values
+                val selectedTextureIndex = textureSizeEntries.indexOf(
+                    binding.dropdownTextureSize.text.toString()
+                )
+                if (selectedTextureIndex >= 0) {
+                    item.setTextureSize(textureSizeValues[selectedTextureIndex])
+                }
+
+                val selectedStreamIndex = streamSizeEntries.indexOf(
+                    binding.dropdownStreamSize.text.toString()
+                )
+                if (selectedStreamIndex >= 0) {
+                    item.setStreamSize(streamSizeValues[selectedStreamIndex])
+                }
+
+                val selectedChunkIndex = chunkSizeEntries.indexOf(
+                    binding.dropdownChunkSize.text.toString()
+                )
+                if (selectedChunkIndex >= 0) {
+                    item.setChunkSize(chunkSizeValues[selectedChunkIndex])
+                }
+            } else {
+                // Disable GPU unswizzle
+                item.disable()
+            }
+
+            settingsViewModel.setAdapterItemChanged(position)
+            settingsViewModel.setShouldReloadSettingsList(true)
+            dialog.dismiss()
+        }
+
+        // Ensure filters are cleared after dialog is shown
+        binding.root.post {
+            textureSizeAdapter.filter.filter(null)
+            streamSizeAdapter.filter.filter(null)
+            chunkSizeAdapter.filter.filter(null)
+        }
+
+        return dialog
+    }
+
+    private fun updateDropdownsState(enabled: Boolean) {
+        binding.layoutTextureSize.isEnabled = enabled
+        binding.dropdownTextureSize.isEnabled = enabled
+        binding.layoutStreamSize.isEnabled = enabled
+        binding.dropdownStreamSize.isEnabled = enabled
+        binding.layoutChunkSize.isEnabled = enabled
+        binding.dropdownChunkSize.isEnabled = enabled
+    }
+
+    companion object {
+        const val TAG = "GpuUnswizzleDialogFragment"
+        const val POSITION = "Position"
+
+        fun newInstance(
+            settingsViewModel: SettingsViewModel,
+            item: GpuUnswizzleSetting,
+            position: Int
+        ): GpuUnswizzleDialogFragment {
+            val dialog = GpuUnswizzleDialogFragment()
+            val args = Bundle()
+            args.putInt(POSITION, position)
+            dialog.arguments = args
+            settingsViewModel.clickedItem = item
+            return dialog
+        }
+    }
+}

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

@@ -102,6 +102,10 @@ class SettingsAdapter(
                 PathViewHolder(ListItemSettingBinding.inflate(inflater), this)
             }
 
+            SettingsItem.TYPE_GPU_UNSWIZZLE -> {
+                GpuUnswizzleViewHolder(ListItemSettingBinding.inflate(inflater), this)
+            }
+
             else -> {
                 HeaderViewHolder(ListItemSettingsHeaderBinding.inflate(inflater), this)
             }
@@ -475,6 +479,14 @@ class SettingsAdapter(
         settingsViewModel.setShouldShowPathResetDialog(true)
     }
 
+    fun onGpuUnswizzleClick(item: GpuUnswizzleSetting, position: Int) {
+        GpuUnswizzleDialogFragment.newInstance(
+            settingsViewModel,
+            item,
+            position
+        ).show(fragment.childFragmentManager, GpuUnswizzleDialogFragment.TAG)
+    }
+
     private class DiffCallback : DiffUtil.ItemCallback<SettingsItem>() {
         override fun areItemsTheSame(oldItem: SettingsItem, newItem: SettingsItem): Boolean {
             return oldItem.setting.key == newItem.setting.key

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

@@ -292,7 +292,6 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
             add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
-            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
 
             add(HeaderSetting(R.string.hacks))

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

@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.features.settings.ui.viewholder
+
+import android.view.View
+import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.databinding.ListItemSettingBinding
+import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting
+import org.yuzu.yuzu_emu.features.settings.model.view.SettingsItem
+import org.yuzu.yuzu_emu.features.settings.ui.SettingsAdapter
+import org.yuzu.yuzu_emu.utils.ViewUtils.setVisible
+
+class GpuUnswizzleViewHolder(val binding: ListItemSettingBinding, adapter: SettingsAdapter) :
+    SettingViewHolder(binding.root, adapter) {
+    private lateinit var setting: GpuUnswizzleSetting
+
+    override fun bind(item: SettingsItem) {
+        setting = item as GpuUnswizzleSetting
+        binding.textSettingName.text = setting.title
+        binding.textSettingDescription.setVisible(item.description.isNotEmpty())
+        binding.textSettingDescription.text = item.description
+
+        binding.textSettingValue.setVisible(true)
+        val resMgr = binding.root.context.resources
+
+        if (setting.isEnabled()) {
+            // Show a summary of current settings
+            val textureSizeEntries = resMgr.getStringArray(setting.textureSizeChoicesId)
+            val textureSizeValues = resMgr.getIntArray(setting.textureSizeValuesId)
+            val textureSizeIndex = textureSizeValues.indexOf(setting.getTextureSize())
+            val textureSizeLabel = if (textureSizeIndex >= 0) textureSizeEntries[textureSizeIndex] else "?"
+
+            val streamSizeEntries = resMgr.getStringArray(setting.streamSizeChoicesId)
+            val streamSizeValues = resMgr.getIntArray(setting.streamSizeValuesId)
+            val streamSizeIndex = streamSizeValues.indexOf(setting.getStreamSize())
+            val streamSizeLabel = if (streamSizeIndex >= 0) streamSizeEntries[streamSizeIndex] else "?"
+
+            val chunkSizeEntries = resMgr.getStringArray(setting.chunkSizeChoicesId)
+            val chunkSizeValues = resMgr.getIntArray(setting.chunkSizeValuesId)
+            val chunkSizeIndex = chunkSizeValues.indexOf(setting.getChunkSize())
+            val chunkSizeLabel = if (chunkSizeIndex >= 0) chunkSizeEntries[chunkSizeIndex] else "?"
+
+            binding.textSettingValue.text = "$textureSizeLabel ⋅ $streamSizeLabel ⋅ $chunkSizeLabel"
+        } else {
+            binding.textSettingValue.text = resMgr.getString(R.string.gpu_unswizzle_disabled)
+        }
+
+        binding.buttonClear.setVisible(setting.clearable)
+        binding.buttonClear.setOnClickListener {
+            adapter.onClearClick(setting, bindingAdapterPosition)
+        }
+
+        setStyle(setting.isEditable, binding)
+    }
+
+    override fun onClick(clicked: View) {
+        if (!setting.isEditable) {
+            return
+        }
+
+        adapter.onGpuUnswizzleClick(setting, bindingAdapterPosition)
+    }
+
+    override fun onLongClick(clicked: View): Boolean {
+        if (setting.isEditable) {
+            return adapter.onLongClick(setting, bindingAdapterPosition)
+        }
+        return false
+    }
+}

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

@@ -516,7 +516,10 @@
     <string name="rescale_hack_description">يُمكّن هذا الخيار من التعامل مع عملية إعادة تحجيم الألعاب بطريقة تقليدية باستخدام مسار إعادة التحجيم السريع</string>
     <string name="renderer_asynchronous_shaders">استخدم تظليل غير متزامن</string>
     <string name="renderer_asynchronous_shaders_description">يقوم بتجميع التظليل بشكل غير متزامن. قد يقلل ذلك من التقطعات ولكنه قد يؤدي أيضًا إلى حدوث أخطاء.</string>
+    <string name="gpu_unswizzle_settings">إعدادات إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
+    <string name="gpu_unswizzle_settings_description">قم بضبط معلمات فكّ تشابك النسيج المستندة إلى وحدة معالجة الرسومات أو تعطيلها تمامًا. اضبط هذه الإعدادات لتحقيق التوازن بين الأداء وجودة تحميل النسيج.</string>
     <string name="gpu_unswizzle_enable">تفعيل إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
+    <string name="gpu_unswizzle_disabled">تعطيل</string>
     <string name="gpu_unswizzle_texture_size">الحد الأقصى لحجم النسيج في وحدة معالجة الرسومات بعد إعادة ترتيب البيانات</string>
     <string name="gpu_unswizzle_texture_size_description">يُحدد هذا الخيار الحد الأقصى لحجم (ميغابايت) معالجة الصور باستخدام وحدة معالجة الرسومات. مع أن وحدة معالجة الرسومات أسرع في معالجة الصور المتوسطة والكبيرة، إلا أن وحدة المعالجة المركزية قد تكون أكثر كفاءة في معالجة الصور الصغيرة جدًا. اضبط هذا الخيار لتحقيق التوازن الأمثل بين سرعة معالجة الرسومات واستهلاك وحدة المعالجة المركزية.</string>
     <string name="gpu_unswizzle_stream_size">حجم تدفق إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
@@ -954,10 +957,25 @@
     <string name="fast_gpu_high">مرتفع (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">صغير جدًا (16 ميغابايت)</string>
+    <string name="gpu_texturesizeswizzle_small">صغير (32 ميغابايت)</string>
+    <string name="gpu_texturesizeswizzle_normal">قياسي (128 ميغابايت)</string>
+    <string name="gpu_texturesizeswizzle_large">كبير (256 ميغابايت)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">كبير جدًا (512 ميغابايت)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">منخفض جدًا (4 ميغابايت)</string>
+    <string name="gpu_swizzle_low">منخفض (8 ميغابايت)</string>
+    <string name="gpu_swizzle_normal">قياسي (16 ميغابايت)</string>
+    <string name="gpu_swizzle_medium">متوسط (32 ميغابايت)</string>
+    <string name="gpu_swizzle_high">عالي (64 ميغابايت)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">منخفض جدًا (32)</string>
+    <string name="gpu_swizzlechunk_low">منخفض (64)</string>
+    <string name="gpu_swizzlechunk_normal">قياسي (128)</string>
+    <string name="gpu_swizzlechunk_medium">متوسط (256)</string>
+    <string name="gpu_swizzlechunk_high">عالي (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">مئوية</string>

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

@@ -890,10 +890,25 @@ Wirklich fortfahren?</string>
     <string name="fast_gpu_high">Hoch (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">Sehr klein (16 MB)</string>
+    <string name="gpu_texturesizeswizzle_small">Klein (32 MB)</string>
+    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
+    <string name="gpu_texturesizeswizzle_large">Groß (256 MB)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">Sehr groß (512 MB)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">Sehr niedrig (4 MB)</string>
+    <string name="gpu_swizzle_low">Niedrig (8 MB)</string>
+    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
+    <string name="gpu_swizzle_medium">Mittel (32 MB)</string>
+    <string name="gpu_swizzle_high">Hoch (64 MB)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">Sehr niedrig (32)</string>
+    <string name="gpu_swizzlechunk_low">Niedrig (64)</string>
+    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
+    <string name="gpu_swizzlechunk_medium">Mittel (256)</string>
+    <string name="gpu_swizzlechunk_high">Hoch (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Celsius</string>

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

@@ -510,7 +510,10 @@
     <string name="rescale_hack_description">Permite el manejo de versiones anteriores para el paso de configuración de reescalado para juegos mediante el uso de una ruta de reescalado rápida.</string>
     <string name="renderer_asynchronous_shaders">Usar sombreadores asíncronos</string>
     <string name="renderer_asynchronous_shaders_description">Compila los sombreadores de forma asíncrona. Esto puede reducir los tirones, pero también puede introducir errores gráficos.</string>
+    <string name="gpu_unswizzle_settings">Ajustes de desentrelazado de la GPU</string>
+    <string name="gpu_unswizzle_settings_description">Configura los parámetros de desentrelazado de texturas basadas ​​en la GPU o desactívelos por completo. Modifique estos ajustes para equilibrar el rendimiento y la calidad de las texturas cargadas.</string>
     <string name="gpu_unswizzle_enable">Activar desentrelazado de la GPU</string>
+    <string name="gpu_unswizzle_disabled">Desactivado</string>
     <string name="gpu_unswizzle_texture_size">Tamaño máximo de textura de desentrelazado de la GPU</string>
     <string name="gpu_unswizzle_texture_size_description">Establece el tamaño máximo (en MB) para el desentrelazado de texturas basada en GPU. Aunque la GPU es más rápida para texturas medianas y grandes, la CPU puede ser más eficiente para texturas muy pequeñas. Ajuste este valor para encontrar el equilibrio entre la aceleración de la GPU y la sobrecarga de la CPU.</string>
     <string name="gpu_unswizzle_stream_size">Tamaño del flujo de desentrelazado de la GPU</string>
@@ -948,10 +951,25 @@
     <string name="fast_gpu_high">Alto (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">Muy pequeño (16 MB)</string>
+    <string name="gpu_texturesizeswizzle_small">Pequeño (32 MB)</string>
+    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
+    <string name="gpu_texturesizeswizzle_large">Grande (256 MB)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">Muy grande (512 MB)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">Muy bajo (4 MB)</string>
+    <string name="gpu_swizzle_low">Bajo (8 MB)</string>
+    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
+    <string name="gpu_swizzle_medium">Medio (32 MB)</string>
+    <string name="gpu_swizzle_high">Alto (64 MB)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">Muy bajo (32)</string>
+    <string name="gpu_swizzlechunk_low">Bajo (64)</string>
+    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
+    <string name="gpu_swizzlechunk_medium">Medio (256)</string>
+    <string name="gpu_swizzlechunk_high">Alto (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Celsius</string>

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

@@ -509,7 +509,10 @@
     <string name="rescale_hack_description">Включает старый метод обработки этапа перенастройки масштабирования для игр за счёт использования быстрого алгоритма перемасштабирования.</string>
     <string name="renderer_asynchronous_shaders">Использовать асинхронные шейдеры</string>
     <string name="renderer_asynchronous_shaders_description">Компилирует шейдеры асинхронно. Это может уменьшить подтормаживания, но также может вызвать графические артефакты.</string>
+    <string name="gpu_unswizzle_settings">Настройки распаковки текстур (Unswizzle)</string>
+    <string name="gpu_unswizzle_settings_description">Настройте параметры распаковки текстур на стороне ГПУ либо полностью отключите эту функцию. Изменение этих параметров позволяет найти баланс между производительностью и качеством загрузки текстур.</string>
     <string name="gpu_unswizzle_enable">Включить распаковку текстур (Unswizzle)</string>
+    <string name="gpu_unswizzle_disabled">Отключено</string>
     <string name="gpu_unswizzle_texture_size">Макс. размер текстуры Unswizzle</string>
     <string name="gpu_unswizzle_texture_size_description">Задает максимальный размер (в МБ) текстур для преобразования формата (unswizzle) на ГПУ. Хотя ГПУ быстрее работает со средними и большими текстурами, ЦП может быть эффективнее для очень маленьких. Настройте это значение, чтобы найти баланс между ускорением на ГПУ и нагрузкой на ЦП.</string>
     <string name="gpu_unswizzle_stream_size">Размер потока Unswizzle</string>
@@ -947,10 +950,25 @@
     <string name="fast_gpu_high">Высокое (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">Очень малый (16 МБ)</string>
+    <string name="gpu_texturesizeswizzle_small">Малый (32 МБ)</string>
+    <string name="gpu_texturesizeswizzle_normal">Обычный (128 МБ)</string>
+    <string name="gpu_texturesizeswizzle_large">Большой (256 МБ)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">Очень большой (512 МБ)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">Очень низкий (4 МБ)</string>
+    <string name="gpu_swizzle_low">Низкий (8 МБ)</string>
+    <string name="gpu_swizzle_normal">Обычный (16 МБ)</string>
+    <string name="gpu_swizzle_medium">Средний (32 МБ)</string>
+    <string name="gpu_swizzle_high">Высокий (64 МБ)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">Очень малый (32)</string>
+    <string name="gpu_swizzlechunk_low">Малый (64)</string>
+    <string name="gpu_swizzlechunk_normal">Обычный (128)</string>
+    <string name="gpu_swizzlechunk_medium">Средний (256)</string>
+    <string name="gpu_swizzlechunk_high">Большой (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Цельсий</string>

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

@@ -512,7 +512,10 @@
     <string name="rescale_hack_description">Вмикає застарілу обробку масштабування для ігор, використовуючи швидкий шлях масштабування</string>
     <string name="renderer_asynchronous_shaders">Асинхронні шейдери</string>
     <string name="renderer_asynchronous_shaders_description">Компілює шейдери асинхронно. Це може зменшити затримки, але також може спричинити графічні баги.</string>
+    <string name="gpu_unswizzle_settings">Налаштування розпакування за допомогою ГП</string>
+    <string name="gpu_unswizzle_settings_description">Налаштуйте розпакування текстур за допомогою ГП або повністю вимкнути його. Відкоригуйте ці налаштування, щоб урівноважити продуктивність і якість завантаження текстур.</string>
     <string name="gpu_unswizzle_enable">Увімкнути розпакування за допомогою ГП</string>
+    <string name="gpu_unswizzle_disabled">Вимкнено</string>
     <string name="gpu_unswizzle_texture_size">Максимальний розмір текстур для розпакування ГП за допомогою ГП</string>
     <string name="gpu_unswizzle_texture_size_description">Встановлює максимальний розмір (МБ) для розпакування текстур за допомогою ГП. ГП швидше справляється з текстурами середніх і великих розмірів, а ЦП ефективніший для дуже маленьких. Налаштуйте, щоб збалансувати ГП-прискоренням і навантаженням на ЦП.</string>
     <string name="gpu_unswizzle_stream_size">Розмір потоку розпакування за допомогою ГП</string>
@@ -950,10 +953,25 @@
     <string name="fast_gpu_high">Високо (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">Дуже малий (16 МБ)</string>
+    <string name="gpu_texturesizeswizzle_small">Малий (32 МБ)</string>
+    <string name="gpu_texturesizeswizzle_normal">Нормальний (128 МБ)</string>
+    <string name="gpu_texturesizeswizzle_large">Великий (256 МБ)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">Дуже великий (512 МБ)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">Дуже низький (4 МБ)</string>
+    <string name="gpu_swizzle_low">Низький (8 МБ)</string>
+    <string name="gpu_swizzle_normal">Нормальний (16 МБ)</string>
+    <string name="gpu_swizzle_medium">Середній (32 МБ)</string>
+    <string name="gpu_swizzle_high">Високий (64 МБ)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">Дуже низький (32)</string>
+    <string name="gpu_swizzlechunk_low">Низький (64)</string>
+    <string name="gpu_swizzlechunk_normal">Нормальний (128)</string>
+    <string name="gpu_swizzlechunk_medium">Середній (256)</string>
+    <string name="gpu_swizzlechunk_high">Високий (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Цельсій</string>

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -947,10 +947,25 @@
     <string name="fast_gpu_high">高 (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">极小 (16 MB)</string>
+    <string name="gpu_texturesizeswizzle_small">较小 (32 MB)</string>
+    <string name="gpu_texturesizeswizzle_normal">正常 (128 MB)</string>
+    <string name="gpu_texturesizeswizzle_large">较大 (256 MB)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">极大 (512 MB)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">极低 (4 MB)</string>
+    <string name="gpu_swizzle_low">低 (8 MB)</string>
+    <string name="gpu_swizzle_normal">正常 (16 MB)</string>
+    <string name="gpu_swizzle_medium">中 (32 MB)</string>
+    <string name="gpu_swizzle_high">高 (64 MB)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">极低 (32)</string>
+    <string name="gpu_swizzlechunk_low">低 (64)</string>
+    <string name="gpu_swizzlechunk_normal">正常 (128)</string>
+    <string name="gpu_swizzlechunk_medium">中 (256)</string>
+    <string name="gpu_swizzlechunk_high">高 (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">摄氏度</string>

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

@@ -545,6 +545,54 @@
         <item>2</item>
     </integer-array>
 
+    <string-array name="gpuTextureSizeSwizzleEntries">
+        <item>@string/gpu_texturesizeswizzle_verysmall</item>
+        <item>@string/gpu_texturesizeswizzle_small</item>
+        <item>@string/gpu_texturesizeswizzle_normal</item>
+        <item>@string/gpu_texturesizeswizzle_large</item>
+        <item>@string/gpu_texturesizeswizzle_verylarge</item>
+    </string-array>
+
+    <integer-array name="gpuTextureSizeSwizzleValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+    </integer-array>
+
+    <string-array name="gpuSwizzleEntries">
+        <item>@string/gpu_swizzle_verylow</item>
+        <item>@string/gpu_swizzle_low</item>
+        <item>@string/gpu_swizzle_normal</item>
+        <item>@string/gpu_swizzle_medium</item>
+        <item>@string/gpu_swizzle_high</item>
+    </string-array>
+
+    <integer-array name="gpuSwizzleValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+    </integer-array>
+    
+    <string-array name="gpuSwizzleChunkEntries">
+        <item>@string/gpu_swizzlechunk_verylow</item>
+        <item>@string/gpu_swizzlechunk_low</item>
+        <item>@string/gpu_swizzlechunk_normal</item>
+        <item>@string/gpu_swizzlechunk_medium</item>
+        <item>@string/gpu_swizzlechunk_high</item>
+    </string-array>
+
+    <integer-array name="gpuSwizzleChunkValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+    </integer-array>
+
     <string-array name="temperatureUnitEntries">
         <item>@string/temperature_celsius</item>
         <item>@string/temperature_fahrenheit</item>

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

@@ -503,8 +503,6 @@
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
-    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
-    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
 
@@ -524,7 +522,10 @@
     <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
+    <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
+    <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
     <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
+    <string name="gpu_unswizzle_disabled">Disabled</string>
     <string name="gpu_unswizzle_texture_size">GPU Unswizzle Max Texture Size</string>
     <string name="gpu_unswizzle_texture_size_description">Sets the maximum size (MB) for GPU-based texture unswizzling. While the GPU is faster for medium and large textures, the CPU may be more efficient for very small ones. Adjust this to find the balance between GPU acceleration and CPU overhead.</string>
     <string name="gpu_unswizzle_stream_size">GPU Unswizzle Stream Size</string>
@@ -975,10 +976,25 @@
     <string name="fast_gpu_high">High (512)</string>
 
     <!-- GPU swizzle texture size -->
+    <string name="gpu_texturesizeswizzle_verysmall">Very Small (16 MB)</string>
+    <string name="gpu_texturesizeswizzle_small">Small (32 MB)</string>
+    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
+    <string name="gpu_texturesizeswizzle_large">Large (256 MB)</string>
+    <string name="gpu_texturesizeswizzle_verylarge">Very Large (512 MB)</string>
 
     <!-- GPU swizzle streams -->
+    <string name="gpu_swizzle_verylow">Very Low (4 MB)</string>
+    <string name="gpu_swizzle_low">Low (8 MB)</string>
+    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
+    <string name="gpu_swizzle_medium">Medium (32 MB)</string>
+    <string name="gpu_swizzle_high">High (64 MB)</string>
 
     <!-- GPU swizzle chunks -->
+    <string name="gpu_swizzlechunk_verylow">Very Low (32)</string>
+    <string name="gpu_swizzlechunk_low">Low (64)</string>
+    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
+    <string name="gpu_swizzlechunk_medium">Medium (256)</string>
+    <string name="gpu_swizzlechunk_high">High (512)</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Celsius</string>

src/common/settings.h

@@ -584,29 +584,23 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
-    SwitchableSetting<u32, true> gpu_unswizzle_texture_size{linkage,
-                                                  6,
-                                                  1,
-                                                  9,
+    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
+                                                  GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",
                                                   Category::RendererHacks,
-                                                  Specialization::Scalar};
+                                                  Specialization::Default};
 
-    SwitchableSetting<u32, true> gpu_unswizzle_stream_size{linkage,
-                                                  4,
-                                                  1,
-                                                  9,
+    SwitchableSetting<GpuUnswizzle> gpu_unswizzle_stream_size{linkage,
+                                                  GpuUnswizzle::Medium,
                                                   "gpu_unswizzle_stream_size",
                                                   Category::RendererHacks,
-                                                  Specialization::Scalar};
+                                                  Specialization::Default};
 
-    SwitchableSetting<u32, true> gpu_unswizzle_chunk_size{linkage,
-                                                  7,
-                                                  1,
-                                                  9,
+    SwitchableSetting<GpuUnswizzleChunk> gpu_unswizzle_chunk_size{linkage,
+                                                  GpuUnswizzleChunk::Medium,
                                                   "gpu_unswizzle_chunk_size",
                                                   Category::RendererHacks,
-                                                  Specialization::Scalar};
+                                                  Specialization::Default};
 
     SwitchableSetting<bool> gpu_unswizzle_enabled{linkage, false, "gpu_unswizzle_enabled",
                                                   Category::RendererHacks};

src/common/settings_enums.h

@@ -152,6 +152,9 @@ ENUM(ConsoleMode, Handheld, Docked);
 ENUM(AppletMode, HLE, LLE);
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuOverclock, Normal, Medium, High)
+ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)
+ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High)
+ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High)
 ENUM(TemperatureUnits, Celsius, Fahrenheit)
 ENUM(ExtendedDynamicState, Disabled, EDS1, EDS2, EDS3);
 ENUM(GpuLogLevel, Off, Errors, Standard, Verbose, All)

src/core/core.cpp

@@ -350,7 +350,7 @@ struct System::Impl {
 
         // Register with applet manager
         // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);
+        applet_manager.CreateAndInsertByFrontendAppletParameters(std::make_unique<Service::Process>(*std::move(process)), params);
 
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {

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

@@ -729,7 +729,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface(ctx, ensure_token_id);
+        rb.PushIpcInterface(ensure_token_id);
     }
 
     void LoadIdTokenCacheDeprecated(HLERequestContext& ctx) {
@@ -921,7 +921,7 @@ void Module::Interface::GetProfile(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IProfile>(ctx, system, user_id, *profile_manager);
+    rb.PushIpcInterface<IProfile>(system, user_id, *profile_manager);
 }
 
 void Module::Interface::IsUserRegistrationRequestPermitted(HLERequestContext& ctx) {
@@ -993,7 +993,7 @@ void Module::Interface::GetBaasAccountManagerForApplication(HLERequestContext& c
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IManagerForApplication>(ctx, system, profile_manager);
+    rb.PushIpcInterface<IManagerForApplication>(system, profile_manager);
 }
 
 void Module::Interface::IsUserAccountSwitchLocked(HLERequestContext& ctx) {
@@ -1089,7 +1089,7 @@ void Module::Interface::GetProfileEditor(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IProfileEditor>(ctx, system, user_id, *profile_manager);
+    rb.PushIpcInterface<IProfileEditor>(system, user_id, *profile_manager);
 }
 
 void Module::Interface::GetBaasAccountAdministrator(HLERequestContext &ctx) {
@@ -1100,7 +1100,7 @@ void Module::Interface::GetBaasAccountAdministrator(HLERequestContext &ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IAdministrator>(ctx, system, uuid);
+    rb.PushIpcInterface<IAdministrator>(system, uuid);
 }
 
 void Module::Interface::ListQualifiedUsers(HLERequestContext& ctx) {
@@ -1143,7 +1143,7 @@ void Module::Interface::GetBaasAccountManagerForSystemService(HLERequestContext&
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IManagerForSystemService>(ctx, system, uuid);
+    rb.PushIpcInterface<IManagerForSystemService>(system, uuid);
 }
 
 void Module::Interface::StoreSaveDataThumbnailSystem(HLERequestContext& ctx) {

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

@@ -35,7 +35,7 @@ void IAsyncContext::GetSystemEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, completion_event->GetReadableEvent());
+    rb.PushCopyObjects(completion_event->GetReadableEvent());
 }
 
 void IAsyncContext::Cancel(HLERequestContext& ctx) {

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

@@ -109,10 +109,6 @@ struct Applet {
     std::list<std::shared_ptr<Applet>> child_applets{};
     bool is_completed{};
 
-    std::shared_ptr<Applet> reserved_applet{};
-    bool unwind_after_reserved{};
-    bool is_winding{};
-
     // Self state
     bool exit_locked{};
     s32 fatal_section_count{};

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

@@ -25,13 +25,6 @@ void AppletStorageChannel::Push(Kernel::KernelCore& kernel, std::shared_ptr<ISto
     m_event.Signal(kernel);
 }
 
-void AppletStorageChannel::Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage) {
-    std::scoped_lock lk{m_lock};
-
-    m_data.emplace_front(std::move(storage));
-    m_event.Signal(kernel);
-}
-
 Result AppletStorageChannel::Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage) {
     std::scoped_lock lk{m_lock};
 

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

@@ -26,7 +26,6 @@ public:
     ~AppletStorageChannel();
 
     void Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
-    void Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
     Result Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage);
     Kernel::KReadableEvent* GetEvent();
 

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

@@ -267,7 +267,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {
 
     if (Settings::values.enable_overlay && m_window_system->GetOverlayDisplayApplet() == nullptr) {
         if (auto overlay_process = CreateProcess(m_system, static_cast<u64>(AppletProgramId::OverlayDisplay), 0, 0)) {
-            auto overlay_applet = std::make_shared<Applet>(m_system, std::move(overlay_process), false);
+            auto overlay_applet = std::make_shared<Applet>(m_system, std::make_unique<Service::Process>(*std::move(overlay_process)), false);
             overlay_applet->program_id = static_cast<u64>(AppletProgramId::OverlayDisplay);
             overlay_applet->applet_id = AppletId::OverlayDisplay;
             overlay_applet->type = AppletType::OverlayApplet;

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,10 +12,7 @@ namespace Service::AM {
 
 HidRegistration::HidRegistration(Core::System& system, Process& process) : m_process(process) {
     m_hid_server = system.ServiceManager().GetService<HID::IHidServer>("hid", true);
-    this->RegisterCurrentProcess();
-}
 
-void HidRegistration::RegisterCurrentProcess() {
     if (m_process.IsInitialized()) {
         m_hid_server->GetResourceManager()->RegisterAppletResourceUserId(m_process.GetProcessId(),
                                                                          true);

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -27,7 +24,6 @@ public:
     explicit HidRegistration(Core::System& system, Process& process);
     ~HidRegistration();
 
-    void RegisterCurrentProcess();
     void EnableAppletToGetInput(bool enable);
 
 private:

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

@@ -171,18 +171,6 @@ void LifecycleManager::SignalSystemEventIfNeeded(Kernel::KernelCore& kernel) {
     }
 }
 
-void LifecycleManager::ResetForRelaunch() {
-    m_unordered_messages.clear();
-
-    m_activity_state = ActivityState::BackgroundVisible;
-    m_requested_focus_state = FocusState{};
-    m_acknowledged_focus_state = FocusState{};
-    m_has_focus_state_changed = true;
-
-    m_suspend_mode = SuspendMode::NoOverride;
-    m_forced_suspend = false;
-}
-
 bool LifecycleManager::PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message) {
     const auto message = this->PopMessageInOrderOfPriority();
     this->SignalSystemEventIfNeeded(kernel);

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

@@ -138,8 +138,6 @@ public:
     void PushUnorderedMessage(Kernel::KernelCore& kernel, AppletMessage message);
     bool PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message);
 
-    void ResetForRelaunch();
-
 private:
     FocusState GetFocusStateWhileForegroundObscured() const;
     FocusState GetFocusStateWhileBackground(bool is_obscured) const;

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

@@ -40,23 +40,23 @@ namespace {
     }
 }
 
-[[nodiscard]] inline std::unique_ptr<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+[[nodiscard]] inline std::optional<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     // Get the appropriate loader to parse this NCA.
     out_loader = Loader::GetLoader(system, file, program_id, program_index);
     // Ensure we have a loader which can parse the NCA.
     if (out_loader) {
         // Try to load the process.
-        auto process = std::make_unique<Process>(system);
+        auto process = std::make_optional<Process>(system);
         if (process->Initialize(*out_loader, out_load_result)) {
             return process;
         }
     }
-    return nullptr;
+    return std::nullopt;
 }
 
 } // Anonymous namespace
 
-std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
+std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
     // Attempt to load program NCA.
     FileSys::VirtualFile nca_raw{};
 
@@ -66,7 +66,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
 
     // Ensure we retrieved a program NCA.
     if (!nca_raw) {
-        return nullptr;
+        return std::nullopt;
     }
 
     // Ensure we have a suitable version.
@@ -76,7 +76,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
             (nca.GetKeyGeneration() < minimum_key_generation ||
              nca.GetKeyGeneration() > maximum_key_generation)) {
             LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id, nca.GetKeyGeneration());
-            return nullptr;
+            return std::nullopt;
         }
     }
 
@@ -85,7 +85,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8
     return CreateProcessImpl(loader, status, system, nca_raw, program_id, 0);
 }
 
-std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     if (auto process = CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index); process) {
         FileSys::NACP nacp;
         if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
@@ -110,23 +110,7 @@ std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control,
         system.GetARPManager().Register(launch.title_id, launch, out_control);
         return process;
     }
-    return nullptr;
-}
-
-bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id) {
-    auto& storage = system.GetContentProviderUnion();
-    const auto nca_raw = storage.GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
-    if (!nca_raw) {
-        return false;
-    }
-
-    auto loader = Loader::GetLoader(system, nca_raw, program_id, 0);
-    if (!loader) {
-        return false;
-    }
-
-    Loader::ResultStatus status{};
-    return process.Initialize(*loader, status);
+    return std::nullopt;
 }
 
 } // namespace Service::AM

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

@@ -27,9 +27,7 @@ class Process;
 
 namespace Service::AM {
 
-std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
-std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
-
-bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id);
+std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
+std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
 
 } // namespace Service::AM

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

@@ -35,9 +35,9 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
     std::unique_ptr<Loader::AppLoader> loader;
     Loader::ResultStatus result;
     auto process = CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
-    R_UNLESS(process != nullptr, ResultUnknown);
+    R_UNLESS(process != std::nullopt, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
+    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
     applet->program_id = program_id;
     applet->applet_id = AppletId::Application;
     applet->type = AppletType::Application;
@@ -88,9 +88,9 @@ Result IApplicationCreator::CreateSystemApplication(
     std::vector<u8> control;
     std::unique_ptr<Loader::AppLoader> loader;
     auto process = CreateProcess(system, application_id, 1, 22);
-    R_UNLESS(process != nullptr, ResultUnknown);
+    R_UNLESS(process != std::nullopt, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
+    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
     applet->program_id = application_id;
     applet->applet_id = AppletId::Starter;
     applet->type = AppletType::LibraryApplet;

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

@@ -75,7 +75,7 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
         {105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
         {106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
         {110, nullptr, "NeedsToExitProcess"},
-        {120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
+        {120, nullptr, "GetLibraryAppletInfo"},
         {150, nullptr, "RequestForAppletToGetForeground"},
         {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
         {170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170"}, //22.0.0+
@@ -218,16 +218,6 @@ Result ILibraryAppletAccessor::GetIndirectLayerConsumerHandle(Out<u64> out_handl
     R_SUCCEED();
 }
 
-Result ILibraryAppletAccessor::GetLibraryAppletInfo(
-    Out<LibraryAppletInfo> out_library_applet_info) {
-    LOG_INFO(Service_AM, "called");
-    *out_library_applet_info = {
-        .applet_id = m_applet->applet_id,
-        .library_applet_mode = m_applet->library_applet_mode,
-    };
-    R_SUCCEED();
-}
-
 Result ILibraryAppletAccessor::Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     *out_event = m_applet->unknown_event.GetHandle();

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

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include "core/hle/service/am/service/library_applet_self_accessor.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
@@ -22,10 +21,6 @@ public:
                                     std::shared_ptr<Applet> applet);
     ~ILibraryAppletAccessor();
 
-    std::shared_ptr<Applet> GetApplet() const {
-        return m_applet;
-    }
-
 private:
     Result GetAppletStateChangedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result IsCompleted(Out<bool> out_is_completed);
@@ -42,7 +37,6 @@ private:
     Result GetPopOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetPopInteractiveOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetIndirectLayerConsumerHandle(Out<u64> out_handle);
-    Result GetLibraryAppletInfo(Out<LibraryAppletInfo> out_library_applet_info);
     Result Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
     void FrontendExecute();

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

@@ -123,7 +123,7 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
 
     auto process = CreateProcess(system, program_id, Firmware1400, Firmware2200);
     if (process) {
-        const auto applet = std::make_shared<Applet>(system, std::move(process), false);
+        const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), false);
         applet->program_id = program_id;
         applet->applet_id = applet_id;
         applet->type = AppletType::LibraryApplet;

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

@@ -233,9 +233,8 @@ Result ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext(
     R_SUCCEED();
 }
 
-Result ILibraryAppletSelfAccessor::UnpopInData(SharedPointer<IStorage> storage) {
-    LOG_INFO(Service_AM, "called");
-    m_broker->GetInData().Unpop(system.Kernel(), storage);
+Result ILibraryAppletSelfAccessor::UnpopInData() {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
     R_SUCCEED();
 }
 

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

@@ -72,7 +72,7 @@ private:
     Result ReportVisibleError(ErrorCode error_code);
     Result ReportVisibleErrorWithErrorContext(
         ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context);
-    Result UnpopInData(SharedPointer<IStorage> storage);
+    Result UnpopInData();
     Result GetMainAppletApplicationDesiredLanguage(Out<u64> out_desired_language);
     Result GetCurrentApplicationId(Out<u64> out_application_id);
     Result GetMainAppletAvailableUsers(Out<bool> out_can_select_any_user, Out<s32> out_users_count,

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

@@ -1,11 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/core.h"
-#include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/library_applet_accessor.h"
 #include "core/hle/service/am/service/process_winding_controller.h"
@@ -45,18 +43,6 @@ Result IProcessWindingController::OpenCallingLibraryApplet(
     Out<SharedPointer<ILibraryAppletAccessor>> out_calling_library_applet) {
     LOG_INFO(Service_AM, "called");
 
-    std::shared_ptr<Applet> reserved_applet;
-    {
-        std::scoped_lock lk{m_applet->lock};
-        reserved_applet = std::move(m_applet->reserved_applet);
-    }
-
-    if (reserved_applet != nullptr) {
-        *out_calling_library_applet = std::make_shared<ILibraryAppletAccessor>(
-            system, reserved_applet->caller_applet_broker, reserved_applet);
-        R_SUCCEED();
-    }
-
     const auto caller_applet = m_applet->caller_applet.lock();
     if (caller_applet == nullptr) {
         LOG_ERROR(Service_AM, "No caller applet available");
@@ -88,82 +74,22 @@ Result IProcessWindingController::PopContext(Out<SharedPointer<IStorage>> out_co
 }
 
 Result IProcessWindingController::CancelWindingReservation() {
-    LOG_INFO(Service_AM, "called");
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet.reset();
-    m_applet->unwind_after_reserved = false;
-
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
 Result IProcessWindingController::WindAndDoReserved() {
-    LOG_INFO(Service_AM, "called");
-
-    std::shared_ptr<Applet> reserved_applet;
-    {
-        std::scoped_lock lk{m_applet->lock};
-
-        reserved_applet = m_applet->reserved_applet;
-        m_applet->display_layer_manager.SetWindowVisibility(false);
-        m_applet->exit_locked = false;
-        system.SetExitLocked(false);
-    }
-
-    if (reserved_applet) {
-        {
-            std::scoped_lock lk{m_applet->lock};
-            m_applet->is_winding = true;
-        }
-
-        {
-            std::scoped_lock lk{reserved_applet->lock};
-            reserved_applet->window_visible = true;
-            reserved_applet->process->Run();
-        }
-
-        if (reserved_applet->frontend) {
-            reserved_applet->frontend->Initialize();
-            reserved_applet->frontend->Execute();
-        }
-    } else {
-        LOG_WARNING(Service_AM, "called without a reserved applet to start");
-    }
-
-    m_applet->process->Terminate();
-
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis(
-    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
-    LOG_INFO(Service_AM, "called");
-
-    if (reserved_applet_accessor == nullptr) {
-        LOG_ERROR(Service_AM, "No applet accessor provided");
-        R_THROW(ResultUnknown);
-    }
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
-    m_applet->unwind_after_reserved = true;
-
+Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis() {
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWait(
-    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
-    LOG_INFO(Service_AM, "called");
-
-    if (reserved_applet_accessor == nullptr) {
-        LOG_ERROR(Service_AM, "No applet accessor provided");
-        R_THROW(ResultUnknown);
-    }
-
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
-    m_applet->unwind_after_reserved = false;
-
+Result IProcessWindingController::ReserveToStartAndWait() {
+    LOG_WARNING(Service_AM, "STUBBED");
     R_SUCCEED();
 }
 

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -29,9 +29,8 @@ private:
     Result PopContext(Out<SharedPointer<IStorage>> out_context);
     Result CancelWindingReservation();
     Result WindAndDoReserved();
-    Result ReserveToStartAndWaitAndUnwindThis(
-        SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
-    Result ReserveToStartAndWait(SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
+    Result ReserveToStartAndWaitAndUnwindThis();
+    Result ReserveToStartAndWait();
 
     const std::shared_ptr<Applet> m_applet;
 };

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

@@ -9,7 +9,6 @@
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/event_observer.h"
-#include "core/hle/service/am/process_creation.h"
 #include "core/hle/service/am/window_system.h"
 
 namespace Service::AM {
@@ -241,37 +240,6 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
             continue;
         }
 
-        // A winding applet has had its own process killed but is kept alive as a transparent slot
-        // while the reserved applet running in its place finishes (see WindAndDoReserved()).
-        if (applet->is_winding) {
-            if (!applet->child_applets.empty()) {
-                it = std::next(it);
-                continue;
-            }
-
-            const bool unwind = applet->unwind_after_reserved;
-            applet->is_winding = false;
-            applet->unwind_after_reserved = false;
-
-            if (unwind && this->RestartAppletProcessLocked(applet.get())) {
-                const u64 new_aruid = applet->aruid.pid;
-                const auto next = std::next(it);
-
-                if (new_aruid != aruid) {
-                    auto node = m_applets.extract(it);
-                    node.key() = new_aruid;
-                    m_applets.insert(std::move(node));
-                }
-
-                applet->process->Run();
-                m_event_observer->RequestUpdate();
-                it = next;
-                continue;
-            }
-
-            applet->reserved_applet.reset();
-        }
-
         // Terminated, so ensure all child applets are terminated.
         if (!applet->child_applets.empty()) {
             this->TerminateChildAppletsLocked(applet.get());
@@ -333,28 +301,6 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
     }
 }
 
-bool WindowSystem::RestartAppletProcessLocked(Applet* applet) {
-    if (!ReinitializeProcess(m_system, *applet->process, applet->program_id)) {
-        LOG_ERROR(Service_AM, "Failed to restart winding applet_id={}",
-                  static_cast<u32>(applet->applet_id));
-        return false;
-    }
-
-    applet->aruid.pid = applet->process->GetProcessId();
-    applet->is_process_running = false;
-    applet->is_completed = false;
-
-    applet->hid_registration.RegisterCurrentProcess();
-
-    applet->lifecycle_manager.ResetForRelaunch();
-    applet->is_activity_runnable = false;
-
-    applet->launch_reason.flag = 1;
-
-    m_event_observer->TrackAppletProcess(*applet);
-    return true;
-}
-
 bool WindowSystem::LockHomeMenuIntoForegroundLocked() {
     // If the home menu is not locked into foreground, then there's nothing to do.
     if (m_home_menu == nullptr || !m_home_menu_foreground_locked) {
@@ -406,9 +352,6 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     const bool has_obscuring_child_applets = [&] {
         for (const auto& child_applet : applet->child_applets) {
             std::scoped_lock lk2{child_applet->lock};
-            if (child_applet->is_winding) {
-                return true;
-            }
             const auto mode = child_applet->library_applet_mode;
             if (child_applet->is_process_running && child_applet->window_visible &&
                 (mode == LibraryAppletMode::AllForeground ||

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

@@ -61,7 +61,6 @@ public:
 
 private:
     void PruneTerminatedAppletsLocked();
-    bool RestartAppletProcessLocked(Applet* applet);
     bool LockHomeMenuIntoForegroundLocked();
     void TerminateChildAppletsLocked(Applet* applet);
     void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking = false);

src/core/hle/service/apm/apm_interface.cpp

@@ -82,7 +82,7 @@ void APM::OpenSession(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(ctx, system, controller);
+    rb.PushIpcInterface<ISession>(system, controller);
 }
 
 void APM::GetPerformanceMode(HLERequestContext& ctx) {
@@ -125,7 +125,7 @@ void APM_Sys::GetPerformanceEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(ctx, system, controller);
+    rb.PushIpcInterface<ISession>(system, controller);
 }
 
 void APM_Sys::SetCpuBoostMode(HLERequestContext& ctx) {

src/core/hle/service/fgm/fgm.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 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
 
@@ -48,7 +45,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IRequest>(ctx, system);
+        rb.PushIpcInterface<IRequest>(system);
     }
 };
 

src/core/hle/service/friend/friend.cpp

@@ -184,7 +184,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(readable_event.Signal(system.Kernel()));
-        rb.PushCopyObjects(ctx, readable_event);
+        rb.PushCopyObjects(readable_event);
     }
 
     void Cancel(HLERequestContext& ctx) {
@@ -400,7 +400,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, notification_event->GetReadableEvent());
+        rb.PushCopyObjects(notification_event->GetReadableEvent());
     }
 
     void Clear(HLERequestContext& ctx) {
@@ -476,7 +476,7 @@ private:
 void Module::Interface::CreateFriendService(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IFriendService>(ctx, system);
+    rb.PushIpcInterface<IFriendService>(system);
     LOG_DEBUG(Service_Friend, "called");
 }
 
@@ -488,12 +488,12 @@ void Module::Interface::CreateNotificationService(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INotificationService>(ctx, system, uuid);
+    rb.PushIpcInterface<INotificationService>(system, uuid);
 }
 
-Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_, const char* name)
-    : ServiceFramework{system_, name}, module{std::move(module_)}
-{}
+Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,
+                             const char* name)
+    : ServiceFramework{system_, name}, module{std::move(module_)} {}
 
 Module::Interface::~Interface() = default;
 

src/core/hle/service/glue/arp.cpp

@@ -279,7 +279,7 @@ void ARP_W::AcquireRegistrar(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface(ctx, registrar);
+    rb.PushIpcInterface(registrar);
 }
 
 void ARP_W::UnregisterApplicationInstance(HLERequestContext& ctx) {

src/core/hle/service/glue/bgtc.cpp

@@ -28,7 +28,7 @@ void BGTC_T::OpenTaskService(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ITaskService>(ctx, system);
+    rb.PushIpcInterface<ITaskService>(system);
 }
 
 ITaskService::ITaskService(Core::System& system_) : ServiceFramework{system_, "ITaskService"} {

src/core/hle/service/glue/ectx.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -59,7 +56,7 @@ ECTX_AW::~ECTX_AW() = default;
 void ECTX_AW::CreateContextRegistrar(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IContextRegistrar>(ctx, system);
+    rb.PushIpcInterface<IContextRegistrar>(std::make_shared<IContextRegistrar>(system));
 }
 
 } // namespace Service::Glue

src/core/hle/service/hid/hid_system_server.cpp

@@ -726,7 +726,7 @@ void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& c
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, acquire_device_registered_event->GetReadableEvent());
+    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
 }
 
 void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx) {
@@ -734,7 +734,7 @@ void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLEReque
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, acquire_device_registered_event->GetReadableEvent());
+    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
 }
 
 void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
@@ -759,7 +759,7 @@ void IHidSystemServer::AcquireUniquePadConnectionEventHandle(HLERequestContext&
     LOG_WARNING(Service_HID, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.PushCopyObjects(ctx, unique_pad_connection_event->GetReadableEvent());
+    rb.PushCopyObjects(unique_pad_connection_event->GetReadableEvent());
     rb.Push(ResultSuccess);
 }
 
@@ -776,7 +776,7 @@ void IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle(HLERequestConte
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, joy_detach_event->GetReadableEvent());
+    rb.PushCopyObjects(joy_detach_event->GetReadableEvent());
 }
 
 void IHidSystemServer::IsUsbFullKeyControllerEnabled(HLERequestContext& ctx) {

src/core/hle/service/hle_ipc.h

@@ -31,7 +31,7 @@ class Memory;
 }
 
 namespace IPC {
-struct ResponseBuilder;
+class ResponseBuilder;
 }
 
 namespace Service {
@@ -392,7 +392,7 @@ public:
     }
 
 private:
-    friend struct IPC::ResponseBuilder;
+    friend class IPC::ResponseBuilder;
 
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 

src/core/hle/service/ipc_helpers.h

@@ -24,7 +24,45 @@ namespace IPC {
 
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};
 
-struct ResponseBuilder {
+class RequestHelperBase {
+protected:
+    Service::HLERequestContext* context = nullptr;
+    u32* cmdbuf;
+    u32 index = 0;
+
+public:
+    explicit RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
+
+    explicit RequestHelperBase(Service::HLERequestContext& ctx)
+        : context(&ctx), cmdbuf(ctx.CommandBuffer()) {}
+
+    void Skip(u32 size_in_words, bool set_to_null) {
+        if (set_to_null) {
+            memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
+        }
+        index += size_in_words;
+    }
+
+    /**
+     * Aligns the current position forward to a 16-byte boundary, padding with zeros.
+     */
+    void AlignWithPadding() {
+        if (index & 3) {
+            Skip(static_cast<u32>(4 - (index & 3)), true);
+        }
+    }
+
+    u32 GetCurrentOffset() const {
+        return index;
+    }
+
+    void SetCurrentOffset(u32 offset) {
+        index = offset;
+    }
+};
+
+class ResponseBuilder : public RequestHelperBase {
+public:
     /// Flags used for customizing the behavior of ResponseBuilder
     enum class Flags : u32 {
         None = 0,
@@ -33,13 +71,14 @@ struct ResponseBuilder {
         AlwaysMoveHandles = 1,
     };
 
-    inline explicit ResponseBuilder(Service::HLERequestContext& ctx, u32 normal_params_size_, u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0, Flags flags = Flags::None)
-        : cmdbuf(ctx.CommandBuffer())
-        , normal_params_size(normal_params_size_)
-        , num_handles_to_copy(num_handles_to_copy_)
-        , num_objects_to_move(num_objects_to_move_)
-    {
-        std::memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
+    explicit ResponseBuilder(Service::HLERequestContext& ctx, u32 normal_params_size_,
+                             u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
+                             Flags flags = Flags::None)
+        : RequestHelperBase(ctx), normal_params_size(normal_params_size_),
+          num_handles_to_copy(num_handles_to_copy_),
+          num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
+
+        memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
 
         IPC::CommandHeader header{};
         auto const mgr = ctx.GetManager().get();
@@ -78,7 +117,9 @@ struct ResponseBuilder {
             handle_descriptor_header.num_handles_to_copy.Assign(num_handles_to_copy_);
             handle_descriptor_header.num_handles_to_move.Assign(num_handles_to_move);
             PushRaw(handle_descriptor_header);
+
             ctx.handles_offset = index;
+
             Skip(num_handles_to_copy + num_handles_to_move, true);
         }
 
@@ -90,6 +131,7 @@ struct ResponseBuilder {
                 domain_header.num_objects = num_domain_objects;
                 PushRaw(domain_header);
             }
+
             IPC::DataPayloadHeader data_payload_header{};
             data_payload_header.magic = Common::MakeMagic('S', 'F', 'C', 'O');
             PushRaw(data_payload_header);
@@ -99,39 +141,34 @@ struct ResponseBuilder {
 
         ctx.data_payload_offset = index;
         ctx.write_size += index;
-        ctx.domain_offset = u32(index + raw_data_size / sizeof(u32));
+        ctx.domain_offset = static_cast<u32>(index + raw_data_size / sizeof(u32));
     }
 
-    inline void Skip(u32 size_in_words, bool set_to_null) {
-        if (set_to_null) std::memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
-        index += size_in_words;
-    }
-    /// @brief Aligns the current position forward to a 16-byte boundary, padding with zeros.
-    inline void AlignWithPadding() { if (index & 3) Skip(u32(4 - (index & 3)), true); }
-    inline u32 GetCurrentOffset() const { return index; }
-    inline void SetCurrentOffset(u32 offset) { index = offset; }
+    template <class T>
+    void PushIpcInterface(std::shared_ptr<T> iface) {
+        auto manager{context->GetManager()};
 
-    template <class T> inline void PushIpcInterface(Service::HLERequestContext& ctx, std::shared_ptr<T> iface) {
-        auto manager = ctx.GetManager();
         if (manager->IsDomain()) {
-            ctx.AddDomainObject(std::move(iface));
+            context->AddDomainObject(std::move(iface));
         } else {
-            ASSERT(Kernel::GetCurrentProcess(ctx.kernel).GetResourceLimit()->Reserve(ctx.kernel, Kernel::LimitableResource::SessionCountMax, 1));
+            ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(kernel, Kernel::LimitableResource::SessionCountMax, 1));
 
-            auto* session = Kernel::KSession::Create(ctx.kernel);
-            session->Initialize(ctx.kernel, nullptr, 0);
-            Kernel::KSession::Register(ctx.kernel, session);
+            auto* session = Kernel::KSession::Create(kernel);
+            session->Initialize(kernel, nullptr, 0);
+            Kernel::KSession::Register(kernel, session);
 
-            auto next_manager = std::make_shared<Service::SessionRequestManager>(ctx.kernel, manager->GetServerManager());
+            auto next_manager = std::make_shared<Service::SessionRequestManager>(
+                kernel, manager->GetServerManager());
             next_manager->SetSessionHandler(iface);
             manager->GetServerManager().RegisterSession(&session->GetServerSession(), next_manager);
 
-            ctx.AddMoveObject(&session->GetClientSession());
+            context->AddMoveObject(&session->GetClientSession());
         }
     }
 
-    template <class T, class... Args> inline void PushIpcInterface(Service::HLERequestContext& ctx, Args&&... args) {
-        PushIpcInterface<T>(ctx, std::make_shared<T>(std::forward<Args>(args)...));
+    template <class T, class... Args>
+    void PushIpcInterface(Args&&... args) {
+        PushIpcInterface<T>(std::make_shared<T>(std::forward<Args>(args)...));
     }
 
     void PushImpl(s8 value);
@@ -147,38 +184,59 @@ struct ResponseBuilder {
     void PushImpl(bool value);
     void PushImpl(Result value);
 
-    template <typename T> inline void Push(T value) {
+    template <typename T>
+    void Push(T value) {
         return PushImpl(value);
     }
 
     template <typename First, typename... Other>
     void Push(const First& first_value, const Other&... other_values);
 
-    /// @brief Helper function for pushing strongly-typed enumeration values.
-    /// @tparam Enum The enumeration type to be pushed
-    /// @param value The value to push.
-    /// @note The underlying size of the enumeration type is the size of the data that gets pushed.
-    /// e.g. "enum class SomeEnum : u16" will push a u16-sized amount of data.
-    template <typename Enum> inline void PushEnum(Enum value) {
+    /**
+     * Helper function for pushing strongly-typed enumeration values.
+     *
+     * @tparam Enum The enumeration type to be pushed
+     *
+     * @param value The value to push.
+     *
+     * @note The underlying size of the enumeration type is the size of the
+     *       data that gets pushed. e.g. "enum class SomeEnum : u16" will
+     *       push a u16-sized amount of data.
+     */
+    template <typename Enum>
+    void PushEnum(Enum value) {
         static_assert(std::is_enum_v<Enum>, "T must be an enum type within a PushEnum call.");
-        static_assert(!std::is_convertible_v<Enum, int>, "enum type in PushEnum must be a strongly typed enum.");
+        static_assert(!std::is_convertible_v<Enum, int>,
+                      "enum type in PushEnum must be a strongly typed enum.");
         Push(static_cast<std::underlying_type_t<Enum>>(value));
     }
 
-    /// @brief Copies the content of the given trivially copyable class to the buffer as a normal param
-    /// @note: The input class must be correctly packed/padded to fit hardware layout.
-    template <typename T> void PushRaw(const T& value);
-    template <typename... O> void PushMoveObjects(Service::HLERequestContext& ctx, O*... pointers);
-    template <typename... O> void PushMoveObjects(Service::HLERequestContext& ctx, O&... pointers);
-    template <typename... O> void PushCopyObjects(Service::HLERequestContext& ctx, O*... pointers);
-    template <typename... O> void PushCopyObjects(Service::HLERequestContext& ctx, O&... pointers);
+    /**
+     * @brief Copies the content of the given trivially copyable class to the buffer as a normal
+     * param
+     * @note: The input class must be correctly packed/padded to fit hardware layout.
+     */
+    template <typename T>
+    void PushRaw(const T& value);
 
-    u32* cmdbuf;
-    u32 index = 0;
+    template <typename... O>
+    void PushMoveObjects(O*... pointers);
+
+    template <typename... O>
+    void PushMoveObjects(O&... pointers);
+
+    template <typename... O>
+    void PushCopyObjects(O*... pointers);
+
+    template <typename... O>
+    void PushCopyObjects(O&... pointers);
+
+private:
     u32 normal_params_size{};
     u32 num_handles_to_copy{};
     u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
     u32 data_payload_index{};
+    Kernel::KernelCore& kernel;
 };
 
 /// Push ///
@@ -193,7 +251,8 @@ inline void ResponseBuilder::PushImpl(u32 value) {
 
 template <typename T>
 void ResponseBuilder::PushRaw(const T& value) {
-    static_assert(std::is_trivially_copyable_v<T>, "It's undefined behavior to use memcpy with non-trivially copyable objects");
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
     std::memcpy(cmdbuf + index, &value, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
@@ -213,8 +272,8 @@ inline void ResponseBuilder::PushImpl(s16 value) {
 }
 
 inline void ResponseBuilder::PushImpl(s64 value) {
-    PushImpl(u32(value));
-    PushImpl(u32(value >> 32));
+    PushImpl(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
 }
 
 inline void ResponseBuilder::PushImpl(u8 value) {
@@ -226,8 +285,8 @@ inline void ResponseBuilder::PushImpl(u16 value) {
 }
 
 inline void ResponseBuilder::PushImpl(u64 value) {
-    PushImpl(u32(value));
-    PushImpl(u32(value >> 32));
+    PushImpl(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
 }
 
 inline void ResponseBuilder::PushImpl(float value) {
@@ -253,88 +312,90 @@ void ResponseBuilder::Push(const First& first_value, const Other&... other_value
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(Service::HLERequestContext& ctx, O*... pointers) {
+inline void ResponseBuilder::PushCopyObjects(O*... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
-        ctx.AddCopyObject(object);
+        context->AddCopyObject(object);
     }
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(Service::HLERequestContext& ctx, O&... pointers) {
+inline void ResponseBuilder::PushCopyObjects(O&... pointers) {
     auto objects = {&pointers...};
     for (auto& object : objects) {
-        ctx.AddCopyObject(object);
+        context->AddCopyObject(object);
     }
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(Service::HLERequestContext& ctx, O*... pointers) {
+inline void ResponseBuilder::PushMoveObjects(O*... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
-        ctx.AddMoveObject(object);
+        context->AddMoveObject(object);
     }
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(Service::HLERequestContext& ctx, O&... pointers) {
+inline void ResponseBuilder::PushMoveObjects(O&... pointers) {
     auto objects = {&pointers...};
     for (auto& object : objects) {
-        ctx.AddMoveObject(object);
+        context->AddMoveObject(object);
     }
 }
 
-struct RequestParser {
-    inline explicit RequestParser(u32* command_buffer) : cmdbuf(command_buffer) {}
-    inline explicit RequestParser(Service::HLERequestContext& ctx)
-        : cmdbuf(ctx.CommandBuffer())
-    {
+class RequestParser : public RequestHelperBase {
+public:
+    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+
+    explicit RequestParser(Service::HLERequestContext& ctx) : RequestHelperBase(ctx) {
         // TIPC does not have data payload offset
         if (!ctx.IsTipc()) {
             ASSERT_MSG(ctx.GetDataPayloadOffset(), "context is incomplete");
             Skip(ctx.GetDataPayloadOffset(), false);
         }
+
         // Skip the u64 command id, it's already stored in the context
         static constexpr u32 CommandIdSize = 2;
         Skip(CommandIdSize, false);
     }
 
-    inline void Skip(u32 size_in_words, bool set_to_null) {
-        if (set_to_null) std::memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
-        index += size_in_words;
-    }
-    /// @brief Aligns the current position forward to a 16-byte boundary, padding with zeros.
-    inline void AlignWithPadding() { if (index & 3) Skip(u32(4 - (index & 3)), true); }
-    inline u32 GetCurrentOffset() const { return index; }
-    inline void SetCurrentOffset(u32 offset) { index = offset; }
+    template <typename T>
+    T Pop();
 
-    template <typename T> T Pop();
-    template <typename T> void Pop(T& value);
-    template <typename First, typename... Other> void Pop(First& first_value, Other&... other_values);
+    template <typename T>
+    void Pop(T& value);
+
+    template <typename First, typename... Other>
+    void Pop(First& first_value, Other&... other_values);
 
     template <typename T>
     T PopEnum() {
         static_assert(std::is_enum_v<T>, "T must be an enum type within a PopEnum call.");
-        static_assert(!std::is_convertible_v<T, int>, "enum type in PopEnum must be a strongly typed enum.");
-        return T(Pop<std::underlying_type_t<T>>());
+        static_assert(!std::is_convertible_v<T, int>,
+                      "enum type in PopEnum must be a strongly typed enum.");
+        return static_cast<T>(Pop<std::underlying_type_t<T>>());
     }
 
-    /// @brief Reads the next normal parameters as a struct, by copying it
-    /// @note: The output class must be correctly packed/padded to fit hardware layout.
-    template <typename T> void PopRaw(T& value);
+    /**
+     * @brief Reads the next normal parameters as a struct, by copying it
+     * @note: The output class must be correctly packed/padded to fit hardware layout.
+     */
+    template <typename T>
+    void PopRaw(T& value);
 
-    /// @brief Reads the next normal parameters as a struct, by copying it into a new value
-    /// @note: The output class must be correctly packed/padded to fit hardware layout.
-    template <typename T> T PopRaw();
+    /**
+     * @brief Reads the next normal parameters as a struct, by copying it into a new value
+     * @note: The output class must be correctly packed/padded to fit hardware layout.
+     */
+    template <typename T>
+    T PopRaw();
 
-    template <class T> [[nodiscard]] std::weak_ptr<T> PopIpcInterface(Service::HLERequestContext& ctx) {
-        ASSERT(ctx.GetManager()->IsDomain());
-        ASSERT(ctx.GetDomainMessageHeader().input_object_count > 0);
-        return ctx.GetDomainHandler<T>(Pop<u32>() - 1);
+    template <class T>
+    std::weak_ptr<T> PopIpcInterface() {
+        ASSERT(context->GetManager()->IsDomain());
+        ASSERT(context->GetDomainMessageHeader().input_object_count > 0);
+        return context->GetDomainHandler<T>(Pop<u32>() - 1);
     }
-
-    u32* cmdbuf;
-    u32 index = 0;
 };
 
 /// Pop ///
@@ -346,7 +407,7 @@ inline u32 RequestParser::Pop() {
 
 template <>
 inline s32 RequestParser::Pop() {
-    return s32(Pop<u32>());
+    return static_cast<s32>(Pop<u32>());
 }
 
 // Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
@@ -356,7 +417,8 @@ inline s32 RequestParser::Pop() {
 #endif
 template <typename T>
 void RequestParser::PopRaw(T& value) {
-    static_assert(std::is_trivially_copyable_v<T>, "It's undefined behavior to use memcpy with non-trivially copyable objects");
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
     std::memcpy(&value, cmdbuf + index, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }

src/core/hle/service/lm/lm.cpp

@@ -353,7 +353,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ILogger>(ctx, system);
+        rb.PushIpcInterface<ILogger>(system);
     }
 };
 

src/core/hle/service/nfc/nfc.cpp

@@ -151,7 +151,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IAm>(ctx, system);
+        rb.PushIpcInterface<IAm>(system);
     }
 };
 
@@ -173,7 +173,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<MFIUser>(ctx, system);
+        rb.PushIpcInterface<MFIUser>(system);
     }
 };
 
@@ -195,7 +195,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IUser>(ctx, system);
+        rb.PushIpcInterface<IUser>(system);
     }
 };
 
@@ -217,7 +217,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISystem>(ctx, system);
+        rb.PushIpcInterface<ISystem>(system);
     }
 };
 

src/core/hle/service/nfc/nfc_interface.cpp

@@ -143,7 +143,7 @@ void NfcInterface::AttachAvailabilityChangeEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, GetManager()->AttachAvailabilityChangeEvent());
+    rb.PushCopyObjects(GetManager()->AttachAvailabilityChangeEvent());
 }
 
 void NfcInterface::StartDetection(HLERequestContext& ctx) {
@@ -203,7 +203,7 @@ void NfcInterface::AttachActivateEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(result);
-    rb.PushCopyObjects(ctx, out_event);
+    rb.PushCopyObjects(out_event);
 }
 
 void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
@@ -217,7 +217,7 @@ void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(result);
-    rb.PushCopyObjects(ctx, out_event);
+    rb.PushCopyObjects(out_event);
 }
 
 void NfcInterface::SetNfcEnabled(HLERequestContext& ctx) {

src/core/hle/service/nfp/nfp.cpp

@@ -157,7 +157,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IUser>(ctx, system);
+        rb.PushIpcInterface<IUser>(system);
     }
 };
 
@@ -179,7 +179,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISystem>(ctx, system);
+        rb.PushIpcInterface<ISystem>(system);
     }
 };
 
@@ -201,7 +201,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IDebug>(ctx, system);
+        rb.PushIpcInterface<IDebug>(system);
     }
 };
 

src/core/hle/service/nifm/nifm.cpp

@@ -307,7 +307,7 @@ private:
     void GetSystemEventReadableHandle(HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2, 2};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, evt_scan_complete->GetReadableEvent(),
+        rb.PushCopyObjects(evt_scan_complete->GetReadableEvent(),
                            evt_processing->GetReadableEvent());
     }
 
@@ -452,7 +452,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 2};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, event1->GetReadableEvent(), event2->GetReadableEvent());
+        rb.PushCopyObjects(event1->GetReadableEvent(), event2->GetReadableEvent());
     }
 
     void Cancel(HLERequestContext& ctx) {
@@ -528,7 +528,7 @@ void IGeneralService::CreateScanRequest(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IScanRequest>(ctx, system);
+    rb.PushIpcInterface<IScanRequest>(system);
 }
 
 void IGeneralService::CreateRequest(HLERequestContext& ctx) {
@@ -537,7 +537,7 @@ void IGeneralService::CreateRequest(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IRequest>(ctx, system);
+    rb.PushIpcInterface<IRequest>(system);
 }
 
 void IGeneralService::GetCurrentNetworkProfile(HLERequestContext& ctx) {
@@ -716,7 +716,7 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INetworkProfile>(ctx, system);
+    rb.PushIpcInterface<INetworkProfile>(system);
 }
 
 void IGeneralService::SetNetworkProfile(HLERequestContext& ctx) {
@@ -869,7 +869,7 @@ void IGeneralService::CreateTemporaryNetworkProfile(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 6, 0, 1};
 
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INetworkProfile>(ctx, system);
+    rb.PushIpcInterface<INetworkProfile>(system);
     rb.PushRaw<u128>(uuid);
 }
 
@@ -1124,7 +1124,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IGeneralService>(ctx, system);
+        rb.PushIpcInterface<IGeneralService>(system);
     }
 
     void CreateGeneralService(HLERequestContext& ctx) {
@@ -1132,7 +1132,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IGeneralService>(ctx, system);
+        rb.PushIpcInterface<IGeneralService>(system);
     }
 };
 

src/core/hle/service/nim/nim.cpp

@@ -53,7 +53,7 @@ private:
         LOG_WARNING(Service_NIM, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAsync>(ctx, system);
+        rb.PushIpcInterface<IShopServiceAsync>(system);
     }
 };
 
@@ -75,7 +75,7 @@ private:
         LOG_WARNING(Service_NIM, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessor>(ctx, system);
+        rb.PushIpcInterface<IShopServiceAccessor>(system);
     }
 };
 
@@ -336,7 +336,7 @@ private:
         LOG_DEBUG(Service_NIM, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessServer>(ctx, system);
+        rb.PushIpcInterface<IShopServiceAccessServer>(system);
     }
 
     void IsLargeResourceAvailable(HLERequestContext& ctx) {
@@ -356,7 +356,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessServer>(ctx, system);
+        rb.PushIpcInterface<IShopServiceAccessServer>(system);
     }
 };
 
@@ -439,7 +439,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, finished_event->GetReadableEvent());
+        rb.PushCopyObjects(finished_event->GetReadableEvent());
     }
 
     void GetResult(HLERequestContext& ctx) {
@@ -500,7 +500,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>(ctx, system);
+        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>(system);
     }
 
     // TODO(ogniK): Do we need these?

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -359,8 +359,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
 
     IPC::ResponseBuilder rb{ctx, 2, 1, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, async_value->ReadableEvent());
-    rb.PushIpcInterface(ctx, std::move(async_value));
+    rb.PushCopyObjects(async_value->ReadableEvent());
+    rb.PushIpcInterface(std::move(async_value));
 }
 
 Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData3(

src/core/hle/service/nvdrv/nvdrv_interface.cpp

@@ -199,7 +199,7 @@ void NVDRV::QueryEvent(HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3, 1};
         rb.Push(ResultSuccess);
         auto& readable_event = event->GetReadableEvent();
-        rb.PushCopyObjects(ctx, readable_event);
+        rb.PushCopyObjects(readable_event);
         rb.PushEnum(NvResult::Success);
     } else {
         LOG_ERROR(Service_NVDRV, "Invalid event request!");

src/core/hle/service/os/process.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#include <utility>
-
 #include "common/common_types.h"
 
 namespace Core {
@@ -30,15 +28,6 @@ public:
     inline explicit Process(Core::System& system) noexcept : m_system(system) {}
     inline ~Process() { this->Finalize(); }
 
-    Process(const Process&) = delete;
-    Process& operator=(const Process&) = delete;
-    Process& operator=(Process&&) = delete;
-    inline Process(Process&& other) noexcept
-        : m_system(other.m_system), m_process(std::exchange(other.m_process, nullptr)),
-          m_main_thread_stack_size(std::exchange(other.m_main_thread_stack_size, 0)),
-          m_main_thread_priority(std::exchange(other.m_main_thread_priority, 0)),
-          m_process_started(std::exchange(other.m_process_started, false)) {}
-
     bool Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result);
     void Finalize();
 

src/core/hle/service/pcv/pcv.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 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
 
@@ -127,7 +124,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IClkrstSession>(ctx, system, device_code);
+        rb.PushIpcInterface<IClkrstSession>(system, device_code);
     }
 };
 

src/core/hle/service/pm/pm.cpp

@@ -161,7 +161,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 10, 1};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, *process);
+        rb.PushCopyObjects(*process);
         rb.PushRaw(program_location);
         rb.PushRaw(override_status);
     }

src/core/hle/service/psc/time/alarms.cpp

@@ -147,7 +147,7 @@ void IAlarmService::CreateWakeupAlarm(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISteadyClockAlarm>(ctx, system, m_alarms, AlarmType::WakeupAlarm);
+    rb.PushIpcInterface<ISteadyClockAlarm>(system, m_alarms, AlarmType::WakeupAlarm);
 }
 
 void IAlarmService::CreateBackgroundTaskAlarm(HLERequestContext& ctx) {
@@ -155,7 +155,7 @@ void IAlarmService::CreateBackgroundTaskAlarm(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISteadyClockAlarm>(ctx, system, m_alarms, AlarmType::BackgroundTaskAlarm);
+    rb.PushIpcInterface<ISteadyClockAlarm>(system, m_alarms, AlarmType::BackgroundTaskAlarm);
 }
 
 ISteadyClockAlarm::ISteadyClockAlarm(Core::System& system_, Alarms& alarms, AlarmType type)
@@ -179,7 +179,7 @@ void ISteadyClockAlarm::GetAlarmEvent(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, m_alarm.GetEventHandle());
+    rb.PushCopyObjects(m_alarm.GetEventHandle());
 }
 
 void ISteadyClockAlarm::Enable(HLERequestContext& ctx) {

src/core/hle/service/ptm/psm.cpp

@@ -67,7 +67,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(ResultSuccess);
-        rb.PushCopyObjects(ctx, state_change_event->GetReadableEvent());
+        rb.PushCopyObjects(state_change_event->GetReadableEvent());
     }
 
     void UnbindStateChangeEvent(HLERequestContext& ctx) {
@@ -186,7 +186,7 @@ void PSM::OpenSession(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IPsmSession>(ctx, system);
+    rb.PushIpcInterface<IPsmSession>(system);
 }
 
 void PSM::GetBatteryVoltageState(HLERequestContext& ctx) {

src/core/hle/service/ptm/ts.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -85,7 +82,7 @@ void TS::OpenSession(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(ctx, system);
+    rb.PushIpcInterface<ISession>(system);
 }
 
 } // namespace Service::PTM

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

@@ -140,7 +140,7 @@ void SM::GetServiceCmif(HLERequestContext& ctx) {
     if (result == ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
         rb.Push(result);
-        rb.PushMoveObjects(ctx, client_session);
+        rb.PushMoveObjects(client_session);
     } else {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(result);
@@ -157,7 +157,7 @@ void SM::GetServiceTipc(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
     rb.Push(result);
-    rb.PushMoveObjects(ctx, result == ResultSuccess ? client_session : nullptr);
+    rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr);
 }
 
 static std::string PopServiceName(IPC::RequestParser& rp) {
@@ -230,7 +230,8 @@ void SM::RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_s
               max_session_count, is_light);
 
     Kernel::KServerPort* server_port{};
-    if (const auto result = service_manager.RegisterService(std::addressof(server_port), name, max_session_count, nullptr);
+    if (const auto result = service_manager.RegisterService(std::addressof(server_port), name,
+                                                            max_session_count, nullptr);
         result.IsError()) {
         LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}", result.raw);
         IPC::ResponseBuilder rb{ctx, 2};
@@ -240,7 +241,7 @@ void SM::RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_s
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
     rb.Push(ResultSuccess);
-    rb.PushMoveObjects(ctx, server_port);
+    rb.PushMoveObjects(server_port);
 }
 
 void SM::UnregisterService(HLERequestContext& ctx) {

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

@@ -60,7 +60,7 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
     // We succeeded.
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
     rb.Push(ResultSuccess);
-    rb.PushMoveObjects(ctx, session->GetClientSession());
+    rb.PushMoveObjects(session->GetClientSession());
 }
 
 void Controller::CloneCurrentObjectEx(HLERequestContext& ctx) {

src/core/hle/service/ssl/ssl.cpp

@@ -543,7 +543,8 @@ private:
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(res);
         if (res == ResultSuccess) {
-            rb.PushIpcInterface<ISslConnection>(ctx, system, ssl_version, shared_data, std::move(backend));
+            rb.PushIpcInterface<ISslConnection>(system, ssl_version, shared_data,
+                                                std::move(backend));
         }
     }
 
@@ -623,11 +624,12 @@ private:
         IPC::RequestParser rp{ctx};
         const auto parameters = rp.PopRaw<Parameters>();
 
-        LOG_WARNING(Service_SSL, "(STUBBED) called, api_version={}, pid_placeholder={}", parameters.ssl_version.api_version, parameters.pid_placeholder);
+        LOG_WARNING(Service_SSL, "(STUBBED) called, api_version={}, pid_placeholder={}",
+                    parameters.ssl_version.api_version, parameters.pid_placeholder);
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISslContext>(ctx, system, parameters.ssl_version);
+        rb.PushIpcInterface<ISslContext>(system, parameters.ssl_version);
     }
 
     void SetInterfaceVersion(HLERequestContext& ctx) {

src/core/hle/service/usb/usb.cpp

@@ -155,7 +155,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IPdSession>(ctx, system);
+        rb.PushIpcInterface<IPdSession>(system);
     }
 };
 
@@ -199,7 +199,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IPdCradleSession>(ctx, system);
+        rb.PushIpcInterface<IPdCradleSession>(system);
     }
 };
 

src/hid_core/resources/npad/npad.cpp

@@ -50,8 +50,8 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service
             auto& controller = controller_data[aruid_index][i];
             controller.device = hid_core.GetEmulatedControllerByIndex(i);
             Core::HID::ControllerUpdateCallback engine_callback{
-                .on_change = [this, i, kernel = &hid_core.kernel](Core::HID::ControllerTriggerType type) {
-                    ControllerUpdate(*kernel, type, i);
+                .on_change = [this, i](Core::HID::ControllerTriggerType type) {
+                    ControllerUpdate(hid_core.kernel, type, i);
                 },
                 .is_npad_service = true,
             };

src/qt_common/config/shared_translation.cpp

@@ -240,16 +240,16 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("Accelerates BCn 3D texture decoding using GPU compute.\n"
               "Disable if experiencing crashes or graphical glitches."));
     INSERT(Settings, gpu_unswizzle_texture_size, tr("GPU Unswizzle Max Texture Size"),
-           tr("Sets the maximum size (power of 2 * 1MiB) for GPU-based texture unswizzling.\n"
+           tr("Sets the maximum size (MiB) for GPU-based texture unswizzling.\n"
               "While the GPU is faster for medium and large textures, the CPU may be more "
               "efficient for very small ones.\n"
               "Adjust this to find the balance between GPU acceleration and CPU overhead."));
     INSERT(Settings, gpu_unswizzle_stream_size, tr("GPU Unswizzle Stream Size"),
-           tr("Sets the maximum amount of texture data (power of 2 * 1MiB) processed per frame.\n"
+           tr("Sets the maximum amount of texture data (in MiB) processed per frame.\n"
               "Higher values can reduce stutter during texture loading but may impact frame "
               "consistency."));
     INSERT(Settings, gpu_unswizzle_chunk_size, tr("GPU Unswizzle Chunk Size"),
-           tr("Determines the number of depth slices (power of 2) processed in a single dispatch.\n"
+           tr("Determines the number of depth slices processed in a single dispatch.\n"
               "Increasing this can improve throughput on high-end GPUs but may cause TDR or driver "
               "timeouts on weaker hardware."));
 
@@ -652,6 +652,31 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(GpuOverclock, Medium, tr("Medium (256)")),
                               PAIR(GpuOverclock, High, tr("High (512)")),
                           }});
+    translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzleSize>::Index(),
+                          {
+                              PAIR(GpuUnswizzleSize, VerySmall, tr("Very Small (16 MB)")),
+                              PAIR(GpuUnswizzleSize, Small, tr("Small (32 MB)")),
+                              PAIR(GpuUnswizzleSize, Normal, tr("Normal (128 MB)")),
+                              PAIR(GpuUnswizzleSize, Large, tr("Large (256 MB)")),
+                              PAIR(GpuUnswizzleSize, VeryLarge, tr("Very Large (512 MB)")),
+                          }});
+    translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzle>::Index(),
+                          {
+                              PAIR(GpuUnswizzle, VeryLow, tr("Very Low (4 MB)")),
+                              PAIR(GpuUnswizzle, Low, tr("Low (8 MB)")),
+                              PAIR(GpuUnswizzle, Normal, tr("Normal (16 MB)")),
+                              PAIR(GpuUnswizzle, Medium, tr("Medium (32 MB)")),
+                              PAIR(GpuUnswizzle, High, tr("High (64 MB)")),
+                          }});
+    translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzleChunk>::Index(),
+                          {
+                              PAIR(GpuUnswizzleChunk, VeryLow, tr("Very Low (32)")),
+                              PAIR(GpuUnswizzleChunk, Low, tr("Low (64)")),
+                              PAIR(GpuUnswizzleChunk, Normal, tr("Normal (128)")),
+                              PAIR(GpuUnswizzleChunk, Medium, tr("Medium (256)")),
+                              PAIR(GpuUnswizzleChunk, High, tr("High (512)")),
+                          }});
+
     translations->insert({Settings::EnumMetadata<Settings::ExtendedDynamicState>::Index(),
                           {
                               PAIR(ExtendedDynamicState, Disabled, tr("Disabled")),

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -236,11 +236,8 @@ void LowerGeometryPassthrough(const IR::Program& program, const HostTranslateInf
 
 IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
                              Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info) {
-    HostTranslateInfo normalized_host_info{host_info};
-    normalized_host_info.ApplyDescriptorLimitPolicy();
-
     IR::Program program;
-    program.syntax_list = BuildASL(inst_pool, block_pool, env, cfg, normalized_host_info);
+    program.syntax_list = BuildASL(inst_pool, block_pool, env, cfg, host_info);
     program.blocks = GenerateBlocks(program.syntax_list);
     program.post_order_blocks = PostOrder(program.syntax_list.front());
     program.stage = env.ShaderStage();
@@ -263,9 +260,9 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
                 program.info.passthrough.mask[i] = ((mask[i / 32] >> (i % 32)) & 1) == 0;
             }
 
-            if (!normalized_host_info.support_geometry_shader_passthrough) {
+            if (!host_info.support_geometry_shader_passthrough) {
                 program.output_vertices = GetOutputTopologyVertices(program.output_topology);
-                LowerGeometryPassthrough(program, normalized_host_info);
+                LowerGeometryPassthrough(program, host_info);
             }
         }
         break;
@@ -280,16 +277,16 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
     RemoveUnreachableBlocks(program);
 
     // Replace instructions before the SSA rewrite
-    if (!normalized_host_info.support_float64) {
+    if (!host_info.support_float64) {
         Optimization::LowerFp64ToFp32(program);
     }
-    if (!normalized_host_info.support_float16) {
+    if (!host_info.support_float16) {
         Optimization::LowerFp16ToFp32(program);
     }
-    if (!normalized_host_info.support_int64) {
+    if (!host_info.support_int64) {
         Optimization::LowerInt64ToInt32(program);
     }
-    if (!normalized_host_info.support_conditional_barrier) {
+    if (!host_info.support_conditional_barrier) {
         Optimization::ConditionalBarrierPass(program);
     }
     Optimization::SsaRewritePass(program);
@@ -298,8 +295,8 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, normalized_host_info);
-    Optimization::TexturePass(env, program, normalized_host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active || Settings::values.rescale_hack.GetValue()) {
         Optimization::RescalingPass(program);
@@ -309,7 +306,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
         Optimization::VerificationPass(program);
     }
     Optimization::CollectShaderInfoPass(env, program);
-    Optimization::LayerPass(program, normalized_host_info);
+    Optimization::LayerPass(program, host_info);
     Optimization::VendorWorkaroundPass(program);
 
     CollectInterpolationInfo(env, program);

src/shader_recompiler/host_translate_info.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#include "common/common_types.h"
-
 namespace Shader {
 
 // Try to keep entries here to a minimum
@@ -15,52 +13,20 @@ namespace Shader {
 
 /// Misc information about the host
 struct HostTranslateInfo {
-    static constexpr u32 DEFAULT_DESCRIPTOR_LIMIT = 1024;
-
-    u64 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
-    u32 max_per_stage_descriptor_sampled_images{}; ///< maximum sampled descriptors per stage
-    u32 max_per_stage_resources{};                 ///< maximum resources per stage
-    u32 max_descriptor_set_samplers{};
-    u32 max_descriptor_set_uniform_buffers{};
-    u32 max_descriptor_set_uniform_buffers_dynamic{};
-    u32 max_descriptor_set_storage_buffers{};
-    u32 max_descriptor_set_storage_buffers_dynamic{};
-    u32 max_descriptor_set_sampled_images{};
-    u32 max_descriptor_set_storage_images{};
-    u32 max_descriptor_set_input_attachements{};
     bool support_float64{};      ///< True when the device supports 64-bit floats
     bool support_float16{};      ///< True when the device supports 16-bit floats
     bool support_int64{};        ///< True when the device supports 64-bit integers
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
+    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
+    u32 max_per_stage_descriptor_sampled_images{1024}; ///< maximum sampled descriptors per stage
+    u32 max_per_stage_resources{4096};                 ///< maximum resources per stage
+    u32 max_descriptor_set_sampled_images{1024};        ///< maximum sampled descriptors per set
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
     bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
                                         ///< control flow
-
-    void ApplyDescriptorLimitPolicy() noexcept {
-        if (min_ssbo_alignment == 0) {
-            min_ssbo_alignment = 1;
-        }
-        ApplyDescriptorLimitFallback(max_per_stage_descriptor_sampled_images);
-        ApplyDescriptorLimitFallback(max_per_stage_resources);
-        ApplyDescriptorLimitFallback(max_descriptor_set_samplers);
-        ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers);
-        ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers_dynamic);
-        ApplyDescriptorLimitFallback(max_descriptor_set_storage_buffers);
-        ApplyDescriptorLimitFallback(max_descriptor_set_storage_buffers_dynamic);
-        ApplyDescriptorLimitFallback(max_descriptor_set_sampled_images);
-        ApplyDescriptorLimitFallback(max_descriptor_set_storage_images);
-        ApplyDescriptorLimitFallback(max_descriptor_set_input_attachements);
-    }
-
-private:
-    static void ApplyDescriptorLimitFallback(u32& limit) noexcept {
-        if (limit == 0) {
-            limit = DEFAULT_DESCRIPTOR_LIMIT;
-        }
-    }
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -548,7 +545,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
         const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, u32(host_info.min_ssbo_alignment))};
+            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
         Replace(*block, *inst, index, offset);
     }
 }

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -32,62 +32,71 @@ struct TextureInst {
 using TextureInstVector = boost::container::small_vector<TextureInst, 24>;
 
 constexpr u32 DESCRIPTOR_SIZE = 8;
-constexpr u32 DESCRIPTOR_SIZE_SHIFT = u32(std::countr_zero(DESCRIPTOR_SIZE));
-constexpr u32 DESCRIPTOR_MAX_COUNT = 1024;
+constexpr u32 DESCRIPTOR_SIZE_SHIFT = static_cast<u32>(std::countr_zero(DESCRIPTOR_SIZE));
+constexpr u32 DYNAMIC_DESCRIPTOR_CBUF_BYTES = 16 * 1024;
+constexpr u32 MAX_DYNAMIC_DESCRIPTOR_COUNT = 1024;
 
 u32 DynamicDescriptorSizeShift(const IR::U32& dynamic_offset) {
-    const IR::Inst* const inst = dynamic_offset.InstRecursive();
-    if (!inst || inst->GetOpcode() != IR::Opcode::ShiftLeftLogical32)
+    const IR::Inst* const inst{dynamic_offset.InstRecursive()};
+    if (!inst || inst->GetOpcode() != IR::Opcode::ShiftLeftLogical32) {
         return DESCRIPTOR_SIZE_SHIFT;
-    const IR::Value shift = inst->Arg(1);
-    if (!shift.IsImmediate())
+    }
+    const IR::Value shift{inst->Arg(1)};
+    if (!shift.IsImmediate()) {
         return DESCRIPTOR_SIZE_SHIFT;
-    const u32 size_shift = shift.U32();
-    return size_shift >= DESCRIPTOR_SIZE_SHIFT && size_shift < 31 ? size_shift : DESCRIPTOR_SIZE_SHIFT;
+    }
+    const u32 size_shift{shift.U32()};
+    return size_shift >= DESCRIPTOR_SIZE_SHIFT && size_shift < 31 ? size_shift
+                                                                  : DESCRIPTOR_SIZE_SHIFT;
 }
 
-u32 DynamicDescriptorCount(u32 base_offset, u32 size_shift, u32 max_descriptors) {
-    auto const descriptor_limit = (std::max)(1U, max_descriptors);
-    auto const max_cbuf_bytes = 16 * descriptor_limit;
-    if (size_shift >= 31 || base_offset >= max_cbuf_bytes)
+u32 DynamicDescriptorCount(u32 base_offset, u32 size_shift) {
+    if (size_shift >= 31 || base_offset >= DYNAMIC_DESCRIPTOR_CBUF_BYTES) {
         return 1;
-    auto const stride = 1U << size_shift;
-    auto const available = max_cbuf_bytes - base_offset;
-    if (available < DESCRIPTOR_SIZE)
+    }
+    const u32 stride{1U << size_shift};
+    const u32 available{DYNAMIC_DESCRIPTOR_CBUF_BYTES - base_offset};
+    if (available < DESCRIPTOR_SIZE) {
         return 1;
-    auto const available_count = 1U + (available - DESCRIPTOR_SIZE) / stride;
-    return std::min(descriptor_limit, available_count);
+    }
+    const u32 available_count{1U + (available - DESCRIPTOR_SIZE) / stride};
+    return std::min(MAX_DYNAMIC_DESCRIPTOR_COUNT, available_count);
 }
 
 u32 SaturatingSub(u32 lhs, u32 rhs) {
     return lhs > rhs ? lhs - rhs : 0;
 }
 
-template <typename T>
-[[nodiscard]] u32 StaticDescriptorCount(T const& descriptors) noexcept {
-    return std::accumulate(descriptors.cbegin(), descriptors.cend(), 0U, [](auto const& acc, auto const& e) {
-        return acc + (e.count <= 1 ? e.count : 0);
-    });
+template <typename Descriptors>
+u32 StaticDescriptorCount(const Descriptors& descriptors) {
+    u32 count{};
+    for (const auto& desc : descriptors) {
+        if (desc.count <= 1) {
+            count += desc.count;
+        }
+    }
+    return count;
 }
 
-u32 DynamicSampledTextureCap(const Info& info, const HostTranslateInfo& host_info, u32 dynamic_arrays) {
-    auto const sampled_limit = (std::max)(1U, std::min(host_info.max_per_stage_descriptor_sampled_images,
-                                                       host_info.max_descriptor_set_sampled_images));
-    auto const resource_limit = (std::max)(1U, host_info.max_per_stage_resources);
-    if (dynamic_arrays > 0) {
-        auto const sampled_static_count = StaticDescriptorCount(info.texture_buffer_descriptors) + StaticDescriptorCount(info.texture_descriptors);
-        auto const resource_static_count =
-            NumDescriptors(info.constant_buffer_descriptors)
-            + NumDescriptors(info.storage_buffers_descriptors)
-            + sampled_static_count + NumDescriptors(info.image_buffer_descriptors)
-            + NumDescriptors(info.image_descriptors);
-        auto const sampled_budget = SaturatingSub(sampled_limit, sampled_static_count);
-        auto const resource_budget = SaturatingSub(resource_limit, resource_static_count);
-        auto const sampled_cap = sampled_budget / dynamic_arrays;
-        auto const resource_cap = resource_budget / dynamic_arrays;
-        return (std::max)(1U, (std::min)(sampled_cap, resource_cap));
+u32 DynamicSampledTextureCap(const Info& info, const HostTranslateInfo& host_info,
+                             u32 dynamic_arrays) {
+    if (dynamic_arrays == 0) {
+        return MAX_DYNAMIC_DESCRIPTOR_COUNT;
     }
-    return (std::min)({DESCRIPTOR_MAX_COUNT, sampled_limit, resource_limit});
+    const u32 sampled_static_count{StaticDescriptorCount(info.texture_buffer_descriptors) +
+                                   StaticDescriptorCount(info.texture_descriptors)};
+    const u32 resource_static_count{
+        NumDescriptors(info.constant_buffer_descriptors) +
+        NumDescriptors(info.storage_buffers_descriptors) + sampled_static_count +
+        NumDescriptors(info.image_buffer_descriptors) + NumDescriptors(info.image_descriptors)};
+    const u32 sampled_limit{std::min(host_info.max_per_stage_descriptor_sampled_images,
+                                     host_info.max_descriptor_set_sampled_images)};
+    const u32 sampled_budget{SaturatingSub(sampled_limit, sampled_static_count)};
+    const u32 resource_budget{SaturatingSub(host_info.max_per_stage_resources,
+                                            resource_static_count)};
+    const u32 sampled_cap{sampled_budget / dynamic_arrays};
+    const u32 resource_cap{resource_budget / dynamic_arrays};
+    return std::max(1U, std::min({MAX_DYNAMIC_DESCRIPTOR_COUNT, sampled_cap, resource_cap}));
 }
 
 IR::Opcode IndexedInstruction(const IR::Inst& inst) {
@@ -295,23 +304,21 @@ static inline bool IsTexturePixelFormatIntegerCached(Environment& env,
 }
 
 
-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info);
-static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env, const HostTranslateInfo& host_info) {
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env);
+static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env) {
     if (const IR::Inst* key = v.InstRecursive()) {
         if (auto it = env.track_cache.find(key); it != env.track_cache.end()) return it->second;
-        auto found = Track(v, env, host_info);
+        auto found = Track(v, env);
         if (found) env.track_cache.emplace(key, *found);
         return found;
     }
-    return Track(v, env, host_info);
+    return Track(v, env);
 }
 
-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info);
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env);
 
-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info) {
-    return IR::BreadthFirstSearch(value, [&env, &host_info](const IR::Inst* inst) {
-        return TryGetConstBuffer(inst, env, host_info);
-    });
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env) {
+    return IR::BreadthFirstSearch(value, [&env](const IR::Inst* inst) { return TryGetConstBuffer(inst, env); });
 }
 
 std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
@@ -335,13 +342,13 @@ std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
     return ReadCbufCached(env, index_number, offset_number);
 }
 
-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info) {
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env) {
     switch (inst->GetOpcode()) {
     default:
         return std::nullopt;
     case IR::Opcode::BitwiseOr32: {
-        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
-        std::optional rhs{TrackCached(inst->Arg(1), env, host_info)};
+        std::optional lhs{TrackCached(inst->Arg(0), env)};
+        std::optional rhs{TrackCached(inst->Arg(1), env)};
         if (!lhs || !rhs) {
             return std::nullopt;
         }
@@ -371,11 +378,12 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
         if (!shift.IsImmediate()) {
             return std::nullopt;
         }
-        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
+        std::optional lhs{TrackCached(inst->Arg(0), env)};
         if (lhs) {
             lhs->shift_left = shift.U32();
         }
         return lhs;
+        break;
     }
     case IR::Opcode::BitwiseAnd32: {
         IR::Value op1{inst->Arg(0)};
@@ -399,7 +407,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
                 return std::nullopt;
             } while (false);
         }
-        std::optional lhs{TrackCached(op1, env, host_info)};
+        std::optional lhs{TrackCached(op1, env)};
         if (lhs) {
             lhs->shift_left = static_cast<u32>(std::countr_zero(op2.U32()));
         }
@@ -445,10 +453,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
     } else {
         return std::nullopt;
     }
-    auto const size_shift = DynamicDescriptorSizeShift(dynamic_offset);
-    auto const sampled_limit = (std::max)(1U, (std::min)(host_info.max_per_stage_descriptor_sampled_images,
-                                                         host_info.max_descriptor_set_sampled_images));
-    auto const resource_limit = (std::max)(1U, host_info.max_per_stage_resources);
+    const u32 size_shift{DynamicDescriptorSizeShift(dynamic_offset)};
     return ConstBufferAddr{
         .index = index.U32(),
         .offset = base_offset,
@@ -457,15 +462,15 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
         .secondary_offset = 0,
         .secondary_shift_left = 0,
         .dynamic_offset = dynamic_offset,
-        .count = DynamicDescriptorCount(base_offset, size_shift, (std::min)({DESCRIPTOR_MAX_COUNT, sampled_limit, resource_limit})),
+        .count = DynamicDescriptorCount(base_offset, size_shift),
         .has_secondary = false,
     };
 }
 
-TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst, const HostTranslateInfo& host_info) {
+TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst) {
     ConstBufferAddr addr;
     if (IsBindless(inst)) {
-        const std::optional<ConstBufferAddr> track_addr{TrackCached(inst.Arg(0), env, host_info)};
+        const std::optional<ConstBufferAddr> track_addr{TrackCached(inst.Arg(0), env)};
 
         if (!track_addr) {
             throw NotImplementedException("Failed to track bindless texture constant buffer");
@@ -501,15 +506,15 @@ u32 GetTextureHandle(Environment& env, const ConstBufferAddr& cbuf) {
     return lhs_raw | rhs_raw;
 }
 
-[[maybe_unused]] TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
+    [[maybe_unused]]TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
     return env.ReadTextureType(GetTextureHandle(env, cbuf));
 }
 
-[[maybe_unused]] TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
+    [[maybe_unused]]TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
-[[maybe_unused]] bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
+    [[maybe_unused]]bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
     return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }
 
@@ -670,7 +675,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             if (!IsTextureInstruction(inst)) {
                 continue;
             }
-            to_replace.push_back(MakeInst(env, block, inst, host_info));
+            to_replace.push_back(MakeInst(env, block, inst));
         }
     }
     // Sort instructions to visit textures by constant buffer index, then by offset
@@ -684,7 +689,8 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
         program.info.texture_descriptors,
         program.info.image_descriptors,
     };
-    const u32 sampled_dynamic_cap = DynamicSampledTextureCap(program.info, host_info, DynamicSampledTextureArrayCount(to_replace));
+    const u32 sampled_dynamic_cap{
+        DynamicSampledTextureCap(program.info, host_info, DynamicSampledTextureArrayCount(to_replace))};
     for (TextureInst& texture_inst : to_replace) {
         // TODO: Handle arrays
         IR::Inst* const inst{texture_inst.inst};

src/shader_recompiler/profile.h

@@ -92,6 +92,7 @@ struct Profile {
     bool has_broken_robust{};
 
     u64 min_ssbo_alignment{};
+
     u32 max_user_clip_distances{};
 };
 

src/tests/common/host_memory.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,19 +15,12 @@ static constexpr auto PERMS = Common::MemoryPermission::ReadWrite;
 static constexpr auto HEAP = false;
 
 TEST_CASE("HostMemory: Initialize and deinitialize", "[common]") {
-    {
-        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-        REQUIRE(mem.BackingBasePointer() != nullptr);
-    }
-    {
-        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-        REQUIRE(mem.BackingBasePointer() != nullptr);
-    }
+    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
+    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
 }
 
 TEST_CASE("HostMemory: Simple map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x8000, 0x1000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -40,7 +30,6 @@ TEST_CASE("HostMemory: Simple map", "[common]") {
 
 TEST_CASE("HostMemory: Simple mirror map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
     mem.Map(0x8000, 0x4000, 0x1000, PERMS, HEAP);
 
@@ -52,7 +41,6 @@ TEST_CASE("HostMemory: Simple mirror map", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -64,7 +52,6 @@ TEST_CASE("HostMemory: Simple unmap", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -82,7 +69,6 @@ TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
 
 TEST_CASE("HostMemory: Nieche allocation", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x20000, PERMS, HEAP);
     mem.Unmap(0x0000, 0x4000, HEAP);
     mem.Map(0x1000, 0, 0x2000, PERMS, HEAP);
@@ -92,7 +78,6 @@ TEST_CASE("HostMemory: Nieche allocation", "[common]") {
 
 TEST_CASE("HostMemory: Full unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
     mem.Map(0x6000, 0, 0x16000, PERMS, HEAP);
@@ -100,7 +85,6 @@ TEST_CASE("HostMemory: Full unmap", "[common]") {
 
 TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
     mem.Map(0x2000, 0x80000, 0x4000, PERMS, HEAP);
@@ -108,7 +92,6 @@ TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x6000, 0x4000, HEAP);
     mem.Map(0x8000, 0, 0x2000, PERMS, HEAP);
@@ -116,7 +99,6 @@ TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x1b000, PERMS, HEAP);
     mem.Unmap(0x3000, 0x1c000, HEAP);
@@ -125,7 +107,6 @@ TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
 
 TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
@@ -134,7 +115,6 @@ TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to origin", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x4000, 0x4000, HEAP);
@@ -144,7 +124,6 @@ TEST_CASE("HostMemory: Unmap to origin", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to right", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
@@ -153,7 +132,6 @@ TEST_CASE("HostMemory: Unmap to right", "[common]") {
 
 TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -166,7 +144,6 @@ TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -181,7 +158,6 @@ TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -196,7 +172,6 @@ TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial sparse middle unmap and check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
-    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x2000, PERMS, HEAP);
     mem.Map(0x6000, 0x20000, 0x2000, PERMS, HEAP);
 

src/video_core/host_shaders/block_linear_unswizzle_2d.comp

@@ -11,8 +11,9 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_INPUT_BUFFER 0
-#define BINDING_OUTPUT_IMAGE 1
+#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 1
+#define BINDING_OUTPUT_IMAGE 2
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -25,7 +26,8 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_INPUT_BUFFER 0
+#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 1
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -41,6 +43,10 @@ UNIFORM(6) uint block_height;
 UNIFORM(7) uint block_height_mask;
 END_PUSH_CONSTANTS
 
+layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
+    uint swizzle_table[];
+};
+
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -65,19 +71,9 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
-uint SwizzleTable(uint pos) {
-    const uint t[8] = uint[](
-        0x12100200, 0x13110301, 0x16140604, 0x17150705,
-        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
-    );
-    const uint i = pos >> 4;
-    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
-    return (h << 4) | (pos & 0xf);
-}
-
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return SwizzleTable(pos.y * 64 + pos.x);
+    return swizzle_table[pos.y * 64 + pos.x];
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d.comp

@@ -11,8 +11,9 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_INPUT_BUFFER 0
-#define BINDING_OUTPUT_IMAGE 1
+#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 1
+#define BINDING_OUTPUT_IMAGE 2
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -25,7 +26,8 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_INPUT_BUFFER 0
+#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 1
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -43,6 +45,10 @@ UNIFORM(8) uint block_depth;
 UNIFORM(9) uint block_depth_mask;
 END_PUSH_CONSTANTS
 
+layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
+    uint swizzle_table[];
+};
+
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -67,19 +73,9 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
-uint SwizzleTable(uint pos) {
-    const uint t[8] = uint[](
-        0x12100200, 0x13110301, 0x16140604, 0x17150705,
-        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
-    );
-    const uint i = pos >> 4;
-    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
-    return (h << 4) | (pos & 0xf);
-}
-
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return SwizzleTable(pos.y * 64 + pos.x);
+    return swizzle_table[pos.y * 64 + pos.x];
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d_bcn.comp

@@ -10,8 +10,9 @@
     #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
     #define END_PUSH_CONSTANTS };
     #define UNIFORM(n)
-    #define BINDING_INPUT_BUFFER   0
-    #define BINDING_OUTPUT_BUFFER  1
+    #define BINDING_SWIZZLE_BUFFER 0
+    #define BINDING_INPUT_BUFFER   1
+    #define BINDING_OUTPUT_BUFFER  2
 #else
     #extension GL_NV_gpu_shader5 : enable
     #ifdef GL_NV_gpu_shader5
@@ -22,6 +23,7 @@
     #define BEGIN_PUSH_CONSTANTS
     #define END_PUSH_CONSTANTS
     #define UNIFORM(n) layout(location = n) uniform
+    #define BINDING_SWIZZLE_BUFFER 0
     #define BINDING_INPUT_BUFFER   1
     #define BINDING_OUTPUT_BUFFER  0
 #endif
@@ -64,9 +66,13 @@ END_PUSH_CONSTANTS
 #endif
 
 // --- Buffers ---
+layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
+    uint swizzle_table[];
+};
+
 #if HAS_EXTENDED_TYPES
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
+    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
+    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
 #endif
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32  { uint   u32data[];  };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64  { uvec2  u64data[];  };
@@ -90,20 +96,10 @@ const uint GOB_SIZE_Z_SHIFT = 0;
 const uint GOB_SIZE_SHIFT   = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHIFT;
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
 
-uint SwizzleTable(uint pos) {
-    const uint t[8] = uint[](
-        0x12100200, 0x13110301, 0x16140604, 0x17150705,
-        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
-    );
-    const uint i = pos >> 4;
-    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
-    return (h << 4) | (pos & 0xf);
-}
-
 // --- Helpers ---
 uint SwizzleOffset(uvec2 pos) {
     pos &= SWIZZLE_MASK;
-    return SwizzleTable(pos.y * 64u + pos.x);
+    return swizzle_table[pos.y * 64u + pos.x];
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -54,7 +54,7 @@ using VideoCommon::LoadPipelines;
 using VideoCommon::SerializePipeline;
 using Context = ShaderContext::Context;
 
-constexpr u32 CACHE_VERSION = 15;
+constexpr u32 CACHE_VERSION = 16;
 
 template <typename Container>
 auto MakeSpan(Container& container) {
@@ -245,31 +245,16 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
               std::min<u32>(device.GetMaxUserClipDistances(), Maxwell::Regs::NumClipDistances),
       },
       host_info{
-        .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
-        .max_per_stage_descriptor_sampled_images =
-            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_per_stage_resources = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_samplers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_uniform_buffers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_uniform_buffers_dynamic =
-            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_storage_buffers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_storage_buffers_dynamic =
-            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_sampled_images = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_storage_images = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .max_descriptor_set_input_attachements =
-            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
-        .support_float64 = true,
-        .support_float16 = false,
-        .support_int64 = device.HasShaderInt64(),
-        .needs_demote_reorder = device.IsAmd(),
-        .support_snorm_render_buffer = false,
-        .support_viewport_index_layer = device.HasVertexViewportLayer(),
-        .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
-        .support_conditional_barrier = device.SupportsConditionalBarriers(),
+          .support_float64 = true,
+          .support_float16 = false,
+          .support_int64 = device.HasShaderInt64(),
+          .needs_demote_reorder = device.IsAmd(),
+          .support_snorm_render_buffer = false,
+          .support_viewport_index_layer = device.HasVertexViewportLayer(),
+          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
+          .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
+          .support_conditional_barrier = device.SupportsConditionalBarriers(),
       } {
-    host_info.ApplyDescriptorLimitPolicy();
     if (use_asynchronous_shaders) {
         workers = CreateWorkers();
     }

src/video_core/renderer_opengl/util_shaders.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -59,8 +56,10 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)),
       convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)),
       convert_ms_to_nonms_program(MakeProgram(CONVERT_MSAA_TO_NON_MSAA_COMP)),
-      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP))
-{
+      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP)) {
+    const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
+    swizzle_table_buffer.Create();
+    glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
 }
 
 UtilShaders::~UtilShaders() = default;
@@ -117,11 +116,13 @@ void UtilShaders::ASTCDecode(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{32, 32, 1};
-    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
+    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
+    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     program_manager.BindComputeProgram(block_linear_unswizzle_2d_program.handle);
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {
@@ -152,11 +153,14 @@ void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload3D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{16, 8, 8};
-    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
+
+    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
+    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
     program_manager.BindComputeProgram(block_linear_unswizzle_3d_program.handle);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {

src/video_core/renderer_opengl/util_shaders.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -48,6 +45,9 @@ public:
 
 private:
     ProgramManager& program_manager;
+
+    OGLBuffer swizzle_table_buffer;
+
     OGLProgram astc_decoder_program;
     OGLProgram block_linear_unswizzle_2d_program;
     OGLProgram block_linear_unswizzle_3d_program;

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -22,15 +22,6 @@ namespace Vulkan {
 
 using Shader::Backend::SPIRV::NUM_TEXTURE_AND_IMAGE_SCALING_WORDS;
 
-[[nodiscard]] inline u32 NumDescriptorEntries(const Shader::Info& info) {
-    return Shader::NumDescriptors(info.constant_buffer_descriptors) +
-           Shader::NumDescriptors(info.storage_buffers_descriptors) +
-           Shader::NumDescriptors(info.texture_buffer_descriptors) +
-           Shader::NumDescriptors(info.image_buffer_descriptors) +
-           Shader::NumDescriptors(info.texture_descriptors) +
-           Shader::NumDescriptors(info.image_descriptors);
-}
-
 class DescriptorLayoutBuilder {
 public:
     DescriptorLayoutBuilder(const Device& device_) : device{&device_} {}
@@ -203,11 +194,7 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
             const VideoCommon::ImageViewId image_view_id{(views++)->id};
             const VideoCommon::SamplerId sampler_id{*(samplers++)};
             ImageView& image_view{texture_cache.GetImageView(image_view_id)};
-            VkImageView vk_image_view{image_view.Handle(desc.type)};
-            if (vk_image_view == VK_NULL_HANDLE) {
-                const VkImageView null_image_view{texture_cache.GetImageView(VideoCommon::NULL_IMAGE_VIEW_ID).Handle(desc.type)};
-                if (null_image_view != VK_NULL_HANDLE) vk_image_view = null_image_view;
-            }
+            const VkImageView vk_image_view{image_view.Handle(desc.type)};
             const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
             const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
                                             !image_view.SupportsAnisotropy()};

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -326,7 +326,7 @@ std::pair<VkBuffer, VkDeviceSize> Uint8Pass::Assemble(u32 num_vertices, VkBuffer
     const u32 staging_size = static_cast<u32>(num_vertices * sizeof(u16));
     const auto staging = staging_buffer_pool.Request(staging_size, MemoryUsage::DeviceLocal);
 
-    compute_pass_descriptor_queue.Acquire(scheduler, 2);
+    compute_pass_descriptor_queue.Acquire();
     compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, num_vertices);
     compute_pass_descriptor_queue.AddBuffer(staging.buffer, staging.offset, staging_size);
     const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -384,7 +384,7 @@ std::pair<VkBuffer, VkDeviceSize> QuadIndexedPass::Assemble(
     const std::size_t staging_size = num_tri_vertices * sizeof(u32);
     const auto staging = staging_buffer_pool.Request(staging_size, MemoryUsage::DeviceLocal);
 
-    compute_pass_descriptor_queue.Acquire(scheduler, 2);
+    compute_pass_descriptor_queue.Acquire();
     compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, input_size);
     compute_pass_descriptor_queue.AddBuffer(staging.buffer, staging.offset, staging_size);
     const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -429,7 +429,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
     }
     const size_t compare_size = compare_to_zero ? 8 : 24;
 
-    compute_pass_descriptor_queue.Acquire(scheduler, 2);
+    compute_pass_descriptor_queue.Acquire();
     compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, compare_size);
     compute_pass_descriptor_queue.AddBuffer(dst_buffer, 0, sizeof(u32));
     const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -498,7 +498,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
         static constexpr size_t DISPATCH_SIZE = 2048U;
         size_t runs_to_do = std::min<size_t>(current_runs, DISPATCH_SIZE);
         current_runs -= runs_to_do;
-        compute_pass_descriptor_queue.Acquire(scheduler, 3);
+        compute_pass_descriptor_queue.Acquire();
         compute_pass_descriptor_queue.AddBuffer(src_buffer, 0, number_of_sums * sizeof(u64));
         compute_pass_descriptor_queue.AddBuffer(dst_buffer, 0, number_of_sums * sizeof(u64));
         compute_pass_descriptor_queue.AddBuffer(accumulation_buffer, 0, sizeof(u64));
@@ -600,7 +600,7 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
         const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 8U);
         const u32 num_dispatches_z = image.info.resources.layers;
 
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
+        compute_pass_descriptor_queue.Acquire();
         compute_pass_descriptor_queue.AddBuffer(map.buffer, input_offset,
                                                 image.guest_size_bytes - swizzle.buffer_offset);
         compute_pass_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
@@ -653,8 +653,71 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
     scheduler.Finish();
 }
 
-constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 0;
-constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 1;
+constexpr u32 BL3D_BINDING_SWIZZLE_TABLE = 0;
+constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 1;
+constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 2;
+
+constexpr std::array<VkDescriptorSetLayoutBinding, 3> BL3D_DESCRIPTOR_SET_BINDINGS{{
+    {
+        .binding = BL3D_BINDING_SWIZZLE_TABLE,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // swizzle_table[]
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL3D_BINDING_INPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL3D_BINDING_OUTPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+}};
+
+constexpr DescriptorBankInfo BL3D_BANK_INFO{
+    .uniform_buffers = 0,
+    .storage_buffers = 3,
+    .texture_buffers = 0,
+    .image_buffers = 0,
+    .textures = 0,
+    .images = 0,
+    .score = 3,
+};
+
+constexpr std::array<VkDescriptorUpdateTemplateEntry, 3>
+    BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY{{
+        {
+            .dstBinding = BL3D_BINDING_SWIZZLE_TABLE,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_SWIZZLE_TABLE * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        },
+        {
+            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        },
+        {
+            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        }
+    }};
 
 struct alignas(16) BlockLinearUnswizzle3DPushConstants {
     u32 blocks_dim[3];           // Offset 0
@@ -682,50 +745,11 @@ BlockLinearUnswizzle3DPass::BlockLinearUnswizzle3DPass(
     DescriptorPool& descriptor_pool_,
     StagingBufferPool& staging_buffer_pool_,
     ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_,
-        std::array<VkDescriptorSetLayoutBinding, 2>{{
-    {
-        .binding = BL3D_BINDING_INPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3D_BINDING_OUTPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-        }},
-        std::array<VkDescriptorUpdateTemplateEntry, 2>{{
-        {
-            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
-        {
-            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        }
-        }},
-        DescriptorBankInfo{
-            .uniform_buffers = 0,
-            .storage_buffers = 2,
-            .texture_buffers = 0,
-            .image_buffers = 0,
-            .textures = 0,
-            .images = 0,
-            .score = 2,
-        },
+    : ComputePass(
+          device_, scheduler_, descriptor_pool_,
+          BL3D_DESCRIPTOR_SET_BINDINGS,
+          BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY,
+          BL3D_BANK_INFO,
           COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle3DPushConstants)>,
           BLOCK_LINEAR_UNSWIZZLE_3D_BCN_COMP_SPV),
       scheduler{scheduler_},
@@ -797,7 +821,9 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
     pc.blocks_dim[1] = blocks_y;
     pc.blocks_dim[2] = z_count; // Only process the count
 
-    compute_pass_descriptor_queue.Acquire(scheduler, 3);
+    compute_pass_descriptor_queue.Acquire();
+    compute_pass_descriptor_queue.AddBuffer(*image.runtime->swizzle_table_buffer, 0,
+                                           image.runtime->swizzle_table_size);
     compute_pass_descriptor_queue.AddBuffer(swizzled.buffer,
                                            sw.buffer_offset + swizzled.offset,
                                            image.guest_size_bytes - sw.buffer_offset);
@@ -963,7 +989,7 @@ void MSAACopyPass::CopyImage(Image& dst_image, Image& src_image,
         ASSERT(copy.dst_subresource.base_layer == 0);
         ASSERT(copy.dst_subresource.num_layers == 1);
 
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
+        compute_pass_descriptor_queue.Acquire();
         compute_pass_descriptor_queue.AddImage(
             src_image.StorageImageView(copy.src_subresource.base_level));
         compute_pass_descriptor_queue.AddImage(

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -45,7 +45,6 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
     }
     std::copy_n(info.constant_buffer_used_sizes.begin(), uniform_buffer_sizes.size(),
                 uniform_buffer_sizes.begin());
-    num_descriptor_entries = NumDescriptorEntries(info);
 
     auto func{[this, &scheduler, &descriptor_pool, shader_notify, pipeline_statistics] {
         DescriptorLayoutBuilder builder{device};
@@ -114,7 +113,7 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
 void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                 Tegra::MemoryManager& gpu_memory, Scheduler& scheduler,
                                 BufferCache& buffer_cache, TextureCache& texture_cache) {
-    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);
+    guest_descriptor_queue.Acquire();
 
     buffer_cache.SetComputeUniformBufferState(info.constant_buffer_mask, &uniform_buffer_sizes);
     buffer_cache.UnbindComputeStorageBuffers();

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -53,7 +53,6 @@ private:
     vk::PipelineCache& pipeline_cache;
     GuestDescriptorQueue& guest_descriptor_queue;
     Shader::Info info;
-    u32 num_descriptor_entries{};
 
     VideoCommon::ComputeUniformBufferSizes uniform_buffer_sizes{};
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -268,7 +268,6 @@ GraphicsPipeline::GraphicsPipeline(
         num_textures += Shader::NumDescriptors(info->texture_descriptors);
         num_image_elements += Shader::NumDescriptors(info->texture_descriptors);
         num_image_elements += Shader::NumDescriptors(info->image_descriptors);
-        num_descriptor_entries += NumDescriptorEntries(*info);
     }
     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] {
@@ -474,7 +473,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     buffer_cache.UpdateGraphicsBuffers(is_indexed);
     buffer_cache.BindHostGeometryBuffers(is_indexed);
 
-    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);
+    guest_descriptor_queue.Acquire();
 
     RescalingPushConstant rescaling;
     RenderAreaPushConstant render_area;

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -159,7 +159,6 @@ private:
     std::array<Shader::Info, NUM_STAGES> stage_infos;
     std::array<u32, 5> enabled_uniform_buffer_masks{};
     VideoCommon::UniformBufferSizes uniform_buffer_sizes{};
-    u32 num_descriptor_entries{};
     size_t num_image_elements{};
     u32 num_textures{};
     bool fragment_has_color0_output{};

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -62,7 +62,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-constexpr u32 CACHE_VERSION = 17;
+constexpr u32 CACHE_VERSION = 18;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
@@ -439,21 +439,10 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
-        .max_user_clip_distances = device.GetMaxUserClipDistances()
+        .max_user_clip_distances = device.GetMaxUserClipDistances(),
     };
 
     host_info = Shader::HostTranslateInfo{
-        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
-        .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
-        .max_per_stage_resources = device.GetMaxPerStageResources(),
-        .max_descriptor_set_samplers = device.GetMaxDescriptorSetSamplers(),
-        .max_descriptor_set_uniform_buffers = device.GetMaxDescriptorSetUniformBuffers(),
-        .max_descriptor_set_uniform_buffers_dynamic = device.GetMaxDescriptorSetUniformBuffersDynamic(),
-        .max_descriptor_set_storage_buffers = device.GetMaxDescriptorSetStorageBuffers(),
-        .max_descriptor_set_storage_buffers_dynamic = device.GetMaxDescriptorSetStorageBuffersDynamic(),
-        .max_descriptor_set_sampled_images = device.GetMaxDescriptorSetSampledImages(),
-        .max_descriptor_set_storage_images = device.GetMaxDescriptorSetStorageImages(),
-        .max_descriptor_set_input_attachements = device.GetMaxDescriptorSetInputAttachments(),
         .support_float64 = device.IsFloat64Supported(),
         .support_float16 = device.IsFloat16Supported(),
         .support_int64 = device.IsShaderInt64Supported(),
@@ -462,10 +451,13 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                                 driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
+        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
+        .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
+        .max_per_stage_resources = device.GetMaxPerStageResources(),
+        .max_descriptor_set_sampled_images = device.GetMaxDescriptorSetSampledImages(),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
     };
-    host_info.ApplyDescriptorLimitPolicy();
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {
         LOG_WARNING(Render_Vulkan, "maxVertexInputAttributes is too low: {} < {}",
@@ -500,14 +492,10 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
-        device.SupportsDynamicState3DepthClampEnable();
+    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
     dynamic_features.has_dynamic_state3_logic_op_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LogicOpEnable();
     dynamic_features.has_dynamic_state3_line_stipple_enable =
-        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LineStippleEnable();
 
     // VIDS: Independent toggle (not affected by dyna_state levels)

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -218,7 +218,8 @@ public:
         }
         PauseCounter();
         const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
             pending_sync.clear();
             sync_values_stash.clear();
             return;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -203,7 +203,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
     : gpu{gpu_}, device_memory{device_memory_}, device{device_},
       memory_allocator{memory_allocator_}, state_tracker{state_tracker_}, scheduler{scheduler_},
       staging_pool(device, memory_allocator, scheduler), descriptor_pool(device, scheduler),
-      guest_descriptor_queue(device), compute_pass_descriptor_queue(device),
+      guest_descriptor_queue(device, scheduler), compute_pass_descriptor_queue(device, scheduler),
       blit_image(device, scheduler, state_tracker, descriptor_pool), render_pass_cache(device),
       texture_cache_runtime{
           device,     scheduler,         memory_allocator, staging_pool,

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -155,14 +155,15 @@ void Scheduler::WaitWorker() {
 }
 
 void Scheduler::DispatchWork() {
-    if (chunk && !chunk->Empty()) {
-        {
-            std::scoped_lock ql{queue_mutex};
-            work_queue.push(std::move(chunk));
-        }
-        event_cv.notify_all();
-        AcquireNewChunk();
+    if (chunk->Empty()) {
+        return;
     }
+    {
+        std::scoped_lock ql{queue_mutex};
+        work_queue.push(std::move(chunk));
+    }
+    event_cv.notify_all();
+    AcquireNewChunk();
 }
 
 void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -909,6 +909,40 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
         bl3d_unswizzle_pass.emplace(device, scheduler, descriptor_pool,
                                    staging_buffer_pool, compute_pass_descriptor_queue);
     }
+
+    // --- Create swizzle table buffer ---
+    {
+        auto table = Tegra::Texture::MakeSwizzleTable();
+
+        swizzle_table_size = static_cast<VkDeviceSize>(table.size() * sizeof(table[0]));
+
+        auto staging = staging_buffer_pool.Request(swizzle_table_size, MemoryUsage::Upload);
+        std::memcpy(staging.mapped_span.data(), table.data(), static_cast<size_t>(swizzle_table_size));
+
+        VkBufferCreateInfo ci{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+            .size = swizzle_table_size,
+            .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
+                     VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+                     VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        };
+        swizzle_table_buffer = memory_allocator.CreateBuffer(ci, MemoryUsage::DeviceLocal);
+
+        scheduler.RequestOutsideRenderPassOperationContext();
+        scheduler.Record([staging_buf = staging.buffer,
+                          dst_buf = *swizzle_table_buffer,
+                          size = swizzle_table_size,
+                          src_off = staging.offset](vk::CommandBuffer cmdbuf) {
+
+            const VkBufferCopy region{
+                .srcOffset = src_off,
+                .dstOffset = 0,
+                .size = size,
+            };
+            cmdbuf.CopyBuffer(staging_buf, dst_buf, region);
+        });
+    }
 }
 
 void TextureCacheRuntime::Finish() {
@@ -2450,13 +2484,18 @@ void TextureCacheRuntime::AccelerateImageUpload(
 
     if (!Settings::values.gpu_unswizzle_enabled.GetValue() || !bl3d_unswizzle_pass) {
         if (IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D) {
-            ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
+            ASSERT_MSG(false, "GPU unswizzle is disabled for BCn 3D texture");
         }
         ASSERT(false);
         return;
     }
 
-    if (bl3d_unswizzle_pass && IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D && image.info.resources.levels == 1 && image.info.resources.layers == 1) {
+    if (bl3d_unswizzle_pass &&
+        IsPixelFormatBCn(image.info.format) &&
+        image.info.type == ImageType::e3D &&
+        image.info.resources.levels == 1 &&
+        image.info.resources.layers == 1) {
+
         return bl3d_unswizzle_pass->Unswizzle(image, map, swizzles, z_start, z_count);
     }
 

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -130,6 +130,9 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
 
     std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
+    vk::Buffer swizzle_table_buffer;
+    VkDeviceSize swizzle_table_size = 0;
+
     std::optional<MSAACopyPass> msaa_copy_pass;
     const Settings::ResolutionScalingInfo& resolution;
     std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;

src/video_core/renderer_vulkan/vk_update_descriptor.cpp

@@ -7,7 +7,6 @@
 #include <variant>
 #include <boost/container/static_vector.hpp>
 
-#include "common/assert.h"
 #include "common/logging.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
@@ -16,9 +15,8 @@
 
 namespace Vulkan {
 
-UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_)
-    : device{device_}
-{
+UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_)
+    : device{device_}, scheduler{scheduler_} {
     payload_start = payload.data();
     payload_cursor = payload.data();
 }
@@ -33,15 +31,13 @@ void UpdateDescriptorQueue::TickFrame() {
     payload_cursor = payload_start;
 }
 
-void UpdateDescriptorQueue::Acquire(Scheduler& scheduler, size_t required_entries) {
-    static constexpr size_t DEFAULT_REQUIRED_ENTRIES = 0x400;
-    const size_t reserve = required_entries > 0 ? required_entries : DEFAULT_REQUIRED_ENTRIES;
-    ASSERT_MSG(reserve < FRAME_PAYLOAD_SIZE, "Descriptor reservation {} >= frame capacity {}",
-               reserve, FRAME_PAYLOAD_SIZE);
-    const size_t used = static_cast<size_t>(std::distance(payload_start, payload_cursor));
-    if (used + reserve >= FRAME_PAYLOAD_SIZE) {
-        LOG_WARNING(Render_Vulkan, "Payload overflow (used={}, reserve={}, capacity={})",
-                    used, reserve, FRAME_PAYLOAD_SIZE);
+void UpdateDescriptorQueue::Acquire() {
+    // Minimum number of entries required.
+    // This is the maximum number of entries a single draw call might use.
+    static constexpr size_t MIN_ENTRIES = 0x400;
+
+    if (std::distance(payload_start, payload_cursor) + MIN_ENTRIES >= FRAME_PAYLOAD_SIZE) {
+        LOG_WARNING(Render_Vulkan, "Payload overflow, waiting for worker thread");
         scheduler.WaitWorker();
         payload_cursor = payload_start;
     }

src/video_core/renderer_vulkan/vk_update_descriptor.h

@@ -34,11 +34,12 @@ class UpdateDescriptorQueue final {
     static constexpr size_t PAYLOAD_SIZE = FRAME_PAYLOAD_SIZE * FRAMES_IN_FLIGHT;
 
 public:
-    explicit UpdateDescriptorQueue(const Device& device_);
+    explicit UpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_);
     ~UpdateDescriptorQueue();
 
     void TickFrame();
-    void Acquire(Scheduler& scheduler, size_t required_entries = 0);
+
+    void Acquire();
 
     const DescriptorUpdateEntry* UpdateData() const noexcept {
         return upload_start;
@@ -74,6 +75,8 @@ public:
 
 private:
     const Device& device;
+    Scheduler& scheduler;
+
     size_t frame_index{0};
     DescriptorUpdateEntry* payload_cursor = nullptr;
     DescriptorUpdateEntry* payload_start = nullptr;

src/video_core/shader_environment.cpp

@@ -255,7 +255,8 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
     static constexpr u64 SELF_BRANCH_A = 0xE2400FFFFF87000FULL;
     static constexpr u64 SELF_BRANCH_B = 0xE2400FFFFF07000FULL;
 
-    static constexpr u64 EXIT_VALUE = 0xE30000000007000FULL;
+    static constexpr u64 MESA_EXIT_MASK = 0xFFF00000000F001FULL;
+    static constexpr u64 MESA_EXIT_VALUE = (0xE30ULL << 52) | (0x7ULL << 16) | 0xFULL;
 
     code.resize(MAXIMUM_SIZE / INST_SIZE);
 
@@ -270,7 +271,7 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
             if (inst == SELF_BRANCH_A || inst == SELF_BRANCH_B) {
                 return offset + index;
             }
-            if (!is_proprietary_driver && inst == EXIT_VALUE) {
+            if ((inst & MESA_EXIT_MASK) == MESA_EXIT_VALUE) {
                 return offset + index + INST_SIZE;
             }
         }

src/video_core/texture_cache/texture_cache.h

@@ -77,10 +77,35 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
         minimum_memory = 0;
     }
 
-    if (Settings::values.gpu_unswizzle_enabled.GetValue()) {
-        gpu_unswizzle_maxsize = (1 << u32(Settings::values.gpu_unswizzle_texture_size.GetValue())) * 1_MiB;
-        swizzle_chunk_size = (1 << u32(Settings::values.gpu_unswizzle_stream_size.GetValue())) * 1_MiB;
-        swizzle_slices_per_batch = 1 << u32(Settings::values.gpu_unswizzle_chunk_size.GetValue());
+    const bool gpu_unswizzle_enabled = Settings::values.gpu_unswizzle_enabled.GetValue();
+
+    if (gpu_unswizzle_enabled) {
+        switch (Settings::values.gpu_unswizzle_texture_size.GetValue()) {
+            case Settings::GpuUnswizzleSize::VerySmall:    gpu_unswizzle_maxsize = 16_MiB; break;
+            case Settings::GpuUnswizzleSize::Small:        gpu_unswizzle_maxsize = 32_MiB; break;
+            case Settings::GpuUnswizzleSize::Normal:       gpu_unswizzle_maxsize = 128_MiB; break;
+            case Settings::GpuUnswizzleSize::Large:        gpu_unswizzle_maxsize = 256_MiB; break;
+            case Settings::GpuUnswizzleSize::VeryLarge:    gpu_unswizzle_maxsize = 512_MiB; break;
+            default:                                       gpu_unswizzle_maxsize = 128_MiB; break;
+        }
+
+        switch (Settings::values.gpu_unswizzle_stream_size.GetValue()) {
+            case Settings::GpuUnswizzle::VeryLow: swizzle_chunk_size = 4_MiB; break;
+            case Settings::GpuUnswizzle::Low:     swizzle_chunk_size = 8_MiB; break;
+            case Settings::GpuUnswizzle::Normal:  swizzle_chunk_size = 16_MiB; break;
+            case Settings::GpuUnswizzle::Medium:  swizzle_chunk_size = 32_MiB; break;
+            case Settings::GpuUnswizzle::High:    swizzle_chunk_size = 64_MiB; break;
+            default:                              swizzle_chunk_size = 16_MiB;
+        }
+
+        switch (Settings::values.gpu_unswizzle_chunk_size.GetValue()) {
+            case Settings::GpuUnswizzleChunk::VeryLow: swizzle_slices_per_batch = 32; break;
+            case Settings::GpuUnswizzleChunk::Low:     swizzle_slices_per_batch = 64; break;
+            case Settings::GpuUnswizzleChunk::Normal:  swizzle_slices_per_batch = 128; break;
+            case Settings::GpuUnswizzleChunk::Medium:  swizzle_slices_per_batch = 256; break;
+            case Settings::GpuUnswizzleChunk::High:    swizzle_slices_per_batch = 512; break;
+            default:                                   swizzle_slices_per_batch = 128;
+        }
     } else {
         gpu_unswizzle_maxsize = 0;
         swizzle_chunk_size = 0;

src/video_core/textures/decoders.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 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
 
@@ -26,6 +23,24 @@ constexpr u32 GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_
 constexpr u32 SWIZZLE_X_BITS = 0b100101111;
 constexpr u32 SWIZZLE_Y_BITS = 0b011010000;
 
+using SwizzleTable = std::array<std::array<u32, GOB_SIZE_X>, GOB_SIZE_Y>;
+
+/**
+ * This table represents the internal swizzle of a gob, in format 16 bytes x 2 sector packing.
+ * Calculates the offset of an (x, y) position within a swizzled texture.
+ * Taken from the Tegra X1 Technical Reference Manual. pages 1187-1188
+ */
+constexpr SwizzleTable MakeSwizzleTable() {
+    SwizzleTable table{};
+    for (u32 y = 0; y < table.size(); ++y) {
+        for (u32 x = 0; x < table[0].size(); ++x) {
+            table[y][x] = ((x % 64) / 32) * 256 + ((y % 8) / 2) * 64 + ((x % 32) / 16) * 32 +
+                          (y % 2) * 16 + (x % 16);
+        }
+    }
+    return table;
+}
+
 /// Unswizzles a block linear texture into linear memory.
 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,

src/video_core/vulkan_common/vulkan_device.h

@@ -321,23 +321,32 @@ public:
         return properties.properties.limits.maxPushConstantsSize;
     }
 
-#define FN_MAX_LIMIT_LIST \
-    FN_MAX_LIMIT_ELEM(ComputeSharedMemorySize) \
-    FN_MAX_LIMIT_ELEM(PerStageDescriptorSampledImages) \
-    FN_MAX_LIMIT_ELEM(PerStageResources) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetSamplers) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffers) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffersDynamic) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetStorageBuffers) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetStorageBuffersDynamic) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetSampledImages) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetStorageImages) \
-    FN_MAX_LIMIT_ELEM(DescriptorSetInputAttachments)
-#define FN_MAX_LIMIT_ELEM(name) \
-    u32 GetMax##name() const { return properties.properties.limits.max##name; }
-FN_MAX_LIMIT_LIST
-#undef FN_MAX_LIMIT_ELEM
-#undef FN_MAX_LIMIT_LIST
+    /// Returns the maximum size for shared memory.
+    u32 GetMaxComputeSharedMemorySize() const {
+        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;
+    }
+
+    u32 GetMaxPerStageDescriptorSampledImages() const {
+        return properties.properties.limits.maxPerStageDescriptorSampledImages;
+    }
+
+    u32 GetMaxPerStageResources() const {
+        return properties.properties.limits.maxPerStageResources;
+    }
+
+    u32 GetMaxDescriptorSetSampledImages() const {
+        return properties.properties.limits.maxDescriptorSetSampledImages;
+    }
 
     /// Returns float control properties of the device.
     const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {

tools/maxwell-ir/main.cpp

@@ -44,7 +44,6 @@ int IrShaderRecompilerImpl(int argc, char *argv[]) {
     host_info.support_geometry_shader_passthrough = true;
     host_info.support_conditional_barrier = true;
     host_info.min_ssbo_alignment = 0;
-    host_info.ApplyDescriptorLimitPolicy();
     auto program = Shader::Maxwell::TranslateProgram(inst_pool, block_pool, env, cfg, host_info);
     auto const dumped_ir = Shader::IR::DumpProgram(program);
     std::printf("%s\n", dumped_ir.c_str());