2026-09-23 11:51:29

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

docs/user/CommandLine.md

@@ -1,44 +1,32 @@
 # User Handbook - Command Line
 
-There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept the same command line arguments.
+There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments.
+
+## eden
 
 - `./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.
-- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
+- `-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.
-- `--config/-c`: Specify alternate configuration file.
+- `-f`: Use fullscreen.
-- `--fullscreen/-f`: Use fullscreen.
+- `-u <number>`: Select the index of the user to load as.
-- `--help/-h`: Display help.
+- `-input-profile <name>`: Specifies input profile name to use (for player #0 only).
-- `--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` (provided with `--room`), and `eden-room` supports the following options as well:
+## eden-cli
 
-- `-n/--room-name`: The name of the room.
+- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
-- `-d/--room-description`: The room description.
+- `--config/-c`: Specify alternate configuration file.
-- `-s/--bind-address`: The bind address for the room.
+- `--fullscreen/-f`: Set fullscreen.
-- `-p/--port`: The port used for the room.
+- `--help/-h`: Display help.
-- `-m/--max-members`: The maximum number of players for this room.
+- `--game/-g`: Specify the game to run.
-- `-w/--password`: The password for the room.
+- `--multiplayer/-m`: Specify multiplayer options.
-- `-g/--preferred-game`: The preferred game for this room.
+- `--program/-p`: Specify the program arguments to pass (optional).
-- `-i/--preferred-game-id`: The preferred game-id for this room.
+- `--user/-u`: Specify the user index.
-- `-u/--username`: The username used for announce.
+- `--version/-v`: Display version and quit.
-- `-t/--token`: The token used for announce.
+- `--input-profile/-i`: Specifies input profile name to use (for player #0 only).
-- `-a/--web-api-url`: yuzu Web API url.
+- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
-- `-b/--ban-list-file`: The file for storing the room ban list.
+- `--filter/-x`: Sets the debug log filter irrespective of settings.
-- `-l/--log-file`: The file for storing the room log.
+- `--singlecore/-s`: Forces single-core regardless of settings.
-- `-h/--help`: Display this help and exit.
-- `-v/--version`: Output version information and exit.

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

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

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

@@ -908,6 +908,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
+                    titleId = R.string.enable_gpu_buffer_readback,
+                    descriptionId = R.string.enable_gpu_buffer_readback_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,

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

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

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

@@ -580,6 +580,8 @@
     <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>
 
@@ -1097,6 +1099,7 @@
     <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>

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

@@ -967,6 +967,7 @@ 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>

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

@@ -524,6 +524,8 @@
     <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>
 
@@ -1036,6 +1038,7 @@
     <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>

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

@@ -569,6 +569,8 @@
     <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>
 
@@ -1086,6 +1088,7 @@
     <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>

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

@@ -570,6 +570,8 @@
     <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>
 
@@ -1087,6 +1089,7 @@
     <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>

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

@@ -561,6 +561,8 @@
     <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>
 

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

@@ -558,6 +558,7 @@
         <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>

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

@@ -586,6 +586,8 @@
     <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>
 
@@ -1136,6 +1138,7 @@
     <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>

src/audio_core/audio_core.cpp

@@ -12,7 +12,7 @@
 namespace AudioCore {
 
 AudioCore::AudioCore(Core::System& system) {
-    audio_manager.emplace();
+    audio_manager.emplace(system);
     CreateSinks();
     // Must be created after the sinks
     adsp.emplace(system, *output_sink);

src/audio_core/audio_in_manager.cpp

@@ -15,12 +15,12 @@
 
 namespace AudioCore::AudioIn {
 
-Manager::Manager(Core::System& system_) : system{system_} {
+Manager::Manager(Core::System& system) {
     std::iota(session_ids.begin(), session_ids.end(), 0);
     num_free_sessions = MaxInSessions;
 }
 
-Result Manager::AcquireSessionId(size_t& session_id) {
+Result Manager::AcquireSessionId(Core::System& system, size_t& session_id) {
     if (num_free_sessions == 0) {
         LOG_ERROR(Service_Audio, "All 4 AudioIn sessions are in use, cannot create any more");
         return Service::Audio::ResultOutOfSessions;
@@ -31,7 +31,7 @@ Result Manager::AcquireSessionId(size_t& session_id) {
     return ResultSuccess;
 }
 
-void Manager::ReleaseSessionId(const size_t session_id) {
+void Manager::ReleaseSessionId(Core::System& system, const size_t session_id) {
     std::scoped_lock l{mutex};
     LOG_DEBUG(Service_Audio, "Freeing AudioIn session {}", session_id);
     session_ids[free_session_id] = session_id;
@@ -41,21 +41,20 @@ void Manager::ReleaseSessionId(const size_t session_id) {
     applet_resource_user_ids[session_id] = 0;
 }
 
-Result Manager::LinkToManager() {
+Result Manager::LinkToManager(Core::System& system) {
     std::scoped_lock l{mutex};
     if (!linked_to_manager) {
-        system.AudioCore().GetAudioManager().SetInManager(std::bind(&Manager::BufferReleaseAndRegister, this));
+        system.AudioCore().GetAudioManager().SetInManager(this, &Manager::BufferReleaseAndRegister);
         linked_to_manager = true;
     }
 
     return ResultSuccess;
 }
 
-void Manager::Start() {
+void Manager::Start(Core::System& system) {
     if (sessions_started) {
         return;
     }
-
     std::scoped_lock l{mutex};
     for (auto& session : sessions) {
         if (session) {
@@ -66,21 +65,19 @@ void Manager::Start() {
     sessions_started = true;
 }
 
-void Manager::BufferReleaseAndRegister() {
+void Manager::BufferReleaseAndRegister(void *data, Core::System& system) noexcept {
-    std::scoped_lock l{mutex};
+    Manager* this_ = (Manager*)data;
-    for (auto& session : sessions) {
+    std::scoped_lock l{this_->mutex};
+    for (auto& session : this_->sessions) {
         if (session != nullptr) {
             session->ReleaseAndRegisterBuffers();
         }
     }
 }
 
-u32 Manager::GetDeviceNames(std::span<Renderer::AudioDevice::AudioDeviceName> names,
+u32 Manager::GetDeviceNames(Core::System& system, std::span<Renderer::AudioDevice::AudioDeviceName> names, [[maybe_unused]] const bool filter) {
-                            [[maybe_unused]] const bool filter) {
     std::scoped_lock l{mutex};
-
+    LinkToManager(system);
-    LinkToManager();
-
     auto input_devices{Sink::GetDeviceListForSink(Settings::values.sink_id.GetValue(), true)};
     if (!input_devices.empty() && !names.empty()) {
         names[0] = Renderer::AudioDevice::AudioDeviceName("Uac");

src/audio_core/audio_in_manager.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -30,31 +33,29 @@ public:
      * @param session_id - Output session_id.
      * @return Result code.
      */
-    Result AcquireSessionId(size_t& session_id);
+    Result AcquireSessionId(Core::System& system, size_t& session_id);
 
     /**
      * Release a session id on close.
      *
      * @param session_id - Session id to free.
      */
-    void ReleaseSessionId(size_t session_id);
+    void ReleaseSessionId(Core::System& system, const size_t session_id);
 
     /**
      * Link the audio in manager to the main audio manager.
      *
      * @return Result code.
      */
-    Result LinkToManager();
+    Result LinkToManager(Core::System& system);
 
     /**
      * Start the audio in manager.
      */
-    void Start();
+    void Start(Core::System& system);
 
-    /**
+    /// @brief Callback function, called by the audio manager when the audio in event is signalled.
-     * Callback function, called by the audio manager when the audio in event is signalled.
+    static void BufferReleaseAndRegister(void *data, Core::System& system) noexcept;
-     */
-    void BufferReleaseAndRegister();
 
     /**
      * Get a list of audio in device names.
@@ -64,10 +65,8 @@ public:
      *
      * @return Number of names written.
      */
-    u32 GetDeviceNames(std::span<Renderer::AudioDevice::AudioDeviceName> names, bool filter);
+    u32 GetDeviceNames(Core::System& system, std::span<Renderer::AudioDevice::AudioDeviceName> names, bool filter);
 
-    /// Core system
-    Core::System& system;
     /// Array of session ids
     std::array<size_t, MaxInSessions> session_ids{};
     /// Array of resource user ids

src/audio_core/audio_manager.cpp

@@ -11,8 +11,8 @@
 
 namespace AudioCore {
 
-AudioManager::AudioManager() {
+AudioManager::AudioManager(Core::System& system) {
-    thread = std::jthread([this](std::stop_token stop_token) {
+    thread = std::jthread([&](std::stop_token stop_token) {
         Common::SetCurrentThreadName("AudioManager");
         std::unique_lock l{events.GetAudioEventLock()};
         events.ClearEvents();
@@ -25,7 +25,7 @@ AudioManager::AudioManager() {
                 const auto event_type = Event::Type(i);
                 if (events.CheckAudioEventSet(event_type) || timed_out) {
                     if (buffer_events[i]) {
-                        buffer_events[i]();
+                        buffer_events[i](buffer_data[i], system);
                     }
                 }
                 events.SetAudioEvent(event_type, false);
@@ -42,12 +42,13 @@ void AudioManager::Shutdown() {
     }
 }
 
-Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
+Result AudioManager::SetOutManager(void *data, BufferEventFunc buffer_func) {
     if (thread.joinable()) {
         std::scoped_lock l{lock};
         const auto index{events.GetManagerIndex(Event::Type::AudioOutManager)};
         if (buffer_events[index] == nullptr) {
             buffer_events[index] = std::move(buffer_func);
+            buffer_data[index] = data;
             needs_update = true;
             events.SetAudioEvent(Event::Type::AudioOutManager, true);
         }
@@ -56,12 +57,13 @@ Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
     return Service::Audio::ResultOperationFailed;
 }
 
-Result AudioManager::SetInManager(BufferEventFunc buffer_func) {
+Result AudioManager::SetInManager(void *data, BufferEventFunc buffer_func) {
     if (thread.joinable()) {
         std::scoped_lock l{lock};
         const auto index{events.GetManagerIndex(Event::Type::AudioInManager)};
         if (buffer_events[index] == nullptr) {
             buffer_events[index] = std::move(buffer_func);
+            buffer_data[index] = data;
             needs_update = true;
             events.SetAudioEvent(Event::Type::AudioInManager, true);
         }

src/audio_core/audio_manager.h

@@ -16,6 +16,10 @@
 
 #include "audio_core/audio_event.h"
 
+namespace Core {
+class System;
+}
+
 union Result;
 
 namespace AudioCore {
@@ -34,31 +38,24 @@ namespace AudioCore {
  * This is only used by audio in and audio out.
  */
 class AudioManager {
-    using BufferEventFunc = std::function<void()>;
+    using BufferEventFunc = void (*)(void *data, Core::System& system) noexcept;
-
 public:
-    explicit AudioManager();
+    explicit AudioManager(Core::System& system);
 
     /**
      * Shutdown the audio manager.
      */
     void Shutdown();
 
-    /**
+    /// Register the out manager, keeping a function to be called when the out event is signalled.
-     * Register the out manager, keeping a function to be called when the out event is signalled.
+    /// @param buffer_func - Function to be called on signal.
-     *
+    /// @return Result code.
-     * @param buffer_func - Function to be called on signal.
+    Result SetOutManager(void *data, BufferEventFunc buffer_func);
-     * @return Result code.
-     */
-    Result SetOutManager(BufferEventFunc buffer_func);
 
-    /**
+    /// Register the in manager, keeping a function to be called when the in event is signalled.
-     * Register the in manager, keeping a function to be called when the in event is signalled.
+    /// @param buffer_func - Function to be called on signal.
-     *
+    /// @return Result code.
-     * @param buffer_func - Function to be called on signal.
+    Result SetInManager(void *data, BufferEventFunc buffer_func);
-     * @return Result code.
-     */
-    Result SetInManager(BufferEventFunc buffer_func);
 
     /**
      * Set an event to signalled, and signal the thread.
@@ -73,8 +70,9 @@ private:
     bool needs_update{};
     /// Events to be set and signalled
     Event events{};
-    /// Callbacks for each manager
+    /// Callbacks (and user data) for each manager
     std::array<BufferEventFunc, 3> buffer_events{};
+    std::array<void*, 3> buffer_data{};
     /// General lock
     std::mutex lock{};
     /// Main thread for waiting and callbacks

src/audio_core/audio_out_manager.cpp

@@ -14,12 +14,12 @@
 
 namespace AudioCore::AudioOut {
 
-Manager::Manager(Core::System& system_) : system{system_} {
+Manager::Manager(Core::System& system) {
     std::iota(session_ids.begin(), session_ids.end(), 0);
     num_free_sessions = MaxOutSessions;
 }
 
-Result Manager::AcquireSessionId(size_t& session_id) {
+Result Manager::AcquireSessionId(Core::System& system, size_t& session_id) {
     if (num_free_sessions == 0) {
         LOG_ERROR(Service_Audio, "All 12 Audio Out sessions are in use, cannot create any more");
         return Service::Audio::ResultOutOfSessions;
@@ -30,7 +30,7 @@ Result Manager::AcquireSessionId(size_t& session_id) {
     return ResultSuccess;
 }
 
-void Manager::ReleaseSessionId(const size_t session_id) {
+void Manager::ReleaseSessionId(Core::System& system, const size_t session_id) {
     std::scoped_lock l{mutex};
     LOG_DEBUG(Service_Audio, "Freeing AudioOut session {}", session_id);
     session_ids[free_session_id] = session_id;
@@ -40,44 +40,36 @@ void Manager::ReleaseSessionId(const size_t session_id) {
     applet_resource_user_ids[session_id] = 0;
 }
 
-Result Manager::LinkToManager() {
+Result Manager::LinkToManager(Core::System& system) {
     std::scoped_lock l{mutex};
     if (!linked_to_manager) {
-        system.AudioCore().GetAudioManager().SetOutManager(std::bind(&Manager::BufferReleaseAndRegister, this));
+        system.AudioCore().GetAudioManager().SetOutManager(this, &Manager::BufferReleaseAndRegister);
         linked_to_manager = true;
     }
 
     return ResultSuccess;
 }
 
-void Manager::Start() {
+void Manager::Start(Core::System& system) {
-    if (sessions_started) {
+    if (!sessions_started) {
-        return;
-    }
-
         std::scoped_lock l{mutex};
         for (auto& session : sessions) {
             if (session) {
                 session->StartSession();
             }
         }
-
         sessions_started = true;
+    }
 }
 
-void Manager::BufferReleaseAndRegister() {
+void Manager::BufferReleaseAndRegister(void *data, Core::System& system) noexcept {
-    std::scoped_lock l{mutex};
+    Manager* this_ = (Manager*)data;
-    for (auto& session : sessions) {
+    std::scoped_lock l{this_->mutex};
+    for (auto& session : this_->sessions) {
         if (session != nullptr) {
             session->ReleaseAndRegisterBuffers();
         }
     }
 }
 
-u32 Manager::GetAudioOutDeviceNames(
-    std::vector<Renderer::AudioDevice::AudioDeviceName>& names) const {
-    names.emplace_back("DeviceOut");
-    return 1;
-}
-
 } // namespace AudioCore::AudioOut

src/audio_core/audio_out_manager.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -29,42 +32,32 @@ public:
      * @param session_id - Output session_id.
      * @return Result code.
      */
-    Result AcquireSessionId(size_t& session_id);
+    Result AcquireSessionId(Core::System& system, size_t& session_id);
 
     /**
      * Release a session id on close.
      *
      * @param session_id - Session id to free.
      */
-    void ReleaseSessionId(size_t session_id);
+    void ReleaseSessionId(Core::System& system, const size_t session_id);
 
     /**
      * Link this manager to the main audio manager.
      *
      * @return Result code.
      */
-    Result LinkToManager();
+    Result LinkToManager(Core::System& system);
 
     /**
      * Start the audio out manager.
      */
-    void Start();
+    void Start(Core::System& system);
 
     /**
      * Callback function, called by the audio manager when the audio out event is signalled.
      */
-    void BufferReleaseAndRegister();
+    static void BufferReleaseAndRegister(void* data, Core::System& system) noexcept;
 
-    /**
-     * Get a list of audio out device names.
-     *
-     * @param names     - Output container to write names to.
-     * @return Number of names written.
-     */
-    u32 GetAudioOutDeviceNames(std::vector<Renderer::AudioDevice::AudioDeviceName>& names) const;
-
-    /// Core system
-    Core::System& system;
     /// Array of session ids
     std::array<size_t, MaxOutSessions> session_ids{};
     /// Array of resource user ids

src/audio_core/audio_render_manager.cpp

@@ -6,14 +6,14 @@
 
 #include "audio_core/audio_render_manager.h"
 #include "audio_core/common/audio_renderer_parameter.h"
+#include "audio_core/renderer/system_manager.h"
 #include "audio_core/common/feature_support.h"
 #include "core/core.h"
 
 namespace AudioCore::Renderer {
 
 Manager::Manager(Core::System& system_)
-    : system{system_}
+    : system_manager{std::make_unique<SystemManager>(system_)}
-    , system_manager{std::make_unique<SystemManager>(system)}
 {
     std::iota(session_ids.begin(), session_ids.end(), 0);
 }
@@ -62,11 +62,11 @@ u32 Manager::GetSessionCount() const {
     return session_count;
 }
 
-bool Manager::AddSystem(System& system_) {
+bool Manager::AddSystem(Renderer::System& system_) {
     return system_manager->Add(system_);
 }
 
-bool Manager::RemoveSystem(System& system_) {
+bool Manager::RemoveSystem(Renderer::System& system_) {
     return system_manager->Remove(system_);
 }
 

src/audio_core/audio_render_manager.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -71,7 +74,7 @@ public:
      * @param system - The system to add.
      * @return True if the system was successfully added, otherwise false.
      */
-    bool AddSystem(System& system);
+    bool AddSystem(Renderer::System& system);
 
     /**
      * Remove a renderer system from the manager.
@@ -79,7 +82,7 @@ public:
      * @param system - The system to remove.
      * @return True if the system was successfully removed, otherwise false.
      */
-    bool RemoveSystem(System& system);
+    bool RemoveSystem(Renderer::System& system);
 
     /**
      * Free a session id when the system wants to shut down.
@@ -89,8 +92,6 @@ public:
     void ReleaseSessionId(s32 session_id);
 
 private:
-    /// Core system
-    Core::System& system;
     /// Session ids, -1 when in use
     std::array<s32, MaxRendererSessions> session_ids{};
     /// Number of active renderers

src/audio_core/in/audio_in.cpp

@@ -1,3 +1,6 @@
+// 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
 
@@ -8,42 +11,43 @@
 namespace AudioCore::AudioIn {
 
 In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
-    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
+    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}
-                                                                            session_id_} {}
+    , audio_system{system_, event, session_id_}
+{}
 
-void In::Free() {
+void In::Free(Core::System& system) {
     std::scoped_lock l{parent_mutex};
-    manager.ReleaseSessionId(system.GetSessionId());
+    manager.ReleaseSessionId(system, audio_system.GetSessionId());
 }
 
 System& In::GetSystem() {
-    return system;
+    return audio_system;
 }
 
 AudioIn::State In::GetState() {
     std::scoped_lock l{parent_mutex};
-    return system.GetState();
+    return audio_system.GetState();
 }
 
 Result In::StartSystem() {
     std::scoped_lock l{parent_mutex};
-    return system.Start();
+    return audio_system.Start();
 }
 
 void In::StartSession() {
     std::scoped_lock l{parent_mutex};
-    system.StartSession();
+    audio_system.StartSession();
 }
 
 Result In::StopSystem() {
     std::scoped_lock l{parent_mutex};
-    return system.Stop();
+    return audio_system.Stop();
 }
 
 Result In::AppendBuffer(const AudioInBuffer& buffer, u64 tag) {
     std::scoped_lock l{parent_mutex};
 
-    if (system.AppendBuffer(buffer, tag)) {
+    if (audio_system.AppendBuffer(buffer, tag)) {
         return ResultSuccess;
     }
     return Service::Audio::ResultBufferCountReached;
@@ -51,20 +55,20 @@ Result In::AppendBuffer(const AudioInBuffer& buffer, u64 tag) {
 
 void In::ReleaseAndRegisterBuffers() {
     std::scoped_lock l{parent_mutex};
-    if (system.GetState() == State::Started) {
+    if (audio_system.GetState() == State::Started) {
-        system.ReleaseBuffers();
+        audio_system.ReleaseBuffers();
-        system.RegisterBuffers();
+        audio_system.RegisterBuffers();
     }
 }
 
 bool In::FlushAudioInBuffers() {
     std::scoped_lock l{parent_mutex};
-    return system.FlushAudioInBuffers();
+    return audio_system.FlushAudioInBuffers();
 }
 
 u32 In::GetReleasedBuffers(std::span<u64> tags) {
     std::scoped_lock l{parent_mutex};
-    return system.GetReleasedBuffers(tags);
+    return audio_system.GetReleasedBuffers(tags);
 }
 
 Kernel::KReadableEvent& In::GetBufferEvent() {
@@ -74,27 +78,27 @@ Kernel::KReadableEvent& In::GetBufferEvent() {
 
 f32 In::GetVolume() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetVolume();
+    return audio_system.GetVolume();
 }
 
 void In::SetVolume(f32 volume) {
     std::scoped_lock l{parent_mutex};
-    system.SetVolume(volume);
+    audio_system.SetVolume(volume);
 }
 
 bool In::ContainsAudioBuffer(u64 tag) const {
     std::scoped_lock l{parent_mutex};
-    return system.ContainsAudioBuffer(tag);
+    return audio_system.ContainsAudioBuffer(tag);
 }
 
 u32 In::GetBufferCount() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetBufferCount();
+    return audio_system.GetBufferCount();
 }
 
 u64 In::GetPlayedSampleCount() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetPlayedSampleCount();
+    return audio_system.GetPlayedSampleCount();
 }
 
 } // namespace AudioCore::AudioIn

src/audio_core/in/audio_in.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -30,7 +33,7 @@ public:
     /**
      * Free this audio in from the audio in manager.
      */
-    void Free();
+    void Free(Core::System& system);
 
     /**
      * Get this audio in's system.
@@ -141,7 +144,7 @@ private:
     /// Buffer event, signalled when buffers are ready to be released
     Kernel::KEvent* event;
     /// Main audio in system
-    System system;
+    System audio_system;
 };
 
 } // namespace AudioCore::AudioIn

src/audio_core/out/audio_out.cpp

@@ -1,3 +1,6 @@
+// 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
 
@@ -8,42 +11,43 @@
 namespace AudioCore::AudioOut {
 
 Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
-    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
+    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}
-                                                                            session_id_} {}
+    , audio_system{system_, event, session_id_}
+{}
 
-void Out::Free() {
+void Out::Free(Core::System& system) {
     std::scoped_lock l{parent_mutex};
-    manager.ReleaseSessionId(system.GetSessionId());
+    manager.ReleaseSessionId(system, audio_system.GetSessionId());
 }
 
 System& Out::GetSystem() {
-    return system;
+    return audio_system;
 }
 
 AudioOut::State Out::GetState() {
     std::scoped_lock l{parent_mutex};
-    return system.GetState();
+    return audio_system.GetState();
 }
 
 Result Out::StartSystem() {
     std::scoped_lock l{parent_mutex};
-    return system.Start();
+    return audio_system.Start();
 }
 
 void Out::StartSession() {
     std::scoped_lock l{parent_mutex};
-    system.StartSession();
+    audio_system.StartSession();
 }
 
 Result Out::StopSystem() {
     std::scoped_lock l{parent_mutex};
-    return system.Stop();
+    return audio_system.Stop();
 }
 
 Result Out::AppendBuffer(const AudioOutBuffer& buffer, const u64 tag) {
     std::scoped_lock l{parent_mutex};
 
-    if (system.AppendBuffer(buffer, tag)) {
+    if (audio_system.AppendBuffer(buffer, tag)) {
         return ResultSuccess;
     }
     return Service::Audio::ResultBufferCountReached;
@@ -51,20 +55,20 @@ Result Out::AppendBuffer(const AudioOutBuffer& buffer, const u64 tag) {
 
 void Out::ReleaseAndRegisterBuffers() {
     std::scoped_lock l{parent_mutex};
-    if (system.GetState() == State::Started) {
+    if (audio_system.GetState() == State::Started) {
-        system.ReleaseBuffers();
+        audio_system.ReleaseBuffers();
-        system.RegisterBuffers();
+        audio_system.RegisterBuffers();
     }
 }
 
 bool Out::FlushAudioOutBuffers() {
     std::scoped_lock l{parent_mutex};
-    return system.FlushAudioOutBuffers();
+    return audio_system.FlushAudioOutBuffers();
 }
 
 u32 Out::GetReleasedBuffers(std::span<u64> tags) {
     std::scoped_lock l{parent_mutex};
-    return system.GetReleasedBuffers(tags);
+    return audio_system.GetReleasedBuffers(tags);
 }
 
 Kernel::KReadableEvent& Out::GetBufferEvent() {
@@ -74,27 +78,27 @@ Kernel::KReadableEvent& Out::GetBufferEvent() {
 
 f32 Out::GetVolume() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetVolume();
+    return audio_system.GetVolume();
 }
 
 void Out::SetVolume(const f32 volume) {
     std::scoped_lock l{parent_mutex};
-    system.SetVolume(volume);
+    audio_system.SetVolume(volume);
 }
 
 bool Out::ContainsAudioBuffer(const u64 tag) const {
     std::scoped_lock l{parent_mutex};
-    return system.ContainsAudioBuffer(tag);
+    return audio_system.ContainsAudioBuffer(tag);
 }
 
 u32 Out::GetBufferCount() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetBufferCount();
+    return audio_system.GetBufferCount();
 }
 
 u64 Out::GetPlayedSampleCount() const {
     std::scoped_lock l{parent_mutex};
-    return system.GetPlayedSampleCount();
+    return audio_system.GetPlayedSampleCount();
 }
 
 } // namespace AudioCore::AudioOut

src/audio_core/out/audio_out.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -30,7 +33,7 @@ public:
     /**
      * Free this audio out from the audio out manager.
      */
-    void Free();
+    void Free(Core::System& system);
 
     /**
      * Get this audio out's system.
@@ -141,7 +144,7 @@ private:
     /// Buffer event, signalled when buffers are ready to be released
     Kernel::KEvent* event;
     /// Main audio out system
-    System system;
+    System audio_system;
 };
 
 } // namespace AudioCore::AudioOut

src/audio_core/renderer/audio_device.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -34,42 +34,37 @@ constexpr std::array output_device_names{
     AudioDevice::AudioDeviceName{"AudioExternalOutput"},
 };
 
-AudioDevice::AudioDevice(Core::System& system, const u64 applet_resource_user_id_,
+AudioDevice::AudioDevice(Core::System& system, const u64 applet_resource_user_id_, const u32 revision)
-                         const u32 revision)
+    : applet_resource_user_id{applet_resource_user_id_}
-    : output_sink{system.AudioCore().GetOutputSink()},
+    , user_revision{revision}
-      applet_resource_user_id{applet_resource_user_id_}, user_revision{revision} {}
+{}
 
 u32 AudioDevice::ListAudioDeviceName(std::span<AudioDeviceName> out_buffer) const {
     std::span<const AudioDeviceName> names{};
-
     if (CheckFeatureSupported(SupportTags::AudioUsbDeviceOutput, user_revision)) {
         names = usb_device_names;
     } else {
         names = device_names;
     }
-
+    const u32 out_count = u32((std::min)(out_buffer.size(), names.size()));
-    const u32 out_count{static_cast<u32>((std::min)(out_buffer.size(), names.size()))};
+    for (u32 i = 0; i < out_count; i++)
-    for (u32 i = 0; i < out_count; i++) {
         out_buffer[i] = names[i];
-    }
     return out_count;
 }
 
 u32 AudioDevice::ListAudioOutputDeviceName(std::span<AudioDeviceName> out_buffer) const {
-    const u32 out_count{static_cast<u32>((std::min)(out_buffer.size(), output_device_names.size()))};
+    const u32 out_count = u32((std::min)(out_buffer.size(), output_device_names.size()));
-
+    for (u32 i = 0; i < out_count; i++)
-    for (u32 i = 0; i < out_count; i++) {
         out_buffer[i] = output_device_names[i];
-    }
     return out_count;
 }
 
-void AudioDevice::SetDeviceVolumes(const f32 volume) {
+void AudioDevice::SetDeviceVolumes(Core::System& system, const f32 volume) {
-    output_sink.SetDeviceVolume(volume);
+    system.AudioCore().GetOutputSink().SetDeviceVolume(volume);
 }
 
-f32 AudioDevice::GetDeviceVolume([[maybe_unused]] std::string_view name) const {
+f32 AudioDevice::GetDeviceVolume(Core::System& system, [[maybe_unused]] std::string_view name) const {
-    return output_sink.GetDeviceVolume();
+    return system.AudioCore().GetOutputSink().GetDeviceVolume();
 }
 
 } // namespace AudioCore::Renderer

src/audio_core/renderer/audio_device.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -54,7 +57,7 @@ public:
      *
      * @param volume - Volume to set.
      */
-    void SetDeviceVolumes(f32 volume);
+    void SetDeviceVolumes(Core::System& system, f32 volume);
 
     /**
      * Get the volume for a given device name.
@@ -63,11 +66,9 @@ public:
      * @param name - Name of the device to check. Unused.
      * @return Volume of the device.
      */
-    f32 GetDeviceVolume(std::string_view name) const;
+    f32 GetDeviceVolume(Core::System& system, std::string_view name) const;
 
 private:
-    /// Backend output sink for the device
-    Sink::Sink& output_sink;
     /// Resource id this device is used for
     const u64 applet_resource_user_id;
     /// User audio renderer revision

src/audio_core/renderer/audio_renderer.cpp

@@ -1,3 +1,6 @@
+// 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
 
@@ -13,56 +16,46 @@
 namespace AudioCore::Renderer {
 
 Renderer::Renderer(Core::System& system_, Manager& manager_, Kernel::KEvent* rendered_event)
-    : core{system_}, manager{manager_}, system{system_, rendered_event} {}
+    : manager{manager_}
+    , audio_system{system_, rendered_event}
+{}
 
-Result Renderer::Initialize(const AudioRendererParameterInternal& params,
+Result Renderer::Initialize(const AudioRendererParameterInternal& params, Kernel::KTransferMemory* transfer_memory, const u64 transfer_memory_size, Kernel::KProcess* process_handle, const u64 applet_resource_user_id, const s32 session_id) {
-                            Kernel::KTransferMemory* transfer_memory,
-                            const u64 transfer_memory_size, Kernel::KProcess* process_handle,
-                            const u64 applet_resource_user_id, const s32 session_id) {
     if (params.execution_mode == ExecutionMode::Auto) {
-        if (!manager.AddSystem(system)) {
+        if (!manager.AddSystem(audio_system)) {
-            LOG_ERROR(Service_Audio,
+            LOG_ERROR(Service_Audio, "Both Audio Render sessions are in use, cannot create any more");
-                      "Both Audio Render sessions are in use, cannot create any more");
             return Service::Audio::ResultOutOfSessions;
         }
         system_registered = true;
     }
-
+    audio_system.Initialize(params, transfer_memory, transfer_memory_size, process_handle, applet_resource_user_id, session_id);
-    initialized = true;
-    system.Initialize(params, transfer_memory, transfer_memory_size, process_handle,
-                      applet_resource_user_id, session_id);
-
     return ResultSuccess;
 }
 
 void Renderer::Finalize() {
-    auto session_id{system.GetSessionId()};
+    auto const session_id{audio_system.GetSessionId()};
-
+    audio_system.Finalize();
-    system.Finalize();
-
     if (system_registered) {
-        manager.RemoveSystem(system);
+        manager.RemoveSystem(audio_system);
         system_registered = false;
     }
-
     manager.ReleaseSessionId(session_id);
 }
 
 System& Renderer::GetSystem() {
-    return system;
+    return audio_system;
 }
 
 void Renderer::Start() {
-    system.Start();
+    audio_system.Start();
 }
 
 void Renderer::Stop() {
-    system.Stop();
+    audio_system.Stop();
 }
 
-Result Renderer::RequestUpdate(std::span<const u8> input, std::span<u8> performance,
+Result Renderer::RequestUpdate(std::span<const u8> input, std::span<u8> performance, std::span<u8> output) {
-                               std::span<u8> output) {
+    return audio_system.Update(input, performance, output);
-    return system.Update(input, performance, output);
 }
 
 } // namespace AudioCore::Renderer

src/audio_core/renderer/audio_renderer.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -83,16 +86,12 @@ public:
                          std::span<u8> output);
 
 private:
-    /// System core
-    Core::System& core;
     /// Manager this renderer is registered with
     Manager& manager;
-    /// Is the audio renderer initialized?
-    bool initialized{};
     /// Is the system registered with the manager?
     bool system_registered{};
     /// Audio render system, main driver of audio rendering
-    System system;
+    System audio_system;
 };
 
 } // namespace Renderer

src/audio_core/renderer/system.cpp

@@ -100,8 +100,9 @@ u64 System::GetWorkBufferSize(const AudioRendererParameterInternal& params) {
 }
 
 System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
-    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()},
+    : core{core_}
-      adsp_rendered_event{adsp_rendered_event_} {}
+    , adsp_rendered_event{adsp_rendered_event_}
+{}
 
 Result System::Initialize(const AudioRendererParameterInternal& params,
                           Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
@@ -406,7 +407,7 @@ void System::Finalize() {
         return;
     }
 
-    if (active) {
+    if (IsActive()) {
         Stop();
     }
 
@@ -433,14 +434,12 @@ 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) {
@@ -480,8 +479,7 @@ Result System::Update(std::span<const u8> input, std::span<u8> performance, std:
         return result;
     }
 
-    result = info_updater.UpdateEffects(effect_context, active, memory_pool_workbuffer,
+    result = info_updater.UpdateEffects(effect_context, IsActive(), memory_pool_workbuffer, memory_pool_count);
-                                        memory_pool_count);
     if (result.IsError()) {
         LOG_ERROR(Service_Audio, "Failed to update Effects!");
         return result;
@@ -582,16 +580,16 @@ u32 System::GetRenderingDevice() const {
 }
 
 bool System::IsActive() const {
-    return active;
+    return state == State::Started;
 }
 
 void System::SendCommandToDsp() {
     std::scoped_lock l{lock};
-
+    auto& audio_renderer = core.AudioCore().ADSP().AudioRenderer();
     if (initialized) {
-        if (active) {
+        if (IsActive()) {
             terminate_event.Reset();
-            const auto remaining_command_count{audio_renderer.GetRemainCommandCount(session_id)};
+            const auto remaining_command_count = audio_renderer.GetRemainCommandCount(session_id);
             u64 command_size{0};
 
             if (remaining_command_count) {
@@ -738,7 +736,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 = audio_renderer.GetRenderingStartTick(session_id);
+    render_start_tick = core.AudioCore().ADSP().AudioRenderer().GetRenderingStartTick(session_id);
     frames_elapsed++;
 
     return command_buffer.size;

src/audio_core/renderer/system.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -219,12 +222,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?
-    std::atomic<bool> active{};
     /// State of the system
     State state{State::Stopped};
     /// Sample rate for the system

src/audio_core/renderer/system_manager.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -16,22 +16,22 @@
 namespace AudioCore::Renderer {
 
 SystemManager::SystemManager(Core::System& core_)
-    : core{core_}, audio_renderer{core.AudioCore().ADSP().AudioRenderer()} {}
+    : core{core_}
+{}
 
 SystemManager::~SystemManager() {
     Stop();
 }
 
 void SystemManager::InitializeUnsafe() {
-    if (!active) {
+    if (!thread.joinable()) {
-        active = true;
+        core.AudioCore().ADSP().AudioRenderer().Start();
-        audio_renderer.Start();
         thread = std::jthread([this](std::stop_token stop_token) {
             Common::SetCurrentThreadName("AudioRenderSystemManager");
-            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+            auto& audio_renderer = core.AudioCore().ADSP().AudioRenderer();
-            while (active && !stop_token.stop_requested()) {
+            while (!stop_token.stop_requested()) {
                 {
-                    std::scoped_lock l{mutex1};
+                    std::scoped_lock lk{mutex};
                     for (auto system : systems)
                         system->SendCommandToDsp();
                 }
@@ -43,39 +43,31 @@ void SystemManager::InitializeUnsafe() {
 }
 
 void SystemManager::Stop() {
-    if (active) {
+    if (thread.joinable()) {
-        active = false;
         thread.request_stop();
         thread.join();
-        audio_renderer.Stop();
+        core.AudioCore().ADSP().AudioRenderer().Stop();
     }
 }
 
 bool SystemManager::Add(System& system_) {
-    std::scoped_lock l2{mutex2};
+    std::scoped_lock lk{mutex};
     if (systems.size() + 1 > MaxRendererSessions) {
         LOG_ERROR(Service_Audio, "Maximum AudioRenderer Systems active, cannot add more!");
         return false;
     }
-    {
-        std::scoped_lock l{mutex1};
     if (systems.empty())
         InitializeUnsafe();
-    }
     systems.push_back(&system_);
     return true;
 }
 
 bool SystemManager::Remove(System& system_) {
-    std::scoped_lock l2{mutex2};
+    std::scoped_lock lk{mutex};
-    {
-        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();
     return true;

src/audio_core/renderer/system_manager.h

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

src/common/CMakeLists.txt

@@ -76,6 +76,7 @@ add_library(
     logging.h
     lz4_compression.cpp
     lz4_compression.h
+    make_unique_for_overwrite.h
     math_util.h
     memory_detect.cpp
     memory_detect.h

src/common/make_unique_for_overwrite.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+    requires(!std::is_array_v<T>)
+std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+    requires std::is_unbounded_array_v<T>
+std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+    requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common

src/common/scratch_buffer.h

@@ -8,7 +8,8 @@
 
 #include <iterator>
 #include <cstring>
-#include <memory>
+
+#include "common/make_unique_for_overwrite.h"
 
 namespace Common {
 
@@ -37,9 +38,8 @@ public:
     ScratchBuffer() = default;
 
     explicit ScratchBuffer(size_type initial_capacity)
-        : last_requested_size{initial_capacity}
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
-        , buffer_capacity{initial_capacity}
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
-        , buffer{std::make_unique_for_overwrite<T[]>(initial_capacity)} {}
 
     ~ScratchBuffer() = default;
     ScratchBuffer(const ScratchBuffer&) = delete;
@@ -64,7 +64,7 @@ public:
     /// The previously held data will remain intact.
     void resize(size_type size) {
         if (size > buffer_capacity) {
-            auto new_buffer = std::make_unique_for_overwrite<T[]>(size);
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
             std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T));
             buffer = std::move(new_buffer);
             buffer_capacity = size;
@@ -77,7 +77,7 @@ public:
     void resize_destructive(size_type size) {
         if (size > buffer_capacity) {
             buffer_capacity = size;
-            buffer = std::make_unique_for_overwrite<T[]>(buffer_capacity);
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
         }
         last_requested_size = size;
     }

src/common/settings.cpp

@@ -178,6 +178,10 @@ 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);

src/common/settings.h

@@ -525,7 +525,7 @@ struct Values {
     SwitchableSetting<GpuFenceBehavior, true> gpu_fence_behavior{linkage,
                                                                  GpuFenceBehavior::Default,
                                                                  GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Accurate,
+                                                                 GpuFenceBehavior::Strict,
                                                                  "gpu_fence_behavior",
                                                                  Category::RendererAdvanced,
                                                                  Specialization::Default,
@@ -655,6 +655,13 @@ 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};
@@ -972,6 +979,7 @@ bool IsDMALevelSafe();
 bool IsGPUFenceBehaviorDefault();
 bool IsGPUFenceBehaviorBalanced();
 bool IsGPUFenceBehaviorAccurate();
+bool IsGPUFenceBehaviorStrict();
 
 bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);

src/common/settings_enums.h

@@ -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);
+ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);
 ENUM(CpuClock, Normal, Boost, Overclock)

src/common/sparse_large_vector.cpp

@@ -6,7 +6,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #ifdef _WIN32
-#include <algorithm>
 #include <windows.h>
 #include <mutex>
 #else
@@ -21,22 +20,19 @@ namespace Common {
 
 #ifdef _WIN32
 static std::vector<std::pair<u64, u64>> vector_regions {};
-static std::mutex vector_regions_mutex {};
 
 // Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
 static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
     DWORD code = info->ExceptionRecord->ExceptionCode;
-    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionInformation[1]);
+    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
 
-    if (code != EXCEPTION_ACCESS_VIOLATION || info->ExceptionRecord->ExceptionInformation[0] == 1) {
+    if (code != EXCEPTION_ACCESS_VIOLATION) {
         // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
     u64 addr = 0, addr2 = 0;
 
-    {
-        std::lock_guard lock(vector_regions_mutex);
     for (auto region: vector_regions) {
         auto addr_shifted = exception_addr >> HostPageBits;
         if (region.first <= addr_shifted && addr_shifted <= region.second) {
@@ -52,7 +48,6 @@ static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
             break;
         }
     }
-    }
 
     if (addr == 0 && addr2 == 0) {
         // Not our problem
@@ -82,16 +77,8 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
     auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
     if (res == 0) {
         LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
-    } else if (info.State == MEM_COMMIT) {
-        DWORD old_protect {};
-        auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
-        if (!VirtualProtect(reinterpret_cast<void*>(addr), HostPageSize, perm, &old_protect)) {
-            LOG_ERROR(HW_Memory, "Failed to change permissions of large buffer region at {:#x}, error {}", addr, GetLastError());
-            return false;
-        }
-        return true;
     } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped (state {:#x})", addr, info.State);
+        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (state {:#x})", addr, info.State);
         return false;
     }
 
@@ -109,21 +96,6 @@ 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) {
@@ -136,8 +108,7 @@ void* AllocateMemoryPages(std::size_t size) noexcept {
     void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
 
     if (base != nullptr) {
-        std::lock_guard lock(vector_regions_mutex);
+        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
-        vector_regions.emplace_back(reinterpret_cast<u64>(base) >> HostPageBits, (reinterpret_cast<u64>(base) + size) >> HostPageBits);
 
         static std::once_flag flag;
         std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
@@ -163,8 +134,6 @@ void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
     if (!base)
         return;
 #ifdef _WIN32
-    std::lock_guard lock(vector_regions_mutex);
-    std::erase_if(vector_regions, [base](const auto& r) {return r.first == reinterpret_cast<u64>(base); });
     ASSERT(VirtualFree(base, 0, MEM_RELEASE));
 #else
     ASSERT(munmap(base, size) == 0);

src/common/sparse_large_vector.h

@@ -28,14 +28,13 @@ constexpr u64 HostPageBits = 12;
 constexpr u64 HostPageMask = ~(HostPageSize - 1);
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
 #else
-inline const u64 HostPageSize = sysconf(_SC_PAGESIZE);
+const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-inline const u64 HostPageBits = std::countr_zero(HostPageSize);
+const u64 HostPageBits = std::countr_zero(HostPageSize);
-inline const u64 HostPageMask = ~(HostPageSize - 1);
+const u64 HostPageMask = ~(HostPageSize - 1);
 #endif
 
 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>
@@ -81,8 +80,8 @@ public:
             UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
         }
 
-        if (!IsCommittedPage(index) && !CommitPage(index)) {
+        if (!IsCommittedPage(index)) {
-            UNREACHABLE_MSG("Cannot access SparseLargeVector index {} with RW permission", index);
+            CommitPage(index);
         }
         return base_ptr[index];
     }
@@ -103,7 +102,8 @@ public:
             LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
             return;
         }
-        if (IsCommittedPage(index) || CommitPage(index))
+        if (!IsCommittedPage(index))
+            CommitPage(index);
         base_ptr[index] = value;
     }
 
@@ -114,7 +114,7 @@ public:
         const u64 end_page = AlignUp(base, HostPageSize);
         const u64 first_size = (std::min)(end_page, end) - base;
 
-        if (IsCommittedPage(start)) {
+        if (IsCommittedPage(start / sizeof(T))) {
             std::memset(reinterpret_cast<void*>(base), 0, first_size);
         }
 
@@ -124,16 +124,11 @@ public:
         base = end_page;
 
         for (u64 page = base; page < end; page += HostPageSize) {
-            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
+            if (!IsCommittedPage((page - reinterpret_cast<u64>(base_ptr)) / sizeof(T))) {
-            if (!IsCommittedPage(index)) {
                 continue;
             }
 
-            if (end - page >= HostPageSize) {
+            std::memset(reinterpret_cast<void*>(page), 0, (std::min)( HostPageSize, end - page));
-                DecommitPage(index);
-            } else {
-                std::memset(reinterpret_cast<void*>(page), 0, end - page);
-            }
         }
     }
 
@@ -176,30 +171,16 @@ private:
         return (val >> (page & 63)) & 1;
     }
 
-    constexpr bool CommitPage(std::size_t index) noexcept {
+    constexpr void CommitPage(std::size_t index) noexcept {
         auto page_index = (index * sizeof(T)) >> HostPageBits;
         auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
 #if defined(_WIN32)
-        if (!CommitVectorPage(page, true)) {
+        CommitVectorPage(page, true);
-            return false;
-        }
 #else
-        if (mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE) != 0) {
+        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
-            LOG_ERROR(Common_Memory, "Failed to commit large buffer region at index {}, error {}", index, strerror(errno));
-            return false;
-        }
 #endif
 
         committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
-        return true;
-    }
-
-    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{};

src/core/CMakeLists.txt

@@ -23,8 +23,6 @@ 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
@@ -1205,9 +1203,6 @@ 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)

src/core/file_sys/vfs/vfs_real.cpp

@@ -109,7 +109,8 @@ VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::op
     auto reference = std::make_unique<FileReference>();
     this->InsertReferenceIntoListLocked(*reference);
 
-    auto file = std::make_shared<RealVfsFile>(*this, std::move(reference), path, perms, size, std::move(parent_path));
+    auto file = std::shared_ptr<RealVfsFile>(
+        new RealVfsFile(*this, std::move(reference), path, perms, size, std::move(parent_path)));
     cache[path] = file;
 
     return file;
@@ -176,7 +177,7 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
 
 VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
@@ -184,7 +185,7 @@ VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode p
     if (!FS::CreateDirs(path)) {
         return nullptr;
     }
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,

src/core/file_sys/vfs/vfs_real.h

@@ -82,9 +82,6 @@ class RealVfsFile : public VfsFile {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
-                const std::string& path, OpenMode perms = OpenMode::Read,
-                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
     ~RealVfsFile() override;
 
     std::string GetName() const override;
@@ -98,6 +95,9 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
+                const std::string& path, OpenMode perms = OpenMode::Read,
+                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
 
     RealVfsFilesystem& base;
     std::unique_ptr<FileReference> reference;
@@ -113,8 +113,6 @@ class RealVfsDirectory : public VfsDirectory {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
-                     OpenMode perms = OpenMode::Read);
     ~RealVfsDirectory() override;
 
     VirtualFile GetFileRelative(std::string_view relative_path) const override;
@@ -140,6 +138,9 @@ public:
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
 private:
+    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
+                     OpenMode perms = OpenMode::Read);
+
     template <typename T, typename R>
     std::vector<std::shared_ptr<R>> IterateEntries() const;
 

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

@@ -517,7 +517,7 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     // Layer ordering. Composition sorts back-to-front. Now with enums for calrity.
     s32 z_index = Background;
     if (is_overlay) {
-        z_index = this->IsOverlayOpenLocked(*applet) ? Overlay : Background;
+        z_index = Overlay;
     } else if (inherited_foreground) {
         z_index = is_obscured ? Foreground : ForegroundVisible;
     }

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

@@ -191,7 +191,7 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService("audout:d", std::make_shared<IAudioOutManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audin:d", std::make_shared<IAudioInManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audrec:d", std::make_shared<IFinalOutputRecorderManagerForDebugger>(system), 30);
-    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioRendererManagerForDebugger>(system), 30);
+    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioInManager>(system), 30);
 
     server_manager->RegisterNamedService("audin:u", std::make_shared<IAudioInManager>(system), 30);
     server_manager->RegisterNamedService("audin:a", std::make_shared<IAudioInManagerForApplet>(system), 30);

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

@@ -97,7 +97,7 @@ Result IAudioDevice::SetAudioDeviceOutputVolumeAuto(
     LOG_DEBUG(Service_Audio, "called. name={}, volume={}", device_name, volume);
 
     if (device_name == "AudioTvOutput") {
-        impl->SetDeviceVolumes(volume);
+        impl->SetDeviceVolumes(system, volume);
     }
 
     R_SUCCEED();
@@ -112,7 +112,7 @@ Result IAudioDevice::GetAudioDeviceOutputVolumeAuto(
 
     *out_volume = 1.0f;
     if (device_name == "AudioTvOutput") {
-        *out_volume = impl->GetDeviceVolume(device_name);
+        *out_volume = impl->GetDeviceVolume(system, device_name);
     }
 
     R_SUCCEED();

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

@@ -50,7 +50,7 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
 }
 
 IAudioIn::~IAudioIn() {
-    impl->Free();
+    impl->Free(system);
     service_context.CloseEvent(event);
     process->Close(system.Kernel());
 }

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -65,7 +68,7 @@ Result IAudioInManager::OpenAudioInAuto(
 Result IAudioInManager::ListAudioInsAutoFiltered(
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_audio_ins, Out<u32> out_count) {
     LOG_DEBUG(Service_Audio, "called");
-    *out_count = impl->GetDeviceNames(out_audio_ins, true);
+    *out_count = impl->GetDeviceNames(system, out_audio_ins, true);
     R_SUCCEED();
 }
 
@@ -90,8 +93,8 @@ Result IAudioInManager::OpenAudioInProtocolSpecified(
 
     size_t new_session_id{};
 
-    R_TRY(impl->LinkToManager());
+    R_TRY(impl->LinkToManager(system));
-    R_TRY(impl->AcquireSessionId(new_session_id));
+    R_TRY(impl->AcquireSessionId(system, new_session_id));
 
     LOG_DEBUG(Service_Audio, "Opening new AudioIn, session_id={}, free sessions={}", new_session_id,
               impl->num_free_sessions);

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

@@ -46,7 +46,7 @@ IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
 }
 
 IAudioOut::~IAudioOut() {
-    impl->Free();
+    impl->Free(system);
     service_context.CloseEvent(event);
     process->Close(system.Kernel());
 }

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

@@ -77,8 +77,8 @@ Result IAudioOutManager::OpenAudioOutAuto(
     }
 
     size_t new_session_id{};
-    R_TRY(impl->LinkToManager());
+    R_TRY(impl->LinkToManager(system));
-    R_TRY(impl->AcquireSessionId(new_session_id));
+    R_TRY(impl->AcquireSessionId(system, new_session_id));
 
     const auto device_name = Common::StringFromBuffer(name[0].name);
     LOG_DEBUG(Service_Audio, "Opening new AudioOut, sessionid={}, free sessions={}", new_session_id,

src/core/hle/service/psc/ovln/receiver_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -24,7 +24,7 @@ IReceiverService::~IReceiverService() = default;
 
 Result IReceiverService::OpenReceiver(Out<SharedPointer<IReceiver>> out_receiver) {
     LOG_DEBUG(Service_PSC, "called");
-    *out_receiver = std::make_shared<IReceiver>(system);
+    *out_receiver = std::shared_ptr<IReceiver>(new IReceiver(system));
     R_SUCCEED();
 }
 

src/core/launch_params.cpp

@@ -1,205 +0,0 @@
-// 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
-        );
-    }
-}
-
-}

src/core/launch_params.h

@@ -1,43 +0,0 @@
-// 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;
-
-}

src/core/memory.cpp

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

src/hid_core/frontend/emulated_controller.cpp

@@ -761,6 +761,9 @@ void EmulatedController::StartMotionCalibration() {
 }
 
 void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index, Common::UUID uuid) {
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -913,10 +916,21 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
         break;
     }
 
-    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
+    if (!is_connected) {
-    const auto& player = Settings::values.players.GetValue()[player_index];
+        if (npad_type == NpadStyleIndex::Handheld) {
-    if (player.connected) {
+            if (npad_id_type == NpadIdType::Handheld) {
                 Connect();
+                controller_connected[player_index] = true;
+            }
+        } else if (npad_type != NpadStyleIndex::Handheld) {
+            if (npad_id_type == NpadIdType::Player1) {
+                Connect();
+                controller_connected[player_index] = true;
+            } else if (player.connected && !controller_connected[player_index]) {
+                Connect();
+                controller_connected[player_index] = true;
+            }
+        }
     }
 
     TriggerOnChange(ControllerTriggerType::Button, true);

src/hid_core/frontend/emulated_controller.h

@@ -22,6 +22,7 @@
 #include "common/settings.h"
 #include "common/vector_math.h"
 #include "hid_core/frontend/motion_input.h"
+#include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/irsensor/irs_types.h"
 
@@ -584,6 +585,7 @@ private:
     std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                        DEFAULT_VIBRATION_VALUE};
     std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
+    std::array<bool, HIDCore::available_controllers> controller_connected{};
 
     // Atomically synched values
     std::atomic<HID::NpadStyleIndex> npad_type{HID::NpadStyleIndex::None};

src/hid_core/resources/npad/npad.cpp

@@ -45,19 +45,6 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service
         AbstractPad{hid_core_.kernel},
     }}
 {
-    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
-        for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
-            auto& controller = controller_data[aruid_index][i];
-            controller.device = hid_core.GetEmulatedControllerByIndex(i);
-            Core::HID::ControllerUpdateCallback engine_callback{
-                .on_change = [this, i, kernel = &hid_core.kernel](Core::HID::ControllerTriggerType type) {
-                    ControllerUpdate(*kernel, type, i);
-                },
-                .is_npad_service = true,
-            };
-            controller.callback_key = controller.device->SetCallback(engine_callback);
-        }
-    }
     for (std::size_t i = 0; i < abstracted_pads.size(); ++i) {
         abstracted_pads[i].SetNpadId(IndexToNpadIdType(i));
     }
@@ -106,6 +93,16 @@ Result NPad::Activate(u64 aruid) {
     for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
         auto& controller = controller_data[aruid_index][i];
         controller.shared_memory = &data->shared_memory_format->npad.npad_entry[i].internal_state;
+        controller.device = hid_core.GetEmulatedControllerByIndex(i);
+        if (!controller.callback_key) {
+            Core::HID::ControllerUpdateCallback engine_callback{
+                .on_change = [this, i](Core::HID::ControllerTriggerType type) {
+                    ControllerUpdate(hid_core.kernel, type, i);
+                },
+                .is_npad_service = true,
+            };
+            controller.callback_key = controller.device->SetCallback(engine_callback);
+        }
     }
 
     // Prefill controller buffers

src/qt_common/config/shared_translation.cpp

@@ -226,7 +226,9 @@ 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.\nDefault follows the GPU Mode setting."));
+           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."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
     INSERT(Settings, gpu_clock, tr("GPU Clocks"),
@@ -440,6 +442,7 @@ 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(),

src/shader_recompiler/backend/glsl/emit_glsl.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -31,6 +28,11 @@ 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>) {
@@ -51,11 +53,22 @@ 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>

src/video_core/buffer_cache/buffer_cache.h

@@ -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 (IsRegionGpuModified(device_addr, size)) {
+    if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
         ClearDownload(device_addr, size);
         gpu_modified_ranges.Subtract(device_addr, size);
     }
@@ -249,10 +249,6 @@ 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>
@@ -315,8 +311,11 @@ std::pair<typename P::Buffer*, u32> BufferCache<P>::ObtainCPUBuffer(
         MarkWrittenBuffer(buffer_id, device_addr, size);
         break;
     case ObtainBufferOperation::DiscardWrite: {
-        ClearDownload(device_addr, size);
+        const DAddr device_addr_start = Common::AlignDown(device_addr, 64);
-        gpu_modified_ranges.Subtract(device_addr, size);
+        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);
         break;
     }
     default:
@@ -1234,7 +1233,7 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
         buffer.MarkUsage(offset, size);
 
         if (is_written) {
-            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size, true);
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
         }
 
         if constexpr (NEEDS_BIND_STORAGE_INDEX) {
@@ -1520,13 +1519,11 @@ void BufferCache<P>::UpdateComputeTextureBuffers() {
 }
 
 template <class P>
-void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync) {
+void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) {
     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);
@@ -1541,11 +1538,8 @@ 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()) {
@@ -1561,13 +1555,19 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
 }
 
 template <class P>
-void BufferCache<P>::SynchronizeBufferWrites(Buffer& buffer) {
+void BufferCache<P>::WaitForGpuFenceIfNeeded(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();
-        if (!runtime.IsFree(buffer_tick)) {
+            const u64 gpu_tick = runtime.KnownGpuTick();
+            if (buffer_tick > gpu_tick + gpu_tick_delay) {
                 runtime.Wait(buffer_tick);
             }
         }
+    }
 }
 
 template <class P>
@@ -1742,24 +1742,14 @@ 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;
-    const auto add_upload = [&](DAddr start, DAddr end) {
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
-        if (start == end) return;
-        const u64 range_size = end - start;
         upload_copies.push_back(BufferCopy{
             .src_offset = total_size_bytes,
-            .dst_offset = start - buffer_start,
+            .dst_offset = device_addr_out - 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;
@@ -1798,6 +1788,9 @@ 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);
             }
@@ -1816,6 +1809,9 @@ 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;

src/video_core/buffer_cache/buffer_cache_base.h

@@ -430,11 +430,11 @@ private:
 
     void UpdateComputeTextureBuffers();
 
-    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync = false);
+    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size);
 
     [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size, bool sparse_compatible);
 
-    void SynchronizeBufferWrites(Buffer& buffer);
+    void WaitForGpuFenceIfNeeded(Buffer& buffer);
 
     [[nodiscard]] OverlapResult ResolveOverlaps(DAddr device_addr, u32 wanted_size);
 

src/video_core/dma_pusher.cpp

@@ -16,7 +16,7 @@
 namespace Tegra {
 
 constexpr u32 MacroRegistersStart = 0xE00;
-constexpr u32 ComputeInline = 0x6D;
+[[maybe_unused]] constexpr u32 ComputeInline = 0x6D;
 
 DmaPusher::DmaPusher(Core::System& system_, MemoryManager& memory_manager_, Control::ChannelState& channel_state_)
     : system{system_}
@@ -73,16 +73,11 @@ 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);

src/video_core/engines/kepler_compute.cpp

@@ -49,16 +49,13 @@ 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;
     }
@@ -67,13 +64,11 @@ 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)) {
+            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x) &&
-                const bool source_dirty = memory_manager.IsMemoryDirty(data.upload_address, data.copy_size);
+                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;
@@ -88,8 +83,6 @@ 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:

src/video_core/engines/kepler_compute.h

@@ -226,13 +226,11 @@ 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{};

src/video_core/fence_manager.h

@@ -72,7 +72,7 @@ public:
     }
 
     void SignalFence(std::function<void()>&& func) {
-        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate();
+        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate() || Settings::IsGPUFenceBehaviorStrict();
         const bool should_flush = ShouldFlush();
         if constexpr (!can_async_check) {
             TryReleasePendingFences<false>();

src/video_core/gpu.cpp

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

src/video_core/gpu.h

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

src/video_core/query_cache/query_cache.h

@@ -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()) && is_fence;
+    bool is_synced = (Settings::IsGPUFenceBehaviorDefault() ? !Settings::IsGPULevelHigh() : !Settings::IsGPUFenceBehaviorBalanced() && !Settings::IsGPUFenceBehaviorAccurate() && !Settings::IsGPUFenceBehaviorStrict()) && 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)) {

src/video_core/renderer_vulkan/present/layer.cpp

@@ -94,14 +94,11 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c
     const u32 scaled_width = texture_info ? texture_info->scaled_width : texture_width;
     const u32 scaled_height = texture_info ? texture_info->scaled_height : texture_height;
     const bool use_accelerated = texture_info.has_value();
-    const bool is_applet =
-        (framebuffer.layer_stack_mask & Service::Nvnflinger::LayerStackBit(
-                                            Service::Nvnflinger::LayerStackId::Recording)) == 0;
 
     RefreshResources(device, framebuffer);
     SetAntiAliasPass(device);
 #ifdef HAS_RESHADE
-    SetPostProcessPass(device, is_applet);
+    SetPostProcessPass(device);
 #endif
 
     // Finish any pending renderpass
@@ -141,12 +138,9 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c
         source_image_view = fsr->Draw(device, scheduler, image_index, source_image, source_image_view, render_extent, crop_rect);
         crop_rect = {0, 0, 1, 1};
     } else if (auto* sgsr = std::get_if<SGSR>(&sr_filter)) {
-        if (!is_applet) {
+        source_image_view = sgsr->Draw(device, scheduler, image_index, source_image, source_image_view, render_extent, crop_rect);
-            source_image_view = sgsr->Draw(device, scheduler, image_index, source_image,
-                                           source_image_view, render_extent, crop_rect);
         crop_rect = {0, 0, 1, 1};
     }
-    }
 
     SetMatrixData(device, *out_push_constants, layout);
     SetVertexData(device, *out_push_constants, layout, crop_rect);
@@ -234,11 +228,7 @@ void Layer::SetAntiAliasPass(const Device& device) {
 }
 
 #ifdef HAS_RESHADE
-void Layer::SetPostProcessPass(const Device& device, bool is_applet) {
+void Layer::SetPostProcessPass(const Device& device) {
-    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),

src/video_core/renderer_vulkan/present/layer.h

@@ -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, bool is_applet);
+    void SetPostProcessPass(const Device& device);
 #endif
     void ReleaseRawImages();
 

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -419,15 +419,15 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
 }
 
 u64 BufferCacheRuntime::CurrentTick() {
-    return scheduler.CurrentTick();
+    return scheduler.GetMasterSemaphore().CurrentTick();
 }
 
-bool BufferCacheRuntime::IsFree(u64 tick) {
+u64 BufferCacheRuntime::KnownGpuTick() {
-    return scheduler.IsFree(tick);
+    return scheduler.GetMasterSemaphore().KnownGpuTick();
 }
 
-void BufferCacheRuntime::Wait(u64 tick) {
+void BufferCacheRuntime::Wait(u64 buffer_tick) {
-    scheduler.Wait(tick);
+    scheduler.Wait(buffer_tick);
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -112,9 +112,9 @@ public:
 
     u64 CurrentTick();
 
-    bool IsFree(u64 tick);
+    u64 KnownGpuTick();
 
-    void Wait(u64 tick);
+    void Wait(u64 buffer_tick);
 
     void Finish();
 

src/yuzu/main_window.cpp

@@ -3,7 +3,6 @@
 
 // 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
@@ -516,28 +515,79 @@ MainWindow::MainWindow(bool has_broken_vulkan)
     // to prevent the UI from blowing up.
     UpdateUITheme();
 
-    if (QStringList args = QApplication::arguments(); args.size() >= 2) {
+    QStringList args = QApplication::arguments();
-        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());
 
-        auto const lp = Core::ParseLaunchParams(*QtCommon::system, args_cstr.size(), args_cstr.data(), nullptr);
+    if (args.size() < 2) {
-
+        return;
-        // Override fullscreen setting if gamepath or argument is provided
-        if (!lp.filepath.empty() || lp.fullscreen) {
-            ui->action_Fullscreen->setChecked(lp.fullscreen);
     }
 
-        if (!lp.filepath.empty()) {
+    QString game_path;
-            BootGame(QString::fromStdString(lp.filepath), ApplicationAppletParameters());
+    bool should_launch_qlaunch = false;
-        } else if (lp.launch_setup) {
+    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;
+        }
+    }
+
+    // Override fullscreen setting if gamepath or argument is provided
+    if (has_gamepath || is_fullscreen) {
+        ui->action_Fullscreen->setChecked(is_fullscreen);
+    }
+
+    if (should_launch_setup) {
         LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::Starter), std::nullopt);
-        } else if (lp.launch_qlaunch) {
+    } else {
+        if (!game_path.isEmpty()) {
+            BootGame(game_path, ApplicationAppletParameters());
+        } else if (should_launch_qlaunch) {
             LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::QLaunch), std::nullopt);
-        } else if (lp.launch_hlaunch) {
+        } else if (should_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();

src/yuzu_cmd/CMakeLists.txt

@@ -42,6 +42,9 @@ 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")

src/yuzu_cmd/yuzu.cpp

@@ -10,7 +10,6 @@
 #include <regex>
 #include <string>
 #include "common/settings_enums.h"
-#include "core/launch_params.h"
 #ifdef __EMSCRIPTEN__
 #include <emscripten.h>
 #endif
@@ -53,6 +52,12 @@
 #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
@@ -62,6 +67,25 @@ __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:
@@ -184,18 +208,168 @@ 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;
     }
-#else
-    wchar_t **argv_w = nullptr;
 #endif
-    Core::LaunchParams lp = Core::ParseLaunchParams(state->system, argc, argv, argv_w);
+    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];
+#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;
+    }
+
 #ifdef _WIN32
     LocalFree(argv_w);
 #endif
-    SdlConfig config{lp.config_path};
 
-    Core::ApplyLaunchParams(lp);
+    if (filepath.empty()) {
-
-    if (lp.filepath.empty()) {
         LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
         return SDL_APP_FAILURE;
     }
@@ -212,14 +386,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, lp.fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, fullscreen);
         break;
 #endif
     case Settings::RendererBackend::Vulkan:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, lp.fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, fullscreen);
         break;
     case Settings::RendererBackend::Null:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, lp.fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, fullscreen);
         break;
     default:
         LOG_CRITICAL(Frontend, "Invalid renderer backend");
@@ -239,12 +413,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, lp.filepath, load_parameters);
+    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, 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 {}!", lp.filepath);
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
         return SDL_APP_FAILURE;
     case Core::SystemResultStatus::ErrorLoader:
         LOG_CRITICAL(Frontend, "Failed to load ROM!");
@@ -266,14 +440,14 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
         return SDL_APP_FAILURE;
     }
 
-    if (lp.use_multiplayer) {
+    if (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 {}", lp.address, lp.port, lp.nickname);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port, nickname);
-            member->Join(lp.nickname, lp.address.c_str(), lp.port, 0, Network::NoPreferredIP, lp.password);
+            member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
         } else {
             LOG_ERROR(Network, "Could not access RoomMember");
             return SDL_APP_FAILURE;