Missed that

Forgot to commit this
Fix Android build
2026-09-25 10:53:03 +00:00 · 2026-09-24 22:41:56 +02:00 · 2026-09-24 15:20:49 -04:00 · 2026-09-24 15:13:01 -04:00 · 2026-09-24 14:37:42 -04:00 · 2026-09-24 14:27:41 -04:00
80 changed files with 923 additions and 1093 deletions
@@ -1,32 +1,44 @@
 # User Handbook - Command Line

-There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments.
-
-## eden
+There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept the same command line arguments.

 - `./eden <path>`: Running with a single argument and nothing else, will make the emulator look for the given file and load it, this behavior is similar to `eden-cli`; allows dragging and dropping games into the application.
- `-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
- `-f`: Use fullscreen.
- `-u <number>`: Select the index of the user to load as.
- `-input-profile <name>`: Specifies input profile name to use (for player #0 only).
+- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
+- `--config/-c`: Specify alternate configuration file.
+- `--fullscreen/-f`: Use fullscreen.
+- `--help/-h`: Display help.
+- `--game/-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
+- `--multiplayer/-m`: Specify multiplayer options.
+- `--program/-p`: Specify the program arguments to pass (optional).
+- `--user/-u <number>`: Specify the user index.
+- `--version/-v`: Display version and quit.
+- `--input-profile/-i <name>`: Specifies input profile name to use (for player #0 only).
+- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
+- `--filter/-x`: Sets the debug log filter irrespective of settings.
+- `--singlecore/-s`: Forces single-core regardless of settings.
+
+Only the Qt frontend supports the following arguments:
+
 - `-qlaunch`: Launch QLaunch.
 - `-hlaunch`: Launch homebrew launcher `nx-hbloader`.
    - Requires a copy of Atmosphere to be extracted onto `sdmc`.
    - This is a shorthand for `<eden folder>/sdmc/atmosphere/hbl.nsp`.
 - `-setup`: Launch setup applet.

-## eden-cli
+`eden` (provided with `--room`), and `eden-room` supports the following options as well:

- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
- `--config/-c`: Specify alternate configuration file.
- `--fullscreen/-f`: Set fullscreen.
- `--help/-h`: Display help.
- `--game/-g`: Specify the game to run.
- `--multiplayer/-m`: Specify multiplayer options.
- `--program/-p`: Specify the program arguments to pass (optional).
- `--user/-u`: Specify the user index.
- `--version/-v`: Display version and quit.
- `--input-profile/-i`: Specifies input profile name to use (for player #0 only).
- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
- `--filter/-x`: Sets the debug log filter irrespective of settings.
- `--singlecore/-s`: Forces single-core regardless of settings.
+- `-n/--room-name`: The name of the room.
+- `-d/--room-description`: The room description.
+- `-s/--bind-address`: The bind address for the room.
+- `-p/--port`: The port used for the room.
+- `-m/--max-members`: The maximum number of players for this room.
+- `-w/--password`: The password for the room.
+- `-g/--preferred-game`: The preferred game for this room.
+- `-i/--preferred-game-id`: The preferred game-id for this room.
+- `-u/--username`: The username used for announce.
+- `-t/--token`: The token used for announce.
+- `-a/--web-api-url`: yuzu Web API url.
+- `-b/--ban-list-file`: The file for storing the room ban list.
+- `-l/--log-file`: The file for storing the room log.
+- `-h/--help`: Display this help and exit.
+- `-v/--version`: Output version information and exit.
@@ -30,7 +30,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
-    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
    SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
    BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
    RENDERER_DEBUG("debug"),
@@ -908,13 +908,6 @@ abstract class SettingsItem(
                    descriptionId = R.string.enable_buffer_history_description
                )
            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
-                    titleId = R.string.enable_gpu_buffer_readback,
-                    descriptionId = R.string.enable_gpu_buffer_readback_description
-                )
-            )
            put(
                SwitchSetting(
                    BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,
@@ -549,7 +549,6 @@ class SettingsFragmentPresenter(
            add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
            add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
            add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
-            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
            add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)

            add(HeaderSetting(R.string.hacks))
@@ -580,8 +580,6 @@
    <string name="renderer_reactive_flushing_description">يحسن دقة العرض في بعض الألعاب على حساب الأداء.</string>
    <string name="enable_buffer_history">تمكين سجل التخزين المؤقت</string>
    <string name="enable_buffer_history_description">يُتيح هذا الخيار الوصول إلى حالات التخزين المؤقت السابقة. وقد يُحسّن جودة العرض وثبات الأداء في بعض الألعاب.</string>
-    <string name="enable_gpu_buffer_readback">تفعيل قراءة مخزن وحدة معالجة الرسومات</string>
-    <string name="enable_gpu_buffer_readback_description">يحافظ هذا النظام على بيانات المخزن المؤقت المُعدّلة بواسطة وحدة معالجة الرسومات عن طريق قراءتها مرة أخرى قبل التحميل. تتطلب بعض الألعاب ذلك لعرض بعض التأثيرات بشكل صحيح. قد يُسبب ذلك مشاكل إذا لم يتمكن الجهاز من التعامل مع عبء العمل الإضافي.</string>
    <string name="use_optimized_vertex_buffers">مخازن الرؤوس المُحسّنة</string>
    <string name="use_optimized_vertex_buffers_description">يُتيح ربطًا مُحسَّنًا لمخازن الرؤوس لتحسين الأداء. يتطلب برامج تشغيل Mesa 26.0+ Turnip/ برامج تشغيل QCOM. قد يتعطل على برامج تشغيل Turnip القديمة (25.3 وما دون).</string>

@@ -1099,7 +1097,6 @@
    <string name="gpu_fence_behavior_immediate">فوري</string>
    <string name="gpu_fence_behavior_balanced">متوازن</string>
    <string name="gpu_fence_behavior_accurate">دقيق</string>
-    <string name="gpu_fence_behavior_strict">صارم</string>

    <string name="vram_usage_conservative">محافظ</string>
    <string name="vram_usage_aggressive">عدواني</string>
@@ -967,7 +967,6 @@ Wirklich fortfahren?</string>
    <string name="gpu_fence_behavior_immediate">Direkt</string>
    <string name="gpu_fence_behavior_balanced">Ausgewogen</string>
    <string name="gpu_fence_behavior_accurate">Genau</string>
-    <string name="gpu_fence_behavior_strict">Strikt</string>

    <string name="vram_usage_conservative">Konservativ</string>
    <string name="vram_usage_aggressive">Aggressiv</string>
@@ -524,8 +524,6 @@
    <string name="renderer_reactive_flushing_description">Mejora la precisión de renderizado en algunos juegos, pero reduce el rendimiento.</string>
    <string name="enable_buffer_history">Activar el historial del búfer</string>
    <string name="enable_buffer_history_description">Permite el acceso al estado del búfer anterior. Esta opción puede mejorar la calidad de renderizado y la consistencia en el rendimiento de algunos juegos.</string>
-    <string name="enable_gpu_buffer_readback">Activar la lectura del buffer de la GPU</string>
-    <string name="enable_gpu_buffer_readback_description">Conserva los datos del búfer modificados por la GPU leyéndolos antes de subirlos.\nAlgunos juegos requieren esto para renderizar correctamente ciertos efectos.\nPuede causar problemas si el hardware no puede soportar la carga de trabajo adicional.</string>
    <string name="use_optimized_vertex_buffers">Búferes de vértices optimizados</string>
    <string name="use_optimized_vertex_buffers_description">Permite la optimización del enlace del búfer de vértices para un mejor rendimiento. Requiere controladores Mesa 26.0+ Turnip/ controladores QCOM. Fallará con controladores Turnip más antiguos (versión 25.3 o inferior).</string>

@@ -1038,7 +1036,6 @@
    <string name="gpu_fence_behavior_immediate">Inmediato</string>
    <string name="gpu_fence_behavior_balanced">Equilibrado</string>
    <string name="gpu_fence_behavior_accurate">Preciso</string>
-    <string name="gpu_fence_behavior_strict">Estricto</string>

    <string name="vram_usage_conservative">Conservador</string>
    <string name="vram_usage_aggressive">Agresivo</string>
@@ -569,8 +569,6 @@
    <string name="renderer_reactive_flushing_description">Повышение точности рендеринга в некоторых играх за счет снижения производительности.</string>
    <string name="enable_buffer_history">Включить историю буфера</string>
    <string name="enable_buffer_history_description">Позволяет обращаться к предыдущим состояниям буфера. Эта опция может повысить качество рендеринга и стабильность производительности в некоторых играх.</string>
-    <string name="enable_gpu_buffer_readback">Включить обратное чтение буфера ГПУ</string>
-    <string name="enable_gpu_buffer_readback_description">Сохраняет измененные ГПУ данные буфера путем чтения их обратно перед выгрузками. Некоторые игры требуют этого, чтобы рендерить определенные эффекты правильно. Может вызывать проблемы если оборудование не может обработать дополнительную рабочую нагрузку.</string>
    <string name="use_optimized_vertex_buffers">Оптимизированные вершинные буферы</string>
    <string name="use_optimized_vertex_buffers_description">Включает оптимизированную привязку вершинного буфера для повышения производительности. Требует Mesa Turnip 26.0+ / QCOM. Приводит к вылету на старых версиях драйверов Turnip (25.3 и ниже).</string>

@@ -1088,7 +1086,6 @@
    <string name="gpu_fence_behavior_immediate">Мгновенный</string>
    <string name="gpu_fence_behavior_balanced">Сбалансированный</string>
    <string name="gpu_fence_behavior_accurate">Точный</string>
-    <string name="gpu_fence_behavior_strict">Строгий</string>

    <string name="vram_usage_conservative">Консервативный</string>
    <string name="vram_usage_aggressive">Агрессивный</string>
@@ -570,8 +570,6 @@
    <string name="renderer_reactive_flushing_description">通过牺牲性能来提升某些游戏的渲染精度。</string>
    <string name="enable_buffer_history">启用缓冲区历史</string>
    <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
-    <string name="enable_gpu_buffer_readback">启用 GPU 缓冲区回读</string>
-    <string name="enable_gpu_buffer_readback_description">在上传前回读经由 GPU 修改过的缓冲区数据，以将其保留。一些游戏会用到这项设定以正确渲染某些效果。如果硬件无法处理额外的工作负载，则可能会导致问题。</string>
    <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
    <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 或 QCOM 驱动程序。若使用较旧版本的 Turnip 驱动 (25.3 及以下版本) 则会导致崩溃。</string>

@@ -1089,7 +1087,6 @@
    <string name="gpu_fence_behavior_immediate">即时</string>
    <string name="gpu_fence_behavior_balanced">均衡</string>
    <string name="gpu_fence_behavior_accurate">精确</string>
-    <string name="gpu_fence_behavior_strict">严格</string>

    <string name="vram_usage_conservative">保守式</string>
    <string name="vram_usage_aggressive">主动式</string>
@@ -561,8 +561,6 @@
    <string name="renderer_reactive_flushing_description">犧牲效能，以改善部分遊戲的轉譯準確度</string>
    <string name="enable_buffer_history">啟用緩衝區歷史</string>
    <string name="enable_buffer_history_description">允許存取先前的緩衝區狀態。此選項可能會改善部分遊戲的渲染品質與效能穩定性</string>
-    <string name="enable_gpu_buffer_readback">啟用 GPU 緩衝區讀回</string>
-    <string name="enable_gpu_buffer_readback_description">透過在上傳之前先將 GPU 修改過的緩衝區資料讀回來保存資料，部分遊戲需要啟用此功能才能正常渲染遊戲特效。如果硬體無法負荷可能會導致錯誤</string>
    <string name="use_optimized_vertex_buffers">最佳化頂點緩衝區</string>
    <string name="use_optimized_vertex_buffers_description">啟用最佳化的頂點緩衝區綁定。需要安裝 Mesa 26.0+ Turnip drivers/Qualcomm drivers。使用舊版 Turnip drivers 會導致當機 (25.3版和更低的版本)</string>

@@ -558,7 +558,6 @@
        <item>@string/gpu_fence_behavior_immediate</item>
        <item>@string/gpu_fence_behavior_balanced</item>
        <item>@string/gpu_fence_behavior_accurate</item>
-        <item>@string/gpu_fence_behavior_strict</item>
    </string-array>
    <integer-array name="gpuFenceBehaviorValues">
        <item>0</item>
@@ -586,8 +586,6 @@
    <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
    <string name="enable_buffer_history">Enable buffer history</string>
    <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
-    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
-    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
    <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
    <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>

@@ -1138,7 +1136,6 @@
    <string name="gpu_fence_behavior_immediate">Immediate</string>
    <string name="gpu_fence_behavior_balanced">Balanced</string>
    <string name="gpu_fence_behavior_accurate">Accurate</string>
-    <string name="gpu_fence_behavior_strict">Strict</string>

    <!-- ASTC Decoding Method Choices -->
    <string name="accelerate_astc_cpu" translatable="false">CPU</string>
@@ -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;
 }
@@ -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();

@@ -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();
+    if (!running) {
+        return;
+    }
+
    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!");
+    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);
+                  "{}, 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);
@@ -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
@@ -41,16 +41,19 @@ OpusDecoder::OpusDecoder(Core::System& system_) : system{system_} {
 }

 OpusDecoder::~OpusDecoder() {
-    if (main_thread.joinable()) {
+    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();
-        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 {
-        init_thread.request_stop();
-    }
+    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
@@ -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{};
@@ -33,7 +33,6 @@ void AudioCore::CreateSinks() {

 void AudioCore::Shutdown() {
    audio_manager->Shutdown();
-    adsp->Shutdown();
 }

 AudioManager& AudioCore::GetAudioManager() {
@@ -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();
    }
 }
@@ -39,7 +39,9 @@ class AudioManager {
 public:
    explicit AudioManager();

-    /// @brief Shutdown the audio manager.
+    /**
+     * Shutdown the audio manager.
+     */
    void Shutdown();

    /**
@@ -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;
@@ -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
@@ -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;
@@ -219,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?
@@ -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()) {
+    {
+        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};
+    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()) {
-        Stop();
    }
+
+    if (systems.empty())
+        Stop();
    return true;
 }

@@ -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
@@ -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.");
        }
@@ -178,10 +178,6 @@ bool IsGPUFenceBehaviorAccurate() {
    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Accurate;
 }

-bool IsGPUFenceBehaviorStrict() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Strict;
-}
-
 bool IsFastmemEnabled() {
    if (values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Debugging)
        return bool(values.cpuopt_fastmem);
@@ -525,7 +525,7 @@ struct Values {
    SwitchableSetting<GpuFenceBehavior, true> gpu_fence_behavior{linkage,
                                                                 GpuFenceBehavior::Default,
                                                                 GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Strict,
+                                                                 GpuFenceBehavior::Accurate,
                                                                 "gpu_fence_behavior",
                                                                 Category::RendererAdvanced,
                                                                 Specialization::Default,
@@ -655,13 +655,6 @@ struct Values {

    SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                         Category::RendererHacks};
-    SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,
-                                                       false,
-                                                       "enable_gpu_buffer_readback",
-                                                       Category::RendererAdvanced,
-                                                       Specialization::Default,
-                                                       true,
-                                                       true};

    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};
@@ -979,7 +972,6 @@ bool IsDMALevelSafe();
 bool IsGPUFenceBehaviorDefault();
 bool IsGPUFenceBehaviorBalanced();
 bool IsGPUFenceBehaviorAccurate();
-bool IsGPUFenceBehaviorStrict();

 bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);
@@ -137,7 +137,7 @@ ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL_GLSL, Vulkan, Null, OpenGL_GLASM, OpenGL_SPIRV);
 ENUM(GpuAccuracy, Low, High);
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);
+ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);
 ENUM(CpuClock, Normal, Boost, Overclock)
@@ -96,6 +96,21 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
 #ifndef MAP_NOCORE
 #define MAP_NOCORE 0
 #endif
+#ifndef MADV_FREE
+#define MADV_FREE MADV_DONTNEED
+#endif
+
+void DecommitVectorPage(uintptr_t base) noexcept {
+#if defined(_WIN32)
+    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
+#elif defined(__linux__)
+    // Linux's MADV_DONTNEED zeros out pages for us
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
+#else
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
+    std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
+#endif
+}

 void* AllocateMemoryPages(std::size_t size) noexcept {
    if (auto page = HostPageSize; size % page != 0) {
@@ -35,6 +35,7 @@ const u64 HostPageMask = ~(HostPageSize - 1);

 void* AllocateMemoryPages(std::size_t size) noexcept;
 void FreeMemoryPages(void* base, std::size_t size) noexcept;
+void DecommitVectorPage(uintptr_t base) noexcept;

 /// A large page-aligned buffer that has optimized memory usage for zero-writes.
 template <typename T>
@@ -114,7 +115,7 @@ public:
        const u64 end_page = AlignUp(base, HostPageSize);
        const u64 first_size = (std::min)(end_page, end) - base;

-        if (IsCommittedPage(start / sizeof(T))) {
+        if (IsCommittedPage(start)) {
            std::memset(reinterpret_cast<void*>(base), 0, first_size);
        }

@@ -124,11 +125,16 @@ public:
        base = end_page;

        for (u64 page = base; page < end; page += HostPageSize) {
-            if (!IsCommittedPage((page - reinterpret_cast<u64>(base_ptr)) / sizeof(T))) {
+            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
+            if (!IsCommittedPage(index)) {
                continue;
            }

-            std::memset(reinterpret_cast<void*>(page), 0, (std::min)( HostPageSize, end - page));
+            if (end - page >= HostPageSize) {
+                DecommitPage(index);
+            } else {
+                std::memset(reinterpret_cast<void*>(page), 0, end - page);
+            }
        }
    }

@@ -183,6 +189,14 @@ private:
        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
    }

+    constexpr void DecommitPage(std::size_t index) noexcept {
+        auto page_index = (index * sizeof(T)) >> HostPageBits;
+        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
+
+        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
+        DecommitVectorPage(page);
+    }
+
    std::size_t alloc_size{};
    T* base_ptr{};

@@ -23,6 +23,8 @@ add_library(core STATIC
    core_timing.h
    cpu_manager.cpp
    cpu_manager.h
+    launch_params.cpp
+    launch_params.h
    crypto/aes_util.cpp
    crypto/aes_util.h
    crypto/ctr_encryption_layer.cpp
@@ -1203,6 +1205,9 @@ endif()

 target_include_directories(core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)
+if (MSVC)
+    target_link_libraries(core PRIVATE getopt)
+endif()

 if (BOOST_NO_HEADERS)
    target_link_libraries(core PUBLIC Boost::container Boost::heap Boost::asio Boost::process Boost::crc)
@@ -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) {
@@ -304,10 +304,10 @@ std::optional<s64> CoreTiming::Advance() {

 void CoreTiming::Reset() {
    paused = true;
-    if (timer_thread.joinable()) {
-        timer_thread.request_stop();
    pause_event.Set();
    event.Set();
+    if (timer_thread.joinable()) {
+        timer_thread.request_stop();
        timer_thread.join();
    }
    has_started = false;
@@ -72,9 +72,11 @@ void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) noe

 void GlobalSchedulerContext::WakeupWaitingDummyThreads(KernelCore& kernel) noexcept {
    ASSERT(this->IsLocked());
+    if (m_woken_dummy_threads.size() > 0) {
        for (auto* thread : m_woken_dummy_threads)
            thread->DummyThreadEndWait(kernel);
        m_woken_dummy_threads.clear();
    }
+}

 } // namespace Kernel
@@ -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) {
@@ -1236,13 +1236,18 @@ namespace Kernel {
        KScopedSchedulerLock sl{kernel};

        // Determine if this is the first termination request.
+        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();
    }

@@ -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
@@ -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
@@ -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)
@@ -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.
@@ -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) {
@@ -15,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));
 }

@@ -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();
+    if (m_thread.joinable()) {
+        // Signal thread and wait for processing to finish.
+        m_thread.request_stop();
        m_wakeup_event.Signal(m_system.Kernel());
-    {
-        std::unique_lock lk{m_process_mutex};
-        m_process_cv.wait(lk);
+        m_thread.join();
    }

    // Free remaining owned sessions.
@@ -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
@@ -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);

@@ -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,8 +122,13 @@ 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();
+    m_thread = std::jthread(std::bind_front(&TimeWorker::ThreadFunc, this));
+}
+
+void TimeWorker::ThreadFunc(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("TimeWorker");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Low);
+
    while (!stop_token.stop_requested()) {
        enum class EventType : s32 {
            Exit = 0,
@@ -140,18 +141,18 @@ void TimeWorker::StartThread() {
            UpdateFileTimestamp = 7,
            AutoCorrect = 8,
        };
+
        s32 index{};
+
        if (m_pm_state_change_handler.m_priority != 0) {
            // TODO: gIPmModuleService::GetEvent() 1
-                index = WaitAny(
-                    m_system.Kernel(),
+            index = WaitAny(m_system.Kernel(),
                            &m_event->GetReadableEvent(), // 0
                            &m_alarm_worker.GetEvent()    // 1
            );
        } else {
            // TODO: gIPmModuleService::GetEvent() 1
-                index = WaitAny(
-                    m_system.Kernel(),
+            index = WaitAny(m_system.Kernel(),
                            &m_event->GetReadableEvent(),                       // 0
                            &m_alarm_worker.GetEvent(),                         // 1
                            &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
@@ -164,10 +165,7 @@ void TimeWorker::StartThread() {
            );
        }

-            if (stop_token.stop_requested())
-                break;
-
-            switch (EventType(index)) {
+        switch (static_cast<EventType>(index)) {
        case EventType::Exit:
            return;

@@ -260,6 +258,7 @@ void TimeWorker::StartThread() {

        case EventType::UpdateFileTimestamp:
            m_timer_file_system->Clear(m_system.Kernel());
+
            m_file_timestamp_worker.SetFilesystemPosixTime();
            break;

@@ -267,21 +266,22 @@ void TimeWorker::StartThread() {
            m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());

            bool automatic_correction{};
-                R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(&automatic_correction));
+            R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
+                &automatic_correction));

            Service::PSC::Time::SteadyClockTimePoint time_point{};
-                R_ASSERT(m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&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();
        }
    }
-        m_process_cv.notify_one();
-    });
 }

 } // namespace Service::Glue::Time
@@ -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;
@@ -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)) {
@@ -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);

@@ -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); });
 }
@@ -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));
 }

@@ -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,26 +29,21 @@ 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_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> {
+        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());
            });
@@ -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;
@@ -0,0 +1,205 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <regex>
+#include <cctype>
+
+#include "common/assert.h"
+#include "common/logging.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "common/scm_rev.h"
+#include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/launch_params.h"
+
+#undef _UNICODE
+#include <getopt.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+namespace Core {
+LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept {
+    LaunchParams p{};
+
+    int option_index = 0;
+    static struct option long_options[] = {
+        // clang-format off
+        {"debug", no_argument, 0, 'd'},
+        {"config", required_argument, 0, 'c'},
+        {"fullscreen", no_argument, 0, 'f'},
+        {"help", no_argument, 0, 'h'},
+        {"game", required_argument, 0, 'g'},
+        {"multiplayer", required_argument, 0, 'm'},
+        {"program", optional_argument, 0, 'p'},
+        {"user", required_argument, 0, 'u'},
+        {"version", no_argument, 0, 'v'},
+        {"input-profile", no_argument, 0, 'i'},
+        {"null-render", no_argument, 0, 'n'},
+        {"singlecore", no_argument, 0, 's'},
+        {"filter", no_argument, 0, 'x'},
+        {0, 0, 0, 0},
+        // clang-format on
+    };
+
+    while (optind < argc) {
+        if (int arg = getopt_long(argc, argv, "dc:fhg:m:p:u:vinsx", long_options, &option_index); arg != -1) {
+            switch (char(arg)) {
+            case 'd':
+                p.override_gdb_port = uint16_t(atoi(optarg));
+                break;
+            case 'c':
+                p.config_path = optarg;
+                break;
+            case 'f':
+                p.fullscreen = true;
+                LOG_INFO(Frontend, "Starting in fullscreen mode...");
+                break;
+            case 'h':
+                p.print_help = true;
+                break;
+            case 'g':
+                p.filepath = std::string(optarg);
+                break;
+            case 'i': {
+                p.input_profile = std::string(optarg);
+                break;
+            }
+            case 'm': {
+                p.use_multiplayer = true;
+                const std::string str_arg(optarg);
+                // regex to check if the format is nickname:password@ip:port
+                // with optional :password
+                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
+                if (std::regex_match(str_arg, re)) {
+                    std::smatch match;
+                    std::regex_search(str_arg, match, re);
+                    ASSERT(match.size() == 5);
+                    p.nickname = match[1];
+                    p.password = match[2];
+                    p.address = match[3];
+                    if (!match[4].str().empty()) {
+                        p.port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
+                    }
+                    std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
+                    ASSERT(std::regex_match(p.nickname, nickname_re) && "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
+                    ASSERT(!p.address.empty() && "Address is empty");
+                }
+                break;
+            }
+            case 'p':
+                p.program_args = argv[optind];
+                ++optind;
+                break;
+            case 'u': {
+                // Launch game with a specific user
+                bool argument_ok = isdigit(optarg[0]);
+                p.selected_user = atoi(optarg);
+                if (!argument_ok) {
+                    // try to look it up by username, only finds the first username that matches.
+                    auto const user_idx = system.GetProfileManager().GetUserIndex(optarg);
+                    if (user_idx != std::nullopt) {
+                        p.selected_user = user_idx.value();
+                    } else {
+                        LOG_ERROR(Frontend, "Invalid user argument '{}'", optarg);
+                        break;
+                    }
+                }
+                if (system.GetProfileManager().UserExistsIndex(*p.selected_user)) {
+                    Settings::values.current_user = s32(*p.selected_user);
+                } else {
+                    LOG_ERROR(Frontend, "Selected user {} doesn't exist", *p.selected_user);
+                }
+                break;
+            }
+            case 'v':
+                p.print_version = true;
+                break;
+            case 'n':
+                p.force_null_render = true;
+                break;
+            case 's':
+                p.force_single_core = true;
+                break;
+            case 'x':
+                p.log_filter = argv[optind];
+                ++optind;
+                break;
+            }
+        } else {
+            // only kept due to shortcuts made by Qt frontend which use "-qlaunch"
+            if (strcmp(argv[optind], "-hlaunch") == 0) {
+                p.launch_hlaunch = true;
+            } else if (strcmp(argv[optind], "-qlaunch") == 0) {
+                p.launch_qlaunch = true;
+            } else if (strcmp(argv[optind], "-setup") == 0) {
+                p.launch_setup = true;
+            } else {
+                // qt feeds utf8 data, sdl frontend feeds raw utf16 data
+#ifdef _WIN32
+                p.filepath = argv_w != nullptr
+                    ? Common::UTF16ToUTF8(argv_w[optind])
+                    : argv[optind];
+#else
+                p.filepath = argv[optind];
+#endif
+            }
+            optind++;
+        }
+    }
+    p.argv0 = argv[0];
+    return p;
+}
+
+void ApplyLaunchParams(LaunchParams const& lp) noexcept {
+    // 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(lp.log_filter.value_or(Settings::values.log_filter.GetValue()));
+    Common::Log::SetGlobalFilter(filter);
+
+    if (!lp.program_args.empty()) {
+        Settings::values.program_args = lp.program_args;
+    }
+    if (!lp.input_profile.empty()) {
+        auto& players = Settings::values.players.GetValue();
+        players[0].profile_name = lp.input_profile;
+    }
+    if (lp.selected_user.has_value()) {
+        Settings::values.current_user = std::clamp(*lp.selected_user, 0, 7);
+    }
+    if (lp.override_gdb_port.has_value()) {
+        Settings::values.use_gdbstub = true;
+        Settings::values.gdbstub_port = *lp.override_gdb_port;
+    }
+    if (lp.force_single_core) {
+        Settings::values.use_multi_core = false;
+    }
+    if (lp.force_null_render) {
+        Settings::values.renderer_backend = Settings::RendererBackend::Null;
+    }
+
+    if (lp.print_version) {
+        LOG_INFO(Frontend, "Eden {} {}", Common::g_scm_branch, Common::g_scm_desc);
+    }
+    if (lp.print_help) {
+        LOG_INFO(Frontend,
+            "Usage: {}"
+            " [options] <filename>\n"
+            "-c, --config          Load the specified configuration file\n"
+            "-f, --fullscreen      Start in fullscreen mode\n"
+            "-g, --game            File path of the game to load\n"
+            "-h, --help            Display this help and exit\n"
+            "-m, --multiplayer=nick:password@address:port"
+            " Nickname, password, address and port for multiplayer\n"
+            "-p, --program         Pass following string as arguments to executable\n"
+            "-u, --user            Select a specific user profile from 0 to 7\n"
+            "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
+            "-v, --version         Output version information and exit\n",
+            lp.argv0
+        );
+    }
+}
+
+}
@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <string>
+#include <optional>
+#include "common/common_types.h"
+#include "network/room.h"
+
+namespace Core {
+
+class System;
+struct LaunchParams {
+    std::string argv0{};
+    std::string filepath{};
+    std::string nickname{};
+    std::string password{};
+    std::string address{};
+    std::string input_profile{};
+    std::string program_args{};
+    std::optional<std::string> config_path{};
+    std::optional<int> selected_user{};
+    std::optional<u16> override_gdb_port{};
+    std::optional<std::string> log_filter{};
+    u16 port = Network::DefaultRoomPort;
+    bool use_multiplayer = false;
+    bool fullscreen = false;
+    bool force_null_render = false;
+    bool force_single_core = false;
+    // print
+    bool print_version = false;
+    bool print_help = false;
+    // qt
+    bool launch_hlaunch = false;
+    bool launch_qlaunch = false;
+    bool launch_setup = false;
+};
+
+LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept;
+void ApplyLaunchParams(LaunchParams const& lp) noexcept;
+
+}
@@ -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
@@ -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,
+    std::variant<StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
                 LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
                 PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
                 PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
                 BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
                 SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
-        ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction
-    > opcode{};
+                 ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction>
+        opcode{};
 };

 class DmntCheatVm {
@@ -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.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);
@@ -79,31 +79,29 @@ 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)];
+        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
        UpdateButtonLifo(npad_entry, data->aruid);
    }
 }
-}

 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)];
+        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* 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) {
    const Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
@@ -226,9 +226,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
    INSERT(Settings, dma_accuracy, tr("DMA Accuracy:"),
           tr("Controls the DMA read mode.\nUnsafe is faster, while Safe is more stable and can fix issues in some games.\nDefault follows the GPU Accuracy setting."));
    INSERT(Settings, gpu_fence_behavior, tr("GPU Fence Behavior:"),
-           tr("Controls the GPU fence synchronization behavior.\nImmediate is the fastest option, but can introduce some issues.\nBalanced offers better compatibility and may fix issues in some games.\nAccurate further improves compatibility at the cost of some performance.\nStrict is the slowest option, but can fix issues that require stricter synchronization.\nDefault follows the GPU Accuracy setting."));
-    INSERT(Settings, enable_gpu_buffer_readback, tr("Enable GPU buffer readback"),
-           tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
+           tr("Controls the GPU fence synchronization behavior.\nImmediate is the fastest option, but can introduce some issues.\nBalanced offers better compatibility and may fix issues in some games.\nAccurate further improves compatibility at the cost of some performance.\nDefault follows the GPU Mode setting."));
    INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
           tr("May reduce shader stutter."));
    INSERT(Settings, gpu_clock, tr("GPU Clocks"),
@@ -442,7 +440,6 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                              PAIR(GpuFenceBehavior, Immediate, tr("Immediate")),
                              PAIR(GpuFenceBehavior, Balanced, tr("Balanced")),
                              PAIR(GpuFenceBehavior, Accurate, tr("Accurate")),
-                              PAIR(GpuFenceBehavior, Strict, tr("Strict")),
                          }});
    translations->insert(
        {Settings::EnumMetadata<Settings::CpuAccuracy>::Index(),
@@ -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();
 }
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -28,11 +31,6 @@ struct FuncTraits<ReturnType_ (*)(Args...)> {
    using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
 };

-template <auto func, typename... Args>
-void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
-    inst->SetDefinition<Id>(func(ctx, std::forward<Args>(args)...));
-}
-
 template <typename ArgType>
 auto Arg(EmitContext& ctx, const IR::Value& arg) {
    if constexpr (std::is_same_v<ArgType, std::string_view>) {
@@ -53,23 +51,12 @@ auto Arg(EmitContext& ctx, const IR::Value& arg) {
 template <auto func, bool is_first_arg_inst, size_t... I>
 void Invoke(EmitContext& ctx, IR::Inst* inst, std::index_sequence<I...>) {
    using Traits = FuncTraits<decltype(func)>;
-    if constexpr (std::is_same_v<typename Traits::ReturnType, Id>) {
-        if constexpr (is_first_arg_inst) {
-            SetDefinition<func>(
-                ctx, inst, *inst,
-                Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
-        } else {
-            SetDefinition<func>(
-                ctx, inst, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
-        }
-    } else {
    if constexpr (is_first_arg_inst) {
        func(ctx, *inst, Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
    } else {
        func(ctx, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
    }
 }
-}

 template <auto func>
 void Invoke(EmitContext& ctx, IR::Inst* inst) {
@@ -511,12 +511,13 @@ void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
            }

            // 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> {
+            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_insts[phi_index];
+                IR::Inst* phi = phi_instructions[phi_index];
                return { ctx.Def(phi->Arg(phi_arg)), parent };
            });
        }
@@ -121,7 +121,7 @@ void BufferCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size

 template <class P>
 void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
-    if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
+    if (IsRegionGpuModified(device_addr, size)) {
        ClearDownload(device_addr, size);
        gpu_modified_ranges.Subtract(device_addr, size);
    }
@@ -249,6 +249,10 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
    runtime.CopyBuffer(dest_buffer, src_buffer, copies, true);
    if (has_new_downloads) {
        memory_tracker.MarkRegionAsGpuModified(*cpu_dest_address, amount);
+        const bool should_sync = Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate();
+        if (should_sync) {
+            runtime.Finish();
+        }
    }

    Tegra::Memory::DeviceGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::UnsafeReadWrite>
@@ -311,11 +315,8 @@ std::pair<typename P::Buffer*, u32> BufferCache<P>::ObtainCPUBuffer(
        MarkWrittenBuffer(buffer_id, device_addr, size);
        break;
    case ObtainBufferOperation::DiscardWrite: {
-        const DAddr device_addr_start = Common::AlignDown(device_addr, 64);
-        const DAddr device_addr_end = Common::AlignUp(device_addr + size, 64);
-        const size_t new_size = device_addr_end - device_addr_start;
-        ClearDownload(device_addr_start, new_size);
-        gpu_modified_ranges.Subtract(device_addr_start, new_size);
+        ClearDownload(device_addr, size);
+        gpu_modified_ranges.Subtract(device_addr, size);
        break;
    }
    default:
@@ -1233,7 +1234,7 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
        buffer.MarkUsage(offset, size);

        if (is_written) {
-            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size, true);
        }

        if constexpr (NEEDS_BIND_STORAGE_INDEX) {
@@ -1519,11 +1520,13 @@ void BufferCache<P>::UpdateComputeTextureBuffers() {
 }

 template <class P>
-void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) {
+void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync) {
    if constexpr (!IS_OPENGL) {
+        if (needs_sync) {
            Buffer& buffer = slot_buffers[buffer_id];
            buffer.setWriteTick(runtime.CurrentTick());
        }
+    }
    memory_tracker.MarkRegionAsGpuModified(device_addr, size);
    gpu_modified_ranges.Add(device_addr, size);
    uncommitted_gpu_modified_ranges.Add(device_addr, size);
@@ -1538,8 +1541,11 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
    const BufferId buffer_id = page_table[page];
    if (buffer_id) {
        Buffer& buffer = slot_buffers[buffer_id];
-        WaitForGpuFenceIfNeeded(buffer);
        if (buffer.IsInBounds(device_addr, size)) {
+            const bool should_sync = Settings::IsGPUFenceBehaviorAccurate();
+            if (should_sync) {
+                SynchronizeBufferWrites(buffer);
+            }
            bool usable = true;
            if constexpr (requires { buffer.IsSparseCompatible(); }) {
                if (sparse_compatible && !buffer.IsSparseCompatible()) {
@@ -1555,20 +1561,14 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
 }

 template <class P>
-void BufferCache<P>::WaitForGpuFenceIfNeeded(Buffer& buffer) {
+void BufferCache<P>::SynchronizeBufferWrites(Buffer& buffer) {
    if constexpr (!IS_OPENGL) {
-        const bool gpu_fence_accurate = Settings::IsGPUFenceBehaviorAccurate();
-        const bool gpu_fence_strict = Settings::IsGPUFenceBehaviorStrict();
-        if (gpu_fence_accurate || gpu_fence_strict) {
-            const u64 gpu_tick_delay = gpu_fence_strict ? 0 : 3;
        const u64 buffer_tick = buffer.getWriteTick();
-            const u64 gpu_tick = runtime.KnownGpuTick();
-            if (buffer_tick > gpu_tick + gpu_tick_delay) {
+        if (!runtime.IsFree(buffer_tick)) {
            runtime.Wait(buffer_tick);
        }
    }
 }
-}

 template <class P>
 typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(DAddr device_addr,
@@ -1742,14 +1742,24 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
    u64 total_size_bytes = 0;
    u64 largest_copy = 0;
    const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+    const auto add_upload = [&](DAddr start, DAddr end) {
+        if (start == end) return;
+        const u64 range_size = end - start;
        upload_copies.push_back(BufferCopy{
            .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
+            .dst_offset = start - buffer_start,
            .size = range_size,
        });
        total_size_bytes += range_size;
        largest_copy = (std::max)(largest_copy, range_size);
+    };
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+        DAddr upload_start = device_addr_out;
+        gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, [&](DAddr gpu_start, DAddr gpu_end) {
+            add_upload(upload_start, gpu_start);
+            upload_start = gpu_end;
+        });
+        add_upload(upload_start, device_addr_out + range_size);
    });
    if (total_size_bytes == 0) {
        return true;
@@ -1788,9 +1798,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
                if (immediate_buffer.empty()) {
                    immediate_buffer = ImmediateBuffer(largest_copy);
                }
-                if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                    DownloadBufferMemory(buffer, device_addr, copy.size);
-                }
                device_memory.ReadBlockUnsafe(device_addr, immediate_buffer.data(), copy.size);
                upload_span = immediate_buffer.subspan(0, copy.size);
            }
@@ -1809,9 +1816,6 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
        for (BufferCopy& copy : copies) {
            u8* const src_pointer = staging_pointer.data() + copy.src_offset;
            const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
-            if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                DownloadBufferMemory(buffer, device_addr, copy.size);
-            }
            device_memory.ReadBlockUnsafe(device_addr, src_pointer, copy.size);
            // Apply the staging offset
            copy.src_offset += upload_staging.offset;
@@ -430,11 +430,11 @@ private:

    void UpdateComputeTextureBuffers();

-    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size);
+    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync = false);

    [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size, bool sparse_compatible);

-    void WaitForGpuFenceIfNeeded(Buffer& buffer);
+    void SynchronizeBufferWrites(Buffer& buffer);

    [[nodiscard]] OverlapResult ResolveOverlaps(DAddr device_addr, u32 wanted_size);

@@ -16,7 +16,7 @@
 namespace Tegra {

 constexpr u32 MacroRegistersStart = 0xE00;
-[[maybe_unused]] constexpr u32 ComputeInline = 0x6D;
+constexpr u32 ComputeInline = 0x6D;

 DmaPusher::DmaPusher(Core::System& system_, MemoryManager& memory_manager_, Control::ChannelState& channel_state_)
    : system{system_}
@@ -73,11 +73,16 @@ bool DmaPusher::Step() {
        synced = false;
    }

-    if (header.size > 0 && dma_state.method >= MacroRegistersStart && subchannels[dma_state.subchannel]) {
-        subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, header.size * sizeof(u32));
-    }
-
    if (header.size > 0) {
+        if (subchannels[dma_state.subchannel] && dma_state.method_count) {
+            const auto engine = subchannel_type[dma_state.subchannel];
+            const bool kepler_payload = engine == Engines::EngineTypes::KeplerCompute && dma_state.method == ComputeInline && dma_state.non_incrementing;
+            const bool macro_payload = engine == Engines::EngineTypes::Maxwell3D && dma_state.method >= MacroRegistersStart;
+            if (kepler_payload || macro_payload) {
+                const size_t words = std::min<size_t>(dma_state.method_count, header.size);
+                subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, words * sizeof(u32));
+            }
+        }
        const bool use_safe = Settings::IsDMALevelDefault() ? Settings::IsGPULevelHigh() : Settings::IsDMALevelSafe();
        if (use_safe) {
            Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader, Tegra::Memory::GuestMemoryFlags::SafeRead>headers(memory_manager, dma_state.dma_get, header.size, &command_headers);
@@ -49,13 +49,16 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu
    case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
        UploadInfo info{.upload_address = upload_address,
                        .exec_address = upload_state.ExecTargetAddress(),
-                        .copy_size = upload_state.GetUploadSize()};
+                        .copy_size = upload_state.GetUploadSize(),
+                        .was_dirty = upload_dirty};
        uploads.push_back(info);
        upload_state.ProcessExec(regs.exec_upload.linear != 0);
        break;
    }
    case KEPLER_COMPUTE_REG_INDEX(data_upload): {
        upload_address = current_dma_segment;
+        upload_dirty = current_dirty;
+        current_dirty = false;
        upload_state.ProcessData(method_argument, is_last_call);
        break;
    }
@@ -64,11 +67,13 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu

        for (auto& data : uploads) {
            const GPUVAddr offset = data.exec_address - launch_desc_loc;
-            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x) &&
-                memory_manager.IsMemoryDirty(data.upload_address, data.copy_size)) {
+            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x)) {
+                const bool source_dirty = memory_manager.IsMemoryDirty(data.upload_address, data.copy_size);
+                if (data.was_dirty || source_dirty) {
                    indirect_compute = {data.upload_address};
                }
            }
+        }
        uploads.clear();
        ProcessLaunch();
        indirect_compute = std::nullopt;
@@ -83,6 +88,8 @@ void KeplerCompute::CallMultiMethod(Core::System& system, u32 method, const u32*
    switch (method) {
    case KEPLER_COMPUTE_REG_INDEX(data_upload):
        upload_address = current_dma_segment;
+        upload_dirty = current_dirty;
+        current_dirty = false;
        upload_state.ProcessData(base_start, amount);
        return;
    default:
@@ -226,11 +226,13 @@ private:
    VideoCore::RasterizerInterface* rasterizer = nullptr;
    Upload::State upload_state;
    GPUVAddr upload_address;
+    bool upload_dirty{};

    struct UploadInfo {
        GPUVAddr upload_address;
        GPUVAddr exec_address;
        u32 copy_size;
+        bool was_dirty;
    };
    std::vector<UploadInfo> uploads;
    std::optional<GPUVAddr> indirect_compute{};
@@ -72,7 +72,7 @@ public:
    }

    void SignalFence(std::function<void()>&& func) {
-        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate() || Settings::IsGPUFenceBehaviorStrict();
+        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate();
        const bool should_flush = ShouldFlush();
        if constexpr (!can_async_check) {
            TryReleasePendingFences<false>();
@@ -260,7 +260,7 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
    };
    u8* pointer = impl->device_memory.template GetPointer<u8>(cpu_addr);
    u8* pointer_timestamp = impl->device_memory.template GetPointer<u8>(cpu_addr + 8);
-    bool is_synced = (Settings::IsGPUFenceBehaviorDefault() ? !Settings::IsGPULevelHigh() : !Settings::IsGPUFenceBehaviorBalanced() && !Settings::IsGPUFenceBehaviorAccurate() && !Settings::IsGPUFenceBehaviorStrict()) && is_fence;
+    bool is_synced = (Settings::IsGPUFenceBehaviorDefault() ? !Settings::IsGPULevelHigh() : !Settings::IsGPUFenceBehaviorBalanced() && !Settings::IsGPUFenceBehaviorAccurate()) && is_fence;
    std::function<void()> operation([this, is_synced, streamer, query_base = query, query_location,
                                     pointer, pointer_timestamp] {
        if (True(query_base->flags & QueryFlagBits::IsInvalidated)) {
@@ -98,7 +98,10 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c
    RefreshResources(device, framebuffer);
    SetAntiAliasPass(device);
 #ifdef HAS_RESHADE
-    SetPostProcessPass(device);
+    const bool is_applet =
+        (framebuffer.layer_stack_mask & Service::Nvnflinger::LayerStackBit(
+                                            Service::Nvnflinger::LayerStackId::Recording)) == 0;
+    SetPostProcessPass(device, is_applet);
 #endif

    // Finish any pending renderpass
@@ -228,7 +231,11 @@ void Layer::SetAntiAliasPass(const Device& device) {
 }

 #ifdef HAS_RESHADE
-void Layer::SetPostProcessPass(const Device& device) {
+void Layer::SetPostProcessPass(const Device& device, bool is_applet) {
+    if (is_applet) {
+        post_process.reset();
+        return;
+    }
    const VkExtent2D render_area{
        .width = Settings::values.resolution_info.ScaleUp(raw_width),
        .height = Settings::values.resolution_info.ScaleUp(raw_height),
@@ -70,7 +70,7 @@ private:
    void RefreshResources(const Device& device, const Tegra::FramebufferConfig& framebuffer);
    void SetAntiAliasPass(const Device& device);
 #ifdef HAS_RESHADE
-    void SetPostProcessPass(const Device& device);
+    void SetPostProcessPass(const Device& device, bool is_applet);
 #endif
    void ReleaseRawImages();

@@ -419,15 +419,15 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
 }

 u64 BufferCacheRuntime::CurrentTick() {
-    return scheduler.GetMasterSemaphore().CurrentTick();
+    return scheduler.CurrentTick();
 }

-u64 BufferCacheRuntime::KnownGpuTick() {
-    return scheduler.GetMasterSemaphore().KnownGpuTick();
+bool BufferCacheRuntime::IsFree(u64 tick) {
+    return scheduler.IsFree(tick);
 }

-void BufferCacheRuntime::Wait(u64 buffer_tick) {
-    scheduler.Wait(buffer_tick);
+void BufferCacheRuntime::Wait(u64 tick) {
+    scheduler.Wait(tick);
 }

 void BufferCacheRuntime::Finish() {
@@ -112,9 +112,9 @@ public:

    u64 CurrentTick();

-    u64 KnownGpuTick();
+    bool IsFree(u64 tick);

-    void Wait(u64 buffer_tick);
+    void Wait(u64 tick);

    void Finish();

@@ -3,6 +3,7 @@

 // Static Qt on macOS doesn't use Vulkan
 // Other platforms do, and thus have conflicting VulkanMemoryAllocator symbols
+#include "core/launch_params.h"
 #if defined(QT_STATICPLUGIN) && !defined(__APPLE__)
 #undef VMA_IMPLEMENTATION
 #endif
@@ -515,79 +516,28 @@ MainWindow::MainWindow(bool has_broken_vulkan)
    // to prevent the UI from blowing up.
    UpdateUITheme();

-    QStringList args = QApplication::arguments();
+    if (QStringList args = QApplication::arguments(); args.size() >= 2) {
+        QList<QByteArray> qba{};
+        for (auto const& e : args)
+            qba.push_back(e.toUtf8());
+        std::vector<char*> args_cstr{};
+        for (auto& e : qba)
+            args_cstr.push_back(e.data());

-    if (args.size() < 2) {
-        return;
-    }
-
-    QString game_path;
-    bool should_launch_qlaunch = false;
-    bool should_launch_hlaunch = false;
-    bool should_launch_setup = false;
-    bool has_gamepath = false;
-    bool is_fullscreen = false;
-
-    // Preserves drag/drop functionality
-    for (int i = 1; i < args.size(); ++i) {
-        if (args[i] == QStringLiteral("-f")) {
-            // Launch game in fullscreen mode
-            is_fullscreen = true;
-        } else if (args[i] == QStringLiteral("-u") && i < args.size() - 1) {
-            // Launch game with a specific user
-            int user_arg_idx = ++i;
-            bool argument_ok;
-            std::size_t selected_user = args[user_arg_idx].toUInt(&argument_ok);
-            if (!argument_ok) {
-                // try to look it up by username, only finds the first username that matches.
-                std::string const user_arg_str = args[user_arg_idx].toStdString();
-                auto const user_idx =
-                    QtCommon::system->GetProfileManager().GetUserIndex(user_arg_str);
-                if (user_idx != std::nullopt) {
-                    selected_user = user_idx.value();
-                } else {
-                    LOG_ERROR(Frontend, "Invalid user argument '{}'", user_arg_str);
-                    continue;
-                }
-            }
-            if (QtCommon::system->GetProfileManager().UserExistsIndex(selected_user)) {
-                Settings::values.current_user = s32(selected_user);
-                user_flag_cmd_line = true;
-            } else {
-                LOG_ERROR(Frontend, "Selected user {} doesn't exist", selected_user);
-            }
-        } else if (args[i] == QStringLiteral("-g") && i < args.size() - 1) {
-            // Launch game at path
-            game_path = args[++i];
-            has_gamepath = true;
-        } else if (args[i] == QStringLiteral("-input-profile") && i < args.size() - 1) {
-            auto& players = Settings::values.players.GetValue();
-            players[0].profile_name = args[++i].toStdString();
-        } else if (args[i] == QStringLiteral("-qlaunch")) {
-            should_launch_qlaunch = true;
-        } else if (args[i] == QStringLiteral("-hlaunch")) {
-            should_launch_hlaunch = true;
-        } else if (args[i] == QStringLiteral("-setup")) {
-            should_launch_setup = true;
-        } else {
-            game_path = args[i];
-            has_gamepath = true;
-        }
-    }
+        auto const lp = Core::ParseLaunchParams(*QtCommon::system, args_cstr.size(), args_cstr.data(), nullptr);

        // Override fullscreen setting if gamepath or argument is provided
-    if (has_gamepath || is_fullscreen) {
-        ui->action_Fullscreen->setChecked(is_fullscreen);
+        if (!lp.filepath.empty() || lp.fullscreen) {
+            ui->action_Fullscreen->setChecked(lp.fullscreen);
        }

-    if (should_launch_setup) {
+        if (!lp.filepath.empty()) {
+            BootGame(QString::fromStdString(lp.filepath), ApplicationAppletParameters());
+        } else if (lp.launch_setup) {
            LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::Starter), std::nullopt);
-    } else {
-        if (!game_path.isEmpty()) {
-            BootGame(game_path, ApplicationAppletParameters());
-        } else if (should_launch_qlaunch) {
+        } else if (lp.launch_qlaunch) {
            LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::QLaunch), std::nullopt);
-        } else if (should_launch_hlaunch) {
+        } else if (lp.launch_hlaunch) {
            std::filesystem::path const sd_dir =
                Common::FS::GetEdenPathString(Common::FS::EdenPath::SDMCDir);
            auto const hbl_path = (sd_dir / "atmosphere" / "hbl.nsp").string();
@@ -42,9 +42,6 @@ target_link_libraries(yuzu-cmd PRIVATE common core input_common frontend_common
 if (ENABLE_OPENGL)
    target_link_libraries(yuzu-cmd PRIVATE glad)
 endif()
-if (MSVC)
-    target_link_libraries(yuzu-cmd PRIVATE getopt)
-endif()
 target_link_libraries(yuzu-cmd PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)

 create_resource("../../dist/eden.bmp" "yuzu_cmd/yuzu_icon.h" "yuzu_icon")
@@ -10,6 +10,7 @@
 #include <regex>
 #include <string>
 #include "common/settings_enums.h"
+#include "core/launch_params.h"
 #ifdef __EMSCRIPTEN__
 #include <emscripten.h>
 #endif
@@ -52,12 +53,6 @@
 #include "common/windows/timer_resolution.h"
 #endif

-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
@@ -67,25 +62,6 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif

-static void PrintHelp(const char* argv0) {
-    std::cout << "Usage: " << argv0
-              << " [options] <filename>\n"
-                 "-c, --config          Load the specified configuration file\n"
-                 "-f, --fullscreen      Start in fullscreen mode\n"
-                 "-g, --game            File path of the game to load\n"
-                 "-h, --help            Display this help and exit\n"
-                 "-m, --multiplayer=nick:password@address:port"
-                 " Nickname, password, address and port for multiplayer\n"
-                 "-p, --program         Pass following string as arguments to executable\n"
-                 "-u, --user            Select a specific user profile from 0 to 7\n"
-                 "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
-                 "-v, --version         Output version information and exit\n";
-}
-
-static void PrintVersion() {
-    std::cout << "Eden " << Common::g_scm_branch << " " << Common::g_scm_desc << std::endl;
-}
-
 static void OnStateChanged(const Network::RoomMember::State& state) {
    switch (state) {
    case Network::RoomMember::State::Idle:
@@ -208,168 +184,18 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
        LOG_CRITICAL(Frontend, "Failed to get command line arguments");
        return SDL_APP_FAILURE;
    }
-#endif
-    std::string filepath;
-    std::optional<std::string> config_path{};
-    std::string program_args;
-    std::optional<int> selected_user{};
-    std::optional<u16> override_gdb_port{};
-    bool use_multiplayer = false;
-    bool fullscreen = false;
-    bool force_null_render = false;
-    bool force_single_core = false;
-    std::string nickname{};
-    std::string password{};
-    std::string address{};
-    std::string input_profile{};
-    std::optional<std::string> log_filter{};
-    u16 port = Network::DefaultRoomPort;
-
-    static struct option long_options[] = {
-        // clang-format off
-        {"debug", no_argument, 0, 'd'},
-        {"config", required_argument, 0, 'c'},
-        {"fullscreen", no_argument, 0, 'f'},
-        {"help", no_argument, 0, 'h'},
-        {"game", required_argument, 0, 'g'},
-        {"multiplayer", required_argument, 0, 'm'},
-        {"program", optional_argument, 0, 'p'},
-        {"user", required_argument, 0, 'u'},
-        {"version", no_argument, 0, 'v'},
-        {"input-profile", no_argument, 0, 'i'},
-        {"null-render", no_argument, 0, 'n'},
-        {"singlecore", no_argument, 0, 's'},
-        {"filter", no_argument, 0, 'x'},
-        {0, 0, 0, 0},
-        // clang-format on
-    };
-
-    while (optind < argc) {
-        int arg = getopt_long(argc, argv, "g:fhvcip::c:u:d:", long_options, &option_index);
-        if (arg != -1) {
-            switch (char(arg)) {
-            case 'd':
-                override_gdb_port = uint16_t(atoi(optarg));
-                break;
-            case 'c':
-                config_path = optarg;
-                break;
-            case 'f':
-                fullscreen = true;
-                LOG_INFO(Frontend, "Starting in fullscreen mode...");
-                break;
-            case 'h':
-                PrintHelp(argv[0]);
-                return SDL_APP_FAILURE;
-            case 'g':
-                filepath = std::string(optarg);
-                break;
-            case 'i': {
-                input_profile = std::string(optarg);
-                break;
-            }
-            case 'm': {
-                use_multiplayer = true;
-                const std::string str_arg(optarg);
-                // regex to check if the format is nickname:password@ip:port
-                // with optional :password
-                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
-                if (!std::regex_match(str_arg, re)) {
-                    std::cout << "Wrong format for option --multiplayer\n";
-                    PrintHelp(argv[0]);
-                    return SDL_APP_FAILURE;
-                }
-
-                std::smatch match;
-                std::regex_search(str_arg, match, re);
-                ASSERT(match.size() == 5);
-                nickname = match[1];
-                password = match[2];
-                address = match[3];
-                if (!match[4].str().empty()) {
-                    port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
-                }
-                std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
-                if (!std::regex_match(nickname, nickname_re)) {
-                    LOG_ERROR(Frontend, "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
-                    return SDL_APP_FAILURE;
-                }
-                if (address.empty()) {
-                    LOG_ERROR(Frontend, "Address to room must not be empty");
-                    return SDL_APP_FAILURE;
-                }
-                break;
-            }
-            case 'p':
-                program_args = argv[optind];
-                ++optind;
-                break;
-            case 'u':
-                selected_user = atoi(optarg);
-                break;
-            case 'v':
-                PrintVersion();
-                return SDL_APP_FAILURE;
-            case 'n':
-                force_null_render = true;
-                break;
-            case 's':
-                force_single_core = true;
-                break;
-            case 'x':
-                log_filter = argv[optind];
-                ++optind;
-                break;
-            }
-        } else {
-#ifdef _WIN32
-            filepath = Common::UTF16ToUTF8(argv_w[optind]);
 #else
-            filepath = argv[optind];
+    wchar_t **argv_w = nullptr;
 #endif
-            optind++;
-        }
-    }
-
-    SdlConfig config{config_path};
-
-    // 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(log_filter.value_or(Settings::values.log_filter.GetValue()));
-    Common::Log::SetGlobalFilter(filter);
-
-    if (!program_args.empty()) {
-        Settings::values.program_args = program_args;
-    }
-
-    if (!input_profile.empty()) {
-        auto& players = Settings::values.players.GetValue();
-        players[0].profile_name = input_profile;
-    }
-
-    if (selected_user.has_value()) {
-        Settings::values.current_user = std::clamp(*selected_user, 0, 7);
-    }
-
-    if (override_gdb_port.has_value()) {
-        Settings::values.use_gdbstub = true;
-        Settings::values.gdbstub_port = *override_gdb_port;
-    }
-
-    if (force_single_core) {
-        Settings::values.use_multi_core = false;
-    }
-
-    if (force_null_render) {
-        Settings::values.renderer_backend = Settings::RendererBackend::Null;
-    }
-
+    Core::LaunchParams lp = Core::ParseLaunchParams(state->system, argc, argv, argv_w);
 #ifdef _WIN32
    LocalFree(argv_w);
 #endif
+    SdlConfig config{lp.config_path};

-    if (filepath.empty()) {
+    Core::ApplyLaunchParams(lp);
+
+    if (lp.filepath.empty()) {
        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
        return SDL_APP_FAILURE;
    }
@@ -386,14 +212,14 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
    case Settings::RendererBackend::OpenGL_GLSL:
    case Settings::RendererBackend::OpenGL_GLASM:
    case Settings::RendererBackend::OpenGL_SPIRV:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, lp.fullscreen);
        break;
 #endif
    case Settings::RendererBackend::Vulkan:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, lp.fullscreen);
        break;
    case Settings::RendererBackend::Null:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, lp.fullscreen);
        break;
    default:
        LOG_CRITICAL(Frontend, "Invalid renderer backend");
@@ -413,12 +239,12 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
    Service::AM::FrontendAppletParameters load_parameters{
        .applet_id = Service::AM::AppletId::Application,
    };
-    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, filepath, load_parameters);
+    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, lp.filepath, load_parameters);
    switch (load_result) {
    case Core::SystemResultStatus::Success:
        break; // Expected case
    case Core::SystemResultStatus::ErrorGetLoader:
-        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", lp.filepath);
        return SDL_APP_FAILURE;
    case Core::SystemResultStatus::ErrorLoader:
        LOG_CRITICAL(Frontend, "Failed to load ROM!");
@@ -440,14 +266,14 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
        return SDL_APP_FAILURE;
    }

-    if (use_multiplayer) {
+    if (lp.use_multiplayer) {
        if (auto member = Network::GetRoomMember().lock()) {
            member->BindOnChatMessageReceived(OnMessageReceived);
            member->BindOnStatusMessageReceived(OnStatusMessageReceived);
            member->BindOnStateChanged(OnStateChanged);
            member->BindOnError(OnNetworkError);
-            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port, nickname);
-            member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", lp.address, lp.port, lp.nickname);
+            member->Join(lp.nickname, lp.address.c_str(), lp.port, 0, Network::NoPreferredIP, lp.password);
        } else {
            LOG_ERROR(Network, "Could not access RoomMember");
            return SDL_APP_FAILURE;
@@ -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"
Author	SHA1	Message	Date
MaranBr	88d43ff216	Missed that	2026-09-24 22:41:56 +02:00
MaranBr	138cfba9fc	Forgot to commit this	2026-09-24 15:20:49 -04:00
MaranBr	14451ec32e	Fix Android build	2026-09-24 15:13:01 -04:00
MaranBr	3ef1736ac0	Ops	2026-09-24 14:37:42 -04:00
MaranBr	0404aea0db	Simplify GPU fence synchronization and remove GPU buffer readback	2026-09-24 14:27:41 -04:00
xbzk	dbeb73ee01	[video_core] cpu buffer fix + kepler uploads / maxwell macro dirty tracking fixes (#4473 ) - [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. ------------------- Aimed to fix two known UE5 crashes: Kepler uploads and Maxwell macros, both caused by CPU/GPU races due dirty tracking issues. Kepler ComputeInline: preserved dirty tracking across dma continuations and async readback. Maxwell macros: preserved gpu owned subranges during page granular cpu uploads. DiscardWrite: stopped clearing neighboring macro arguments by rounding up ranges. DMA Step: improved continuation aware dirty sampling. To the Ender Magnolia crew (maybe 1 or 2 persons): This will fix the dash crash, and the random / shackled beast vaper crashes. There are some more UE5 issues to go next. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4473 Reviewed-by: lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-09-24 18:44:14 +02:00
PavelBARABANOV	cb73a4dcc7	[renderer_vulkan] Skip post-processing on applet layers (#4474 ) - [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. ------------------- Detect applet layers via the absence of the Recording bit in layer_stack_mask (only AppletId::Application sets it) and skip PostProcessChain creation and application for them. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4474 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: lizzie <lizzie@eden-emu.dev>	2026-09-24 02:48:46 +02:00
lizzie	278f411dad	[frontend] Unify cmdline parsing (#4424 ) Addresses #4383. Makes it so both the Qt and SDL frontends now share the same options (bar `-hlaunch` and `-qlaunch`). Signed-off-by: lizzie <lizzie@eden-emu.dev> - [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/4424 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-09-23 14:51:51 +02:00
lizzie	3d37a816c6	[glsl] fix clang 23 build error for unused function `SetDefinition` (#4389 ) Reported by @gixel > unused function template SetDefinition in: src/shader_recompiler/backend/glsl/emit_glsl.cpp:32:6: error: unused function template 'SetDefinition' [-Werror,-Wunused-template] - [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/4389 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-09-23 14:51:18 +02:00
lizzie	a25e32676f	[hle] Use correct `audren:d` service framework (#4472 ) Trivial change. Signed-off-by: lizzie <lizzie@eden-emu.dev> - [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/4472 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-09-23 14:39:12 +02:00
Exverge	38df54edfe	[common/sparse_large_vector] decommit unused pages + fix first page in zeroed region (#4471 ) - [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. ------------------- Fixes a bug where the first page of a zeroed out region would not be properly zeroed, and now frees unused memory. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4471 Reviewed-by: lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-09-23 13:52:29 +02:00