NO WONDER WHY IT CRASHES ON ANDROID?? sob

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

cpmfile.json

@@ -340,10 +340,10 @@
         "version": "vulkan-sdk-%NUMERIC_VERSION%"
     },
     "xbyak": {
-        "hash": "e0aa0a603dd3ac1a39d82213df1e73c042831aec2d6b2fe382c899651eaae4ed7e8aeb6be9c41ea0097087c9d091961ab18f313cd6a9e10d621715ffd49bfe36",
+        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
         "package": "xbyak",
         "repo": "herumi/xbyak",
-        "version": "v7.40.1"
+        "version": "v7.35.2"
     },
     "zlib": {
         "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",

dist/qt_themes/default/style.qss

@@ -509,8 +509,6 @@ QWidget#contentRichDialog QLabel#label_title_rich {
 }
 
 QWidget#contentDialog QLabel#label_dialog {
-    background: #2E2E2E;
-
     padding: 20px 65px;
 }
 

docs/Settings.md

@@ -43,7 +43,6 @@ This guide will walk you through adding a new boolean toggle setting to Eden's c
 Firstly add your desired toggle:
 
 Example: `src/common/setting.h`
-
 ```cpp
 SwitchableSetting<bool> your_setting_name{linkage, false, "your_setting_name", Category::RendererExtensions};
 ```
@@ -68,7 +67,6 @@ Common Categories:
 Add the toggle to the Qt UI, where you wish for it to appear and place it there.
 
 Example: `src/qt_common/config/shared_translation.cpp`
-
 ```cpp
 INSERT(Settings,
        your_setting_name,
@@ -93,7 +91,6 @@ INSERT(Settings,
 Add where it should be in the settings.
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt`
-
 ```kts
 RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 ```
@@ -109,7 +106,6 @@ RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 Add the toggle to the Kotlin (Android) UI
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt`
-
 ```kts
 put(
     SwitchSetting(
@@ -127,7 +123,6 @@ put(
 Add your setting within the right category.
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt`
-
 ```kts
 add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 ```
@@ -142,7 +137,6 @@ add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 Add your setting and description in the appropriate place.
 
 Example: `src/android/app/src/main/res/values/strings.xml`
-
 ```xml
 <string name="your_setting_name">Your Setting Display Name</string>
 <string name="your_setting_name_description">Detailed description of what this setting does. Explain any caveats, requirements, or warnings here.</string>
@@ -156,7 +150,6 @@ Now the UI part is done find a place in the code for the toggle,
 And use it to your heart's desire!
 
 Example:
-
 ```cpp
 const bool your_value = Settings::values.your_setting_name.GetValue();
 
@@ -203,31 +196,25 @@ Common advantages recap:
 
 #### Accessing Debug Knobs (dev side)
 
-Use the `Settings::GetDebugKnobAt(u8 i)` function to check if a specific bit is set:
+Use the `Settings::getDebugKnobAt(u8 i)` function to check if a specific bit is set:
 
 ```cpp
 //cpp side
 #include "common/settings.h"
 
-//To use it as a general purpose uint var:
-unsigned int debug_knobs = Settings::values.debug_knobs.GetValue();
-
 // Check if bit 0 is set
-bool feature_enabled = Settings::GetDebugKnobAt(0);
+bool feature_enabled = Settings::getDebugKnobAt(0);
 
 // Check if bit 15 is set
-bool another_feature = Settings::GetDebugKnobAt(15);
+bool another_feature = Settings::getDebugKnobAt(15);
 ```
 
 ```kts
 //kotlin side
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 
-//To use it as a general purpose uint var
-val debug_knobs: Int = UShortSetting.DEBUG_KNOBS.getInt()
-
 // Check if bit x is set
-bool feature_enabled = Settings.GetDebugKnobAt(x); //x as integer from 0 to 15
+bool feature_enabled = Settings.getDebugKnobAt(x); //x as integer from 0 to 15
 ```
 
 The function returns `true` if the specified bit (0-15) is set in the `debug_knobs` value, `false` otherwise.
@@ -260,7 +247,6 @@ There are two main confusions when talking about knobs:
 Sometimes when an user reports: knobs 1 and 2 gets better performance, dev may get confuse whether he means the knobs 1 and 2 literally, or the 1st and 2nd knobs (knobs 0 and 1).
 
 Debug knobs are **zero-based**, which means:
-
 * The first knob is the knob(0) (or knob0 henceforth), and the last one is the 15 (knob15, likewise)
 * You can talk: "knob0 is enabled/disabled", "In this video i was using only knobs 0 and 2", etc.
 
@@ -273,7 +259,6 @@ Whenever you're instructing tests or reporting results, be precise about whether
 
 ALWAYS use the word in PLURAL (knobs), without mentioning which one, to refer to the setting, aka multiple knobs at once:
 Examples:
-
 - **knobs=0**: no knobs enabled
 - **knobs=1**: knob0 enabled, others disabled
 - **knobs=2**: knob1 enabled, others disabled
@@ -285,7 +270,6 @@ Examples:
 
 Use the word in SINGULAR (knob), or in plural but referring which ones, when meaning multiple knobs at once:
 Examples:
-
 - **knob0**: knob 0 enabled, others disabled
 - **knob1**: knob 1 enabled, others disabled
 - **knobs 0 and 1**: knobs 0 and 1 enabled, others disabled
@@ -298,12 +282,12 @@ Examples:
 
 ```cpp
 void SomeFunction() {
-    if (Settings::GetDebugKnobAt(0)) {
+    if (Settings::getDebugKnobAt(0)) {
         LOG_DEBUG(Common, "Debug feature 0 is enabled");
         // Additional debug code here
     }
-  
-    if (Settings::GetDebugKnobAt(1)) {
+    
+    if (Settings::getDebugKnobAt(1)) {
         LOG_DEBUG(Common, "Debug feature 1 is enabled");
         // Different debug behavior
     }
@@ -315,7 +299,7 @@ void SomeFunction() {
 ```cpp
 bool UseOptimizedPath() {
     // Skip optimization if debug bit 2 is set for testing
-    return !Settings::GetDebugKnobAt(2);
+    return !Settings::getDebugKnobAt(2);
 }
 ```
 
@@ -324,13 +308,13 @@ bool UseOptimizedPath() {
 ```cpp
 void ExperimentalFeature() {
     static constexpr u8 EXPERIMENTAL_FEATURE_BIT = 3;
-  
-    if (!Settings::GetDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
+    
+    if (!Settings::getDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
         // Fallback to stable implementation
         StableImplementation();
         return;
     }
-  
+    
     // Experimental implementation
     ExperimentalImplementation();
 }

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

@@ -220,7 +220,7 @@ object NativeLibrary {
 
     external fun refreshThreadPolicies()
 
-    external fun GetDebugKnobAt(index: Int): Boolean
+    external fun getDebugKnobAt(index: Int): Boolean
 
     /**
      * Set the current speed limit to the configured turbo speed.

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

@@ -35,8 +35,8 @@ object Settings {
     fun getPlayerString(player: Int): String =
         YuzuApplication.appContext.getString(R.string.preferences_player, player)
 
-    fun GetDebugKnobAt(index: Int): Boolean {
-        return org.yuzu.yuzu_emu.NativeLibrary.GetDebugKnobAt(index)
+    fun getDebugKnobAt(index: Int): Boolean {
+        return org.yuzu.yuzu_emu.NativeLibrary.getDebugKnobAt(index)
     }
 
     const val PREF_FIRST_APP_LAUNCH = "FirstApplicationLaunch"

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

@@ -11,7 +11,8 @@ import org.yuzu.yuzu_emu.utils.NativeConfig
 enum class ShortSetting(override val key: String) : AbstractShortSetting {
     RENDERER_SPEED_LIMIT("speed_limit"),
     RENDERER_TURBO_SPEED_LIMIT("turbo_speed_limit"),
-    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit")
+    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit"),
+    DEBUG_KNOBS("debug_knobs")
     ;
 
     override fun getShort(needsGlobal: Boolean): Short = NativeConfig.getShort(key, needsGlobal)
@@ -28,4 +29,4 @@ enum class ShortSetting(override val key: String) : AbstractShortSetting {
     override fun getValueAsString(needsGlobal: Boolean): String = getShort(needsGlobal).toString()
 
     override fun reset() = NativeConfig.setShort(key, defaultValue)
-}
+}

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

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package org.yuzu.yuzu_emu.features.settings.model
-
-import org.yuzu.yuzu_emu.utils.NativeConfig
-
-enum class UShortSetting(override val key: String) : AbstractIntSetting {
-    DEBUG_KNOBS("debug_knobs")
-    ;
-
-    override fun getInt(needsGlobal: Boolean): Int =
-        NativeConfig.getUnsignedShort(key, needsGlobal)
-
-    override fun setInt(value: Int) {
-        if (NativeConfig.isPerGameConfigLoaded()) {
-            global = false
-        }
-        NativeConfig.setUnsignedShort(key, value)
-    }
-
-    override val defaultValue: Int by lazy { NativeConfig.getDefaultToString(key).toInt() }
-
-    override fun getValueAsString(needsGlobal: Boolean): String = getInt(needsGlobal).toString()
-
-    override fun reset() = NativeConfig.setUnsignedShort(key, defaultValue)
-}

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

@@ -20,7 +20,6 @@ import org.yuzu.yuzu_emu.features.settings.model.IntSetting
 import org.yuzu.yuzu_emu.features.settings.model.LongSetting
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
-import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.network.NetDataValidators
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
 import org.yuzu.yuzu_emu.utils.NativeConfig
@@ -1035,7 +1034,7 @@ abstract class SettingsItem(
             )
             put(
                 SpinBoxSetting(
-                    UShortSetting.DEBUG_KNOBS,
+                    ShortSetting.DEBUG_KNOBS,
                     titleId = R.string.debug_knobs,
                     descriptionId = R.string.debug_knobs_description,
                     valueHint = R.string.debug_knobs_hint,

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

@@ -25,7 +25,6 @@ import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.Settings.MenuTag
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
-import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.view.*
 import org.yuzu.yuzu_emu.utils.InputHandler
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
@@ -1327,7 +1326,7 @@ class SettingsFragmentPresenter(
 
             add(HeaderSetting(R.string.general))
 
-            add(UShortSetting.DEBUG_KNOBS.key)
+            add(ShortSetting.DEBUG_KNOBS.key)
             add(StringSetting.PROGRAM_ARGS.key)
 
             if (!NativeConfig.isPerGameConfigLoaded()) {

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/GamesFragment.kt

@@ -47,6 +47,7 @@ import info.debatty.java.stringsimilarity.Jaccard
 import info.debatty.java.stringsimilarity.JaroWinkler
 import java.util.Locale
 import androidx.core.content.edit
+import androidx.core.view.doOnNextLayout
 
 class GamesFragment : Fragment() {
     private var _binding: FragmentGamesBinding? = null
@@ -58,6 +59,7 @@ class GamesFragment : Fragment() {
     private var originalHeaderLeftMargin: Int? = null
 
     private var lastViewType: Int = GameAdapter.VIEW_TYPE_GRID
+    private var fallbackBottomInset: Int = 0
     private var pendingPostReloadListSettle = false
     private var pendingPostReloadListSettleGeneration = 0
     private var gameListSubmitGeneration = 0
@@ -225,7 +227,12 @@ class GamesFragment : Fragment() {
                 }
                 else -> throw IllegalArgumentException("Invalid view type: $savedViewType")
             }
-            if (savedViewType != GameAdapter.VIEW_TYPE_CAROUSEL) {
+            if (savedViewType == GameAdapter.VIEW_TYPE_CAROUSEL) {
+                (binding.gridGames as? View)?.let { it -> ViewCompat.requestApplyInsets(it)}
+                doOnNextLayout { //Carousel: important to avoid overlap issues
+                    (this as? CarouselRecyclerView)?.notifyLaidOut(fallbackBottomInset)
+                }
+            } else {
                 (this as? CarouselRecyclerView)?.setupCarousel(false)
             }
             adapter = gameAdapter
@@ -583,6 +590,11 @@ class GamesFragment : Fragment() {
                 qlaunchButton.layoutParams = mlpQLaunch
             }
 
+            val navInsets = windowInsets.getInsets(WindowInsetsCompat.Type.navigationBars())
+            val gestureInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemGestures())
+            val bottomInset = maxOf(navInsets.bottom, gestureInsets.bottom, cutoutInsets.bottom)
+            fallbackBottomInset = bottomInset
+            (binding.gridGames as? CarouselRecyclerView)?.notifyInsetsReady(bottomInset)
             windowInsets
         }
 }

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

@@ -80,12 +80,6 @@ object NativeConfig {
     @Synchronized
     external fun setShort(key: String, value: Short)
 
-    @Synchronized
-    external fun getUnsignedShort(key: String, needsGlobal: Boolean): Int
-
-    @Synchronized
-    external fun setUnsignedShort(key: String, value: Int)
-
     @Synchronized
     external fun getInt(key: String, needsGlobal: Boolean): Int
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/views/CarouselRecyclerView.kt

@@ -12,16 +12,13 @@ import androidx.recyclerview.widget.PagerSnapHelper
 import androidx.recyclerview.widget.RecyclerView
 import kotlin.math.abs
 import kotlin.math.cos
-import kotlin.math.pow
 import kotlin.math.sin
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.adapters.GameAdapter
 import androidx.core.view.doOnNextLayout
-import androidx.core.view.ViewCompat
 import org.yuzu.yuzu_emu.YuzuApplication
 import androidx.preference.PreferenceManager
 import androidx.core.view.WindowInsetsCompat
-import org.yuzu.yuzu_emu.utils.FullscreenHelper
 /**
  * CarouselRecyclerView encapsulates all carousel content for the games UI.
  * It manages overlapping cards, center snapping, custom drawing order,
@@ -35,9 +32,7 @@ class CarouselRecyclerView @JvmOverloads constructor(
 
     private var overlapFactor: Float = 0f
     private var overlapPx: Int = 0
-    private var bottomInset: Int = 0
-    private var latestWindowInsets: WindowInsetsCompat? = null
-    private var cardGeometryInitialized: Boolean = false
+    private var bottomInset: Int = -1
     private var overlapDecoration: OverlappingDecoration? = null
     private var pagerSnapHelper: PagerSnapHelper? = null
     private var scalingScrollListener: OnScrollListener? = null
@@ -96,38 +91,6 @@ class CarouselRecyclerView @JvmOverloads constructor(
 
     init {
         setChildrenDrawingOrderEnabled(true)
-        ViewCompat.setOnApplyWindowInsetsListener(this) { _, insets ->
-            latestWindowInsets = insets
-            updateCardGeometry()
-            applyCarouselPadding()
-            insets
-        }
-    }
-
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        ViewCompat.requestApplyInsets(this)
-    }
-
-    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-        super.onSizeChanged(w, h, oldw, oldh)
-        if (w != oldw || h != oldh) {
-            updateCardGeometry()
-            applyCarouselPadding()
-        }
-    }
-
-    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-        super.onLayout(changed, left, top, right, bottom)
-        if (isCarouselMode) updateChildScalesAndAlpha()
-    }
-
-    override fun onWindowFocusChanged(hasFocus: Boolean) {
-        super.onWindowFocusChanged(hasFocus)
-        if (hasFocus) {
-            ViewCompat.requestApplyInsets(this)
-            post { updateCardGeometry() }
-        }
     }
 
     override fun setAdapter(adapter: Adapter<*>?) {
@@ -140,8 +103,6 @@ class CarouselRecyclerView @JvmOverloads constructor(
         super.setAdapter(adapter)
 
         (adapter as? GameAdapter)?.registerAdapterDataObserver(carouselAdapterObserver)
-        updateCardGeometry()
-        applyCarouselPadding()
     }
 
     private fun calculateCenter(width: Int, paddingStart: Int, paddingEnd: Int): Int {
@@ -292,71 +253,40 @@ class CarouselRecyclerView @JvmOverloads constructor(
         }
     }
 
-    private fun resolveBottomInset(windowInsets: WindowInsetsCompat): Int {
-        val navigationBottom = if (FullscreenHelper.isFullscreenEnabled(context)) {
-            0
-        } else {
-            windowInsets.getInsetsIgnoringVisibility(WindowInsetsCompat.Type.navigationBars()).bottom
+    fun notifyInsetsReady(newBottomInset: Int) {
+        if (bottomInset != newBottomInset) {
+            bottomInset = newBottomInset
+        }
+
+        if (isCarouselMode) {
+            setupCarousel(true)
+        } else {
+            setupCarousel(false)
         }
-        val gestureInsets = windowInsets.getInsetsIgnoringVisibility(
-            WindowInsetsCompat.Type.systemGestures()
-        )
-        val cutoutInsets = windowInsets.getInsetsIgnoringVisibility(
-            WindowInsetsCompat.Type.displayCutout()
-        )
-        return maxOf(navigationBottom, gestureInsets.bottom, cutoutInsets.bottom)
     }
 
-    private fun updateCardGeometry() {
-        if (!isCarouselMode || height <= 0) return
+    fun notifyLaidOut(fallBackBottomInset: Int) {
+        if (bottomInset < 0) bottomInset = fallBackBottomInset
+        var gameAdapter = adapter as? GameAdapter ?: return
+        var newCardSize = cardSize(bottomInset)
+        if (gameAdapter.cardSize != newCardSize) {
+            gameAdapter.setCardSize(newCardSize)
+        }
 
-        val gameAdapter = adapter as? GameAdapter ?: return
-        val windowInsets = latestWindowInsets ?: ViewCompat.getRootWindowInsets(this) ?: return
+        if (isCarouselMode) {
+            setupCarousel(true)
+        }
+    }
 
-        if (cardGeometryInitialized && !hasWindowFocus()) return
-
-        val newBottomInset = resolveBottomInset(windowInsets).coerceIn(0, height)
+    fun cardSize(bottomInset: Int): Int {
         val internalFactor = resources.getFraction(R.fraction.carousel_card_size_factor, 1, 1)
         val userFactor = preferences.getFloat(CAROUSEL_CARD_SIZE_FACTOR, internalFactor).coerceIn(
             0f,
             1f
         )
-        val screenWidth = resources.displayMetrics.widthPixels.toFloat()
-        val screenHeight = resources.displayMetrics.heightPixels.toFloat()
-        val aspectFactor = ((screenWidth / screenHeight) / (20f / 9f))
-            .pow(0.75f)
-            .coerceIn(0.5f, 1f)
-        val newCardSize = minOf(
-            (height * userFactor).toInt(),
-            height - newBottomInset,
-            (height * aspectFactor).toInt()
-        )
-        if (newCardSize <= 0) return
-        val insetChanged = bottomInset != newBottomInset
-        val cardSizeChanged = gameAdapter.cardSize != newCardSize
-
-        bottomInset = newBottomInset
-        cardGeometryInitialized = true
-
-        if (cardSizeChanged) gameAdapter.setCardSize(newCardSize)
-        if (insetChanged || cardSizeChanged) setupCarousel(true)
-    }
-
-    private fun applyCarouselPadding() {
-        if (!isCarouselMode) return
-
-        val gameAdapter = adapter as? GameAdapter ?: return
-        val cardSize = gameAdapter.cardSize
-        if (cardSize <= 0 || bottomInset < 0) return
-
-        val topPadding = ((height - bottomInset - cardSize) / 2).coerceAtLeast(0)
-        val sidePadding = (width - cardSize) / 2
-        if (paddingLeft != sidePadding || paddingTop != topPadding ||
-            paddingRight != sidePadding || paddingBottom != 0
-        ) {
-            setPadding(sidePadding, topPadding, sidePadding, 0)
-        }
-        clipToPadding = false
+        val scaledHeight = height * userFactor
+        val availableHeight = height - bottomInset
+        return minOf(scaledHeight.toInt(), availableHeight.toInt())
     }
 
     fun setupCarousel(enabled: Boolean) {
@@ -385,6 +315,9 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 internalFlingMultiplier
             ).coerceIn(1f, 5f)
 
+            // Detach SnapHelper during setup
+            pagerSnapHelper?.attachToRecyclerView(null)
+
             // Add overlap decoration if not present
             if (overlapDecoration == null) {
                 overlapDecoration = OverlappingDecoration(overlapPx)
@@ -402,7 +335,12 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 addOnScrollListener(scalingScrollListener!!)
             }
 
-            applyCarouselPadding()
+            if (cardSize > 0) {
+                val topPadding = ((height - bottomInset - cardSize) / 2).coerceAtLeast(0) // Center vertically
+                val sidePadding = (width - cardSize) / 2 // Center first/last card
+                setPadding(sidePadding, topPadding, sidePadding, 0)
+                clipToPadding = false
+            }
 
             if (pagerSnapHelper == null) {
                 pagerSnapHelper = CenterPagerSnapHelper()
@@ -424,7 +362,6 @@ class CarouselRecyclerView @JvmOverloads constructor(
                 }
                 savedItemAnimator = null
             }
-            cardGeometryInitialized = false
             useCustomDrawingOrder = false
             // Reset padding and fling
             setPadding(0, 0, 0, 0)

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

@@ -1300,8 +1300,8 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_refreshThreadPolicies(JNIEnv* env, jo
     Common::RefreshThreadPolicies();
 }
 
-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_GetDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
-    return static_cast<jboolean>(Settings::GetDebugKnobAt(static_cast<u8>(index)));
+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_getDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
+    return static_cast<jboolean>(Settings::getDebugKnobAt(static_cast<u8>(index)));
 }
 
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_setTurboSpeedLimit(JNIEnv *env, jobject jobj, jboolean enabled) {

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

@@ -130,25 +130,6 @@ void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setShort(JNIEnv* env, jobject ob
     setting->SetValue(value);
 }
 
-jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getUnsignedShort(JNIEnv* env, jobject obj,
-                                                                 jstring jkey,
-                                                                 jboolean needGlobal) {
-    auto setting = getSetting<u16>(env, jkey);
-    if (setting == nullptr) {
-        return -1;
-    }
-    return static_cast<jint>(setting->GetValue(static_cast<bool>(needGlobal)));
-}
-
-void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setUnsignedShort(JNIEnv* env, jobject obj,
-                                                                  jstring jkey, jint value) {
-    auto setting = getSetting<u16>(env, jkey);
-    if (setting == nullptr) {
-        return;
-    }
-    setting->SetValue(static_cast<u16>(value));
-}
-
 jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getInt(JNIEnv* env, jobject obj, jstring jkey,
                                                        jboolean needGlobal) {
     auto setting = getSetting<int>(env, jkey);

src/common/CMakeLists.txt

@@ -63,8 +63,6 @@ add_library(
     fs/path_util.cpp
     fs/path_util.h
     hash.h
-    heap_tracker.cpp
-    heap_tracker.h
     hex_util.cpp
     hex_util.h
     host_memory.cpp

src/common/heap_tracker.cpp

@@ -1,282 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <fstream>
-#include "common/heap_tracker.h"
-#include "common/logging.h"
-#include "common/assert.h"
-
-namespace Common {
-
-namespace {
-
-s64 GetMaxPermissibleResidentMapCount() {
-    // Default value.
-    s64 value = 65530;
-
-    // Try to read how many mappings we can make.
-    std::ifstream s("/proc/sys/vm/max_map_count");
-    s >> value;
-
-    // Print, for debug.
-    LOG_INFO(HW_Memory, "Current maximum map count: {}", value);
-
-    // Allow 20000 maps for other code and to account for split inaccuracy.
-    return std::max<s64>(value - 20000, 0);
-}
-
-} // namespace
-
-HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
-HeapTracker::~HeapTracker() = default;
-
-void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
-                      MemoryPermission perm, bool is_separate_heap) {
-    // When mapping other memory, map pages immediately.
-    if (!is_separate_heap) {
-        m_buffer.Map(virtual_offset, host_offset, length, perm, false);
-        return;
-    }
-
-    {
-        // We are mapping part of a separate heap.
-        std::scoped_lock lk{m_lock};
-
-        auto* const map = new SeparateHeapMap{
-            .vaddr = virtual_offset,
-            .paddr = host_offset,
-            .size = length,
-            .tick = m_tick++,
-            .perm = perm,
-            .is_resident = false,
-        };
-
-        // Insert into mappings.
-        m_map_count++;
-        m_mappings.insert(*map);
-    }
-
-    // Finally, map.
-    this->DeferredMapSeparateHeap(virtual_offset);
-}
-
-void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_heap) {
-    // If this is a separate heap...
-    if (is_separate_heap) {
-        std::scoped_lock lk{m_lock};
-
-        const SeparateHeapMap key{
-            .vaddr = virtual_offset,
-        };
-
-        // Split at the boundaries of the region we are removing.
-        this->SplitHeapMapLocked(virtual_offset);
-        this->SplitHeapMapLocked(virtual_offset + size);
-
-        // Erase all mappings in range.
-        auto it = m_mappings.find(key);
-        while (it != m_mappings.end() && it->vaddr < virtual_offset + size) {
-            // Get underlying item.
-            auto* const item = std::addressof(*it);
-
-            // If resident, erase from resident map.
-            if (item->is_resident) {
-                ASSERT(--m_resident_map_count >= 0);
-                m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
-            }
-
-            // Erase from map.
-            ASSERT(--m_map_count >= 0);
-            it = m_mappings.erase(it);
-
-            // Free the item.
-            delete item;
-        }
-    }
-
-    // Unmap pages.
-    m_buffer.Unmap(virtual_offset, size, false);
-}
-
-void HeapTracker::Protect(size_t virtual_offset, size_t size, MemoryPermission perm) {
-    // Ensure no rebuild occurs while reprotecting.
-    std::shared_lock lk{m_rebuild_lock};
-
-    // Split at the boundaries of the region we are reprotecting.
-    this->SplitHeapMap(virtual_offset, size);
-
-    // Declare tracking variables.
-    const VAddr end = virtual_offset + size;
-    VAddr cur = virtual_offset;
-
-    while (cur < end) {
-        VAddr next = cur;
-        bool should_protect = false;
-
-        {
-            std::scoped_lock lk2{m_lock};
-
-            const SeparateHeapMap key{
-                .vaddr = next,
-            };
-
-            // Try to get the next mapping corresponding to this address.
-            const auto it = m_mappings.nfind(key);
-
-            if (it == m_mappings.end()) {
-                // There are no separate heap mappings remaining.
-                next = end;
-                should_protect = true;
-            } else if (it->vaddr == cur) {
-                // We are in range.
-                // Update permission bits.
-                it->perm = perm;
-
-                // Determine next address and whether we should protect.
-                next = cur + it->size;
-                should_protect = it->is_resident;
-            } else /* if (it->vaddr > cur) */ {
-                // We weren't in range, but there is a block coming up that will be.
-                next = it->vaddr;
-                should_protect = true;
-            }
-        }
-
-        // Clamp to end.
-        next = (std::min)(next, end);
-        // Reprotect, if we need to.
-        if (should_protect) {
-            m_buffer.Protect(cur, next - cur, perm);
-        }
-
-        // Advance.
-        cur = next;
-    }
-}
-
-bool HeapTracker::DeferredMapSeparateHeap(u8* fault_address) {
-    if (m_buffer.IsInVirtualRange(fault_address)) {
-        return this->DeferredMapSeparateHeap(fault_address - m_buffer.VirtualBasePointer());
-    }
-
-    return false;
-}
-
-bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {
-    bool rebuild_required = false;
-
-    {
-        std::scoped_lock lk{m_lock};
-
-        // Check to ensure this was a non-resident separate heap mapping.
-        const auto it = this->GetNearestHeapMapLocked(virtual_offset);
-        if (it == m_mappings.end() || it->is_resident) {
-            return false;
-        }
-
-        // Update tick before possible rebuild.
-        it->tick = m_tick++;
-
-        // Check if we need to rebuild.
-        if (m_resident_map_count > m_max_resident_map_count) {
-            rebuild_required = true;
-        }
-
-        // Map the area.
-        m_buffer.Map(it->vaddr, it->paddr, it->size, it->perm, false);
-
-        // This map is now resident.
-        it->is_resident = true;
-        m_resident_map_count++;
-        m_resident_mappings.insert(*it);
-    }
-
-    if (rebuild_required) {
-        // A rebuild was required, so perform it now.
-        this->RebuildSeparateHeapAddressSpace();
-    }
-
-    return true;
-}
-
-void HeapTracker::RebuildSeparateHeapAddressSpace() {
-    std::scoped_lock lk{m_rebuild_lock, m_lock};
-
-    ASSERT(!m_resident_mappings.empty());
-
-    // Dump half of the mappings.
-    //
-    // Despite being worse in theory, this has proven to be better in practice than more
-    // regularly dumping a smaller amount, because it significantly reduces average case
-    // lock contention.
-    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
-    std::size_t const evict_count = m_resident_map_count - desired_count;
-    auto it = m_resident_mappings.begin();
-
-    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
-        // Unmark and unmap.
-        it->is_resident = false;
-        m_buffer.Unmap(it->vaddr, it->size, false);
-
-        // Advance.
-        ASSERT(--m_resident_map_count >= 0);
-        it = m_resident_mappings.erase(it);
-    }
-}
-
-void HeapTracker::SplitHeapMap(VAddr offset, size_t size) {
-    std::scoped_lock lk{m_lock};
-
-    this->SplitHeapMapLocked(offset);
-    this->SplitHeapMapLocked(offset + size);
-}
-
-void HeapTracker::SplitHeapMapLocked(VAddr offset) {
-    const auto it = this->GetNearestHeapMapLocked(offset);
-    if (it == m_mappings.end() || it->vaddr == offset) {
-        // Not contained or no split required.
-        return;
-    }
-
-    // Cache the original values.
-    auto* const left = std::addressof(*it);
-    const size_t orig_size = left->size;
-
-    // Adjust the left map.
-    const size_t left_size = offset - left->vaddr;
-    left->size = left_size;
-
-    // Create the new right map.
-    auto* const right = new SeparateHeapMap{
-        .vaddr = left->vaddr + left_size,
-        .paddr = left->paddr + left_size,
-        .size = orig_size - left_size,
-        .tick = left->tick,
-        .perm = left->perm,
-        .is_resident = left->is_resident,
-    };
-
-    // Insert the new right map.
-    m_map_count++;
-    m_mappings.insert(*right);
-
-    // If resident, also insert into resident map.
-    if (right->is_resident) {
-        m_resident_map_count++;
-        m_resident_mappings.insert(*right);
-    }
-}
-
-HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
-    const SeparateHeapMap key{
-        .vaddr = offset,
-    };
-
-    return m_mappings.find(key);
-}
-
-} // namespace Common

src/common/heap_tracker.h

@@ -1,98 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <mutex>
-#include <set>
-#include <shared_mutex>
-
-#include "common/host_memory.h"
-#include "common/intrusive_red_black_tree.h"
-
-namespace Common {
-
-struct SeparateHeapMap {
-    Common::IntrusiveRedBlackTreeNode addr_node{};
-    Common::IntrusiveRedBlackTreeNode tick_node{};
-    VAddr vaddr{};
-    PAddr paddr{};
-    size_t size{};
-    size_t tick{};
-    MemoryPermission perm{};
-    bool is_resident{};
-};
-
-struct SeparateHeapMapAddrComparator {
-    static constexpr int Compare(const SeparateHeapMap& lhs, const SeparateHeapMap& rhs) {
-        if (lhs.vaddr < rhs.vaddr) {
-            return -1;
-        } else if (lhs.vaddr <= (rhs.vaddr + rhs.size - 1)) {
-            return 0;
-        } else {
-            return 1;
-        }
-    }
-};
-
-struct SeparateHeapMapTickComparator {
-    static constexpr int Compare(const SeparateHeapMap& lhs, const SeparateHeapMap& rhs) {
-        if (lhs.tick < rhs.tick) {
-            return -1;
-        } else if (lhs.tick > rhs.tick) {
-            return 1;
-        } else {
-            return SeparateHeapMapAddrComparator::Compare(lhs, rhs);
-        }
-    }
-};
-
-class HeapTracker {
-public:
-    explicit HeapTracker(Common::HostMemory& buffer);
-    ~HeapTracker();
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perm,
-             bool is_separate_heap);
-    void Unmap(size_t virtual_offset, size_t size, bool is_separate_heap);
-    void Protect(size_t virtual_offset, size_t length, MemoryPermission perm);
-    u8* VirtualBasePointer() {
-        return m_buffer.VirtualBasePointer();
-    }
-
-    bool DeferredMapSeparateHeap(u8* fault_address);
-    bool DeferredMapSeparateHeap(size_t virtual_offset);
-
-private:
-    using AddrTreeTraits =
-        Common::IntrusiveRedBlackTreeMemberTraitsDeferredAssert<&SeparateHeapMap::addr_node>;
-    using AddrTree = AddrTreeTraits::TreeType<SeparateHeapMapAddrComparator>;
-
-    using TickTreeTraits =
-        Common::IntrusiveRedBlackTreeMemberTraitsDeferredAssert<&SeparateHeapMap::tick_node>;
-    using TickTree = TickTreeTraits::TreeType<SeparateHeapMapTickComparator>;
-
-    AddrTree m_mappings{};
-    TickTree m_resident_mappings{};
-
-private:
-    void SplitHeapMap(VAddr offset, size_t size);
-    void SplitHeapMapLocked(VAddr offset);
-
-    AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);
-
-    void RebuildSeparateHeapAddressSpace();
-
-private:
-    Common::HostMemory& m_buffer;
-    const s64 m_max_resident_map_count;
-
-    std::shared_mutex m_rebuild_lock{};
-    std::mutex m_lock{};
-    s64 m_map_count{};
-    s64 m_resident_map_count{};
-    size_t m_tick{};
-};
-
-} // namespace Common

src/common/logging.cpp

@@ -329,7 +329,7 @@ struct LogcatBackend : public Backend {
             }
         }();
         auto const df = GetDirectFormatArgs(entry);
-        __android_log_print(android_log_priority, "YuzuNative", "%s %s:%u:%s: %s", df.class_name, entry.filename, entry.line_num, entry.function, entry.message);
+        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
     }
     void Flush() noexcept override {}
 };
@@ -428,33 +428,21 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, u
         auto const flush = ::Settings::values.log_flush_line.GetValue();
         char buffer[BUFSIZ];
         auto result = fmt::vformat_to_n(buffer, sizeof(buffer) - 1, format, args);
-        Entry e{
-            .message = nullptr,
-            .message_len = 0,
-            .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),
-            .log_class = log_class,
-            .log_level = log_level,
-            .filename = TrimSourcePath(filename),
-            .function = function,
-            .line_num = line_num,
-        };
-        if (result.size <= sizeof(buffer) - 1) {
-            buffer[(std::min)(result.size, sizeof(buffer) - 1)] = '\0';
-            e.message = buffer;
-            e.message_len = (std::min)(result.size, sizeof(buffer) - 1);
-            logging_instance->ForEachBackend([=](Backend& backend) {
-                backend.Write(e);
-                if (flush) backend.Flush();
+        buffer[(std::min)(result.size, sizeof(buffer) - 1)] = '\0';
+        logging_instance->ForEachBackend([=](Backend& backend) {
+            backend.Write(Entry{
+                .message = buffer,
+                .message_len = (std::min)(result.size, sizeof(buffer) - 1),
+                .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),
+                .log_class = log_class,
+                .log_level = log_level,
+                .filename = TrimSourcePath(filename),
+                .function = function,
+                .line_num = line_num,
             });
-        } else {
-            std::string s = fmt::vformat(format, args);
-            e.message = s.c_str();
-            e.message_len = s.size();
-            logging_instance->ForEachBackend([=](Backend& backend) {
-                backend.Write(e);
-                if (flush) backend.Flush();
-            });
-        }
+            if (flush)
+                backend.Flush();
+        });
     }
 }
 } // namespace Common::Log

src/common/net/net.h

@@ -11,14 +11,14 @@
 
 namespace Common::Net {
 
-struct Asset {
+typedef struct {
     std::string name;
     std::string url;
     std::string path;
     std::string filename;
-};
+} Asset;
 
-struct Release {
+typedef struct Release {
     std::string title;
     std::string body;
     std::string tag;
@@ -39,7 +39,7 @@ struct Release {
     static std::optional<Release> FromJson(const std::string_view& json, const std::string &host, const std::string& repo);
     static std::vector<Release> ListFromJson(const nlohmann::json &json, const std::string &host, const std::string &repo);
     static std::vector<Release> ListFromJson(const std::string_view &json, const std::string &host, const std::string &repo);
-};
+} Release;
 
 // Make a request via httplib, and return the response body if applicable.
 std::optional<std::string> MakeRequest(const std::string &url, const std::string &path);

src/common/settings.cpp

@@ -126,9 +126,9 @@ void LogSettings() {
                     setting->UsingGlobal() ? '-' : 'C', TranslateCategory(category),
                     setting->GetLabel());
                 if (is_default)
-                    settings_list.push_back(fmt::format("{}: {}", name, setting->Canonicalize()));
+                    settings_list.push_back(fmt::format("{}: {}\n", name, setting->Canonicalize()));
                 else
-                    settings_list.push_front(fmt::format("{}: {}", name, setting->Canonicalize()));
+                    settings_list.push_front(fmt::format("{}: {}\n", name, setting->Canonicalize()));
             }
         }
     }
@@ -146,7 +146,7 @@ void LogSettings() {
 #undef LOG_PATH
 }
 
-bool GetDebugKnobAt(u8 i) {
+bool getDebugKnobAt(u8 i) {
     return (values.debug_knobs.GetValue() & (1 << (i & 0xF))) != 0;
 }
 

src/common/settings.h

@@ -904,7 +904,7 @@ struct Values {
                                            0,
                                            65535,
                                            "debug_knobs",
-                                           Category::System,
+                                           Category::Debugging,
                                            Specialization::Countable,
                                            true,
                                            true};
@@ -947,7 +947,7 @@ constexpr u32 MAX_FRAME_GEN_MULTIPLIER = 4;
 
 [[nodiscard]] size_t FrameGenMaxGenerations();
 
-bool GetDebugKnobAt(u8 i);
+bool getDebugKnobAt(u8 i);
 
 void UpdateGPUAccuracy();
 bool IsGPULevelHigh();

src/core/core.cpp

@@ -4,7 +4,6 @@
 #include <array>
 #include <atomic>
 #include <memory>
-#include <unordered_map>
 #include <utility>
 
 #include "game_settings.h"
@@ -249,30 +248,12 @@ struct System::Impl {
         }
     }
 
-    void NotifyNVDECChannelOpen(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        ++nvdec_active_channels[process_id];
-    }
-
-    void NotifyNVDECChannelClose(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        const auto it = nvdec_active_channels.find(process_id);
-        if (it == nvdec_active_channels.end()) {
-            return;
-        }
-        if (--it->second == 0) {
-            nvdec_active_channels.erase(it);
-        }
+    void SetNVDECActive(bool is_nvdec_active) {
+        nvdec_active = is_nvdec_active;
     }
 
     bool GetNVDECActive() {
-        std::scoped_lock lock{nvdec_active_mutex};
-        return !nvdec_active_channels.empty();
-    }
-
-    bool IsNVDECActiveForProcess(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        return nvdec_active_channels.contains(process_id);
+        return nvdec_active;
     }
 
     void InitializeDebugger(System& system, u16 port) {
@@ -524,8 +505,6 @@ struct System::Impl {
 
     mutable std::mutex suspend_guard;
     std::mutex general_channel_mutex;
-    std::mutex nvdec_active_mutex;
-    std::unordered_map<u64, u32> nvdec_active_channels;
     std::atomic_bool is_paused{};
     std::atomic_bool is_shutting_down{};
     std::atomic_bool is_powered_on{};
@@ -533,6 +512,7 @@ struct System::Impl {
     bool extended_memory_layout : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
+    bool nvdec_active : 1 = false;
 
     void EnsureGeneralChannelInitialized(System& system) {
         if (!general_channel_event) {
@@ -596,22 +576,14 @@ void System::UnstallApplication() {
     impl->UnstallApplication();
 }
 
-void System::NotifyNVDECChannelOpen(u64 process_id) {
-    impl->NotifyNVDECChannelOpen(process_id);
-}
-
-void System::NotifyNVDECChannelClose(u64 process_id) {
-    impl->NotifyNVDECChannelClose(process_id);
+void System::SetNVDECActive(bool is_nvdec_active) {
+    impl->SetNVDECActive(is_nvdec_active);
 }
 
 bool System::GetNVDECActive() {
     return impl->GetNVDECActive();
 }
 
-bool System::IsNVDECActiveForProcess(u64 process_id) {
-    return impl->IsNVDECActiveForProcess(process_id);
-}
-
 void System::InitializeDebugger() {
     impl->InitializeDebugger(*this, Settings::values.gdbstub_port.GetValue());
 }

src/core/core.h

@@ -191,10 +191,8 @@ public:
     std::unique_lock<std::mutex> StallApplication();
     void UnstallApplication();
 
-    void NotifyNVDECChannelOpen(u64 process_id);
-    void NotifyNVDECChannelClose(u64 process_id);
+    void SetNVDECActive(bool is_nvdec_active);
     [[nodiscard]] bool GetNVDECActive();
-    [[nodiscard]] bool IsNVDECActiveForProcess(u64 process_id);
 
     /**
      * Initialize the debugger.

src/core/file_sys/ips_layer.cpp

@@ -3,12 +3,10 @@
 
 #include <algorithm>
 #include <cstring>
+#include <map>
 #include <sstream>
 #include <string>
 #include <utility>
-#include <span>
-#include <cctype>
-#include <ankerl/unordered_dense.h>
 
 #include "common/hex_util.h"
 #include "common/logging.h"
@@ -24,30 +22,61 @@ enum class IPSFileType {
     Error,
 };
 
-static IPSFileType IdentifyMagic(std::span<const u8> magic) {
-    if (magic.size() >= 5) {
-        if (std::memcmp(magic.data(), "PATCH", 5) == 0)
-            return IPSFileType::IPS;
-        if (std::memcmp(magic.data(), "IPS32", 5) == 0)
-            return IPSFileType::IPS32;
+constexpr std::array<std::pair<const char*, const char*>, 11> ESCAPE_CHARACTER_MAP{{
+    {"\\a", "\a"},
+    {"\\b", "\b"},
+    {"\\f", "\f"},
+    {"\\n", "\n"},
+    {"\\r", "\r"},
+    {"\\t", "\t"},
+    {"\\v", "\v"},
+    {"\\\\", "\\"},
+    {"\\\'", "\'"},
+    {"\\\"", "\""},
+    {"\\\?", "\?"},
+}};
+
+static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
+    if (magic.size() != 5) {
+        return IPSFileType::Error;
     }
+
+    static constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
+    if (std::equal(magic.begin(), magic.end(), patch_magic.begin())) {
+        return IPSFileType::IPS;
+    }
+
+    static constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
+    if (std::equal(magic.begin(), magic.end(), ips32_magic.begin())) {
+        return IPSFileType::IPS32;
+    }
+
     return IPSFileType::Error;
 }
 
-static bool IsEOF(IPSFileType type, std::span<const u8> magic) {
-    return (type == IPSFileType::IPS && magic.size() > 3 && std::memcmp(magic.data(), "EOF", 3) == 0)
-        || (type == IPSFileType::IPS32 && magic.size() > 4 && std::memcmp(magic.data(), "EEOF", 4) == 0);
+static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
+    static constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
+    if (type == IPSFileType::IPS && std::equal(data.begin(), data.end(), eof.begin())) {
+        return true;
+    }
+
+    static constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
+    return type == IPSFileType::IPS32 && std::equal(data.begin(), data.end(), eeof.begin());
 }
 
 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
     if (in == nullptr || ips == nullptr)
         return nullptr;
 
-    auto in_data = in->ReadAllBytes();
-    auto const type = IdentifyMagic(in_data);
+    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
     if (type == IPSFileType::Error)
         return nullptr;
 
+    auto in_data = in->ReadAllBytes();
+    if (in_data.size() == 0) {
+        return nullptr;
+    }
+
     std::vector<u8> temp(type == IPSFileType::IPS ? 3 : 4);
     u64 offset = 5; // After header
     while (ips->Read(temp.data(), temp.size(), offset) == temp.size()) {
@@ -56,9 +85,12 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
             break;
         }
 
-        u32 real_offset = (type == IPSFileType::IPS32)
-            ? ((temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3])
-            : ((temp[0] << 16) | (temp[1] << 8) | temp[2]);
+        u32 real_offset{};
+        if (type == IPSFileType::IPS32)
+            real_offset = (temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3];
+        else
+            real_offset = (temp[0] << 16) | (temp[1] << 8) | temp[2];
+
         if (real_offset > in_data.size()) {
             return nullptr;
         }
@@ -81,35 +113,34 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
                 return nullptr;
 
             if (real_offset + rle_size > in_data.size())
-                rle_size = u16(in_data.size() - real_offset);
+                rle_size = static_cast<u16>(in_data.size() - real_offset);
             std::memset(in_data.data() + real_offset, *data, rle_size);
         } else { // Standard Patch
             auto read = data_size;
             if (real_offset + read > in_data.size())
-                read = u16(in_data.size() - real_offset);
+                read = static_cast<u16>(in_data.size() - real_offset);
             if (ips->Read(in_data.data() + real_offset, read, offset) != data_size)
                 return nullptr;
             offset += data_size;
         }
     }
-    if (IsEOF(type, temp)) {
-        return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(), in->GetContainingDirectory());
+
+    if (!IsEOF(type, temp)) {
+        return nullptr;
     }
-    return nullptr;
+
+    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
+                                           in->GetContainingDirectory());
 }
 
-
-struct IPSwitchRecord {
-    std::array<uint8_t, 256 - sizeof(size_t)> data;
-    size_t count;
-};
 struct IPSwitchCompiler::IPSwitchPatch {
-    ankerl::unordered_dense::map<u32, IPSwitchRecord> records;
+    std::string name;
     bool enabled;
+    std::map<u32, std::vector<u8>> records;
 };
 
 IPSwitchCompiler::IPSwitchCompiler(VirtualFile patch_text_) : patch_text(std::move(patch_text_)) {
-    Parse(patch_text->ReadAllBytes());
+    Parse();
 }
 
 IPSwitchCompiler::~IPSwitchCompiler() = default;
@@ -118,159 +149,201 @@ std::array<u8, 32> IPSwitchCompiler::GetBuildID() const {
     return nso_build_id;
 }
 
-static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
-    IPSwitchRecord r{};
-    for (auto it = sv.cbegin(); it != sv.cend(); ) {
-        if (*it == '\\' && it + 1 < sv.cend()) {
-            switch (it[1]) {
-            case 'n': r.data[r.count] = '\n'; break;
-            case 't': r.data[r.count] = '\t'; break;
-            case 'b': r.data[r.count] = '\b'; break;
-            case 'r': r.data[r.count] = '\r'; break;
-            case 'e': r.data[r.count] = '\e'; break;
-            case 'v': r.data[r.count] = '\v'; break;
-            case '?': r.data[r.count] = '\?'; break;
-            default: r.data[r.count] = it[1]; break;
-            }
-            ++r.count;
-            it += 2;
-        } else {
-            ++r.count;
-            ++it;
+bool IPSwitchCompiler::IsValid() const {
+    return valid;
+}
+
+static bool StartsWith(std::string_view base, std::string_view check) {
+    return base.size() >= check.size() && base.substr(0, check.size()) == check;
+}
+
+static std::string EscapeStringSequences(std::string in) {
+    for (const auto& seq : ESCAPE_CHARACTER_MAP) {
+        for (auto index = in.find(seq.first); index != std::string::npos;
+             index = in.find(seq.first, index)) {
+            in.replace(index, std::strlen(seq.first), seq.second);
+            index += std::strlen(seq.second);
         }
     }
-    return r;
+
+    return in;
 }
 
-[[nodiscard]] static inline std::array<u8, 32> ReadNSOBuildId(std::string_view const s) {
-    std::array<u8, 32> r{};
-    for (std::size_t i = 0; i < s.size(); ++i)
-        r[i / 2] |= u8(u8(Common::ToHexNibble(s[i])) << u8((i % 2) * 4));
-    return r;
+void IPSwitchCompiler::ParseFlag(const std::string& line) {
+    if (StartsWith(line, "@flag offset_shift ")) {
+        // Offset Shift Flag
+        offset_shift = std::strtoll(line.substr(19).c_str(), nullptr, 0);
+    } else if (StartsWith(line, "@little-endian")) {
+        // Set values to read as little endian
+        is_little_endian = true;
+    } else if (StartsWith(line, "@big-endian")) {
+        // Set values to read as big endian
+        is_little_endian = false;
+    } else if (StartsWith(line, "@flag print_values")) {
+        // Force printing of applied values
+        print_values = true;
+    }
 }
 
-void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
-    LOG_INFO(Loader, "IPSwitchCompiler: '{}'", patch_text->GetName());
-    bool is_little_endian = false;
-    s64 offset_shift = 0;
-    //bool print_values = false;
+void IPSwitchCompiler::Parse() {
+    const auto bytes = patch_text->ReadAllBytes();
+    std::stringstream s;
+    s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
 
-    auto const parse_line = [&](std::string_view const line) {
-        // Keep in mind lines have trimmed spaces (at the end & start)!
-        LOG_INFO(Loader, "<{}>", line);
-        if (line.starts_with("@stop")) {
-            return false; // Force stop
-        } else if (line.starts_with("@nsobid-")) { // NSO Build ID Specifier
-            nso_build_id = ReadNSOBuildId(line.substr(8));
-        } else if (line.starts_with("@enabled")) {
-            patches.push_back({{}, true}); //enabled patch
-        } else if (line.starts_with("@disabled")) {
-            patches.push_back({{}, false}); //disabled patch
-        } else if (line.starts_with("@flag offset_shift ")) {
-            offset_shift = std::strtoll(line.data() + 19, nullptr, 0);  // Offset Shift Flag
-        } else if (line.starts_with("@little-endian")) {
-            is_little_endian = true;  // Set values to read as little endian
-        } else if (line.starts_with("@big-endian")) {
-            is_little_endian = false;  // Set values to read as big endian
-        } else if (line.starts_with("@flag print_values")) {
-            //print_values = true; // Force printing of applied values
-        } else if (line.starts_with("@")) {
-            LOG_WARNING(Loader, "Unknown flag {}", line);
-        } else {
-            size_t offset = size_t(std::strtoul(line.data(), nullptr, 16));
-            offset += size_t(offset_shift);
-            if (auto const first_quote = line.find_first_of("\"\'"); first_quote != std::string::npos) {
-                // string replacement
-                char quote = line[first_quote];
-                auto const start = line.cbegin() + first_quote + 1;
-                auto end = start;
-                for (; end < line.cend() && *end != quote; )
-                    end += (*end == '\\') ? 2 : 1;
-                if (start <= line.cend() && end <= line.cend()) {
-                    LOG_INFO(Loader, "[S] value @ {:#08X} ", offset);
-                    patches.back().records.insert_or_assign(u32(offset), EscapeStringSequences({start, end}));
-                } else {
-                    LOG_WARNING(Loader, "invalid string");
-                }
-            } else if (auto const first_space = line.find_last_of(" /\t\r\n"); first_space != std::string::npos) {
-                IPSwitchRecord r{}; // hex replacement
-                auto const start = line.cbegin() + first_space + 1;
-                auto const end = line.cend();
-                if (start <= line.cend() && end <= line.cend()) {
-                    auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
-                    std::memcpy(r.data.data(), hs.data(), hs.size());
-                    r.count = hs.size();
-                    LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
-                    patches.back().records.insert_or_assign(u32(offset), std::move(r));
-                } else {
-                    LOG_WARNING(Loader, "invalid line");
-                }
-            } else {
-                LOG_WARNING(Loader, "unhandled line!");
-            }
-        }
-        return true; //continue
-    };
+    std::vector<std::string> lines;
+    std::string stream_line;
+    while (std::getline(s, stream_line)) {
+        // Remove a trailing \r
+        if (!stream_line.empty() && stream_line.back() == '\r')
+            stream_line.pop_back();
+        lines.push_back(std::move(stream_line));
+    }
 
-    for (auto it = bytes.begin(); it < bytes.end(); ) {
-        auto const start = it;
-        auto end = start;
-        for (; end < bytes.end() && *end != '\n' && *end != '\r'; ++end)
-            ;
-        it = end + 1; //prepare for next line
-        std::string_view const sline{
-            reinterpret_cast<const char*>(bytes.data() + std::distance(bytes.begin(), start)),
-            size_t(std::distance(start, end))
-        };
-        if (sline.size() > 0) {
-            auto p = sline.cbegin();
-            // skip space off line
-            for (; p < sline.cend() && std::isspace(*p); ++p)
-                ;
-            // now make a nominal preprocessed line: remove comments
-            char quote = '\0';
-            auto const sline_start = p;
-            for (; p < sline.cend(); ) {
-                if ((!quote && p + 1 < sline.cend() && p[0] == '/' && p[1] == '/')
-                || (!quote && p[0] == '#')) {
-                    break;
-                } else if (p[0] == '\"' || p[0] == '\'') {
-                    quote = (p[0] == quote) ? '\0' : p[0];
-                    ++p;
-                } else if (p + 1 < sline.cend() && p[0] == '\\') {
-                    p += 2;
-                } else {
-                    ++p;
-                }
-            }
-            // now we have the preprocessed string ;)
-            std::string_view pp_str(sline_start, p);
-            if (pp_str.size() > 0 && !parse_line(pp_str)) {
+    for (std::size_t i = 0; i < lines.size(); ++i) {
+        auto line = lines[i];
+
+        // Remove midline comments
+        std::size_t comment_index = std::string::npos;
+        bool within_string = false;
+        for (std::size_t k = 0; k < line.size(); ++k) {
+            if (line[k] == '\"' && (k > 0 && line[k - 1] != '\\')) {
+                within_string = !within_string;
+            } else if (line[k] == '\\' && (k < line.size() - 1 && line[k + 1] == '\\')) {
+                comment_index = k;
                 break;
             }
         }
+
+        if (!StartsWith(line, "//") && comment_index != std::string::npos) {
+            last_comment = line.substr(comment_index + 2);
+            line = line.substr(0, comment_index);
+        }
+
+        if (StartsWith(line, "@stop")) {
+            // Force stop
+            break;
+        } else if (StartsWith(line, "@nsobid-")) {
+            // NSO Build ID Specifier
+            const auto raw_build_id = fmt::format("{:0<64}", line.substr(8));
+            nso_build_id = Common::HexStringToArray<0x20>(raw_build_id);
+        } else if (StartsWith(line, "#")) {
+            // Mandatory Comment
+            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Forced output comment: {}",
+                     patch_text->GetName(), line.substr(1));
+        } else if (StartsWith(line, "//")) {
+            // Normal Comment
+            last_comment = line.substr(2);
+            if (last_comment.find_first_not_of(' ') == std::string::npos)
+                continue;
+            if (last_comment.find_first_not_of(' ') != 0)
+                last_comment = last_comment.substr(last_comment.find_first_not_of(' '));
+        } else if (StartsWith(line, "@enabled") || StartsWith(line, "@disabled")) {
+            // Start of patch
+            const auto enabled = StartsWith(line, "@enabled");
+            if (i == 0)
+                return;
+            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Parsing patch '{}' ({})",
+                     patch_text->GetName(), last_comment, line.substr(1));
+
+            IPSwitchPatch patch{last_comment, enabled, {}};
+
+            // Read rest of patch
+            while (true) {
+                if (i + 1 >= lines.size()) {
+                    break;
+                }
+
+                const auto& patch_line = lines[++i];
+
+                // Patch line may contain comments
+                if (StartsWith(patch_line, "//") || StartsWith(patch_line, "#")) {
+                    continue;
+                }
+
+                // Start of new patch
+                if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {
+                    --i;
+                    break;
+                }
+
+                // Check for a flag
+                if (StartsWith(patch_line, "@")) {
+                    ParseFlag(patch_line);
+                    continue;
+                }
+
+                // 11 - 8 hex digit offset + space + minimum two digit overwrite val
+                if (patch_line.length() < 11)
+                    break;
+                auto offset = std::strtoul(patch_line.substr(0, 8).c_str(), nullptr, 16);
+                offset += static_cast<unsigned long>(offset_shift);
+
+                std::vector<u8> replace;
+                // 9 - first char of replacement val
+                if (patch_line[9] == '\"') {
+                    // string replacement
+                    auto end_index = patch_line.find('\"', 10);
+                    if (end_index == std::string::npos || end_index < 10)
+                        return;
+                    while (patch_line[end_index - 1] == '\\') {
+                        end_index = patch_line.find('\"', end_index + 1);
+                        if (end_index == std::string::npos || end_index < 10)
+                            return;
+                    }
+
+                    auto value = patch_line.substr(10, end_index - 10);
+                    value = EscapeStringSequences(value);
+                    replace.reserve(value.size());
+                    std::copy(value.begin(), value.end(), std::back_inserter(replace));
+                } else {
+                    // hex replacement
+                    const auto value =
+                        patch_line.substr(9, patch_line.find_first_of(" /\r\n", 9) - 9);
+                    replace = Common::HexStringToVector(value, is_little_endian);
+                }
+
+                if (print_values) {
+                    LOG_INFO(Loader,
+                             "[IPSwitchCompiler ('{}')]     - Patching value at offset {:#08x} "
+                             "with byte string '{}'",
+                             patch_text->GetName(), offset, Common::HexToString(replace));
+                }
+
+                patch.records.insert_or_assign(static_cast<u32>(offset), std::move(replace));
+            }
+
+            patches.push_back(std::move(patch));
+        } else if (StartsWith(line, "@")) {
+            ParseFlag(line);
+        }
     }
+
+    valid = true;
 }
 
 VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
-    if (in == nullptr)
+    if (in == nullptr || !valid)
         return nullptr;
 
     auto in_data = in->ReadAllBytes();
 
     for (const auto& patch : patches) {
-        if (patch.enabled) {
-            for (const auto& record : patch.records) {
-                if (record.first < in_data.size()) {
-                    auto replace_size = record.second.count;
-                    if (record.first + replace_size > in_data.size())
-                        replace_size = in_data.size() - record.first;
-                    std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);
-                }
-            }
+        if (!patch.enabled)
+            continue;
+
+        for (const auto& record : patch.records) {
+            if (record.first >= in_data.size())
+                continue;
+            auto replace_size = record.second.size();
+            if (record.first + replace_size > in_data.size())
+                replace_size = in_data.size() - record.first;
+            for (std::size_t i = 0; i < replace_size; ++i)
+                in_data[i + record.first] = record.second[i];
         }
     }
-    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(), in->GetContainingDirectory());
+
+    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
+                                           in->GetContainingDirectory());
 }
 
 } // namespace FileSys

src/core/file_sys/ips_layer.h

@@ -1,14 +1,11 @@
-// 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
 
 #pragma once
 
 #include <array>
+#include <memory>
 #include <vector>
-#include <span>
 
 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs.h"
@@ -23,17 +20,24 @@ public:
     ~IPSwitchCompiler();
 
     std::array<u8, 0x20> GetBuildID() const;
+    bool IsValid() const;
     VirtualFile Apply(const VirtualFile& in) const;
 
 private:
     struct IPSwitchPatch;
 
     void ParseFlag(const std::string& flag);
-    void Parse(std::span<u8 const> bytes);
+    void Parse();
+
+    bool valid = false;
 
     VirtualFile patch_text;
     std::vector<IPSwitchPatch> patches;
     std::array<u8, 0x20> nso_build_id{};
+    bool is_little_endian = false;
+    s64 offset_shift = 0;
+    bool print_values = false;
+    std::string last_comment = "";
 };
 
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -345,7 +345,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     return exefs;
 }
 
-std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
+std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+                                                      const std::string& build_id) const {
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto nso_build_id = fmt::format("{:0<64}", build_id);
 
@@ -360,11 +361,16 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
             for (const auto& file : exefs_dir->GetFiles()) {
                 if (file->GetExtension() == "ips") {
                     auto name = file->GetName();
-                    const auto this_build_id = fmt::format("{:0<64}", name.substr(0, name.find('.')));
+
+                    const auto this_build_id =
+                        fmt::format("{:0<64}", name.substr(0, name.find('.')));
                     if (nso_build_id == this_build_id)
                         out.push_back(file);
                 } else if (file->GetExtension() == "pchtxt") {
                     IPSwitchCompiler compiler{file};
+                    if (!compiler.IsValid())
+                        continue;
+
                     const auto this_build_id = Common::HexToString(compiler.GetBuildID());
                     if (nso_build_id == this_build_id)
                         out.push_back(file);
@@ -372,6 +378,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
             }
         }
     }
+
     return out;
 }
 

src/core/hle/kernel/k_server_session.cpp

@@ -1216,7 +1216,7 @@ Result KServerSession::ReceiveRequest(KernelCore& kernel, uintptr_t server_messa
 }
 
 Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                                 KPhysicalAddress server_message_paddr, bool is_hle, bool session_closed) {
+                                 KPhysicalAddress server_message_paddr, bool is_hle) {
     // Lock the session.
     KScopedLightLock lk{m_lock};
 
@@ -1248,7 +1248,7 @@ Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, u
     KEvent* event = request->GetEvent();
 
     // Check whether we're closed.
-    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed() || session_closed);
+    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed());
 
     Result result = ResultSuccess;
     if (!closed) {

src/core/hle/kernel/k_server_session.h

@@ -54,14 +54,14 @@ public:
 
     Result OnRequest(KernelCore& kernel, KSessionRequest* request);
     Result SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                     KPhysicalAddress server_message_paddr, bool is_hle = false, bool session_closed = false);
+                     KPhysicalAddress server_message_paddr, bool is_hle = false);
     Result ReceiveRequest(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
                           KPhysicalAddress server_message_paddr,
                           std::shared_ptr<Service::HLERequestContext>* out_context = nullptr,
                           std::weak_ptr<Service::SessionRequestManager> manager = {});
 
-    Result SendReplyHLE(KernelCore& kernel, bool session_closed = false) {
-        R_RETURN(this->SendReply(kernel, 0, 0, 0, true, session_closed));
+    Result SendReplyHLE(KernelCore& kernel) {
+        R_RETURN(this->SendReply(kernel, 0, 0, 0, true));
     }
 
     Result ReceiveRequestHLE(KernelCore& kernel, std::shared_ptr<Service::HLERequestContext>* out_context,

src/core/hle/kernel/svc/svc_debug_string.cpp

@@ -17,12 +17,56 @@
 
 namespace Kernel::Svc {
 
+constexpr auto MAX_MSG_TIME = std::chrono::milliseconds(250);
+const auto MAX_MSG_SIZE = 0x1000;
+
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
 Result OutputDebugString(Core::System& system, u64 address, u64 len) {
+    static struct DebugFlusher {
+        std::string msg_buffer;
+        std::mutex msg_mutex;
+        std::condition_variable msg_cv;
+        std::chrono::steady_clock::time_point last_msg_time;
+        std::optional<std::jthread> thread;
+    } flusher_data;
     R_SUCCEED_IF(len == 0);
-    std::string msg_buffer(len, 0);
-    GetCurrentMemory(system.Kernel()).ReadBlock(address, msg_buffer.data(), len);
-    LOG_INFO(Debug_Emulated, "{}", msg_buffer);
+    // Only start the thread the very first time this function is called
+    if (!flusher_data.thread) {
+        flusher_data.thread.emplace([](std::stop_token stop_token) {
+            while (!stop_token.stop_requested()) {
+                std::unique_lock lock(flusher_data.msg_mutex);
+                flusher_data.msg_cv.wait(lock, [&stop_token] {
+                    return !flusher_data.msg_buffer.empty() || stop_token.stop_requested();
+                });
+                if (stop_token.stop_requested() && flusher_data.msg_buffer.empty())
+                    break;
+                auto timeout = flusher_data.last_msg_time + MAX_MSG_TIME;
+                bool woke_early = flusher_data.msg_cv.wait_until(lock, timeout, [&stop_token] {
+                    return flusher_data.msg_buffer.size() >= MAX_MSG_SIZE || stop_token.stop_requested();
+                });
+                if (!woke_early || flusher_data.msg_buffer.size() >= MAX_MSG_SIZE || stop_token.stop_requested()) {
+                    if (!flusher_data.msg_buffer.empty()) {
+                        // Remove trailing newline as LOG_INFO adds that anyways
+                        if (flusher_data.msg_buffer.back() == '\n')
+                            flusher_data.msg_buffer.pop_back();
+
+                        LOG_INFO(Debug_Emulated, "\n{}", flusher_data.msg_buffer);
+                        flusher_data.msg_buffer.clear();
+                    }
+                    if (stop_token.stop_requested()) break;
+                }
+            }
+            flusher_data.msg_cv.notify_all();
+        });
+    }
+    {
+        std::lock_guard lock(flusher_data.msg_mutex);
+        const auto old_size = flusher_data.msg_buffer.size();
+        flusher_data.msg_buffer.resize(old_size + len);
+        GetCurrentMemory(system.Kernel()).ReadBlock(address, flusher_data.msg_buffer.data() + old_size, len);
+        flusher_data.last_msg_time = std::chrono::steady_clock::now();
+    }
+    flusher_data.msg_cv.notify_one();
     R_SUCCEED();
 }
 

src/core/hle/service/filesystem/filesystem.cpp

@@ -227,13 +227,12 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
     std::string src_path(Common::FS::SanitizePath(src_path_));
     std::string dest_path(Common::FS::SanitizePath(dest_path_));
     auto src = GetDirectoryRelativeWrapped(backing, src_path);
-    if (src == nullptr)
-        return FileSys::ResultPathNotFound;
-
     if (Common::FS::GetParentPath(src_path) == Common::FS::GetParentPath(dest_path)) {
-        std::string full_src_path = backing->GetFullPath() + "/" + src_path;
-        std::string full_dest_path = backing->GetFullPath() + "/" + dest_path;
-        if (!Common::FS::RenameDir(full_src_path, full_dest_path)) {
+        // Use more-optimized vfs implementation rename.
+        if (src == nullptr)
+            return FileSys::ResultPathNotFound;
+        if (!src->Rename(Common::FS::GetFilename(dest_path))) {
+            // TODO(DarkLordZach): Find a better error code for this
             return ResultUnknown;
         }
         return ResultSuccess;

src/core/hle/service/filesystem/fsp/fs_i_filesystem.cpp

@@ -24,7 +24,7 @@ IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGe
         {3, D<&IFileSystem::DeleteDirectory>, "DeleteDirectory"},
         {4, D<&IFileSystem::DeleteDirectoryRecursively>, "DeleteDirectoryRecursively"},
         {5, D<&IFileSystem::RenameFile>, "RenameFile"},
-        {6, D<&IFileSystem::RenameDirectory>, "RenameDirectory"},
+        {6, nullptr, "RenameDirectory"},
         {7, D<&IFileSystem::GetEntryType>, "GetEntryType"},
         {8, D<&IFileSystem::OpenFile>, "OpenFile"},
         {9, D<&IFileSystem::OpenDirectory>, "OpenDirectory"},
@@ -88,14 +88,6 @@ Result IFileSystem::RenameFile(
     R_RETURN(backend->RenameFile(FileSys::Path(old_path->str), FileSys::Path(new_path->str)));
 }
 
-Result IFileSystem::RenameDirectory(
-    const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> old_path,
-    const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> new_path) {
-    LOG_DEBUG(Service_FS, "called. directory '{}' to directory '{}'", old_path->str, new_path->str);
-
-    R_RETURN(backend->RenameDirectory(FileSys::Path(old_path->str), FileSys::Path(new_path->str)));
-}
-
 Result IFileSystem::OpenFile(OutInterface<IFile> out_interface,
                              const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path,
                              u32 mode) {

src/core/hle/service/filesystem/fsp/fs_i_filesystem.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -39,8 +36,6 @@ public:
         const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path);
     Result RenameFile(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> old_path,
                       const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> new_path);
-    Result RenameDirectory(const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> old_path,
-                           const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> new_path);
     Result OpenFile(OutInterface<IFile> out_interface,
                     const InLargeData<FileSys::Sf::Path, BufferAttr_HipcPointer> path, u32 mode);
     Result OpenDirectory(OutInterface<IDirectory> out_interface,

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -8,7 +8,6 @@
 #include "common/assert.h"
 #include "common/logging.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
@@ -72,23 +71,17 @@ NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 
 void nvhost_nvdec::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream started");
+    system.SetNVDECActive(true);
     sessions[fd] = session_id;
-    if (const auto* session = core.GetSession(session_id);
-        session != nullptr && session->process != nullptr) {
-        system.NotifyNVDECChannelOpen(session->process->GetId());
-    }
     host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
     host1x.StopDevice(fd, Tegra::Host1x::ChannelType::NvDec);
+    system.SetNVDECActive(false);
     auto it = sessions.find(fd);
     if (it != sessions.end()) {
-        if (const auto* session = core.GetSession(it->second);
-            session != nullptr && session->process != nullptr) {
-            system.NotifyNVDECChannelClose(session->process->GetId());
-        }
         sessions.erase(it);
     }
 }

src/core/hle/service/server_manager.cpp

@@ -393,7 +393,7 @@ Result ServerManager::CompleteSyncRequest(Session* session) {
     }
 
     // Send the reply.
-    res = server_session->SendReplyHLE(m_system.Kernel(), service_res == IPC::ResultSessionClosed);
+    res = server_session->SendReplyHLE(m_system.Kernel());
 
     // If the session has been closed, we're done.
     if (res == Kernel::ResultSessionClosed || service_res == IPC::ResultSessionClosed) {

src/core/hle/service/service.cpp

@@ -4,16 +4,12 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <chrono>
 #include <fmt/ranges.h>
-#include <string_view>
-#include <thread>
 #include "common/assert.h"
 #include "common/logging.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/hle/ipc.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/service.h"
@@ -37,7 +33,6 @@ ServiceFrameworkBase::ServiceFrameworkBase(Core::System& system_, const char* se
     : SessionRequestHandler(system_.Kernel(), service_name_)
     , system{system_}
     , service_name{service_name_}
-    , is_i_storage{std::string_view{service_name_} == "IStorage"}
     , handler_invoker{handler_invoker_}
     , max_sessions{max_sessions_}
 {}
@@ -82,22 +77,13 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx,
 }
 
 void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
-    const auto command = ctx.GetCommand();
-    auto it = handlers.find(command);
-    const bool is_cmd_read = command == 0;
+    auto it = handlers.find(ctx.GetCommand());
     FunctionInfoBase const* info = it == handlers.end() ? nullptr : &it->second;
     if (info == nullptr || info->handler_callback == nullptr)
         return ReportUnimplementedFunction(ctx, info);
 
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
-
-    if (is_i_storage && is_cmd_read) {
-        const auto* const process = ctx.GetThread().GetOwnerProcess();
-        if (process != nullptr && system.IsNVDECActiveForProcess(process->GetId())) {
-            std::this_thread::sleep_for(std::chrono::microseconds{600});
-        }
-    }
 }
 
 void ServiceFrameworkBase::InvokeRequestTipc(HLERequestContext& ctx) {

src/core/hle/service/service.h

@@ -107,8 +107,6 @@ protected:
     Core::System& system;
     /// Identifier string used to connect to the service.
     const char* service_name;
-    /// Whether this is the IStorage service.
-    const bool is_i_storage;
     /// Function used to safely up-cast pointers to the derived class before invoking a handler.
     InvokerFn* handler_invoker;
     /// Maximum number of concurrent sessions that this service can handle.

src/core/memory.cpp

@@ -16,7 +16,6 @@
 #include "common/assert.h"
 #include "common/atomic_ops.h"
 #include "common/common_types.h"
-#include "common/heap_tracker.h"
 #include "common/logging.h"
 #include "common/page_table.h"
 #include "common/scope_exit.h"
@@ -55,36 +54,24 @@ struct Memory::Impl {
         } else {
             current_page_table->fastmem_arena = nullptr;
         }
-
-#ifdef __ANDROID__
-        heap_tracker.emplace(system.DeviceMemory().buffer);
-        host_buffer = std::addressof(*heap_tracker);
-#else
         host_buffer = std::addressof(system.DeviceMemory().buffer);
-#endif
     }
 
-    void MapMemoryRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size,
-                         Common::PhysicalAddress target, Common::MemoryPermission perms,
-                         bool separate_heap) {
+    void MapMemoryRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size, Common::PhysicalAddress target, Common::MemoryPermission perms, bool separate_heap) {
         ASSERT_MSG((size & YUZU_PAGEMASK) == 0, "non-page aligned size: {:016X}", size);
         ASSERT_MSG((base & YUZU_PAGEMASK) == 0, "non-page aligned base: {:016X}", GetInteger(base));
-        ASSERT_MSG(target >= DramMemoryMap::Base, "Out of bounds target: {:016X}",
-                   GetInteger(target));
-        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, target,
-                 Common::PageType::Memory);
+        ASSERT_MSG(target >= DramMemoryMap::Base, "Out of bounds target: {:016X}", GetInteger(target));
+        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, target, Common::PageType::Memory);
 
         if (current_page_table->fastmem_arena) {
             host_buffer->Map(GetInteger(base), GetInteger(target) - DramMemoryMap::Base, size, perms, separate_heap);
         }
     }
 
-    void UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size,
-                     bool separate_heap) {
+    void UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size, bool separate_heap) {
         ASSERT_MSG((size & YUZU_PAGEMASK) == 0, "non-page aligned size: {:016X}", size);
         ASSERT_MSG((base & YUZU_PAGEMASK) == 0, "non-page aligned base: {:016X}", GetInteger(base));
-        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, 0,
-                 Common::PageType::Unmapped);
+        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, 0, Common::PageType::Unmapped);
 
         if (current_page_table->fastmem_arena) {
             host_buffer->Unmap(GetInteger(base), size, separate_heap);
@@ -767,12 +754,7 @@ struct Memory::Impl {
     std::array<Common::ScratchBuffer<u32>, Core::Hardware::NUM_CPU_CORES> scratch_buffers{};
     std::span<Core::GPUDirtyMemoryManager> gpu_dirty_managers;
     std::mutex sys_core_guard;
-#ifdef __ANDROID__
-    std::optional<Common::HeapTracker> heap_tracker;
-    Common::HeapTracker* host_buffer{};
-#else
     Common::HostMemory* host_buffer{};
-#endif
 };
 
 Memory::Memory(Core::System& system_) : system{system_} {
@@ -965,30 +947,14 @@ bool Memory::InvalidateNCE(Common::ProcessAddress vaddr, size_t size) {
     u8* const ptr = impl->GetPointerImpl(
         GetInteger(vaddr),
         [&] {
-            LOG_ERROR(HW_Memory, "Unmapped InvalidateNCE for {} bytes @ {:#x}", size,
-                      GetInteger(vaddr));
+            LOG_ERROR(HW_Memory, "Unmapped InvalidateNCE for {} bytes @ {:#x}", size, GetInteger(vaddr));
             mapped = false;
         },
         [&] { rasterizer = true; });
     if (rasterizer) {
         impl->InvalidateGPUMemory(ptr, size);
     }
-
-#ifdef __ANDROID__
-    if (!rasterizer && mapped) {
-        impl->host_buffer->DeferredMapSeparateHeap(GetInteger(vaddr));
-    }
-#endif
-
     return mapped && ptr != nullptr;
 }
 
-bool Memory::InvalidateSeparateHeap(void* fault_address) {
-#ifdef __ANDROID__
-    return impl->host_buffer->DeferredMapSeparateHeap(static_cast<u8*>(fault_address));
-#else
-    return false;
-#endif
-}
-
 } // namespace Core::Memory

src/core/memory.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
@@ -490,13 +490,8 @@ public:
      *              marked as debug or non-debug.
      */
     void MarkRegionDebug(Common::ProcessAddress vaddr, u64 size, bool debug);
-
     void SetGPUDirtyManagers(std::span<Core::GPUDirtyMemoryManager> managers);
-
     bool InvalidateNCE(Common::ProcessAddress vaddr, size_t size);
-
-    bool InvalidateSeparateHeap(void* fault_address);
-
 private:
     Core::System& system;
 

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

@@ -247,7 +247,7 @@ void A32EmitX64::GenTerminalHandlers() {
     calculate_location_descriptor();
     code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)]);
     code.sub(eax, 1);
-    code.and_(eax, u32(A32JitState::RSB_PTR_MASK));
+    code.and_(eax, u32(A32JitState::RSBPtrMask));
     code.mov(dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)], eax);
     code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
     if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {

src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp

@@ -37,9 +37,9 @@ using namespace Backend::X64;
 
 static RunCodeCallbacks GenRunCodeCallbacks(A32::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A32::UserConfig& conf) {
     return RunCodeCallbacks{
-        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
-        ArgCallback(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
-        ArgCallback(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
+        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
         conf.enable_cycle_counting,
     };
 }
@@ -79,7 +79,7 @@ struct Jit::Impl {
         jit_interface->is_executing = true;
         const CodePtr current_codeptr = [this] {
             // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSB_PTR_MASK;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSBPtrMask;
             if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                 jit_state.rsb_ptr = new_rsb_ptr;
                 return reinterpret_cast<CodePtr>(jit_state.rsb_codeptrs[new_rsb_ptr]);

src/dynarmic/src/dynarmic/backend/x64/a32_jitstate.h

@@ -27,9 +27,6 @@ struct A32JitState {
 
     A32JitState() { ResetRSB(); }
 
-    static constexpr std::size_t RSB_SIZE = 8;  // MUST be a power of 2.
-    static constexpr std::size_t RSB_PTR_MASK = RSB_SIZE - 1;
-
     std::array<u32, 16> Reg{};  // Current register file.
     // TODO: Mode-specific register sets unimplemented.
 
@@ -39,9 +36,8 @@ struct A32JitState {
     u32 cpsr_q = 0;
     u32 cpsr_nzcv = 0;
     u32 cpsr_jaifm = 0;
-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpsr_nzcv = 0;
+    u32 Cpsr() const;
+    void SetCpsr(u32 cpsr);
 
     alignas(16) std::array<u32, 64> ExtReg{};  // Extension registers.
 
@@ -53,19 +49,21 @@ struct A32JitState {
     // Exclusive state
     u32 exclusive_state = 0;
 
+    static constexpr std::size_t RSBSize = 8;  // MUST be a power of 2.
+    static constexpr std::size_t RSBPtrMask = RSBSize - 1;
     u32 rsb_ptr = 0;
-    std::array<u64, RSB_SIZE> rsb_location_descriptors;
-    std::array<u64, RSB_SIZE> rsb_codeptrs;
-
-    u32 Cpsr() const;
-    void SetCpsr(u32 cpsr);
-
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
     void ResetRSB();
+
+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpsr_nzcv = 0;
     u32 Fpscr() const;
     void SetFpscr(u32 FPSCR);
 
     u64 GetUniqueHash() const noexcept {
-        return (u64(upper_location_descriptor) << 32) | (u64(Reg[15]));
+        return (static_cast<u64>(upper_location_descriptor) << 32) | (static_cast<u64>(Reg[15]));
     }
 
     void TransferJitState(const A32JitState& src, bool reset_rsb) {

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

@@ -208,7 +208,7 @@ void A64EmitX64::GenTerminalHandlers() {
     calculate_location_descriptor();
     code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)]);
     code.sub(eax, 1);
-    code.and_(eax, u32(A64JitState::RSB_PTR_MASK));
+    code.and_(eax, u32(A64JitState::RSBPtrMask));
     code.mov(dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)], eax);
     code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
     if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {

src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp

@@ -33,9 +33,9 @@ using namespace Backend::X64;
 
 static RunCodeCallbacks GenRunCodeCallbacks(A64::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A64::UserConfig& conf) {
     return RunCodeCallbacks{
-        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
-        ArgCallback(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
-        ArgCallback(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
+        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
         conf.enable_cycle_counting,
     };
 }
@@ -78,7 +78,7 @@ public:
         // TODO: Check code alignment
         const CodePtr current_code_ptr = [this] {
             // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSB_PTR_MASK;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSBPtrMask;
             if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                 jit_state.rsb_ptr = new_rsb_ptr;
                 return CodePtr(jit_state.rsb_codeptrs[new_rsb_ptr]);

src/dynarmic/src/dynarmic/backend/x64/a64_jitstate.h

@@ -29,19 +29,18 @@ struct A64JitState {
 
     A64JitState() { ResetRSB(); }
 
-    // Exclusive state stuff
-    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
-    // Return stack buffer
-    static constexpr size_t RSB_SIZE = 8;  // MUST be a power of 2.
-    static constexpr size_t RSB_PTR_MASK = RSB_SIZE - 1;
-
     std::array<u64, 31> reg{};
     u64 sp = 0;
     u64 pc = 0;
+
     u32 cpsr_nzcv = 0;
-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpcr = 0;
+
+    u32 GetPstate() const {
+        return NZCV::FromX64(cpsr_nzcv);
+    }
+    void SetPstate(u32 new_pstate) {
+        cpsr_nzcv = NZCV::ToX64(new_pstate);
+    }
 
     alignas(16) std::array<u64, 64> vec{};  // Extension registers.
 
@@ -51,31 +50,29 @@ struct A64JitState {
     volatile u32 halt_reason = 0;
 
     // Exclusive state
+    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
     u8 exclusive_state = 0;
+
+    static constexpr size_t RSBSize = 8;  // MUST be a power of 2.
+    static constexpr size_t RSBPtrMask = RSBSize - 1;
     u32 rsb_ptr = 0;
-    std::array<u64, RSB_SIZE> rsb_location_descriptors;
-    std::array<u64, RSB_SIZE> rsb_codeptrs;
-
-    u32 GetPstate() const {
-        return NZCV::FromX64(cpsr_nzcv);
-    }
-
-    void SetPstate(u32 new_pstate) {
-        cpsr_nzcv = NZCV::ToX64(new_pstate);
-    }
-
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
     void ResetRSB() {
         rsb_location_descriptors.fill(0xFFFFFFFFFFFFFFFFull);
         rsb_codeptrs.fill(0);
     }
 
+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpcr = 0;
     u32 GetFpcr() const;
     u32 GetFpsr() const;
     void SetFpcr(u32 value);
     void SetFpsr(u32 value);
 
     u64 GetUniqueHash() const noexcept {
-        const u64 fpcr_u64 = u64(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
+        const u64 fpcr_u64 = static_cast<u64>(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
         const u64 pc_u64 = pc & A64::LocationDescriptor::pc_mask;
         return pc_u64 | fpcr_u64;
     }

src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp

@@ -61,6 +61,73 @@ namespace {
 constexpr size_t CONSTANT_POOL_SIZE = 2 * 1024 * 1024;
 constexpr size_t PRELUDE_COMMIT_SIZE = 16 * 1024 * 1024;
 
+class CustomXbyakAllocator : public Xbyak::Allocator {
+public:
+#ifdef _WIN32
+    uint8_t* alloc(size_t size) override {
+        void* p = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
+        if (p == nullptr) {
+            using Xbyak::Error;
+            XBYAK_THROW(Xbyak::ERR_CANT_ALLOC);
+        }
+        return static_cast<uint8_t*>(p);
+    }
+
+    void free(uint8_t* p) override {
+        VirtualFree(static_cast<void*>(p), 0, MEM_RELEASE);
+    }
+
+    bool useProtect() const override { return false; }
+#else
+    static constexpr size_t DYNARMIC_PAGE_SIZE = 4096;
+
+    // Can't subclass Xbyak::MmapAllocator because it is not a pure interface
+    // and doesn't expose its construtor
+    uint8_t* alloc(size_t size) override {
+        // Waste a page to store the size
+        size += DYNARMIC_PAGE_SIZE;
+
+        int mode = MAP_PRIVATE;
+#if defined(MAP_ANONYMOUS)
+        mode |= MAP_ANONYMOUS;
+#elif defined(MAP_ANON)
+        mode |= MAP_ANON;
+#else
+#   error "not supported"
+#endif
+#ifdef MAP_JIT
+        mode |= MAP_JIT;
+#endif
+        int prot = PROT_READ | PROT_WRITE;
+#ifdef PROT_MPROTECT
+        // https://man.netbsd.org/mprotect.2 specifies that an mprotect() that is LESS
+        // restrictive than the original mapping MUST fail
+        prot |= PROT_MPROTECT(PROT_READ) | PROT_MPROTECT(PROT_WRITE) | PROT_MPROTECT(PROT_EXEC);
+#endif
+        void* p = mmap(nullptr, size, prot, mode, -1, 0);
+        if (p == MAP_FAILED) {
+            using Xbyak::Error;
+            XBYAK_THROW(Xbyak::ERR_CANT_ALLOC);
+        }
+        std::memcpy(p, &size, sizeof(size_t));
+        return static_cast<uint8_t*>(p) + DYNARMIC_PAGE_SIZE;
+    }
+
+    void free(uint8_t* p) override {
+        size_t size;
+        std::memcpy(&size, p - DYNARMIC_PAGE_SIZE, sizeof(size_t));
+        munmap(p - DYNARMIC_PAGE_SIZE, size);
+    }
+
+#    ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
+    bool useProtect() const override { return false; }
+#    endif
+#endif
+};
+
+// This is threadsafe as Xbyak::Allocator does not contain any state; it is a pure interface.
+CustomXbyakAllocator s_allocator;
+
 #ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
 void ProtectMemory(const void* base, size_t size, bool is_executable) {
 #    ifdef _WIN32
@@ -78,9 +145,11 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {
 
 HostFeature GetHostFeatures() {
     HostFeature features = {};
+
 #ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
     using Cpu = Xbyak::util::Cpu;
-    Xbyak::util::Cpu cpu_info{};
+    Xbyak::util::Cpu cpu_info;
+
     if (cpu_info.has(Cpu::tSSSE3))
         features |= HostFeature::SSSE3;
     if (cpu_info.has(Cpu::tSSE41))
@@ -127,6 +196,7 @@ HostFeature GetHostFeatures() {
         features |= HostFeature::GFNI;
     if (cpu_info.has(Cpu::tWAITPKG))
         features |= HostFeature::WAITPKG;
+
     if (cpu_info.has(Cpu::tBMI2)) {
         // BMI2 instructions such as pdep and pext have been very slow up until Zen 3.
         // Check for Zen 3 or newer by its family (0x19).
@@ -144,6 +214,7 @@ HostFeature GetHostFeatures() {
         }
     }
 #endif
+
     return features;
 }
 
@@ -162,27 +233,23 @@ bool IsUnderRosetta() {
 
 }  // anonymous namespace
 
-BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi, size_t total_code_size, std::function<void(BlockOfCode&)> rcp)
-    : Xbyak::CodeGenerator(total_code_size
 #ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
-        , Xbyak::DontSetProtectRWE
+static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
 #else
-        , nullptr //Allow RWE
+static const auto default_cg_mode = nullptr; //Allow RWE
 #endif
-        , nullptr)
-    , constant_pool(*this, CONSTANT_POOL_SIZE)
-    , jsi(jsi)
-    , cb(std::move(cb))
-{
+
+BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi, size_t total_code_size, std::function<void(BlockOfCode&)> rcp)
+        : Xbyak::CodeGenerator(total_code_size, default_cg_mode, &s_allocator)
+        , cb(std::move(cb))
+        , jsi(jsi)
+        , constant_pool(*this, CONSTANT_POOL_SIZE)
+        , host_features(GetHostFeatures()) {
     EnableWriting();
     EnsureMemoryCommitted(PRELUDE_COMMIT_SIZE);
     GenRunCode(rcp);
 }
 
-bool BlockOfCode::HasHostFeature(HostFeature feature) const noexcept {
-    return (GetHostFeatures() & feature) == feature;
-}
-
 void BlockOfCode::PreludeComplete() {
     prelude_complete = true;
     code_begin = getCurr();
@@ -274,7 +341,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
     mov(rbx, ABI_PARAM2); // save temporarily in non-volatile register
 
     if (cb.enable_cycle_counting) {
-        cb.GetTicksRemaining.EmitCall(*this);
+        cb.GetTicksRemaining->EmitCall(*this);
         mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
         mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
     }
@@ -321,7 +388,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
         cmp(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], 0);
         jng(return_to_caller);
     }
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
     jmp(ABI_RETURN);
 
     align();
@@ -334,7 +401,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
         jng(return_to_caller_mxcsr_already_exited);
     }
     SwitchMxcsrOnEntry();
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
     jmp(ABI_RETURN);
 
     align();
@@ -348,7 +415,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
     L(return_to_caller_mxcsr_already_exited);
 
     if (cb.enable_cycle_counting) {
-        cb.AddTicks.EmitCall(*this, [this](RegList param) {
+        cb.AddTicks->EmitCall(*this, [this](RegList param) {
             mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
             sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
         });
@@ -388,18 +455,18 @@ void BlockOfCode::UpdateTicks() {
         return;
     }
 
-    cb.AddTicks.EmitCall(*this, [this](RegList param) {
+    cb.AddTicks->EmitCall(*this, [this](RegList param) {
         mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
         sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
     });
 
-    cb.GetTicksRemaining.EmitCall(*this);
+    cb.GetTicksRemaining->EmitCall(*this);
     mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
     mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
 }
 
 void BlockOfCode::LookupBlock() {
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
 }
 
 void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
@@ -453,7 +520,7 @@ void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
 }
 
 Xbyak::Address BlockOfCode::Const(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
-    return constant_pool.GetConstant(*this, frame, lower, upper);
+    return constant_pool.GetConstant(frame, lower, upper);
 }
 
 CodePtr BlockOfCode::GetCodeBegin() const {

src/dynarmic/src/dynarmic/backend/x64/block_of_code.h

@@ -31,9 +31,9 @@ namespace Dynarmic::Backend::X64 {
 using CodePtr = const void*;
 
 struct RunCodeCallbacks {
-    ArgCallback LookupBlock;
-    ArgCallback AddTicks;
-    ArgCallback GetTicksRemaining;
+    std::unique_ptr<Callback> LookupBlock;
+    std::unique_ptr<Callback> AddTicks;
+    std::unique_ptr<Callback> GetTicksRemaining;
     bool enable_cycle_counting;
 };
 
@@ -166,24 +166,27 @@ public:
 
     JitStateInfo GetJitStateInfo() const { return jsi; }
 
-    bool HasHostFeature(HostFeature feature) const noexcept;
+    bool HasHostFeature(HostFeature feature) const {
+        return (host_features & feature) == feature;
+    }
 
 private:
     using RunCodeFuncType = HaltReason (*)(void*, CodePtr);
     static constexpr size_t MXCSR_ALREADY_EXITED = 1 << 0;
     static constexpr size_t FORCE_RETURN = 1 << 1;
 
-    ConstantPool constant_pool;
-    JitStateInfo jsi;
-    std::array<const void*, 4> return_from_run_code;
-    RunCodeFuncType run_code = nullptr;
-    RunCodeFuncType step_code = nullptr;
     RunCodeCallbacks cb;
+    JitStateInfo jsi;
     CodePtr code_begin = nullptr;
 #ifdef _WIN32
     size_t committed_size = 0;
 #endif
+    ConstantPool constant_pool;
+    RunCodeFuncType run_code = nullptr;
+    RunCodeFuncType step_code = nullptr;
+    std::array<const void*, 4> return_from_run_code;
     bool prelude_complete = false;
+    const HostFeature host_features;
 
     void GenRunCode(std::function<void(BlockOfCode&)> rcp);
 };

src/dynarmic/src/dynarmic/backend/x64/constant_pool.cpp

@@ -16,7 +16,8 @@
 namespace Dynarmic::Backend::X64 {
 
 ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
-    : insertion_point(0)
+    : code(code)
+    , insertion_point(0)
 {
     code.EnsureMemoryCommitted(align_size + size);
     code.int3();
@@ -24,17 +25,17 @@ ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
     pool = std::span<ConstantT>(reinterpret_cast<ConstantT*>(code.AllocateFromCodeSpace(size)), size / align_size);
 }
 
-Xbyak::Address ConstantPool::GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
+Xbyak::Address ConstantPool::GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
     const auto constant = ConstantT(lower, upper);
-    auto it = constant_info.find(constant);
-    if (it == constant_info.end()) {
+    auto iter = constant_info.find(constant);
+    if (iter == constant_info.end()) {
         ASSERT(insertion_point < pool.size());
         ConstantT& target_constant = pool[insertion_point];
         target_constant = constant;
-        it = constant_info.insert({constant, &target_constant}).first;
+        iter = constant_info.insert({constant, &target_constant}).first;
         ++insertion_point;
     }
-    return frame[code.rip + it->second];
+    return frame[code.rip + iter->second];
 }
 
 }  // namespace Dynarmic::Backend::X64

src/dynarmic/src/dynarmic/backend/x64/constant_pool.h

@@ -29,7 +29,7 @@ class ConstantPool final {
 public:
     ConstantPool(BlockOfCode& code, size_t size);
 
-    Xbyak::Address GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);
+    Xbyak::Address GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);
 
 private:
     static constexpr size_t align_size = 16;  // bytes
@@ -45,6 +45,7 @@ private:
 
     ankerl::unordered_dense::map<ConstantT, void*, ConstantHash> constant_info;
     std::span<ConstantT> pool;
+    BlockOfCode& code;
     std::size_t insertion_point;
 };
 

src/dynarmic/src/dynarmic/backend/x64/host_feature.h

@@ -12,7 +12,7 @@
 
 namespace Dynarmic::Backend::X64 {
 
-enum class HostFeature : u32 {
+enum class HostFeature : u64 {
     SSSE3 = 1ULL << 0,
     SSE41 = 1ULL << 1,
     SSE42 = 1ULL << 2,

src/dynarmic/src/dynarmic/backend/x64/jitstate_info.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* This file is part of the dynarmic project.
  * Copyright (c) 2016 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -18,7 +15,7 @@ struct JitStateInfo {
             : offsetof_guest_MXCSR(offsetof(JitStateType, guest_MXCSR))
             , offsetof_asimd_MXCSR(offsetof(JitStateType, asimd_MXCSR))
             , offsetof_rsb_ptr(offsetof(JitStateType, rsb_ptr))
-            , rsb_ptr_mask(JitStateType::RSB_PTR_MASK)
+            , rsb_ptr_mask(JitStateType::RSBPtrMask)
             , offsetof_rsb_location_descriptors(offsetof(JitStateType, rsb_location_descriptors))
             , offsetof_rsb_codeptrs(offsetof(JitStateType, rsb_codeptrs))
             , offsetof_cpsr_nzcv(offsetof(JitStateType, cpsr_nzcv))

src/qt_common/util/mod.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <filesystem>
-#include <system_error>
 #include <JlCompress.h>
 #include "frontend_common/mod_manager.h"
 #include "mod.h"
@@ -125,8 +124,8 @@ const QString ExtractMod(const QString& path) {
     fs::remove_all(tmp, ec);
     if (!fs::create_directories(tmp, ec)) {
         QtCommon::Frontend::Critical(tr("Mod Extract Failed"),
-                                    tr("Failed to create temporary directory %1")
-                                        .arg(QString::fromStdString(tmp.string())));
+                                     tr("Failed to create temporary directory %1")
+                                         .arg(QString::fromStdString(tmp.string())));
         return QString();
     }
 

src/shader_recompiler/backend/spirv/emit_spirv_warp.cpp

@@ -198,10 +198,6 @@ Id EmitSubgroupGeMask(EmitContext& ctx) {
 
 Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                     Id segmentation_mask) {
-    if (!StageSupportsSubgroups(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
     const Id not_seg_mask{ctx.OpNot(ctx.U32[1], segmentation_mask)};
     const Id thread_id{EmitLaneId(ctx)};
     const Id min_thread_id{ComputeMinThreadId(ctx, thread_id, segmentation_mask)};
@@ -221,10 +217,6 @@ Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id cla
 
 Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                  Id segmentation_mask) {
-    if (!StageSupportsSubgroups(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
     const Id thread_id{EmitLaneId(ctx)};
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
@@ -240,10 +232,6 @@ Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
 
 Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                    Id segmentation_mask) {
-    if (!StageSupportsSubgroups(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
     const Id thread_id{EmitLaneId(ctx)};
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
@@ -259,10 +247,6 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam
 
 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                         Id segmentation_mask) {
-    if (!StageSupportsSubgroups(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
     const Id thread_id{EmitLaneId(ctx)};
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};

src/video_core/renderer_vulkan/blit_image.cpp

@@ -1281,7 +1281,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceColorPipeline(const BlitImagePipelineKe
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *blit_color_pipelines.back();
 }
 
@@ -1313,7 +1313,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceDepthStencilPipeline(const BlitImagePip
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *blit_depth_stencil_pipelines.back();
 }
 
@@ -1366,7 +1366,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearColorPipeline(const BlitImagePipel
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *clear_color_pipelines.back();
 }
 
@@ -1422,7 +1422,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceClearStencilPipeline(
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *clear_stencil_pipelines.back();
 }
 
@@ -1465,7 +1465,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceBlitColorMSAAPipeline(const BlitMSAAPip
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *blit_msaa_color_pipelines.back();
 }
 
@@ -1584,7 +1584,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceResolveDepthStencilPipeline(VkRenderPas
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *pipelines.back();
 }
 
@@ -1697,7 +1697,7 @@ VkPipeline BlitImageHelper::FindOrEmplaceMSAACopyPipeline(const MSAACopyPipeline
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache()));
+    }));
     return *msaa_copy_pipelines.back();
 }
 
@@ -1817,7 +1817,7 @@ void BlitImageHelper::ConvertPipelineEx(vk::Pipeline& pipeline, VkRenderPass ren
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache());
+    });
 }
 
 void BlitImageHelper::ConvertPipelineColorTargetEx(vk::Pipeline& pipeline, VkRenderPass renderpass,
@@ -1860,7 +1860,7 @@ void BlitImageHelper::ConvertPipeline(vk::Pipeline& pipeline, VkRenderPass rende
         .subpass = 0,
         .basePipelineHandle = VK_NULL_HANDLE,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache());
+    });
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/util.cpp

@@ -521,7 +521,7 @@ static vk::Pipeline CreateWrappedPipelineImpl(
         .subpass = 0,
         .basePipelineHandle = 0,
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache());
+    });
 }
 
 vk::Pipeline CreateWrappedPipeline(const Device& device, vk::RenderPass& renderpass,

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -268,7 +268,7 @@ ComputePass::ComputePass(const Device& device_, Scheduler& scheduler, Descriptor
         .layout = *layout,
         .basePipelineHandle = {},
         .basePipelineIndex = 0,
-    }, device.StaticPipelineCache());
+    });
 }
 
 ComputePass::~ComputePass() = default;

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -63,8 +63,6 @@ using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
 constexpr u32 CACHE_VERSION = 18;
-constexpr size_t VULKAN_CACHE_FLUSH_PIPELINES = 128;
-constexpr size_t VULKAN_CACHE_FLUSH_MIN_SECONDS = 30;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
@@ -712,10 +710,6 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
     if (use_vulkan_pipeline_cache) {
         SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
                                      CACHE_VERSION);
-        size_t size = 0;
-        vulkan_pipeline_cache.Read(&size, nullptr);
-        last_cache_size.store(size, std::memory_order_relaxed);
-        last_flush = std::chrono::steady_clock::now();
     }
 
     if (state.statistics) {
@@ -723,35 +717,6 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
     }
 }
 
-void PipelineCache::QueueVulkanPipelineCacheFlush() {
-    if (!use_vulkan_pipeline_cache || vulkan_pipeline_cache_filename.empty()) {
-        return;
-    }
-    if (++pipelines_since_flush < VULKAN_CACHE_FLUSH_PIPELINES) {
-        return;
-    }
-    const auto now = std::chrono::steady_clock::now();
-    const auto megabytes = last_cache_size.load(std::memory_order_relaxed) / (1024 * 1024);
-    const std::chrono::seconds interval{
-        std::max<size_t>(VULKAN_CACHE_FLUSH_MIN_SECONDS, megabytes)};
-    if (last_flush.time_since_epoch().count() != 0 && now - last_flush < interval) {
-        return;
-    }
-    if (flush_in_flight.exchange(true, std::memory_order_acq_rel)) {
-        return;
-    }
-    pipelines_since_flush = 0;
-    last_flush = now;
-    serialization_thread.QueueWork([this] {
-        SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
-                                     CACHE_VERSION);
-        size_t size = 0;
-        vulkan_pipeline_cache.Read(&size, nullptr);
-        last_cache_size.store(size, std::memory_order_relaxed);
-        flush_in_flight.store(false, std::memory_order_release);
-    });
-}
-
 GraphicsPipeline* PipelineCache::CurrentGraphicsPipelineSlowPath() {
     const auto [pair, is_new]{graphics_cache.try_emplace(graphics_key)};
     auto& pipeline{pair->second};
@@ -790,7 +755,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
     std::span<Shader::Environment* const> envs, PipelineStatistics* statistics,
     bool build_in_parallel) try {
     auto hash = key.Hash();
-    LOG_DEBUG(Render_Vulkan, "{:#016x}", hash);
+    LOG_INFO(Render_Vulkan, "{:#016x}", hash);
     size_t env_index{0};
     std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
     const bool uses_vertex_a{key.unique_hashes[0] != 0};
@@ -926,7 +891,6 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
         }
         SerializePipeline(key, env_ptrs, pipeline_cache_filename, CACHE_VERSION);
     });
-    QueueVulkanPipelineCacheFlush();
     return pipeline;
 }
 
@@ -946,7 +910,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
         SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env_},
                           pipeline_cache_filename, CACHE_VERSION);
     });
-    QueueVulkanPipelineCacheFlush();
     return pipeline;
 }
 
@@ -959,7 +922,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
         return nullptr;
     }
 
-    LOG_DEBUG(Render_Vulkan, "{:#016x}", hash);
+    LOG_INFO(Render_Vulkan, "{:#016x}", hash);
 
     Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
 

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -7,8 +7,6 @@
 #pragma once
 
 #include <array>
-#include <atomic>
-#include <chrono>
 #include <cstddef>
 #include <filesystem>
 #include <memory>
@@ -146,8 +144,6 @@ private:
     vk::PipelineCache LoadVulkanPipelineCache(const std::filesystem::path& filename,
                                               u32 expected_cache_version);
 
-    void QueueVulkanPipelineCacheFlush();
-
     const Device& device;
     Scheduler& scheduler;
     DescriptorPool& descriptor_pool;
@@ -175,10 +171,6 @@ private:
 
     std::filesystem::path vulkan_pipeline_cache_filename;
     vk::PipelineCache vulkan_pipeline_cache;
-    size_t pipelines_since_flush{};
-    std::chrono::steady_clock::time_point last_flush{};
-    std::atomic<size_t> last_cache_size{};
-    std::atomic_bool flush_in_flight{};
 
     Common::ThreadWorker workers;
     Common::ThreadWorker serialization_thread;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -7,8 +7,6 @@
 #include <algorithm>
 #include <bitset>
 #include <chrono>
-#include <filesystem>
-#include <fstream>
 #include <optional>
 #include <thread>
 #include <ankerl/unordered_dense.h>
@@ -18,8 +16,6 @@
 #include <fmt/format.h>
 
 #include "common/assert.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
 #include "common/literals.h"
 #include <ranges>
 #include "common/settings.h"
@@ -397,17 +393,6 @@ std::vector<const char*> ExtensionListForVulkan(
     return output;
 }
 
-constexpr std::array<char, 8> STATIC_CACHE_MAGIC_NUMBER{'e', 'd', 'e', 'n', 's', 't', 'p', 'c'};
-constexpr u32 STATIC_CACHE_VERSION = 1;
-
-std::filesystem::path StaticPipelineCacheFilename() {
-    const auto shader_dir = Common::FS::GetEdenPath(Common::FS::EdenPath::ShaderDir);
-    if (!Common::FS::CreateDir(shader_dir)) {
-        return {};
-    }
-    return shader_dir / "vulkan_static_pipelines.bin";
-}
-
 } // Anonymous namespace
 
 void Device::RemoveExtension(bool& extension, const std::string& extension_name) {
@@ -765,100 +750,15 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
 
     vk::Check(vmaCreateAllocator(&allocator_info, &allocator));
 
-    owns_static_pipeline_cache = surface != VkSurfaceKHR{};
-    LoadStaticPipelineCache();
-
     // Initialize GPU logging if enabled
     InitializeGPULogging();
 }
 
 Device::~Device() {
-    SaveStaticPipelineCache();
     ShutdownGPULogging();
     vmaDestroyAllocator(allocator);
 }
 
-void Device::LoadStaticPipelineCache() {
-    const auto create = [this](size_t size, const void* data) {
-        static_pipeline_cache = logical.CreatePipelineCache({
-            .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .initialDataSize = size,
-            .pInitialData = data,
-        });
-    };
-    if (!owns_static_pipeline_cache) {
-        create(0, nullptr);
-        return;
-    }
-    const auto filename = StaticPipelineCacheFilename();
-    if (filename.empty()) {
-        create(0, nullptr);
-        return;
-    }
-    std::vector<char> data;
-    try {
-        std::ifstream file(filename, std::ios::binary | std::ios::ate);
-        if (!file.is_open()) {
-            create(0, nullptr);
-            return;
-        }
-        file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        const size_t total = static_cast<size_t>(file.tellg());
-        file.seekg(0, std::ios::beg);
-        std::array<char, 8> magic{};
-        u32 version{};
-        if (total < magic.size() + sizeof(version)) {
-            create(0, nullptr);
-            return;
-        }
-        file.read(magic.data(), magic.size())
-            .read(reinterpret_cast<char*>(&version), sizeof(version));
-        if (magic != STATIC_CACHE_MAGIC_NUMBER || version != STATIC_CACHE_VERSION) {
-            create(0, nullptr);
-            return;
-        }
-        data.resize(total - magic.size() - sizeof(version));
-        file.read(data.data(), static_cast<std::streamsize>(data.size()));
-    } catch (const std::ios_base::failure& e) {
-        create(0, nullptr);
-        return;
-    }
-    create(data.size(), data.empty() ? nullptr : data.data());
-}
-
-void Device::SaveStaticPipelineCache() const {
-    if (!owns_static_pipeline_cache || !static_pipeline_cache) {
-        return;
-    }
-    const auto filename = StaticPipelineCacheFilename();
-    if (filename.empty()) {
-        return;
-    }
-    size_t size = 0;
-    std::vector<char> data;
-    static_pipeline_cache.Read(&size, nullptr);
-    if (size == 0) {
-        return;
-    }
-    data.resize(size);
-    static_pipeline_cache.Read(&size, data.data());
-    try {
-        std::ofstream file(filename, std::ios::binary | std::ios::trunc);
-        file.exceptions(std::ofstream::failbit);
-        if (!file.is_open()) {
-            return;
-        }
-        file.write(STATIC_CACHE_MAGIC_NUMBER.data(), STATIC_CACHE_MAGIC_NUMBER.size())
-            .write(reinterpret_cast<const char*>(&STATIC_CACHE_VERSION),
-                   sizeof(STATIC_CACHE_VERSION))
-            .write(data.data(), static_cast<std::streamsize>(size));
-    } catch (const std::ios_base::failure& e) {
-        Common::FS::RemoveFile(filename);
-    }
-}
-
 VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
                                     FormatType format_type) const {
     if (IsFormatSupported(wanted_format, wanted_usage, format_type)) {

src/video_core/vulkan_common/vulkan_device.h

@@ -273,10 +273,6 @@ public:
         return physical;
     }
 
-    VkPipelineCache StaticPipelineCache() const noexcept {
-        return *static_pipeline_cache;
-    }
-
     /// Returns the main graphics queue.
     vk::Queue GetGraphicsQueue() const {
         return graphics_queue;
@@ -1131,9 +1127,6 @@ private:
     /// Returns true if the device natively supports blitting depth stencil images.
     bool TestDepthStencilBlits(VkFormat format) const;
 
-    void LoadStaticPipelineCache();
-    void SaveStaticPipelineCache() const;
-
 private:
     VkInstance instance;         ///< Vulkan instance.
     VmaAllocator allocator;      ///< VMA allocator.
@@ -1142,8 +1135,6 @@ private:
     vk::Device logical;          ///< Logical device.
     vk::Queue graphics_queue;    ///< Main graphics queue.
     vk::Queue present_queue;     ///< Main present queue.
-    vk::PipelineCache static_pipeline_cache;
-    bool owns_static_pipeline_cache{};
     u32 instance_version{};      ///< Vulkan instance version.
     u32 graphics_family{};       ///< Main graphics queue family index.
     u32 present_family{};        ///< Main present queue family index.