[settings] add PR4490 & PR4492 toggles

Switch to ffmpeg with liz's gamescope patches.

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md)
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4501
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: lizzie <lizzie@eden-emu.dev>

cpmfile.json

@@ -79,7 +79,7 @@
         "name": "ffmpeg",
         "package": "FFmpeg",
         "repo": "crueter-ci/FFmpeg",
-        "version": "9.0.1-1788120736-bf1b838f2a"
+        "version": "9.0.2-1790726865-946fcce07b"
     },
     "fmt": {
         "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",

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

@@ -16,6 +16,8 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_USE_SPEED_LIMIT("use_speed_limit"),
     USE_CUSTOM_CPU_TICKS("use_custom_cpu_ticks"),
     SKIP_CPU_INNER_INVALIDATION("skip_cpu_inner_invalidation"),
+    NCE_INVALIDATION_GPU_READBACK("nce_invalidation_gpu_readback"),
+    NCE_RUNTIME_NRO_PATCH("nce_runtime_nro_patch"),
     FIX_BLOOM_EFFECTS("fix_bloom_effects"),
     EMULATE_BGR565("emulate_bgr565"),
     RESCALE_HACK("rescale_hack"),

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

@@ -866,6 +866,20 @@ abstract class SettingsItem(
                     descriptionId = R.string.skip_cpu_inner_invalidation_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.NCE_INVALIDATION_GPU_READBACK,
+                    titleId = R.string.nce_invalidation_gpu_readback,
+                    descriptionId = R.string.nce_invalidation_gpu_readback_description
+                )
+            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.NCE_RUNTIME_NRO_PATCH,
+                    titleId = R.string.nce_runtime_nro_patch,
+                    descriptionId = R.string.nce_runtime_nro_patch_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.FIX_BLOOM_EFFECTS,

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

@@ -554,6 +554,8 @@ class SettingsFragmentPresenter(
             add(HeaderSetting(R.string.hacks))
 
             add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
+            add(BooleanSetting.NCE_INVALIDATION_GPU_READBACK.key)
+            add(BooleanSetting.NCE_RUNTIME_NRO_PATCH.key)
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
             add(BooleanSetting.EMULATE_BGR565.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/DriverViewModel.kt

@@ -23,6 +23,7 @@ import org.yuzu.yuzu_emu.model.Driver.Companion.toDriver
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.utils.GpuDriverMetadata
+import org.yuzu.yuzu_emu.utils.DirectoryInitialization
 import org.yuzu.yuzu_emu.utils.NativeConfig
 import java.io.File
 
@@ -146,11 +147,11 @@ class DriverViewModel : ViewModel() {
     private fun wipeGameShaders(game: Game) {
         viewModelScope.launch {
             withContext(Dispatchers.IO) {
-                val externalFilesDir = YuzuApplication.appContext.getExternalFilesDir(null)
+                val userDirectory = DirectoryInitialization.userDirectory
                     ?: return@withContext
                 val shaderDir = File(
-                    externalFilesDir.absolutePath +
-                    "/shader/" + game.settingsName.lowercase()
+                    userDirectory +
+                    "/cache/shader/" + game.settingsName.lowercase()
                 )
                 if (shaderDir.exists()) {
                     shaderDir.deleteRecursively()

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

@@ -595,6 +595,10 @@
     <string name="fast_gpu_time_description">Makes the game believe GPU work finishes faster than it does, so it stops lowering resolution and render distance to fit the Switch\'s clocks.</string>
     <string name="skip_cpu_inner_invalidation">Skip CPU Inner Invalidation</string>
     <string name="skip_cpu_inner_invalidation_description">Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and improving it\'s performance. This may cause glitches or crashes on some games.</string>
+    <string name="nce_invalidation_gpu_readback">GPU Readback Before NCE Invalidation</string>
+    <string name="nce_invalidation_gpu_readback_description">Temporary. Fix Ender Magnolia (and other UE titles) crashes. May reduce performance. Improvement in progress.</string>
+    <string name="nce_runtime_nro_patch">Patch Runtime NROs for NCE</string>
+    <string name="nce_runtime_nro_patch_description">Temporary. Fix Biomutant boot. May impact performance. Improvement in progress.</string>
     <string name="fix_bloom_effects">Fix Bloom Effects</string>
     <string name="fix_bloom_effects_description">Reduces bloom blur in LA/EOW (Adreno A6XX - A7XX/ Turnip), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</string>
     <string name="emulate_bgr565">Emulate BGR565</string>

src/audio_core/adsp/adsp.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -19,11 +19,6 @@ ADSP::ADSP(Core::System& system, Sink::Sink& sink) {
     }
 }
 
-void ADSP::Shutdown() {
-    audio_renderer->Stop();
-    opus_decoder->Shutdown();
-}
-
 AudioRenderer::AudioRenderer& ADSP::AudioRenderer() {
     return *audio_renderer;
 }

src/audio_core/adsp/adsp.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -45,7 +45,6 @@ public:
     explicit ADSP(Core::System& system, Sink::Sink& sink);
     ~ADSP() = default;
 
-    void Shutdown();
     AudioRenderer::AudioRenderer& AudioRenderer();
     OpusDecoder::OpusDecoder& OpusDecoder();
 

src/audio_core/adsp/apps/audio_renderer/audio_renderer.cpp

@@ -34,19 +34,26 @@ void AudioRenderer::Start() {
 
     mailbox.Send(Direction::DSP, Message::InitializeOK);
     if (mailbox.Receive(Direction::Host) != Message::InitializeOK) {
-        LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown message response from ADSP!");
+        LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
+                                 "message response from ADSP!");
+        return;
     }
+    running = true;
 }
 
 void AudioRenderer::Stop() {
-    if (main_thread.joinable()) {
-        main_thread.request_stop();
-        mailbox.Send(Direction::DSP, Message::Shutdown);
-        if (mailbox.Receive(Direction::Host, main_thread.get_stop_token()) != Message::Shutdown) {
-            LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown message response from ADSP!");
-        }
-        main_thread.join();
+    if (!running) {
+        return;
     }
+
+    mailbox.Send(Direction::DSP, Message::Shutdown);
+    if (mailbox.Receive(Direction::Host) != Message::Shutdown) {
+        LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
+                                 "message response from ADSP!");
+    }
+    main_thread.request_stop();
+    main_thread.join();
+
     for (auto& stream : streams) {
         if (stream) {
             stream->Stop();
@@ -54,6 +61,7 @@ void AudioRenderer::Stop() {
             stream = nullptr;
         }
     }
+    running = false;
 }
 
 void AudioRenderer::Signal() {
@@ -61,12 +69,13 @@ void AudioRenderer::Signal() {
     Send(Direction::DSP, Message::Render);
 }
 
-void AudioRenderer::Wait(std::stop_token stop_token) {
-    auto msg = mailbox.Receive(Direction::Host, stop_token);
+void AudioRenderer::Wait() {
+    auto msg = Receive(Direction::Host);
     if (msg != Message::RenderResponse) {
         LOG_ERROR(Service_Audio,
-            "Did not receive the expected render response from the AudioRenderer! Expected "
-            "{}, got {}", Message::RenderResponse, msg);
+                  "Did not receive the expected render response from the AudioRenderer! Expected "
+                  "{}, got {}",
+                  Message::RenderResponse, msg);
     }
     PostDSPClearCommandBuffer();
 }
@@ -138,9 +147,7 @@ void AudioRenderer::Main(std::stop_token stop_token) {
     constexpr u64 max_process_time{2'304'000ULL};
 
     while (!stop_token.stop_requested()) {
-        auto msg = mailbox.Receive(Direction::DSP, stop_token);
-        if (stop_token.stop_requested())
-            break;
+        auto msg{mailbox.Receive(Direction::DSP)};
         switch (msg) {
         case Message::Shutdown:
             mailbox.Send(Direction::Host, Message::Shutdown);

src/audio_core/adsp/apps/audio_renderer/audio_renderer.h

@@ -63,15 +63,13 @@ public:
      */
     void Start();
 
-    void NotifyShutdown();
-
     /**
      * Stop the AudioRenderer.
      */
     void Stop();
 
     void Signal();
-    void Wait(std::stop_token stop_token);
+    void Wait();
 
     void Send(Direction dir, u32 message);
     u32 Receive(Direction dir);
@@ -104,6 +102,8 @@ private:
     Mailbox mailbox;
     /// Main thread
     std::jthread main_thread{};
+    /// The current state
+    std::atomic<bool> running{};
     /// Shared memory of input command buffers, set by host, read by DSP
     std::array<CommandBuffer, MaxRendererSessions> command_buffers{};
     /// The command lists to process

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -41,16 +41,19 @@ OpusDecoder::OpusDecoder(Core::System& system_) : system{system_} {
 }
 
 OpusDecoder::~OpusDecoder() {
-    if (main_thread.joinable()) {
-        // Shutdown the thread
-        Send(Direction::DSP, Message::Shutdown);
-        main_thread.request_stop();
-        auto msg = Receive(Direction::Host, main_thread.get_stop_token());
-        ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}", Message::ShutdownOK, msg);
-        main_thread.join();
-    } else {
+    if (!running) {
         init_thread.request_stop();
+        return;
     }
+
+    // Shutdown the thread
+    Send(Direction::DSP, Message::Shutdown);
+    auto msg = Receive(Direction::Host);
+    ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}",
+               Message::ShutdownOK, msg);
+    main_thread.request_stop();
+    main_thread.join();
+    running = false;
 }
 
 void OpusDecoder::Send(Direction dir, u32 message) {
@@ -70,6 +73,7 @@ void OpusDecoder::Init(std::stop_token stop_token) {
         return;
     }
     main_thread = std::jthread([this](std::stop_token st) { Main(st); });
+    running = true;
     Send(Direction::Host, Message::StartOK);
 }
 
@@ -78,15 +82,12 @@ void OpusDecoder::Main(std::stop_token stop_token) {
 
     while (!stop_token.stop_requested()) {
         auto msg = Receive(Direction::DSP, stop_token);
-        if (stop_token.stop_requested())
-            break;
-
         switch (msg) {
-        case Message::Shutdown:
+        case Shutdown:
             Send(Direction::Host, Message::ShutdownOK);
             return;
 
-        case Message::GetWorkBufferSize: {
+        case GetWorkBufferSize: {
             auto channel_count = static_cast<s32>(shared_memory->host_send_data[0]);
 
             ASSERT(IsValidChannelCount(channel_count));
@@ -95,7 +96,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::GetWorkBufferSizeOK);
         } break;
 
-        case Message::InitializeDecodeObject: {
+        case InitializeDecodeObject: {
             auto buffer = shared_memory->host_send_data[0];
             auto buffer_size = shared_memory->host_send_data[1];
             auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
@@ -112,7 +113,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::InitializeDecodeObjectOK);
         } break;
 
-        case Message::ShutdownDecodeObject: {
+        case ShutdownDecodeObject: {
             auto buffer = shared_memory->host_send_data[0];
             [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
 
@@ -122,7 +123,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::ShutdownDecodeObjectOK);
         } break;
 
-        case Message::DecodeInterleaved: {
+        case DecodeInterleaved: {
             auto start_time = system.CoreTiming().GetGlobalTimeUs();
 
             auto buffer = shared_memory->host_send_data[0];
@@ -160,19 +161,19 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::DecodeInterleavedOK);
         } break;
 
-        case Message::MapMemory: {
+        case MapMemory: {
             [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
             [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
             Send(Direction::Host, Message::MapMemoryOK);
         } break;
 
-        case Message::UnmapMemory: {
+        case UnmapMemory: {
             [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
             [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
             Send(Direction::Host, Message::UnmapMemoryOK);
         } break;
 
-        case Message::GetWorkBufferSizeForMultiStream: {
+        case GetWorkBufferSizeForMultiStream: {
             auto total_stream_count = static_cast<s32>(shared_memory->host_send_data[0]);
             auto stereo_stream_count = static_cast<s32>(shared_memory->host_send_data[1]);
 
@@ -183,7 +184,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::GetWorkBufferSizeForMultiStreamOK);
         } break;
 
-        case Message::InitializeMultiStreamDecodeObject: {
+        case InitializeMultiStreamDecodeObject: {
             auto buffer = shared_memory->host_send_data[0];
             auto buffer_size = shared_memory->host_send_data[1];
             auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
@@ -210,7 +211,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::InitializeMultiStreamDecodeObjectOK);
         } break;
 
-        case Message::ShutdownMultiStreamDecodeObject: {
+        case ShutdownMultiStreamDecodeObject: {
             auto buffer = shared_memory->host_send_data[0];
             [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
 
@@ -220,7 +221,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             Send(Direction::Host, Message::ShutdownMultiStreamDecodeObjectOK);
         } break;
 
-        case Message::DecodeInterleavedForMultiStream: {
+        case DecodeInterleavedForMultiStream: {
             auto start_time = system.CoreTiming().GetGlobalTimeUs();
 
             auto buffer = shared_memory->host_send_data[0];
@@ -265,15 +266,4 @@ void OpusDecoder::Main(std::stop_token stop_token) {
     }
 }
 
-void OpusDecoder::Shutdown() {
-    if (init_thread.joinable()) {
-        init_thread.request_stop();
-        init_thread.join(); //must explicitly wait for init to join
-    }
-    if (main_thread.joinable()) {
-        main_thread.request_stop();
-        Send(Direction::DSP, Message::Shutdown);
-    }
-}
-
 } // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_decoder.h

@@ -57,7 +57,7 @@ public:
     ~OpusDecoder();
 
     bool IsRunning() const noexcept {
-        return main_thread.joinable();
+        return running;
     }
 
     void Send(Direction dir, u32 message);
@@ -67,8 +67,6 @@ public:
         shared_memory = &shared_memory_;
     }
 
-    void Shutdown();
-
 private:
     /**
      * Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
@@ -87,6 +85,8 @@ private:
     std::jthread init_thread{};
     /// Main thread
     std::jthread main_thread{};
+    /// The current state
+    bool running{};
     /// Structure shared with the host, input data set by the host before sending a mailbox message,
     /// and the responses are written back by the OpusDecoder.
     SharedMemory* shared_memory{};

src/audio_core/audio_core.cpp

@@ -33,7 +33,6 @@ void AudioCore::CreateSinks() {
 
 void AudioCore::Shutdown() {
     audio_manager->Shutdown();
-    adsp->Shutdown();
 }
 
 AudioManager& AudioCore::GetAudioManager() {

src/audio_core/audio_manager.cpp

@@ -17,7 +17,7 @@ AudioManager::AudioManager() {
         std::unique_lock l{events.GetAudioEventLock()};
         events.ClearEvents();
         while (!stop_token.stop_requested()) {
-            const auto timed_out = events.Wait(l, std::chrono::seconds{2});
+            const auto timed_out{events.Wait(l, std::chrono::seconds(2))};
             if (events.CheckAudioEventSet(Event::Type::Max)) {
                 break;
             }
@@ -35,9 +35,9 @@ AudioManager::AudioManager() {
 }
 
 void AudioManager::Shutdown() {
+    events.SetAudioEvent(Event::Type::Max, true);
     if (thread.joinable()) {
         thread.request_stop();
-        events.SetAudioEvent(Event::Type::Max, true);
         thread.join();
     }
 }

src/audio_core/audio_manager.h

@@ -39,7 +39,9 @@ class AudioManager {
 public:
     explicit AudioManager();
 
-    /// @brief Shutdown the audio manager.
+    /**
+     * Shutdown the audio manager.
+     */
     void Shutdown();
 
     /**

src/audio_core/renderer/sink/circular_buffer_sink_info.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -38,7 +35,7 @@ void CircularBufferSinkInfo::Update(BehaviorInfo::ErrorInfo& error_info, OutStat
     auto current_params{reinterpret_cast<CircularBufferInParameter*>(parameter.data())};
     auto current_state{reinterpret_cast<CircularBufferState*>(state.data())};
 
-    if (in_use == bool(buffer_params->in_use) && !buffer_unmapped) {
+    if (in_use == buffer_params->in_use && !buffer_unmapped) {
         error_info.error_code = ResultSuccess;
         error_info.address = CpuAddr(0);
         out_status.writeOffset = current_state->last_pos2;

src/audio_core/renderer/sink/sink_info_base.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -31,10 +31,10 @@ public:
     };
 
     struct DeviceInParameter {
-        /* 0x000 */ u8 name[0x100];
+        /* 0x000 */ char name[0x100];
         /* 0x100 */ u32 input_count;
         /* 0x104 */ std::array<s8, MaxChannels> inputs;
-        /* 0x10A */ u8 unk10A[0x1];
+        /* 0x10A */ char unk10A[0x1];
         /* 0x10B */ bool downmix_enabled;
         /* 0x10C */ std::array<f32, 4> downmix_coeff;
     };
@@ -43,7 +43,7 @@ public:
     struct DeviceState {
         /* 0x00 */ UpsamplerInfo* upsampler_info;
         /* 0x08 */ std::array<Common::FixedPoint<16, 16>, 4> downmix_coeff;
-        /* 0x18 */ u8 unk18[0x18];
+        /* 0x18 */ char unk18[0x18];
     };
     static_assert(sizeof(DeviceState) == 0x30, "DeviceState has the wrong size!");
 
@@ -55,8 +55,8 @@ public:
         /* 0x14 */ u32 previous_pos;
         /* 0x18 */ SampleFormat format;
         /* 0x1C */ std::array<s8, MaxChannels> inputs;
-        /* 0x22 */ u8 in_use;
-        /* 0x23 */ u8 unk23[0x5];
+        /* 0x22 */ bool in_use;
+        /* 0x23 */ char unk23[0x5];
     };
     static_assert(sizeof(CircularBufferInParameter) == 0x28,
                   "CircularBufferInParameter has the wrong size!");
@@ -65,16 +65,16 @@ public:
         /* 0x00 */ u32 last_pos2;
         /* 0x04 */ s32 current_pos;
         /* 0x08 */ u32 last_pos;
-        /* 0x0C */ u8 unk0C[0x4];
+        /* 0x0C */ char unk0C[0x4];
         /* 0x10 */ AddressInfo address_info;
     };
     static_assert(sizeof(CircularBufferState) == 0x30, "CircularBufferState has the wrong size!");
 
     struct InParameter {
         /* 0x000 */ Type type;
-        /* 0x001 */ u8 in_use;
+        /* 0x001 */ bool in_use;
         /* 0x004 */ u32 node_id;
-        /* 0x008 */ u8 unk08[0x18];
+        /* 0x008 */ char unk08[0x18];
         union {
             /* 0x020 */ DeviceInParameter device;
             /* 0x020 */ CircularBufferInParameter circular_buffer;
@@ -84,7 +84,7 @@ public:
 
     struct OutStatus {
         /* 0x00 */ u32 writeOffset;
-        /* 0x04 */ u8 unk04[0x1C];
+        /* 0x04 */ char unk04[0x1C];
     }; // size == 0x20
     static_assert(sizeof(OutStatus) == 0x20, "SinkInfoBase::OutStatus has the wrong size!");
 
@@ -162,18 +162,19 @@ public:
     u8* GetParameter();
 
 protected:
+    /// Type of this sink
+    Type type{Type::Invalid};
+    /// Is this sink in use?
+    bool in_use{};
+    /// Is this sink's buffer unmapped? Circular only
+    bool buffer_unmapped{};
+    /// Node id for this sink
+    u32 node_id{};
     /// State buffer for this sink
     std::array<u8, (std::max)(sizeof(DeviceState), sizeof(CircularBufferState))> state{};
     /// Parameter buffer for this sink
-    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))> parameter{};
-    /// Type of this sink
-    Type type{Type::Invalid};
-    /// Node id for this sink
-    u32 node_id{};
-    /// Is this sink in use?
-    bool in_use : 1 = false;
-    /// Is this sink's buffer unmapped? Circular only
-    bool buffer_unmapped : 1 = false;
+    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))>
+        parameter{};
 };
 
 } // namespace AudioCore::Renderer

src/audio_core/renderer/system.cpp

@@ -100,9 +100,8 @@ u64 System::GetWorkBufferSize(const AudioRendererParameterInternal& params) {
 }
 
 System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
-    : core{core_}
-    , adsp_rendered_event{adsp_rendered_event_}
-{}
+    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()},
+      adsp_rendered_event{adsp_rendered_event_} {}
 
 Result System::Initialize(const AudioRendererParameterInternal& params,
                           Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
@@ -407,7 +406,7 @@ void System::Finalize() {
         return;
     }
 
-    if (IsActive()) {
+    if (active) {
         Stop();
     }
 
@@ -434,12 +433,14 @@ void System::Start() {
     std::scoped_lock l{lock};
     frames_elapsed = 0;
     state = State::Started;
+    active = true;
 }
 
 void System::Stop() {
     {
         std::scoped_lock l{lock};
         state = State::Stopped;
+        active = false;
     }
 
     if (execution_mode == ExecutionMode::Auto) {
@@ -479,7 +480,7 @@ Result System::Update(std::span<const u8> input, std::span<u8> performance, std:
         return result;
     }
 
-    result = info_updater.UpdateEffects(effect_context, IsActive(), memory_pool_workbuffer,
+    result = info_updater.UpdateEffects(effect_context, active, memory_pool_workbuffer,
                                         memory_pool_count);
     if (result.IsError()) {
         LOG_ERROR(Service_Audio, "Failed to update Effects!");
@@ -581,16 +582,16 @@ u32 System::GetRenderingDevice() const {
 }
 
 bool System::IsActive() const {
-    return state == State::Started;
+    return active;
 }
 
 void System::SendCommandToDsp() {
     std::scoped_lock l{lock};
 
     if (initialized) {
-        if (IsActive()) {
+        if (active) {
             terminate_event.Reset();
-            const auto remaining_command_count = core.AudioCore().ADSP().AudioRenderer().GetRemainCommandCount(session_id);
+            const auto remaining_command_count{audio_renderer.GetRemainCommandCount(session_id)};
             u64 command_size{0};
 
             if (remaining_command_count) {
@@ -617,17 +618,16 @@ void System::SendCommandToDsp() {
             auto time_limit{
                 static_cast<u64>((time_limit_percent / 100) * 2'880'000.0 *
                                  (static_cast<f32>(render_time_limit_percent) / 100.0f))};
-            core.AudioCore().ADSP().AudioRenderer().SetCommandBuffer(session_id,
-                translated_addr, command_size,
-                time_limit, applet_resource_user_id,
-                process_handle, reset_command_buffers);
+            audio_renderer.SetCommandBuffer(session_id, translated_addr, command_size, time_limit,
+                                            applet_resource_user_id, process_handle,
+                                            reset_command_buffers);
             reset_command_buffers = false;
             command_buffer_size = command_size;
             if (remaining_command_count == 0) {
                 adsp_rendered_event->Signal(core.Kernel());
             }
         } else {
-            core.AudioCore().ADSP().AudioRenderer().ClearRemainCommandCount(session_id);
+            audio_renderer.ClearRemainCommandCount(session_id);
             terminate_event.Set();
         }
     }
@@ -738,7 +738,7 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
     const auto end_time{core.CoreTiming().GetGlobalTimeNs().count()};
     total_ticks_elapsed += end_time - start_time;
     num_command_lists_generated++;
-    render_start_tick = core.AudioCore().ADSP().AudioRenderer().GetRenderingStartTick(session_id);
+    render_start_tick = audio_renderer.GetRenderingStartTick(session_id);
     frames_elapsed++;
 
     return command_buffer.size;

src/audio_core/renderer/system.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -222,6 +219,8 @@ public:
 private:
     /// Core system
     Core::System& core;
+    /// Reference to the ADSP's AudioRenderer for communication
+    ::AudioCore::ADSP::AudioRenderer::AudioRenderer& audio_renderer;
     /// Is this system initialized?
     bool initialized{};
     /// Is this system currently active?

src/audio_core/renderer/system_manager.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -11,70 +11,73 @@
 #include "audio_core/renderer/system_manager.h"
 #include "common/thread.h"
 #include "core/core.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/k_scheduler.h"
 #include "core/core_timing.h"
 
 namespace AudioCore::Renderer {
 
 SystemManager::SystemManager(Core::System& core_)
-    : core{core_}
-{
-}
+    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()} {}
 
 SystemManager::~SystemManager() {
     Stop();
 }
 
 void SystemManager::InitializeUnsafe() {
-    if (!thread.joinable()) {
-        core.AudioCore().ADSP().AudioRenderer().Start();
-        thread = core.Kernel().RunOnHostCoreThread("AudioRenderSystemManager", [this]() {
-            auto& audio_renderer = core.AudioCore().ADSP().AudioRenderer();
-            auto const stop_token = thread.get_stop_token();
-            while (!stop_token.stop_requested()) {
+    if (!active) {
+        active = true;
+        audio_renderer.Start();
+        thread = std::jthread([this](std::stop_token stop_token) {
+            Common::SetCurrentThreadName("AudioRenderSystemManager");
+            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+            while (active && !stop_token.stop_requested()) {
                 {
-                    std::scoped_lock lk{mutex};
+                    std::scoped_lock l{mutex1};
                     for (auto system : systems)
                         system->SendCommandToDsp();
                 }
                 audio_renderer.Signal();
-                audio_renderer.Wait(stop_token);
+                audio_renderer.Wait();
             }
         });
     }
 }
 
 void SystemManager::Stop() {
-    core.AudioCore().ADSP().AudioRenderer().Stop();
-    if (thread.joinable()) {
+    if (active) {
+        active = false;
         thread.request_stop();
         thread.join();
+        audio_renderer.Stop();
     }
 }
 
 bool SystemManager::Add(System& system_) {
-    std::scoped_lock lk{mutex};
-    if (systems.size() >= MaxRendererSessions) {
+    std::scoped_lock l2{mutex2};
+    if (systems.size() + 1 > MaxRendererSessions) {
         LOG_ERROR(Service_Audio, "Maximum AudioRenderer Systems active, cannot add more!");
         return false;
     }
-    systems.push_back(&system_);
-    if (!systems.empty()) {
-        InitializeUnsafe();
+    {
+        std::scoped_lock l{mutex1};
+        if (systems.empty())
+            InitializeUnsafe();
     }
+    systems.push_back(&system_);
     return true;
 }
 
 bool SystemManager::Remove(System& system_) {
-    std::scoped_lock lk{mutex};
-    if (systems.remove(&system_) == 0) {
-        LOG_ERROR(Service_Audio, "Failed to remove a render system, it was not found in the list!");
-        return false;
+    std::scoped_lock l2{mutex2};
+    {
+        std::scoped_lock l{mutex1};
+        if (systems.remove(&system_) == 0) {
+            LOG_ERROR(Service_Audio, "Failed to remove a render system, it was not found in the list!");
+            return false;
+        }
     }
-    if (systems.empty()) {
+
+    if (systems.empty())
         Stop();
-    }
     return true;
 }
 

src/audio_core/renderer/system_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -75,8 +75,14 @@ private:
     std::list<System*> systems{};
     /// Main worker thread for generating command lists
     std::jthread thread;
-    /// Mutex for the reading and adding/removing systems
-    std::mutex mutex{};
+    /// Mutex for the systems
+    std::mutex mutex1{};
+    /// Mutex for adding/removing systems
+    std::mutex mutex2{};
+    /// Is the system manager thread active?
+    std::atomic<bool> active{};
+    /// Reference to the ADSP's AudioRenderer for communication
+    ::AudioCore::ADSP::AudioRenderer::AudioRenderer& audio_renderer;
 };
 
 } // namespace AudioCore::Renderer

src/common/bounded_threadsafe_queue.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -109,6 +109,12 @@ private:
             if (read_index == producer.index.load(std::memory_order::acquire)) {
                 return false;
             }
+        } else if constexpr (Mode == PopMode::Wait) {
+            // Wait until the queue is not empty.
+            std::unique_lock lock{consumer.cv_mutex};
+            consumer.cv.wait(lock, [this, read_index] {
+                return read_index != producer.index.load(std::memory_order::acquire);
+            });
         } else if constexpr (Mode == PopMode::WaitWithStopToken) {
             // Wait until the queue is not empty.
             std::unique_lock lock{consumer.cv_mutex};
@@ -118,12 +124,6 @@ private:
             if (stop_token.stop_requested()) {
                 return false;
             }
-        } else if constexpr (Mode == PopMode::Wait) {
-            // Wait until the queue is not empty.
-            std::unique_lock lock{consumer.cv_mutex};
-            consumer.cv.wait(lock, [this, read_index] {
-                return read_index != producer.index.load(std::memory_order::acquire);
-            });
         } else {
             static_assert(Mode < PopMode::Count, "Invalid PopMode.");
         }

src/common/settings.h

@@ -639,6 +639,10 @@ struct Values {
                                                         Specialization::Default,
                                                         true,
                                                         true};
+    SwitchableSetting<bool> nce_invalidation_gpu_readback{
+        linkage, false, "nce_invalidation_gpu_readback", Category::RendererHacks};
+    SwitchableSetting<bool> nce_runtime_nro_patch{
+        linkage, false, "nce_runtime_nro_patch", Category::RendererHacks};
     SwitchableSetting<bool> async_presentation{linkage,
 #ifdef __ANDROID__
                                                false,

src/common/settings_enums.h

@@ -150,7 +150,7 @@ ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, Lanczos, Scale
 ENUM(AntiAliasing, None, Fxaa, Smaa);
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 ENUM(ConsoleMode, Handheld, Docked);
-ENUM(AppletMode, HLE, LLE);
+ENUM(AppletMode, HLE, LLE, Disabled);
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuClock, Normal, Boost, Overclock)
 ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)

src/core/core.cpp

@@ -110,13 +110,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
 struct System::Impl {
     explicit Impl(System& system)
-        : kernel{system}
-        , fs_controller{system}
-        , hid_core{kernel}
-        , cpu_manager{system}
-        , reporter{system}
-        , profile_manager{}
-    {}
+        : kernel{system}, fs_controller{system}, hid_core{kernel}, cpu_manager{system},
+          reporter{system}, applet_manager{system}, frontend_applets{system}, profile_manager{} {}
 
     u64 program_id;
 
@@ -129,12 +124,6 @@ struct System::Impl {
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        applet_manager.emplace(system);
-        frontend_applets.emplace(system);
-        apm_controller.emplace(core_timing);
-        arp_manager.emplace();
-        profile_manager.emplace();
-
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr) {
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
@@ -144,7 +133,7 @@ struct System::Impl {
         }
 
         // Create default implementations of applets if one is not provided.
-        frontend_applets->SetDefaultAppletsIfMissing();
+        frontend_applets.SetDefaultAppletsIfMissing();
 
         auto const is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
 
@@ -387,7 +376,7 @@ struct System::Impl {
 
         // Register with applet manager
         // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager->CreateAndInsertByFrontendAppletParameters(std::move(process), params);
+        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);
 
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {
@@ -439,27 +428,13 @@ struct System::Impl {
         core_timing.SyncPause(false);
         Network::CancelPendingSocketOperations();
         kernel.SuspendEmulation(true);
-        kernel.ShutdownCores();
-
-        // Notify services helpers of shutdown
-        audio_core->Shutdown();
-
-        // Wait for threads/services to join
         kernel.CloseServices();
-
-        // service shutdown
+        kernel.ShutdownCores();
         services.reset();
         service_manager.reset();
-        frontend_applets.reset();
-        applet_manager.reset();
-        apm_controller.reset();
-        arp_manager.reset();
-        profile_manager.reset();
-
         fs_controller.Reset();
         cheat_engine.reset();
         core_timing.ClearPendingEvents();
-        core_timing.Reset();
         app_loader.reset();
         audio_core.reset();
         gpu_core.reset();
@@ -476,6 +451,9 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
+        // Reset all glue registrations
+        arp_manager.ResetAll();
+
         LOG_DEBUG(Core, "Shutdown OK");
     }
 
@@ -504,13 +482,13 @@ struct System::Impl {
     CpuManager cpu_manager;
     Reporter reporter;
     /// Applets
-    std::optional<Service::AM::AppletManager> applet_manager;
-    std::optional<Service::AM::Frontend::FrontendAppletHolder> frontend_applets;
+    Service::AM::AppletManager applet_manager;
+    Service::AM::Frontend::FrontendAppletHolder frontend_applets;
     /// APM (Performance) services
-    std::optional<Service::APM::Controller> apm_controller;
+    Service::APM::Controller apm_controller{core_timing};
     /// Service State
-    std::optional<Service::Glue::ARPManager> arp_manager;
-    std::optional<Service::Account::ProfileManager> profile_manager;
+    Service::Glue::ARPManager arp_manager;
+    Service::Account::ProfileManager profile_manager;
     /// Network instance
     Network::NetworkInstance network_instance;
     Core::SpeedLimiter speed_limiter;
@@ -837,19 +815,19 @@ void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
 }
 
 void System::SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet&& set) {
-    impl->frontend_applets->SetFrontendAppletSet(std::move(set));
+    impl->frontend_applets.SetFrontendAppletSet(std::move(set));
 }
 
 Service::AM::Frontend::FrontendAppletHolder& System::GetFrontendAppletHolder() {
-    return *impl->frontend_applets;
+    return impl->frontend_applets;
 }
 
 const Service::AM::Frontend::FrontendAppletHolder& System::GetFrontendAppletHolder() const {
-    return *impl->frontend_applets;
+    return impl->frontend_applets;
 }
 
 Service::AM::AppletManager& System::GetAppletManager() {
-    return *impl->applet_manager;
+    return impl->applet_manager;
 }
 
 void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
@@ -890,27 +868,27 @@ const Reporter& System::GetReporter() const {
 }
 
 Service::Glue::ARPManager& System::GetARPManager() {
-    return *impl->arp_manager;
+    return impl->arp_manager;
 }
 
 const Service::Glue::ARPManager& System::GetARPManager() const {
-    return *impl->arp_manager;
+    return impl->arp_manager;
 }
 
 Service::APM::Controller& System::GetAPMController() {
-    return *impl->apm_controller;
+    return impl->apm_controller;
 }
 
 const Service::APM::Controller& System::GetAPMController() const {
-    return *impl->apm_controller;
+    return impl->apm_controller;
 }
 
 Service::Account::ProfileManager& System::GetProfileManager() {
-    return *impl->profile_manager;
+    return impl->profile_manager;
 }
 
 const Service::Account::ProfileManager& System::GetProfileManager() const {
-    return *impl->profile_manager;
+    return impl->profile_manager;
 }
 
 void System::SetExitLocked(bool locked) {

src/core/core_timing.cpp

@@ -304,10 +304,10 @@ std::optional<s64> CoreTiming::Advance() {
 
 void CoreTiming::Reset() {
     paused = true;
+    pause_event.Set();
+    event.Set();
     if (timer_thread.joinable()) {
         timer_thread.request_stop();
-        pause_event.Set();
-        event.Set();
         timer_thread.join();
     }
     has_started = false;

src/core/hle/kernel/global_scheduler_context.cpp

@@ -72,9 +72,11 @@ void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) noe
 
 void GlobalSchedulerContext::WakeupWaitingDummyThreads(KernelCore& kernel) noexcept {
     ASSERT(this->IsLocked());
-    for (auto* thread : m_woken_dummy_threads)
-        thread->DummyThreadEndWait(kernel);
-    m_woken_dummy_threads.clear();
+    if (m_woken_dummy_threads.size() > 0) {
+        for (auto* thread : m_woken_dummy_threads)
+            thread->DummyThreadEndWait(kernel);
+        m_woken_dummy_threads.clear();
+    }
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_process.cpp

@@ -59,6 +59,7 @@ Result TerminateChildren(KernelCore& kernel, KProcess* process, const KThread* t
         KThread* cur_child = nullptr;
         {
             KScopedLightLock proc_lk(process->GetListLock());
+
             auto& thread_list = process->GetThreadList();
             for (auto it = thread_list.begin(); it != thread_list.end(); ++it) {
                 if (KThread* thread = std::addressof(*it); thread != thread_to_not_terminate) {

src/core/hle/kernel/k_thread.cpp

@@ -1236,13 +1236,18 @@ namespace Kernel {
         KScopedSchedulerLock sl{kernel};
 
         // Determine if this is the first termination request.
-        // Perform an atomic compare-and-swap from false to true.
-        bool expected = false;
+        const bool first_request = [&]() -> bool {
+            // Perform an atomic compare-and-swap from false to true.
+            bool expected = false;
+            return m_termination_requested.compare_exchange_strong(expected, true);
+        }();
+
         // If this is the first request, start termination procedure.
-        if (m_termination_requested.compare_exchange_strong(expected, true)) {
+        if (first_request) {
             // If the thread is in initialized state, just change state to terminated.
             if (this->GetState() == ThreadState::Initialized) {
-                return m_thread_state = ThreadState::Terminated;
+                m_thread_state = ThreadState::Terminated;
+                return ThreadState::Terminated;
             }
 
             // Register the terminating dpc.
@@ -1276,6 +1281,7 @@ namespace Kernel {
                 m_wait_queue->CancelWait(kernel, this, ResultTerminationRequested, true);
             }
         }
+
         return this->GetState();
     }
 

src/core/hle/kernel/k_worker_task_manager.cpp

@@ -4,9 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <thread>
 #include "common/assert.h"
-#include "common/thread.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_worker_task.h"
@@ -28,33 +26,7 @@ void KWorkerTask::DoWorkerTask(KernelCore& kernel) {
     }
 }
 
-KWorkerTaskManager::KWorkerTaskManager(KernelCore& kernel) {
-    m_waiting_thread = std::jthread([&kernel, this](std::stop_token stop_token) {
-        Common::SetCurrentThreadName("KWorkerManager");
-        while (!stop_token.stop_requested()) {
-            KWorkerTask* t;
-            {
-                std::unique_lock lk{m_task_mutex};
-                m_task_cv.wait(lk, m_waiting_thread.get_stop_token(), [&]() {
-                    return !m_task_queue.empty();
-                });
-                if (stop_token.stop_requested())
-                    break;
-                t = m_task_queue.back();
-                m_task_queue.pop_back();
-            }
-            t->DoWorkerTask(kernel);
-        }
-    });
-}
-
-KWorkerTaskManager::~KWorkerTaskManager() {
-    if (m_waiting_thread.joinable()) {
-        m_waiting_thread.request_stop();
-        m_task_cv.notify_one();
-        m_waiting_thread.join();
-    }
-}
+KWorkerTaskManager::KWorkerTaskManager() : m_waiting_thread(1, "KWorkerTaskManager") {}
 
 void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task) {
     ASSERT(type <= WorkerType::Count);
@@ -63,11 +35,10 @@ void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTas
 
 void KWorkerTaskManager::AddTask(KernelCore& kernel, KWorkerTask* task) {
     KScopedSchedulerLock sl(kernel);
-    {
-        std::scoped_lock lk{m_task_mutex};
-        m_task_queue.emplace_back(task);
-    }
-    m_task_cv.notify_one();
+    m_waiting_thread.QueueWork([&kernel, task]() {
+        // Do the task.
+        task->DoWorkerTask(kernel);
+    });
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_worker_task_manager.h

@@ -1,13 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include <condition_variable>
-#include <thread>
 #include "common/common_types.h"
 #include "common/thread_worker.h"
 
@@ -23,17 +18,15 @@ public:
         Count,
     };
 
-    KWorkerTaskManager(KernelCore& kernel);
-    ~KWorkerTaskManager();
+    KWorkerTaskManager();
 
     static void AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task);
+
 private:
     void AddTask(KernelCore& kernel, KWorkerTask* task);
-    std::jthread m_waiting_thread;
 
-    std::mutex m_task_mutex;
-    std::condition_variable_any m_task_cv;
-    std::vector<KWorkerTask*> m_task_queue;
+private:
+    Common::ThreadWorker m_waiting_thread;
 };
 
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -80,10 +80,7 @@ struct KernelCore::Impl {
     // so it will be statically given a TLS slot anyways.
     static inline thread_local ThreadLocalData tls_data = {};
 
-    explicit Impl(Core::System& system_, KernelCore& kernel_)
-        : worker_task_manager{kernel_}
-        , system{system_}
-    {
+    explicit Impl(Core::System& system_, KernelCore& kernel_) : system{system_} {
         tls_data.lock = true;
     }
 
@@ -970,16 +967,12 @@ Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
     return *impl->hardware_timer;
 }
 
-KAutoObjectWithListContainer* KernelCore::ObjectListContainer() {
-    if (!impl->global_object_list_container)
-        return nullptr;
-    return std::addressof(*impl->global_object_list_container);
+KAutoObjectWithListContainer& KernelCore::ObjectListContainer() {
+    return *impl->global_object_list_container;
 }
 
-const KAutoObjectWithListContainer* KernelCore::ObjectListContainer() const {
-    if (!impl->global_object_list_container)
-        return nullptr;
-    return std::addressof(*impl->global_object_list_container);
+const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const {
+    return *impl->global_object_list_container;
 }
 
 void KernelCore::PrepareReschedule(std::size_t id) {
@@ -1008,10 +1001,16 @@ void KernelCore::UnregisterInUseObject(KAutoObject* object) {
 
 void KernelCore::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
     auto* manager = server_manager.get();
-    if (!impl->is_shutting_down) {
+
+    {
         std::scoped_lock lk{impl->server_lock};
+        if (impl->is_shutting_down) {
+            return;
+        }
+
         impl->server_managers.emplace_back(std::move(server_manager));
     }
+
     manager->LoopProcess();
 }
 
@@ -1256,10 +1255,6 @@ void KernelCore::SuspendEmulation(bool suspended) {
 }
 
 void KernelCore::ShutdownCores() {
-    // Notify shutdown (pre-emptively)
-    for (auto& sm : impl->server_managers) {
-        sm->NotifyShutdown();
-    }
     impl->TerminateAllProcesses();
     KScopedSchedulerLock lk{*this};
     for (auto* thread : impl->shutdown_threads)

src/core/hle/kernel/kernel.h

@@ -175,8 +175,9 @@ public:
     /// Stops execution of 'id' core, in order to reschedule a new thread.
     void PrepareReschedule(std::size_t id);
 
-    KAutoObjectWithListContainer* ObjectListContainer();
-    const KAutoObjectWithListContainer* ObjectListContainer() const;
+    KAutoObjectWithListContainer& ObjectListContainer();
+
+    const KAutoObjectWithListContainer& ObjectListContainer() const;
 
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.

src/core/hle/kernel/slab_helpers.h

@@ -151,8 +151,7 @@ public:
         const bool is_initialized = this->IsInitialized();
         uintptr_t arg = 0;
         if (is_initialized) {
-            if (auto const olc = kernel.ObjectListContainer(); olc)
-                olc->Unregister(this);
+            kernel.ObjectListContainer().Unregister(this);
             arg = this->GetPostDestroyArgument();
             this->Finalize(kernel);
         }
@@ -176,7 +175,7 @@ public:
 public:
     static void InitializeSlabHeap(KernelCore& kernel, void* memory, size_t memory_size) {
         kernel.SlabHeap<Derived>().Initialize(memory, memory_size);
-        kernel.ObjectListContainer()->Initialize();
+        kernel.ObjectListContainer().Initialize();
     }
 
     static Derived* Create(KernelCore& kernel) {
@@ -187,7 +186,7 @@ public:
     }
 
     static void Register(KernelCore& kernel, Derived* obj) {
-        return kernel.ObjectListContainer()->Register(obj);
+        return kernel.ObjectListContainer().Register(obj);
     }
 
     static size_t GetObjectSize(KernelCore& kernel) {

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,9 +15,13 @@ void LoopProcess(Core::System& system) {
     WindowSystem window_system(system);
     ButtonPoller button_poller(system, window_system);
     EventObserver event_observer(system, window_system);
+
     auto server_manager = std::make_unique<ServerManager>(system);
-    server_manager->RegisterNamedService("appletAE", std::make_shared<IAllSystemAppletProxiesService>(system, window_system));
-    server_manager->RegisterNamedService("appletOE", std::make_shared<IApplicationProxyService>(system, window_system));
+
+    server_manager->RegisterNamedService(
+        "appletAE", std::make_shared<IAllSystemAppletProxiesService>(system, window_system));
+    server_manager->RegisterNamedService(
+        "appletOE", std::make_shared<IApplicationProxyService>(system, window_system));
     ServerManager::RunServer(std::move(server_manager));
 }
 

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

@@ -26,25 +26,24 @@ EventObserver::EventObserver(Core::System& system, WindowSystem& window_system)
     m_window_system.SetEventObserver(this);
     m_wakeup_holder.SetUserData(static_cast<uintptr_t>(UserDataTag::WakeupEvent));
     m_wakeup_holder.LinkToMultiWait(std::addressof(m_multi_wait));
-    system.Kernel().RunOnGuestCoreProcess("am:EventObserver", [this]() {
-        auto const stop_token = m_stop_source.get_token();
+    m_thread = std::jthread([this](std::stop_token stop_token) {
+        Common::SetCurrentThreadName("am:EventObserver");
         while (!stop_token.stop_requested()) {
             auto* signaled_holder = this->WaitSignaled(stop_token);
-            if (stop_token.stop_requested() || !signaled_holder)
+            if (!signaled_holder)
                 break;
             this->Process(signaled_holder);
         }
-        m_process_cv.notify_one();
     });
 }
 
 EventObserver::~EventObserver() {
     // Signal thread and wait for processing to finish.
-    m_stop_source.request_stop();
-    m_wakeup_event.Signal(m_system.Kernel());
-    {
-        std::unique_lock lk{m_process_mutex};
-        m_process_cv.wait(lk);
+    if (m_thread.joinable()) {
+        // Signal thread and wait for processing to finish.
+        m_thread.request_stop();
+        m_wakeup_event.Signal(m_system.Kernel());
+        m_thread.join();
     }
 
     // Free remaining owned sessions.

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

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#include <condition_variable>
-#include <stop_token>
 #include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/hle/service/kernel_helpers.h"
@@ -64,9 +62,7 @@ private:
     MultiWait m_deferred_wait_list;
 
     // Processing thread.
-    std::stop_source m_stop_source{};
-    std::mutex m_process_mutex;
-    std::condition_variable m_process_cv{};
+    std::jthread m_thread{};
 };
 
 } // namespace Service::AM

src/core/hle/service/glue/time/manager.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -90,9 +90,10 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
 }
 
 TimeManager::TimeManager(Core::System& system)
-    : m_steady_clock_resource{system}, m_time_zone_binary{system}
-    , m_worker{system, m_steady_clock_resource, m_file_timestamp_worker}
-{
+    : m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
+                                                                       system,
+                                                                       m_steady_clock_resource,
+                                                                       m_file_timestamp_worker} {
     m_time_m =
         system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
 

src/core/hle/service/glue/time/worker.cpp

@@ -20,17 +20,15 @@
 
 namespace Service::Glue::Time {
 
-TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource, FileTimestampWorker& file_timestamp_worker)
-    : m_system{system}
-    , m_ctx{m_system, "Glue:TimeWorker"}
-    , m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")}
-    , m_steady_clock_resource{steady_clock_resource}
-    , m_file_timestamp_worker{file_timestamp_worker}
-    , m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")}
-    , m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")}
-    , m_alarm_worker{m_system, m_steady_clock_resource}
-    , m_pm_state_change_handler{m_alarm_worker}
-{
+TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
+                       FileTimestampWorker& file_timestamp_worker)
+    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
+                                                                "Glue:TimeWorker:Event")},
+      m_steady_clock_resource{steady_clock_resource},
+      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
+                                                          "Glue:TimeWorker:SteadyClockTimerEvent")},
+      m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
+      m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
     m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
         "Time::SteadyClockEvent",
         [this](s64 time,
@@ -49,16 +47,14 @@ TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady
 }
 
 TimeWorker::~TimeWorker() {
-    // Wait for processing to stop
-    m_stop_source.request_stop();
     m_local_clock_event->Signal(m_system.Kernel());
     m_network_clock_event->Signal(m_system.Kernel());
     m_ephemeral_clock_event->Signal(m_system.Kernel());
+    std::this_thread::sleep_for(std::chrono::milliseconds(16));
+
+    m_thread.request_stop();
     m_event->Signal(m_system.Kernel());
-    {
-        std::unique_lock lk{m_process_mutex};
-        m_process_cv.wait(lk);
-    }
+    m_thread.join();
 
     m_ctx.CloseEvent(m_event);
     m_system.CoreTiming().UnscheduleEvent(m_timer_steady_clock_timing_event);
@@ -126,162 +122,166 @@ void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> t
 }
 
 void TimeWorker::StartThread() {
-    m_system.Kernel().RunOnGuestCoreProcess("TimeWorker", [this]() {
-        auto const stop_token = m_stop_source.get_token();
-        while (!stop_token.stop_requested()) {
-            enum class EventType : s32 {
-                Exit = 0,
-                PowerStateChange = 1,
-                SignalAlarms = 2,
-                UpdateLocalSystemClock = 3,
-                UpdateNetworkSystemClock = 4,
-                UpdateEphemeralSystemClock = 5,
-                UpdateSteadyClock = 6,
-                UpdateFileTimestamp = 7,
-                AutoCorrect = 8,
-            };
-            s32 index{};
-            if (m_pm_state_change_handler.m_priority != 0) {
-                // TODO: gIPmModuleService::GetEvent() 1
-                index = WaitAny(
-                    m_system.Kernel(),
-                    &m_event->GetReadableEvent(), // 0
-                    &m_alarm_worker.GetEvent()    // 1
-                );
-            } else {
-                // TODO: gIPmModuleService::GetEvent() 1
-                index = WaitAny(
-                    m_system.Kernel(),
-                    &m_event->GetReadableEvent(),                       // 0
-                    &m_alarm_worker.GetEvent(),                         // 1
-                    &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
-                    m_local_clock_event,                                // 3
-                    m_network_clock_event,                              // 4
-                    m_ephemeral_clock_event,                            // 5
-                    &m_timer_steady_clock->GetReadableEvent(),          // 6
-                    &m_timer_file_system->GetReadableEvent(),           // 7
-                    m_standard_user_auto_correct_clock_event            // 8
-                );
-            }
+    m_thread = std::jthread(std::bind_front(&TimeWorker::ThreadFunc, this));
+}
 
-            if (stop_token.stop_requested())
-                break;
+void TimeWorker::ThreadFunc(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("TimeWorker");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Low);
 
-            switch (EventType(index)) {
-            case EventType::Exit:
-                return;
+    while (!stop_token.stop_requested()) {
+        enum class EventType : s32 {
+            Exit = 0,
+            PowerStateChange = 1,
+            SignalAlarms = 2,
+            UpdateLocalSystemClock = 3,
+            UpdateNetworkSystemClock = 4,
+            UpdateEphemeralSystemClock = 5,
+            UpdateSteadyClock = 6,
+            UpdateFileTimestamp = 7,
+            AutoCorrect = 8,
+        };
 
-            case EventType::PowerStateChange:
-                m_alarm_worker.GetEvent().Clear(m_system.Kernel());
-                if (m_pm_state_change_handler.m_priority <= 1) {
-                    m_alarm_worker.OnPowerStateChanged();
-                }
-                break;
+        s32 index{};
 
-            case EventType::SignalAlarms:
-                m_alarm_worker.GetTimerEvent().Clear(m_system.Kernel());
-                m_time_m->CheckAndSignalAlarms();
-                break;
-
-            case EventType::UpdateLocalSystemClock: {
-                m_local_clock_event->Clear(m_system.Kernel());
-
-                Service::PSC::Time::SystemClockContext context{};
-                R_ASSERT(m_local_clock->GetSystemClockContext(&context));
-
-                m_set_sys->SetUserSystemClockContext(context);
-                m_file_timestamp_worker.SetFilesystemPosixTime();
-                break;
-            }
-
-            case EventType::UpdateNetworkSystemClock: {
-                m_network_clock_event->Clear(m_system.Kernel());
-
-                Service::PSC::Time::SystemClockContext context{};
-                R_ASSERT(m_network_clock->GetSystemClockContext(&context));
-
-                m_set_sys->SetNetworkSystemClockContext(context);
-
-                s64 time{};
-                if (m_network_clock->GetCurrentTime(&time) != ResultSuccess) {
-                    break;
-                }
-
-                [[maybe_unused]] auto offset_before{
-                    m_ig_report_network_clock_context_set ? m_report_network_clock_context.offset : 0};
-                // TODO system report "standard_netclock_operation"
-                //              "clock_time" = time
-                //              "context_offset_before" = offset_before
-                //              "context_offset_after"  = context.offset
-                m_report_network_clock_context = context;
-                if (!m_ig_report_network_clock_context_set) {
-                    m_ig_report_network_clock_context_set = true;
-                }
-
-                m_file_timestamp_worker.SetFilesystemPosixTime();
-                break;
-            }
-
-            case EventType::UpdateEphemeralSystemClock: {
-                m_ephemeral_clock_event->Clear(m_system.Kernel());
-
-                Service::PSC::Time::SystemClockContext context{};
-                auto res = m_ephemeral_clock->GetSystemClockContext(&context);
-                if (res != ResultSuccess) {
-                    break;
-                }
-
-                s64 time{};
-                res = m_ephemeral_clock->GetCurrentTime(&time);
-                if (res != ResultSuccess) {
-                    break;
-                }
-
-                [[maybe_unused]] auto offset_before{m_ig_report_ephemeral_clock_context_set
-                                                        ? m_report_ephemeral_clock_context.offset
-                                                        : 0};
-                // TODO system report "ephemeral_netclock_operation"
-                //              "clock_time" = time
-                //              "context_offset_before" = offset_before
-                //              "context_offset_after"  = context.offset
-                m_report_ephemeral_clock_context = context;
-                if (!m_ig_report_ephemeral_clock_context_set) {
-                    m_ig_report_ephemeral_clock_context_set = true;
-                }
-                break;
-            }
-
-            case EventType::UpdateSteadyClock:
-                m_timer_steady_clock->Clear(m_system.Kernel());
-
-                m_steady_clock_resource.UpdateTime();
-                m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
-                break;
-
-            case EventType::UpdateFileTimestamp:
-                m_timer_file_system->Clear(m_system.Kernel());
-                m_file_timestamp_worker.SetFilesystemPosixTime();
-                break;
-
-            case EventType::AutoCorrect: {
-                m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());
-
-                bool automatic_correction{};
-                R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(&automatic_correction));
-
-                Service::PSC::Time::SteadyClockTimePoint time_point{};
-                R_ASSERT(m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point));
-
-                m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
-                m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
-                break;
-            }
-            default:
-                UNREACHABLE();
-            }
+        if (m_pm_state_change_handler.m_priority != 0) {
+            // TODO: gIPmModuleService::GetEvent() 1
+            index = WaitAny(m_system.Kernel(),
+                            &m_event->GetReadableEvent(), // 0
+                            &m_alarm_worker.GetEvent()    // 1
+            );
+        } else {
+            // TODO: gIPmModuleService::GetEvent() 1
+            index = WaitAny(m_system.Kernel(),
+                            &m_event->GetReadableEvent(),                       // 0
+                            &m_alarm_worker.GetEvent(),                         // 1
+                            &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
+                            m_local_clock_event,                                // 3
+                            m_network_clock_event,                              // 4
+                            m_ephemeral_clock_event,                            // 5
+                            &m_timer_steady_clock->GetReadableEvent(),          // 6
+                            &m_timer_file_system->GetReadableEvent(),           // 7
+                            m_standard_user_auto_correct_clock_event            // 8
+            );
         }
-        m_process_cv.notify_one();
-    });
+
+        switch (static_cast<EventType>(index)) {
+        case EventType::Exit:
+            return;
+
+        case EventType::PowerStateChange:
+            m_alarm_worker.GetEvent().Clear(m_system.Kernel());
+            if (m_pm_state_change_handler.m_priority <= 1) {
+                m_alarm_worker.OnPowerStateChanged();
+            }
+            break;
+
+        case EventType::SignalAlarms:
+            m_alarm_worker.GetTimerEvent().Clear(m_system.Kernel());
+            m_time_m->CheckAndSignalAlarms();
+            break;
+
+        case EventType::UpdateLocalSystemClock: {
+            m_local_clock_event->Clear(m_system.Kernel());
+
+            Service::PSC::Time::SystemClockContext context{};
+            R_ASSERT(m_local_clock->GetSystemClockContext(&context));
+
+            m_set_sys->SetUserSystemClockContext(context);
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+            break;
+        }
+
+        case EventType::UpdateNetworkSystemClock: {
+            m_network_clock_event->Clear(m_system.Kernel());
+
+            Service::PSC::Time::SystemClockContext context{};
+            R_ASSERT(m_network_clock->GetSystemClockContext(&context));
+
+            m_set_sys->SetNetworkSystemClockContext(context);
+
+            s64 time{};
+            if (m_network_clock->GetCurrentTime(&time) != ResultSuccess) {
+                break;
+            }
+
+            [[maybe_unused]] auto offset_before{
+                m_ig_report_network_clock_context_set ? m_report_network_clock_context.offset : 0};
+            // TODO system report "standard_netclock_operation"
+            //              "clock_time" = time
+            //              "context_offset_before" = offset_before
+            //              "context_offset_after"  = context.offset
+            m_report_network_clock_context = context;
+            if (!m_ig_report_network_clock_context_set) {
+                m_ig_report_network_clock_context_set = true;
+            }
+
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+            break;
+        }
+
+        case EventType::UpdateEphemeralSystemClock: {
+            m_ephemeral_clock_event->Clear(m_system.Kernel());
+
+            Service::PSC::Time::SystemClockContext context{};
+            auto res = m_ephemeral_clock->GetSystemClockContext(&context);
+            if (res != ResultSuccess) {
+                break;
+            }
+
+            s64 time{};
+            res = m_ephemeral_clock->GetCurrentTime(&time);
+            if (res != ResultSuccess) {
+                break;
+            }
+
+            [[maybe_unused]] auto offset_before{m_ig_report_ephemeral_clock_context_set
+                                                    ? m_report_ephemeral_clock_context.offset
+                                                    : 0};
+            // TODO system report "ephemeral_netclock_operation"
+            //              "clock_time" = time
+            //              "context_offset_before" = offset_before
+            //              "context_offset_after"  = context.offset
+            m_report_ephemeral_clock_context = context;
+            if (!m_ig_report_ephemeral_clock_context_set) {
+                m_ig_report_ephemeral_clock_context_set = true;
+            }
+            break;
+        }
+
+        case EventType::UpdateSteadyClock:
+            m_timer_steady_clock->Clear(m_system.Kernel());
+
+            m_steady_clock_resource.UpdateTime();
+            m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
+            break;
+
+        case EventType::UpdateFileTimestamp:
+            m_timer_file_system->Clear(m_system.Kernel());
+
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+            break;
+
+        case EventType::AutoCorrect: {
+            m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());
+
+            bool automatic_correction{};
+            R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
+                &automatic_correction));
+
+            Service::PSC::Time::SteadyClockTimePoint time_point{};
+            R_ASSERT(
+                m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point));
+
+            m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
+            m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
+            break;
+        }
+
+        default:
+            UNREACHABLE();
+        }
+    }
 }
 
 } // namespace Service::Glue::Time

src/core/hle/service/glue/time/worker.h

@@ -1,12 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include <condition_variable>
 #include "common/common_types.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/glue/time/alarm_worker.h"
@@ -37,17 +33,17 @@ public:
 
     void StartThread();
 
+private:
     template <typename T>
     T GetSettingsItemValue(const std::string& category, const std::string& name);
 
+    void ThreadFunc(std::stop_token stop_token);
+
     Core::System& m_system;
     KernelHelpers::ServiceContext m_ctx;
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
 
-    std::mutex m_process_mutex;
-    std::condition_variable m_process_cv;
-    std::stop_source m_stop_source;
-
+    std::jthread m_thread;
     Kernel::KEvent* m_event{};
     std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m;
     std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm;

src/core/hle/service/ro/ro.cpp

@@ -16,6 +16,10 @@
 #include "core/hle/service/ro/ro_types.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
+#ifdef HAS_NCE
+#include "core/arm/nce/patcher.h"
+#include "core/hle/kernel/k_shared_memory.h"
+#endif
 
 namespace Service::RO {
 
@@ -386,7 +390,7 @@ public:
         R_SUCCEED();
     }
 
-    Result MapManualLoadModuleMemory(u64* out_address, size_t context_id, u64 nro_address,
+    Result MapManualLoadModuleMemory(Kernel::KernelCore& kernel, u64* out_address, size_t context_id, u64 nro_address,
                                      u64 nro_size, u64 bss_address, u64 bss_size) {
         // Get context.
         ProcessContext* context = this->GetContextById(context_id);
@@ -421,7 +425,33 @@ public:
         R_TRY(context->ValidateNro(std::addressof(nro_info->module_id), std::addressof(rx_size),
                                    std::addressof(ro_size), std::addressof(rw_size),
                                    nro_info->base_address, nro_size, bss_size));
+#ifdef HAS_NCE
+        if (Settings::values.nce_runtime_nro_patch.GetValue()) {
+            if (Settings::IsNceEnabled()) {
+                auto* process = context->GetProcess();
+                auto& memory = process->GetMemory();
 
+                std::vector<u8> image(total_size);
+                memory.ReadBlock(nro_info->base_address, image.data(), rx_size);
+
+                Kernel::CodeSet::Segment code{.size = static_cast<u32>(rx_size)};
+                Core::NCE::Patcher patch;
+                patch.PatchText(image, code);
+                patch.RelocateAndCopy(nro_info->base_address, code, image, nullptr);
+
+                const u64 patch_address = nro_info->base_address + total_size;
+                const size_t patch_size = patch.GetSectionSize();
+                constexpr auto permission = Kernel::Svc::MemoryPermission::ReadExecute;
+
+                auto* patch_memory = Kernel::KSharedMemory::Create(kernel);
+                R_TRY(patch_memory->Initialize(kernel, kernel.System().DeviceMemory(), process, permission, permission, patch_size));
+                std::memcpy(patch_memory->GetPointer(), image.data() + total_size, patch_size);
+                R_TRY(process->AddSharedMemory(kernel, patch_memory, patch_address, patch_size));
+                R_TRY(patch_memory->Map(*process, patch_address, patch_size, permission));
+                memory.WriteBlock(nro_info->base_address, image.data(), rx_size);
+            }
+        }
+#endif
         // Set NRO perms.
         R_TRY(SetNroPerms(context->GetProcess(), nro_info->base_address, rx_size, ro_size,
                           rw_size + bss_size));
@@ -531,7 +561,7 @@ public:
     Result MapManualLoadModuleMemory(Out<u64> out_load_address, ClientProcessId client_pid,
                                      u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) {
         R_TRY(m_ro->ValidateProcess(m_context_id, *client_pid));
-        R_RETURN(m_ro->MapManualLoadModuleMemory(out_load_address.Get(), m_context_id, nro_address,
+        R_RETURN(m_ro->MapManualLoadModuleMemory(system.Kernel(), out_load_address.Get(), m_context_id, nro_address,
                                                  nro_size, bss_address, bss_size));
     }
 

src/core/hle/service/server_manager.cpp

@@ -98,10 +98,8 @@ ServerManager::~ServerManager() {
     // Signal stop.
     m_stop_source.request_stop();
     m_wakeup_event->Signal(m_system.Kernel());
-    if (m_deferral_event) m_deferral_event->Signal(m_system.Kernel()); //for sm: and ports
 
-
-    // Wait for processing to stop. Schedule
+    // Wait for processing to stop.
     m_stopped.Wait();
     m_threads.clear();
 
@@ -255,14 +253,6 @@ void ServerManager::StartAdditionalHostThreads(const char* name, size_t num_thre
     }
 }
 
-/// @brief Notifies that the system is shutting down (pre-emptively terminate threads)
-void ServerManager::NotifyShutdown() {
-    m_stop_source.request_stop();
-    // Wake them up regardless
-    m_wakeup_event->Signal(m_system.Kernel());
-    if (m_deferral_event) m_deferral_event->Signal(m_system.Kernel()); //for sm: and ports
-}
-
 Result ServerManager::LoopProcess() {
     SCOPE_EXIT {
         m_stopped.Set();
@@ -295,8 +285,9 @@ MultiWaitHolder* ServerManager::WaitSignaled() {
         this->LinkDeferred();
 
         // If we're done, return before we start waiting.
-        if (m_stop_source.stop_requested())
+        if (m_stop_source.stop_requested()) {
             return nullptr;
+        }
 
         auto* selected = m_multi_wait.WaitAny(m_system.Kernel());
         if (selected == std::addressof(*m_wakeup_holder)) {

src/core/hle/service/server_manager.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
 
@@ -52,7 +49,6 @@ public:
 
     Result LoopProcess();
     void StartAdditionalHostThreads(const char* name, size_t num_threads);
-    void NotifyShutdown();
 
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 

src/core/hle/service/services.cpp

@@ -117,6 +117,7 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
         {"friends",    &Friend::LoopProcess},
         {"settings",   &Set::LoopProcess},
         {"psc",        &PSC::LoopProcess},
+        {"glue",       &Glue::LoopProcess},
         {"grc",        &GRC::LoopProcess},
         {"hid",        &HID::LoopProcess},
         {"jit",        &JIT::LoopProcess},
@@ -152,7 +153,6 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
         {"usb",        &USB::LoopProcess},
         {"i2c",        &I2C::LoopProcess},
         {"gpio",        &GPIO::LoopProcess},
-        {"glue",       &Glue::LoopProcess},
     })
         kernel.RunOnGuestCoreProcess(std::string(e.first), [&system, f = e.second] { f(system); });
 }

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

@@ -305,14 +305,16 @@ SM::SM(ServiceManager& service_manager_, Core::System& system_)
 SM::~SM() = default;
 
 void LoopProcess(Core::System& system) {
+    auto& service_manager = system.ServiceManager();
     auto server_manager = std::make_unique<ServerManager>(system);
+
     Kernel::KEvent* deferral_event{};
     server_manager->ManageDeferral(&deferral_event);
-    system.ServiceManager().SetDeferralEvent(deferral_event);
+    service_manager.SetDeferralEvent(deferral_event);
+
     auto sm_service = std::make_shared<SM>(system.ServiceManager(), system);
-    server_manager->ManageNamedPort("sm:", [sm_service] {
-        return sm_service;
-    });
+    server_manager->ManageNamedPort("sm:", [sm_service] { return sm_service; });
+
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/vi/conductor.cpp

@@ -11,7 +11,6 @@
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/service/vi/conductor.h"
 #include "core/hle/service/vi/container.h"
 #include "core/hle/service/vi/display_list.h"
@@ -30,29 +29,24 @@ Conductor::Conductor(Core::System& system, Container& container, DisplayList& di
     });
 
     if (system.IsMulticore()) {
-        m_event = Core::Timing::CreateEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            m_signal.Set();
-            return std::chrono::nanoseconds(this->GetNextTicks());
-        });
+        m_event = Core::Timing::CreateEvent(
+            "ScreenComposition",
+            [this](s64 time,
+                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+                m_signal.Set();
+                return std::chrono::nanoseconds(this->GetNextTicks());
+            });
 
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
-        m_thread = system.Kernel().RunOnHostCoreThread("VSyncThread", [this]() {
-            auto const stop_token = m_thread.get_stop_token();
-            Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
-            Common::SetCurrentThreadToPerformanceCores();
-            while (!stop_token.stop_requested()) {
-                m_signal.Wait();
-                if (stop_token.stop_requested() || m_system.IsShuttingDown()) {
-                    break;
-                }
-                this->ProcessVsync();
-            }
-        });
+        m_thread = std::jthread([this](std::stop_token token) { this->VsyncThread(token); });
     } else {
-        m_event = Core::Timing::CreateEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            this->ProcessVsync();
-            return std::chrono::nanoseconds(this->GetNextTicks());
-        });
+        m_event = Core::Timing::CreateEvent(
+            "ScreenComposition",
+            [this](s64 time,
+                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+                this->ProcessVsync();
+                return std::chrono::nanoseconds(this->GetNextTicks());
+            });
 
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
     }
@@ -60,10 +54,10 @@ Conductor::Conductor(Core::System& system, Container& container, DisplayList& di
 
 Conductor::~Conductor() {
     m_system.CoreTiming().UnscheduleEvent(m_event);
-    if (m_thread.joinable()) {
+
+    if (m_system.IsMulticore()) {
         m_thread.request_stop();
         m_signal.Set();
-        m_thread.join();
     }
 }
 
@@ -89,6 +83,22 @@ void Conductor::ProcessVsync() {
     }
 }
 
+void Conductor::VsyncThread(std::stop_token token) {
+    Common::SetCurrentThreadName("VSyncThread");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
+    Common::SetCurrentThreadToPerformanceCores();
+
+    while (!token.stop_requested()) {
+        m_signal.Wait();
+
+        if (m_system.IsShuttingDown()) {
+            return;
+        }
+
+        this->ProcessVsync();
+    }
+}
+
 s64 Conductor::GetNextTicks() const {
     const auto& settings = Settings::values;
     auto speed_scale = 1.f;

src/core/memory.cpp

@@ -757,7 +757,7 @@ struct Memory::Impl {
         };
         auto& gpu = system.GPU();
         gpu_device_memory->ApplyOpOnPointer(
-            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size); });
+            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size, true); });
     }
 
     Core::System& system;

src/core/memory/dmnt_cheat_vm.cpp

@@ -1,15 +1,6 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-// gcc14 bug
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/memory/dmnt_cheat_types.h"
@@ -1275,8 +1266,3 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
 }
 
 } // namespace Core::Memory
-
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif

src/core/memory/dmnt_cheat_vm.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -254,16 +254,14 @@ struct UnrecognizedInstruction {
 
 struct CheatVmOpcode {
     bool begin_conditional_block{};
-    std::variant<
-        std::monostate,
-        StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
-        LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
-        PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
-        PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
-        BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
-        SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
-        ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction
-    > opcode{};
+    std::variant<StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
+                 LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
+                 PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
+                 PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
+                 BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
+                 SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
+                 ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction>
+        opcode{};
 };
 
 class DmntCheatVm {

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -170,19 +170,13 @@ template<>
 
     // check for marked bit, use as unmapped if marked
     if (ctx.conf.page_table_marked_bit) {
-        auto const marked_bit = *ctx.conf.page_table_marked_bit;
-        if (s64(s32(1 << marked_bit)) == s64(1 << marked_bit)) {
-            code.test(page, s32(1 << marked_bit));
-            code.jnz(abort, code.T_NEAR);
-        } else {
-            code.bt(page, marked_bit);
-            code.jc(abort, code.T_NEAR);
-        }
+        code.bt(page, *ctx.conf.page_table_marked_bit);
+        code.jc(abort, code.T_NEAR);
     }
     // mask away attributes
     if (ctx.conf.page_table_pointer_mask == 0) {
         code.test(page, page);
-    } else if (s64(s32(ctx.conf.page_table_pointer_mask)) == s64(ctx.conf.page_table_pointer_mask)) {
+    } else if (std::in_range<s32>(ctx.conf.page_table_pointer_mask)) {
         code.and_(page, ctx.conf.page_table_pointer_mask);
     } else {
         code.mov(tmp, ctx.conf.page_table_pointer_mask);

src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp

@@ -79,10 +79,8 @@ void NpadAbstractButtonHandler::UpdateAllButtonLifo() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        if (auto const shfmt = data->shared_memory_format; shfmt) {
-            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-            UpdateButtonLifo(npad_entry, data->aruid);
-        }
+        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+        UpdateButtonLifo(npad_entry, data->aruid);
     }
 }
 
@@ -90,19 +88,19 @@ void NpadAbstractButtonHandler::UpdateCoreBatteryState() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        if (auto const shfmt = data->shared_memory_format; shfmt) {
-            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-            UpdateButtonLifo(npad_entry, data->aruid);
-        }
+        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+        UpdateButtonLifo(npad_entry, data->aruid);
     }
 }
 
 void NpadAbstractButtonHandler::UpdateButtonState(u64 aruid) {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
-    if (auto data = applet_resource_holder->applet_resource->GetAruidData(aruid); data) {
-        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateButtonLifo(npad_entry, aruid);
+    auto* data = applet_resource_holder->applet_resource->GetAruidData(aruid);
+    if (data == nullptr) {
+        return;
     }
+    auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+    UpdateButtonLifo(npad_entry, aruid);
 }
 
 Result NpadAbstractButtonHandler::SetHomeProtection(bool is_enabled, u64 aruid) {

src/qt_common/config/shared_translation.cpp

@@ -194,6 +194,14 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     INSERT(Settings, skip_cpu_inner_invalidation, tr("Skip CPU Inner Invalidation"),
            tr("Skips certain cache invalidations during memory updates, reducing CPU usage and "
               "improving latency. This may cause soft-crashes."));
+    INSERT(Settings, nce_invalidation_gpu_readback,
+           tr("GPU Readback Before NCE Invalidation"),
+           tr("Flushes GPU buffer data back to guest memory before NCE invalidates the whole "
+              "guest page, preserving it while the CPU store proceeds."));
+    INSERT(Settings, nce_runtime_nro_patch,
+           tr("Patch Runtime NROs for NCE"),
+           tr("Applies NCE code patches to runtime-loaded NRO modules."
+              "This is required for some games to run correctly."));
     INSERT(Settings, vsync_mode, tr("VSync Mode:"),
            tr("FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
               "refresh rate.\nFIFO Relaxed allows tearing as it recovers from a slow down.\n"
@@ -342,9 +350,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
               "it bypasses such prompts and directly exits the emulation."));
     INSERT(UISettings, hide_mouse, tr("Hide mouse on inactivity"),
            tr("Hides the mouse after 2.5s of inactivity."));
-    INSERT(UISettings, controller_applet_disabled, tr("Disable controller applet"),
-           tr("Forcibly disables the use of the controller applet in emulated programs.\n"
-              "When a program attempts to open the controller applet, it is immediately closed."));
     INSERT(UISettings, check_for_updates, tr("Check for updates"),
            tr("Whether or not to check for updates upon startup."));
 
@@ -380,6 +385,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                           {
                               PAIR(AppletMode, HLE, tr("Custom frontend")),
                               PAIR(AppletMode, LLE, tr("Real applet")),
+                              PAIR(AppletMode, Disabled, tr("Disabled")),
                           }});
 
     translations->insert({Settings::EnumMetadata<Settings::SpirvOptimizeMode>::Index(),

src/qt_common/config/uisettings.h

@@ -127,8 +127,6 @@ struct Values {
     Setting<bool> hide_mouse{
         linkage, true, "hideInactiveMouse", Category::UiGeneral, Settings::Specialization::Default,
         true,    true};
-    Setting<bool> controller_applet_disabled{linkage, false, "disableControllerApplet",
-                                             Category::UiGeneral};
     // Set when Vulkan is known to crash the application
     bool has_broken_vulkan = false;
 

src/qt_common/render/emu_thread.cpp

@@ -66,17 +66,14 @@ void EmuThread::run() {
         } else {
             QtCommon::system->Pause();
             m_stopped.Set();
+
             EmulationPaused(lk);
-            m_should_run_cv.wait(lk, stop_token, [&] {
-                return m_should_run;
-            });
+            m_should_run_cv.wait(lk, stop_token, [&] { return m_should_run; });
             EmulationResumed(lk);
         }
     }
 
     // Shutdown the main emulated process
-    // Needs to pause first, we may not have paused before shutting down.
-    QtCommon::system->Pause();
     QtCommon::system->DetachDebugger();
     QtCommon::system->ShutdownMainProcess();
 }

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -496,30 +496,31 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
 }
 
 void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
-    // Flatten all leading PHIs from each block into a vector
-    std::vector<IR::Inst*> phi_instructions;
-    for (IR::Block* block : program.blocks) {
-        for (auto it = block->begin(); it != block->end(); ++it) {
-            if (it->GetOpcode() != IR::Opcode::Phi)
-                break;
-            phi_instructions.push_back(&*it);
-        }
-    }
+            // Flatten all leading PHIs from each block into a vector
+            std::vector<IR::Inst*> phi_instructions;
+            for (IR::Block* block : program.blocks) {
+                for (auto it = block->begin(); it != block->end(); ++it) {
+                    if (it->GetOpcode() != IR::Opcode::Phi)
+                        break;
+                    phi_instructions.push_back(&*it);
+                }
+            }
 
-    if (phi_instructions.empty()) {
-        return; // nothing to patch
-    }
+            if (phi_instructions.empty()) {
+                return; // nothing to patch
+            }
 
-    // Start "before" first PHI; advance on phi_arg == 0
-    size_t phi_index = size_t(-1);
-    ctx.PatchDeferredPhi([&ctx, &phi_index, phi_insts = std::move(phi_instructions)](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
-        if (phi_arg == 0) {
-            ++phi_index;
+            // Start "before" first PHI; advance on phi_arg == 0
+            size_t phi_index = static_cast<size_t>(-1);
+
+            ctx.PatchDeferredPhi([&](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
+                if (phi_arg == 0) {
+                    ++phi_index;
+                }
+                IR::Inst* phi = phi_instructions[phi_index];
+                return { ctx.Def(phi->Arg(phi_arg)), parent };
+            });
         }
-        IR::Inst* phi = phi_insts[phi_index];
-        return { ctx.Def(phi->Arg(phi_arg)), parent };
-    });
-}
 } // Anonymous namespace
 
 std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program, Bindings& bindings) {

src/video_core/gpu.cpp

@@ -226,7 +226,19 @@ struct GPU::Impl {
     }
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size) {
+    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
+        if (Settings::values.nce_invalidation_gpu_readback.GetValue()) {
+            VideoCore::RasterizerInterface* rasterizer = renderer->ReadRasterizer();
+            if (preserve_gpu_writes && rasterizer->MustFlushRegion(addr, size, VideoCommon::CacheType::BufferCache)) {
+                const u64 fence = RequestSyncOperation([rasterizer, addr, size] {
+                    rasterizer->FlushRegion(addr, size, VideoCommon::CacheType::BufferCache);
+                    rasterizer->OnCacheInvalidation(addr, size);
+                });
+                gpu_thread.TickGPU(is_async);
+                WaitForSyncOperation(fence);
+                return;
+            }
+        }
         gpu_thread.InvalidateRegion(addr, size);
     }
 
@@ -518,8 +530,8 @@ void GPU::FlushRegion(DAddr addr, u64 size) {
     impl->FlushRegion(addr, size);
 }
 
-void GPU::InvalidateRegion(DAddr addr, u64 size) {
-    impl->InvalidateRegion(addr, size);
+void GPU::InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
+    impl->InvalidateRegion(addr, size, preserve_gpu_writes);
 }
 
 bool GPU::OnCPUWrite(DAddr addr, u64 size) {

src/video_core/gpu.h

@@ -248,7 +248,7 @@ public:
     void FlushRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size);
+    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes = false);
 
     /// Notify rasterizer that CPU is trying to write this area. It returns true if the area is
     /// sensible, false otherwise, addr and size must be a valid combination

src/yuzu/configuration/configure_applets.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,7 +11,6 @@
 
 class QCheckBox;
 class QLineEdit;
-class QComboBox;
 class QDateTimeEdit;
 namespace Core {
 class System;

src/yuzu/configuration/shared_widget.cpp

@@ -140,7 +140,12 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
     if (combobox_enumerations.contains(type)) {
         enumeration = &combobox_enumerations.at(type);
         for (const auto& [id, name] : *enumeration) {
-            combobox->addItem(name);
+            if (type == Settings::EnumMetadata<Settings::AppletMode>::Index() &&
+                id == static_cast<u32>(Settings::AppletMode::Disabled) &&
+                setting.Id() != Settings::values.controller_applet_mode.Id()) {
+                continue;
+            }
+            combobox->addItem(name, id);
         }
     } else {
         return combobox;
@@ -158,9 +163,8 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
     const u32 setting_value = std::strtoul(setting.ToString().c_str(), nullptr, 0);
     combobox->setCurrentIndex(find_index(setting_value));
 
-    serializer = [this, enumeration]() {
-        int current = combobox->currentIndex();
-        return std::to_string(enumeration->at(current).first);
+    serializer = [this]() {
+        return std::to_string(combobox->currentData().toUInt());
     };
 
     restore_func = [this, find_index]() {

src/yuzu/main_window.cpp

@@ -1786,7 +1786,7 @@ bool MainWindow::LoadROM(const QString& filename, Service::AM::FrontendAppletPar
 
     QtCommon::system->SetFrontendAppletSet({
         std::make_unique<QtAmiiboSettings>(*this), // Amiibo Settings
-        (UISettings::values.controller_applet_disabled.GetValue() == true)
+        (Settings::values.controller_applet_mode.GetValue() == Settings::AppletMode::Disabled)
             ? nullptr
             : std::make_unique<QtControllerSelector>(*this), // Controller Selector
         std::make_unique<QtErrorDisplay>(*this),             // Error Display

src/yuzu_headless/main.cpp

@@ -1,122 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <chrono>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <regex>
-#include <string>
-
-#include "common/logging.h"
-#include "common/settings.h"
-#include "core/core.h"
-#include "core/cpu_manager.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/vfs/vfs_real.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/loader/loader.h"
-#include "frontend_common/config.h"
-#include "input_common/main.h"
-#include "video_core/gpu.h"
-#include "video_core/renderer_base.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl3.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl3_null.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl3_vk.h"
-
-class EmuWindow_Headless : public Core::Frontend::EmuWindow {
-public:
-    explicit EmuWindow_Headless() = default;
-    ~EmuWindow_Headless() = default;
-
-    bool IsShown() const override {
-        return true;
-    }
-    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override {
-
-    }
-    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override {
-        return std::make_unique<DummyContext>();
-    }
-};
-
-int main(int argc, char *argv[]) {
-    struct {
-        Core::System system{};
-        EmuWindow_Headless emu_window{};
-    } state = {};
-
-    Common::Log::Initialize();
-    Common::Log::SetColorConsoleBackendEnabled(true);
-    Common::Log::Start();
-
-    if (argc < 2) {
-        LOG_CRITICAL(Frontend, "Usage: {} [ms-to-run] [file]", argv[0]);
-        return EXIT_FAILURE;
-    }
-
-    std::chrono::milliseconds time_quanta = std::chrono::milliseconds{atoi(argv[1])};
-    auto const time_end = std::chrono::steady_clock::now() + time_quanta;
-    std::string filepath = argv[2];
-
-    // apply the log_filter setting
-    // the logger was initialized before and doesn't pick up the filter on its own
-    Common::Log::Filter filter;
-    filter.ParseFilterString("*:Info");
-    Common::Log::SetGlobalFilter(filter);
-
-    if (filepath.empty()) {
-        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
-        return EXIT_FAILURE;
-    }
-
-    state.system.Initialize();
-
-    InputCommon::InputSubsystem input_subsystem{};
-
-    // Apply the command line arguments
-    state.system.ApplySettings();
-    Settings::values.renderer_backend.SetValue(Settings::RendererBackend::Null);
-
-    state.system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-    state.system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
-    state.system.GetFileSystemController().CreateFactories(*state.system.GetFilesystem());
-    state.system.GetUserChannel().clear();
-
-    Service::AM::FrontendAppletParameters load_parameters{
-        .applet_id = Service::AM::AppletId::Application,
-    };
-    if (auto const load_result = state.system.Load(state.emu_window, filepath, load_parameters); load_result != Core::SystemResultStatus::Success) {
-        LOG_CRITICAL(Frontend, "load result = {}", u32(load_result));
-        // shutdown
-        void(state.system.Pause());
-        state.system.DetachDebugger();
-        state.system.ShutdownMainProcess();
-        return EXIT_FAILURE;
-    }
-    // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
-    state.system.GPU().Start();
-    state.system.GetCpuManager().OnGpuReady();
-    // don't do anything, SDL3 already exists for us :D
-    state.system.RegisterExitCallback([] {});
-    void(state.system.Run());
-    if (state.system.DebuggerEnabled())
-        state.system.InitializeDebugger();
-    while (state.system.IsPoweredOn() && !state.system.GetExitRequested()) {
-        auto const time_now = std::chrono::steady_clock::now();
-        if (time_now > time_end)
-            break;
-    }
-    // shutdown
-    void(state.system.Pause());
-    state.system.DetachDebugger();
-    state.system.ShutdownMainProcess();
-    return EXIT_SUCCESS;
-}
-
-#define VMA_IMPLEMENTATION
-#include "video_core/vulkan_common/vma.h"