L;ICENSES

ploo
[vk] implement VK_EXT_border_color_swizzle
2026-08-14 04:24:31 +00:00 · 2026-07-01 06:32:09 +00:00 · 2026-07-01 06:31:43 +00:00 · 2026-07-01 05:22:23 +00:00 · 2026-06-30 04:33:30 +02:00 · 2026-06-29 08:11:12 +02:00
80 changed files with 743 additions and 459 deletions
@@ -31,6 +31,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"),
@@ -806,6 +806,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,
@@ -292,6 +292,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))
@@ -503,6 +503,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>

@@ -350,7 +350,7 @@ struct System::Impl {

        // Register with applet manager
        // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager.CreateAndInsertByFrontendAppletParameters(std::make_unique<Service::Process>(*std::move(process)), params);
+        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);

        if (Settings::values.gamecard_inserted) {
            if (Settings::values.gamecard_current_game) {
@@ -729,7 +729,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface(ensure_token_id);
+        rb.PushIpcInterface(ctx, ensure_token_id);
    }

    void LoadIdTokenCacheDeprecated(HLERequestContext& ctx) {
@@ -921,7 +921,7 @@ void Module::Interface::GetProfile(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IProfile>(system, user_id, *profile_manager);
+    rb.PushIpcInterface<IProfile>(ctx, system, user_id, *profile_manager);
 }

 void Module::Interface::IsUserRegistrationRequestPermitted(HLERequestContext& ctx) {
@@ -993,7 +993,7 @@ void Module::Interface::GetBaasAccountManagerForApplication(HLERequestContext& c
    LOG_DEBUG(Service_ACC, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IManagerForApplication>(system, profile_manager);
+    rb.PushIpcInterface<IManagerForApplication>(ctx, system, profile_manager);
 }

 void Module::Interface::IsUserAccountSwitchLocked(HLERequestContext& ctx) {
@@ -1089,7 +1089,7 @@ void Module::Interface::GetProfileEditor(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IProfileEditor>(system, user_id, *profile_manager);
+    rb.PushIpcInterface<IProfileEditor>(ctx, system, user_id, *profile_manager);
 }

 void Module::Interface::GetBaasAccountAdministrator(HLERequestContext &ctx) {
@@ -1100,7 +1100,7 @@ void Module::Interface::GetBaasAccountAdministrator(HLERequestContext &ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IAdministrator>(system, uuid);
+    rb.PushIpcInterface<IAdministrator>(ctx, system, uuid);
 }

 void Module::Interface::ListQualifiedUsers(HLERequestContext& ctx) {
@@ -1143,7 +1143,7 @@ void Module::Interface::GetBaasAccountManagerForSystemService(HLERequestContext&

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IManagerForSystemService>(system, uuid);
+    rb.PushIpcInterface<IManagerForSystemService>(ctx, system, uuid);
 }

 void Module::Interface::StoreSaveDataThumbnailSystem(HLERequestContext& ctx) {
@@ -35,7 +35,7 @@ void IAsyncContext::GetSystemEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(completion_event->GetReadableEvent());
+    rb.PushCopyObjects(ctx, completion_event->GetReadableEvent());
 }

 void IAsyncContext::Cancel(HLERequestContext& ctx) {
@@ -109,6 +109,10 @@ struct Applet {
    std::list<std::shared_ptr<Applet>> child_applets{};
    bool is_completed{};

+    std::shared_ptr<Applet> reserved_applet{};
+    bool unwind_after_reserved{};
+    bool is_winding{};
+
    // Self state
    bool exit_locked{};
    s32 fatal_section_count{};
@@ -25,6 +25,13 @@ void AppletStorageChannel::Push(Kernel::KernelCore& kernel, std::shared_ptr<ISto
    m_event.Signal(kernel);
 }

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

@@ -26,6 +26,7 @@ public:
    ~AppletStorageChannel();

    void Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
+    void Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
    Result Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage);
    Kernel::KReadableEvent* GetEvent();

@@ -267,7 +267,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {

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

@@ -12,7 +15,10 @@ namespace Service::AM {

 HidRegistration::HidRegistration(Core::System& system, Process& process) : m_process(process) {
    m_hid_server = system.ServiceManager().GetService<HID::IHidServer>("hid", true);
+    this->RegisterCurrentProcess();
+}

+void HidRegistration::RegisterCurrentProcess() {
    if (m_process.IsInitialized()) {
        m_hid_server->GetResourceManager()->RegisterAppletResourceUserId(m_process.GetProcessId(),
                                                                         true);
@@ -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

@@ -24,6 +27,7 @@ public:
    explicit HidRegistration(Core::System& system, Process& process);
    ~HidRegistration();

+    void RegisterCurrentProcess();
    void EnableAppletToGetInput(bool enable);

 private:
@@ -171,6 +171,18 @@ void LifecycleManager::SignalSystemEventIfNeeded(Kernel::KernelCore& kernel) {
    }
 }

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

+    void ResetForRelaunch();
+
 private:
    FocusState GetFocusStateWhileForegroundObscured() const;
    FocusState GetFocusStateWhileBackground(bool is_obscured) const;
@@ -40,23 +40,23 @@ namespace {
    }
 }

-[[nodiscard]] inline std::optional<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+[[nodiscard]] inline std::unique_ptr<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
    // Get the appropriate loader to parse this NCA.
    out_loader = Loader::GetLoader(system, file, program_id, program_index);
    // Ensure we have a loader which can parse the NCA.
    if (out_loader) {
        // Try to load the process.
-        auto process = std::make_optional<Process>(system);
+        auto process = std::make_unique<Process>(system);
        if (process->Initialize(*out_loader, out_load_result)) {
            return process;
        }
    }
-    return std::nullopt;
+    return nullptr;
 }

 } // Anonymous namespace

-std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
+std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
    // Attempt to load program NCA.
    FileSys::VirtualFile nca_raw{};

@@ -66,7 +66,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi

    // Ensure we retrieved a program NCA.
    if (!nca_raw) {
-        return std::nullopt;
+        return nullptr;
    }

    // Ensure we have a suitable version.
@@ -76,7 +76,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi
            (nca.GetKeyGeneration() < minimum_key_generation ||
             nca.GetKeyGeneration() > maximum_key_generation)) {
            LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id, nca.GetKeyGeneration());
-            return std::nullopt;
+            return nullptr;
        }
    }

@@ -85,7 +85,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi
    return CreateProcessImpl(loader, status, system, nca_raw, program_id, 0);
 }

-std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
    if (auto process = CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index); process) {
        FileSys::NACP nacp;
        if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
@@ -110,7 +110,23 @@ std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, st
        system.GetARPManager().Register(launch.title_id, launch, out_control);
        return process;
    }
-    return std::nullopt;
+    return nullptr;
+}
+
+bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id) {
+    auto& storage = system.GetContentProviderUnion();
+    const auto nca_raw = storage.GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
+    if (!nca_raw) {
+        return false;
+    }
+
+    auto loader = Loader::GetLoader(system, nca_raw, program_id, 0);
+    if (!loader) {
+        return false;
+    }
+
+    Loader::ResultStatus status{};
+    return process.Initialize(*loader, status);
 }

 } // namespace Service::AM
@@ -27,7 +27,9 @@ class Process;

 namespace Service::AM {

-std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
-std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
+std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
+std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
+
+bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id);

 } // namespace Service::AM
@@ -35,9 +35,9 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
    std::unique_ptr<Loader::AppLoader> loader;
    Loader::ResultStatus result;
    auto process = CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
-    R_UNLESS(process != std::nullopt, ResultUnknown);
+    R_UNLESS(process != nullptr, ResultUnknown);

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

-    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
+    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
    applet->program_id = application_id;
    applet->applet_id = AppletId::Starter;
    applet->type = AppletType::LibraryApplet;
@@ -75,7 +75,7 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
        {105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
        {106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
        {110, nullptr, "NeedsToExitProcess"},
-        {120, nullptr, "GetLibraryAppletInfo"},
+        {120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
        {150, nullptr, "RequestForAppletToGetForeground"},
        {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
        {170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170"}, //22.0.0+
@@ -218,6 +218,16 @@ Result ILibraryAppletAccessor::GetIndirectLayerConsumerHandle(Out<u64> out_handl
    R_SUCCEED();
 }

+Result ILibraryAppletAccessor::GetLibraryAppletInfo(
+    Out<LibraryAppletInfo> out_library_applet_info) {
+    LOG_INFO(Service_AM, "called");
+    *out_library_applet_info = {
+        .applet_id = m_applet->applet_id,
+        .library_applet_mode = m_applet->library_applet_mode,
+    };
+    R_SUCCEED();
+}
+
 Result ILibraryAppletAccessor::Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event) {
    LOG_WARNING(Service_AM, "(STUBBED) called");
    *out_event = m_applet->unknown_event.GetHandle();
@@ -6,6 +6,7 @@

 #pragma once

+#include "core/hle/service/am/service/library_applet_self_accessor.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"

@@ -21,6 +22,10 @@ public:
                                    std::shared_ptr<Applet> applet);
    ~ILibraryAppletAccessor();

+    std::shared_ptr<Applet> GetApplet() const {
+        return m_applet;
+    }
+
 private:
    Result GetAppletStateChangedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result IsCompleted(Out<bool> out_is_completed);
@@ -37,6 +42,7 @@ private:
    Result GetPopOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result GetPopInteractiveOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result GetIndirectLayerConsumerHandle(Out<u64> out_handle);
+    Result GetLibraryAppletInfo(Out<LibraryAppletInfo> out_library_applet_info);
    Result Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event);

    void FrontendExecute();
@@ -123,7 +123,7 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,

    auto process = CreateProcess(system, program_id, Firmware1400, Firmware2200);
    if (process) {
-        const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), false);
+        const auto applet = std::make_shared<Applet>(system, std::move(process), false);
        applet->program_id = program_id;
        applet->applet_id = applet_id;
        applet->type = AppletType::LibraryApplet;
@@ -233,8 +233,9 @@ Result ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext(
    R_SUCCEED();
 }

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

@@ -72,7 +72,7 @@ private:
    Result ReportVisibleError(ErrorCode error_code);
    Result ReportVisibleErrorWithErrorContext(
        ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context);
-    Result UnpopInData();
+    Result UnpopInData(SharedPointer<IStorage> storage);
    Result GetMainAppletApplicationDesiredLanguage(Out<u64> out_desired_language);
    Result GetCurrentApplicationId(Out<u64> out_application_id);
    Result GetMainAppletAvailableUsers(Out<bool> out_can_select_any_user, Out<s32> out_users_count,
@@ -1,9 +1,11 @@
-// 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 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include "core/core.h"
+#include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/library_applet_accessor.h"
 #include "core/hle/service/am/service/process_winding_controller.h"
@@ -43,6 +45,18 @@ Result IProcessWindingController::OpenCallingLibraryApplet(
    Out<SharedPointer<ILibraryAppletAccessor>> out_calling_library_applet) {
    LOG_INFO(Service_AM, "called");

+    std::shared_ptr<Applet> reserved_applet;
+    {
+        std::scoped_lock lk{m_applet->lock};
+        reserved_applet = std::move(m_applet->reserved_applet);
+    }
+
+    if (reserved_applet != nullptr) {
+        *out_calling_library_applet = std::make_shared<ILibraryAppletAccessor>(
+            system, reserved_applet->caller_applet_broker, reserved_applet);
+        R_SUCCEED();
+    }
+
    const auto caller_applet = m_applet->caller_applet.lock();
    if (caller_applet == nullptr) {
        LOG_ERROR(Service_AM, "No caller applet available");
@@ -74,22 +88,82 @@ Result IProcessWindingController::PopContext(Out<SharedPointer<IStorage>> out_co
 }

 Result IProcessWindingController::CancelWindingReservation() {
-    LOG_WARNING(Service_AM, "STUBBED");
+    LOG_INFO(Service_AM, "called");
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet.reset();
+    m_applet->unwind_after_reserved = false;
+
    R_SUCCEED();
 }

 Result IProcessWindingController::WindAndDoReserved() {
-    LOG_WARNING(Service_AM, "STUBBED");
+    LOG_INFO(Service_AM, "called");
+
+    std::shared_ptr<Applet> reserved_applet;
+    {
+        std::scoped_lock lk{m_applet->lock};
+
+        reserved_applet = m_applet->reserved_applet;
+        m_applet->display_layer_manager.SetWindowVisibility(false);
+        m_applet->exit_locked = false;
+        system.SetExitLocked(false);
+    }
+
+    if (reserved_applet) {
+        {
+            std::scoped_lock lk{m_applet->lock};
+            m_applet->is_winding = true;
+        }
+
+        {
+            std::scoped_lock lk{reserved_applet->lock};
+            reserved_applet->window_visible = true;
+            reserved_applet->process->Run();
+        }
+
+        if (reserved_applet->frontend) {
+            reserved_applet->frontend->Initialize();
+            reserved_applet->frontend->Execute();
+        }
+    } else {
+        LOG_WARNING(Service_AM, "called without a reserved applet to start");
+    }
+
+    m_applet->process->Terminate();
+
    R_SUCCEED();
 }

-Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis() {
-    LOG_WARNING(Service_AM, "STUBBED");
+Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis(
+    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
+    LOG_INFO(Service_AM, "called");
+
+    if (reserved_applet_accessor == nullptr) {
+        LOG_ERROR(Service_AM, "No applet accessor provided");
+        R_THROW(ResultUnknown);
+    }
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
+    m_applet->unwind_after_reserved = true;
+
    R_SUCCEED();
 }

-Result IProcessWindingController::ReserveToStartAndWait() {
-    LOG_WARNING(Service_AM, "STUBBED");
+Result IProcessWindingController::ReserveToStartAndWait(
+    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
+    LOG_INFO(Service_AM, "called");
+
+    if (reserved_applet_accessor == nullptr) {
+        LOG_ERROR(Service_AM, "No applet accessor provided");
+        R_THROW(ResultUnknown);
+    }
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
+    m_applet->unwind_after_reserved = false;
+
    R_SUCCEED();
 }

@@ -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 2024 yuzu Emulator Project
@@ -29,8 +29,9 @@ private:
    Result PopContext(Out<SharedPointer<IStorage>> out_context);
    Result CancelWindingReservation();
    Result WindAndDoReserved();
-    Result ReserveToStartAndWaitAndUnwindThis();
-    Result ReserveToStartAndWait();
+    Result ReserveToStartAndWaitAndUnwindThis(
+        SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
+    Result ReserveToStartAndWait(SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);

    const std::shared_ptr<Applet> m_applet;
 };
@@ -9,6 +9,7 @@
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/event_observer.h"
+#include "core/hle/service/am/process_creation.h"
 #include "core/hle/service/am/window_system.h"

 namespace Service::AM {
@@ -240,6 +241,37 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
            continue;
        }

+        // A winding applet has had its own process killed but is kept alive as a transparent slot
+        // while the reserved applet running in its place finishes (see WindAndDoReserved()).
+        if (applet->is_winding) {
+            if (!applet->child_applets.empty()) {
+                it = std::next(it);
+                continue;
+            }
+
+            const bool unwind = applet->unwind_after_reserved;
+            applet->is_winding = false;
+            applet->unwind_after_reserved = false;
+
+            if (unwind && this->RestartAppletProcessLocked(applet.get())) {
+                const u64 new_aruid = applet->aruid.pid;
+                const auto next = std::next(it);
+
+                if (new_aruid != aruid) {
+                    auto node = m_applets.extract(it);
+                    node.key() = new_aruid;
+                    m_applets.insert(std::move(node));
+                }
+
+                applet->process->Run();
+                m_event_observer->RequestUpdate();
+                it = next;
+                continue;
+            }
+
+            applet->reserved_applet.reset();
+        }
+
        // Terminated, so ensure all child applets are terminated.
        if (!applet->child_applets.empty()) {
            this->TerminateChildAppletsLocked(applet.get());
@@ -301,6 +333,28 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
    }
 }

+bool WindowSystem::RestartAppletProcessLocked(Applet* applet) {
+    if (!ReinitializeProcess(m_system, *applet->process, applet->program_id)) {
+        LOG_ERROR(Service_AM, "Failed to restart winding applet_id={}",
+                  static_cast<u32>(applet->applet_id));
+        return false;
+    }
+
+    applet->aruid.pid = applet->process->GetProcessId();
+    applet->is_process_running = false;
+    applet->is_completed = false;
+
+    applet->hid_registration.RegisterCurrentProcess();
+
+    applet->lifecycle_manager.ResetForRelaunch();
+    applet->is_activity_runnable = false;
+
+    applet->launch_reason.flag = 1;
+
+    m_event_observer->TrackAppletProcess(*applet);
+    return true;
+}
+
 bool WindowSystem::LockHomeMenuIntoForegroundLocked() {
    // If the home menu is not locked into foreground, then there's nothing to do.
    if (m_home_menu == nullptr || !m_home_menu_foreground_locked) {
@@ -352,6 +406,9 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
    const bool has_obscuring_child_applets = [&] {
        for (const auto& child_applet : applet->child_applets) {
            std::scoped_lock lk2{child_applet->lock};
+            if (child_applet->is_winding) {
+                return true;
+            }
            const auto mode = child_applet->library_applet_mode;
            if (child_applet->is_process_running && child_applet->window_visible &&
                (mode == LibraryAppletMode::AllForeground ||
@@ -61,6 +61,7 @@ public:

 private:
    void PruneTerminatedAppletsLocked();
+    bool RestartAppletProcessLocked(Applet* applet);
    bool LockHomeMenuIntoForegroundLocked();
    void TerminateChildAppletsLocked(Applet* applet);
    void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking = false);
@@ -82,7 +82,7 @@ void APM::OpenSession(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(system, controller);
+    rb.PushIpcInterface<ISession>(ctx, system, controller);
 }

 void APM::GetPerformanceMode(HLERequestContext& ctx) {
@@ -125,7 +125,7 @@ void APM_Sys::GetPerformanceEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(system, controller);
+    rb.PushIpcInterface<ISession>(ctx, system, controller);
 }

 void APM_Sys::SetCpuBoostMode(HLERequestContext& ctx) {
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -45,7 +48,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IRequest>(system);
+        rb.PushIpcInterface<IRequest>(ctx, system);
    }
 };

@@ -184,7 +184,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(readable_event.Signal(system.Kernel()));
-        rb.PushCopyObjects(readable_event);
+        rb.PushCopyObjects(ctx, readable_event);
    }

    void Cancel(HLERequestContext& ctx) {
@@ -400,7 +400,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(notification_event->GetReadableEvent());
+        rb.PushCopyObjects(ctx, notification_event->GetReadableEvent());
    }

    void Clear(HLERequestContext& ctx) {
@@ -476,7 +476,7 @@ private:
 void Module::Interface::CreateFriendService(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IFriendService>(system);
+    rb.PushIpcInterface<IFriendService>(ctx, system);
    LOG_DEBUG(Service_Friend, "called");
 }

@@ -488,12 +488,12 @@ void Module::Interface::CreateNotificationService(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INotificationService>(system, uuid);
+    rb.PushIpcInterface<INotificationService>(ctx, system, uuid);
 }

-Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,
-                             const char* name)
-    : ServiceFramework{system_, name}, module{std::move(module_)} {}
+Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_, const char* name)
+    : ServiceFramework{system_, name}, module{std::move(module_)}
+{}

 Module::Interface::~Interface() = default;

@@ -279,7 +279,7 @@ void ARP_W::AcquireRegistrar(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface(registrar);
+    rb.PushIpcInterface(ctx, registrar);
 }

 void ARP_W::UnregisterApplicationInstance(HLERequestContext& ctx) {
@@ -28,7 +28,7 @@ void BGTC_T::OpenTaskService(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ITaskService>(system);
+    rb.PushIpcInterface<ITaskService>(ctx, system);
 }

 ITaskService::ITaskService(Core::System& system_) : ServiceFramework{system_, "ITaskService"} {
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -56,7 +59,7 @@ ECTX_AW::~ECTX_AW() = default;
 void ECTX_AW::CreateContextRegistrar(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IContextRegistrar>(std::make_shared<IContextRegistrar>(system));
+    rb.PushIpcInterface<IContextRegistrar>(ctx, system);
 }

 } // namespace Service::Glue
@@ -726,7 +726,7 @@ void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& c

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
+    rb.PushCopyObjects(ctx, acquire_device_registered_event->GetReadableEvent());
 }

 void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx) {
@@ -734,7 +734,7 @@ void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLEReque

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
+    rb.PushCopyObjects(ctx, acquire_device_registered_event->GetReadableEvent());
 }

 void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
@@ -759,7 +759,7 @@ void IHidSystemServer::AcquireUniquePadConnectionEventHandle(HLERequestContext&
    LOG_WARNING(Service_HID, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.PushCopyObjects(unique_pad_connection_event->GetReadableEvent());
+    rb.PushCopyObjects(ctx, unique_pad_connection_event->GetReadableEvent());
    rb.Push(ResultSuccess);
 }

@@ -776,7 +776,7 @@ void IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle(HLERequestConte

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(joy_detach_event->GetReadableEvent());
+    rb.PushCopyObjects(ctx, joy_detach_event->GetReadableEvent());
 }

 void IHidSystemServer::IsUsbFullKeyControllerEnabled(HLERequestContext& ctx) {
@@ -31,7 +31,7 @@ class Memory;
 }

 namespace IPC {
-class ResponseBuilder;
+struct ResponseBuilder;
 }

 namespace Service {
@@ -392,7 +392,7 @@ public:
    }

 private:
-    friend class IPC::ResponseBuilder;
+    friend struct IPC::ResponseBuilder;

    void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);

@@ -24,45 +24,7 @@ namespace IPC {

 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};

-class RequestHelperBase {
-protected:
-    Service::HLERequestContext* context = nullptr;
-    u32* cmdbuf;
-    u32 index = 0;
-
-public:
-    explicit RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
-
-    explicit RequestHelperBase(Service::HLERequestContext& ctx)
-        : context(&ctx), cmdbuf(ctx.CommandBuffer()) {}
-
-    void Skip(u32 size_in_words, bool set_to_null) {
-        if (set_to_null) {
-            memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
-        }
-        index += size_in_words;
-    }
-
-    /**
-     * Aligns the current position forward to a 16-byte boundary, padding with zeros.
-     */
-    void AlignWithPadding() {
-        if (index & 3) {
-            Skip(static_cast<u32>(4 - (index & 3)), true);
-        }
-    }
-
-    u32 GetCurrentOffset() const {
-        return index;
-    }
-
-    void SetCurrentOffset(u32 offset) {
-        index = offset;
-    }
-};
-
-class ResponseBuilder : public RequestHelperBase {
-public:
+struct ResponseBuilder {
    /// Flags used for customizing the behavior of ResponseBuilder
    enum class Flags : u32 {
        None = 0,
@@ -71,14 +33,13 @@ public:
        AlwaysMoveHandles = 1,
    };

-    explicit ResponseBuilder(Service::HLERequestContext& ctx, u32 normal_params_size_,
-                             u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
-                             Flags flags = Flags::None)
-        : RequestHelperBase(ctx), normal_params_size(normal_params_size_),
-          num_handles_to_copy(num_handles_to_copy_),
-          num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
-
-        memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
+    inline explicit ResponseBuilder(Service::HLERequestContext& ctx, u32 normal_params_size_, u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0, Flags flags = Flags::None)
+        : cmdbuf(ctx.CommandBuffer())
+        , normal_params_size(normal_params_size_)
+        , num_handles_to_copy(num_handles_to_copy_)
+        , num_objects_to_move(num_objects_to_move_)
+    {
+        std::memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);

        IPC::CommandHeader header{};
        auto const mgr = ctx.GetManager().get();
@@ -117,9 +78,7 @@ public:
            handle_descriptor_header.num_handles_to_copy.Assign(num_handles_to_copy_);
            handle_descriptor_header.num_handles_to_move.Assign(num_handles_to_move);
            PushRaw(handle_descriptor_header);
-
            ctx.handles_offset = index;
-
            Skip(num_handles_to_copy + num_handles_to_move, true);
        }

@@ -131,7 +90,6 @@ public:
                domain_header.num_objects = num_domain_objects;
                PushRaw(domain_header);
            }
-
            IPC::DataPayloadHeader data_payload_header{};
            data_payload_header.magic = Common::MakeMagic('S', 'F', 'C', 'O');
            PushRaw(data_payload_header);
@@ -141,34 +99,39 @@ public:

        ctx.data_payload_offset = index;
        ctx.write_size += index;
-        ctx.domain_offset = static_cast<u32>(index + raw_data_size / sizeof(u32));
+        ctx.domain_offset = u32(index + raw_data_size / sizeof(u32));
    }

-    template <class T>
-    void PushIpcInterface(std::shared_ptr<T> iface) {
-        auto manager{context->GetManager()};
+    inline void Skip(u32 size_in_words, bool set_to_null) {
+        if (set_to_null) std::memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
+        index += size_in_words;
+    }
+    /// @brief Aligns the current position forward to a 16-byte boundary, padding with zeros.
+    inline void AlignWithPadding() { if (index & 3) Skip(u32(4 - (index & 3)), true); }
+    inline u32 GetCurrentOffset() const { return index; }
+    inline void SetCurrentOffset(u32 offset) { index = offset; }

+    template <class T> inline void PushIpcInterface(Service::HLERequestContext& ctx, std::shared_ptr<T> iface) {
+        auto manager = ctx.GetManager();
        if (manager->IsDomain()) {
-            context->AddDomainObject(std::move(iface));
+            ctx.AddDomainObject(std::move(iface));
        } else {
-            ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(kernel, Kernel::LimitableResource::SessionCountMax, 1));
+            ASSERT(Kernel::GetCurrentProcess(ctx.kernel).GetResourceLimit()->Reserve(ctx.kernel, Kernel::LimitableResource::SessionCountMax, 1));

-            auto* session = Kernel::KSession::Create(kernel);
-            session->Initialize(kernel, nullptr, 0);
-            Kernel::KSession::Register(kernel, session);
+            auto* session = Kernel::KSession::Create(ctx.kernel);
+            session->Initialize(ctx.kernel, nullptr, 0);
+            Kernel::KSession::Register(ctx.kernel, session);

-            auto next_manager = std::make_shared<Service::SessionRequestManager>(
-                kernel, manager->GetServerManager());
+            auto next_manager = std::make_shared<Service::SessionRequestManager>(ctx.kernel, manager->GetServerManager());
            next_manager->SetSessionHandler(iface);
            manager->GetServerManager().RegisterSession(&session->GetServerSession(), next_manager);

-            context->AddMoveObject(&session->GetClientSession());
+            ctx.AddMoveObject(&session->GetClientSession());
        }
    }

-    template <class T, class... Args>
-    void PushIpcInterface(Args&&... args) {
-        PushIpcInterface<T>(std::make_shared<T>(std::forward<Args>(args)...));
+    template <class T, class... Args> inline void PushIpcInterface(Service::HLERequestContext& ctx, Args&&... args) {
+        PushIpcInterface<T>(ctx, std::make_shared<T>(std::forward<Args>(args)...));
    }

    void PushImpl(s8 value);
@@ -184,59 +147,38 @@ public:
    void PushImpl(bool value);
    void PushImpl(Result value);

-    template <typename T>
-    void Push(T value) {
+    template <typename T> inline void Push(T value) {
        return PushImpl(value);
    }

    template <typename First, typename... Other>
    void Push(const First& first_value, const Other&... other_values);

-    /**
-     * Helper function for pushing strongly-typed enumeration values.
-     *
-     * @tparam Enum The enumeration type to be pushed
-     *
-     * @param value The value to push.
-     *
-     * @note The underlying size of the enumeration type is the size of the
-     *       data that gets pushed. e.g. "enum class SomeEnum : u16" will
-     *       push a u16-sized amount of data.
-     */
-    template <typename Enum>
-    void PushEnum(Enum value) {
+    /// @brief Helper function for pushing strongly-typed enumeration values.
+    /// @tparam Enum The enumeration type to be pushed
+    /// @param value The value to push.
+    /// @note The underlying size of the enumeration type is the size of the data that gets pushed.
+    /// e.g. "enum class SomeEnum : u16" will push a u16-sized amount of data.
+    template <typename Enum> inline void PushEnum(Enum value) {
        static_assert(std::is_enum_v<Enum>, "T must be an enum type within a PushEnum call.");
-        static_assert(!std::is_convertible_v<Enum, int>,
-                      "enum type in PushEnum must be a strongly typed enum.");
+        static_assert(!std::is_convertible_v<Enum, int>, "enum type in PushEnum must be a strongly typed enum.");
        Push(static_cast<std::underlying_type_t<Enum>>(value));
    }

-    /**
-     * @brief Copies the content of the given trivially copyable class to the buffer as a normal
-     * param
-     * @note: The input class must be correctly packed/padded to fit hardware layout.
-     */
-    template <typename T>
-    void PushRaw(const T& value);
+    /// @brief Copies the content of the given trivially copyable class to the buffer as a normal param
+    /// @note: The input class must be correctly packed/padded to fit hardware layout.
+    template <typename T> void PushRaw(const T& value);
+    template <typename... O> void PushMoveObjects(Service::HLERequestContext& ctx, O*... pointers);
+    template <typename... O> void PushMoveObjects(Service::HLERequestContext& ctx, O&... pointers);
+    template <typename... O> void PushCopyObjects(Service::HLERequestContext& ctx, O*... pointers);
+    template <typename... O> void PushCopyObjects(Service::HLERequestContext& ctx, O&... pointers);

-    template <typename... O>
-    void PushMoveObjects(O*... pointers);
-
-    template <typename... O>
-    void PushMoveObjects(O&... pointers);
-
-    template <typename... O>
-    void PushCopyObjects(O*... pointers);
-
-    template <typename... O>
-    void PushCopyObjects(O&... pointers);
-
-private:
+    u32* cmdbuf;
+    u32 index = 0;
    u32 normal_params_size{};
    u32 num_handles_to_copy{};
    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
    u32 data_payload_index{};
-    Kernel::KernelCore& kernel;
 };

 /// Push ///
@@ -251,8 +193,7 @@ inline void ResponseBuilder::PushImpl(u32 value) {

 template <typename T>
 void ResponseBuilder::PushRaw(const T& value) {
-    static_assert(std::is_trivially_copyable_v<T>,
-                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
+    static_assert(std::is_trivially_copyable_v<T>, "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(cmdbuf + index, &value, sizeof(T));
    index += (sizeof(T) + 3) / 4; // round up to word length
 }
@@ -272,8 +213,8 @@ inline void ResponseBuilder::PushImpl(s16 value) {
 }

 inline void ResponseBuilder::PushImpl(s64 value) {
-    PushImpl(static_cast<u32>(value));
-    PushImpl(static_cast<u32>(value >> 32));
+    PushImpl(u32(value));
+    PushImpl(u32(value >> 32));
 }

 inline void ResponseBuilder::PushImpl(u8 value) {
@@ -285,8 +226,8 @@ inline void ResponseBuilder::PushImpl(u16 value) {
 }

 inline void ResponseBuilder::PushImpl(u64 value) {
-    PushImpl(static_cast<u32>(value));
-    PushImpl(static_cast<u32>(value >> 32));
+    PushImpl(u32(value));
+    PushImpl(u32(value >> 32));
 }

 inline void ResponseBuilder::PushImpl(float value) {
@@ -312,90 +253,88 @@ void ResponseBuilder::Push(const First& first_value, const Other&... other_value
 }

 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(O*... pointers) {
+inline void ResponseBuilder::PushCopyObjects(Service::HLERequestContext& ctx, O*... pointers) {
    auto objects = {pointers...};
    for (auto& object : objects) {
-        context->AddCopyObject(object);
+        ctx.AddCopyObject(object);
    }
 }

 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(O&... pointers) {
+inline void ResponseBuilder::PushCopyObjects(Service::HLERequestContext& ctx, O&... pointers) {
    auto objects = {&pointers...};
    for (auto& object : objects) {
-        context->AddCopyObject(object);
+        ctx.AddCopyObject(object);
    }
 }

 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(O*... pointers) {
+inline void ResponseBuilder::PushMoveObjects(Service::HLERequestContext& ctx, O*... pointers) {
    auto objects = {pointers...};
    for (auto& object : objects) {
-        context->AddMoveObject(object);
+        ctx.AddMoveObject(object);
    }
 }

 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(O&... pointers) {
+inline void ResponseBuilder::PushMoveObjects(Service::HLERequestContext& ctx, O&... pointers) {
    auto objects = {&pointers...};
    for (auto& object : objects) {
-        context->AddMoveObject(object);
+        ctx.AddMoveObject(object);
    }
 }

-class RequestParser : public RequestHelperBase {
-public:
-    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
-    explicit RequestParser(Service::HLERequestContext& ctx) : RequestHelperBase(ctx) {
+struct RequestParser {
+    inline explicit RequestParser(u32* command_buffer) : cmdbuf(command_buffer) {}
+    inline explicit RequestParser(Service::HLERequestContext& ctx)
+        : cmdbuf(ctx.CommandBuffer())
+    {
        // TIPC does not have data payload offset
        if (!ctx.IsTipc()) {
            ASSERT_MSG(ctx.GetDataPayloadOffset(), "context is incomplete");
            Skip(ctx.GetDataPayloadOffset(), false);
        }
-
        // Skip the u64 command id, it's already stored in the context
        static constexpr u32 CommandIdSize = 2;
        Skip(CommandIdSize, false);
    }

-    template <typename T>
-    T Pop();
+    inline void Skip(u32 size_in_words, bool set_to_null) {
+        if (set_to_null) std::memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
+        index += size_in_words;
+    }
+    /// @brief Aligns the current position forward to a 16-byte boundary, padding with zeros.
+    inline void AlignWithPadding() { if (index & 3) Skip(u32(4 - (index & 3)), true); }
+    inline u32 GetCurrentOffset() const { return index; }
+    inline void SetCurrentOffset(u32 offset) { index = offset; }

-    template <typename T>
-    void Pop(T& value);
-
-    template <typename First, typename... Other>
-    void Pop(First& first_value, Other&... other_values);
+    template <typename T> T Pop();
+    template <typename T> void Pop(T& value);
+    template <typename First, typename... Other> void Pop(First& first_value, Other&... other_values);

    template <typename T>
    T PopEnum() {
        static_assert(std::is_enum_v<T>, "T must be an enum type within a PopEnum call.");
-        static_assert(!std::is_convertible_v<T, int>,
-                      "enum type in PopEnum must be a strongly typed enum.");
-        return static_cast<T>(Pop<std::underlying_type_t<T>>());
+        static_assert(!std::is_convertible_v<T, int>, "enum type in PopEnum must be a strongly typed enum.");
+        return T(Pop<std::underlying_type_t<T>>());
    }

-    /**
-     * @brief Reads the next normal parameters as a struct, by copying it
-     * @note: The output class must be correctly packed/padded to fit hardware layout.
-     */
-    template <typename T>
-    void PopRaw(T& value);
+    /// @brief Reads the next normal parameters as a struct, by copying it
+    /// @note: The output class must be correctly packed/padded to fit hardware layout.
+    template <typename T> void PopRaw(T& value);

-    /**
-     * @brief Reads the next normal parameters as a struct, by copying it into a new value
-     * @note: The output class must be correctly packed/padded to fit hardware layout.
-     */
-    template <typename T>
-    T PopRaw();
+    /// @brief Reads the next normal parameters as a struct, by copying it into a new value
+    /// @note: The output class must be correctly packed/padded to fit hardware layout.
+    template <typename T> T PopRaw();

-    template <class T>
-    std::weak_ptr<T> PopIpcInterface() {
-        ASSERT(context->GetManager()->IsDomain());
-        ASSERT(context->GetDomainMessageHeader().input_object_count > 0);
-        return context->GetDomainHandler<T>(Pop<u32>() - 1);
+    template <class T> [[nodiscard]] std::weak_ptr<T> PopIpcInterface(Service::HLERequestContext& ctx) {
+        ASSERT(ctx.GetManager()->IsDomain());
+        ASSERT(ctx.GetDomainMessageHeader().input_object_count > 0);
+        return ctx.GetDomainHandler<T>(Pop<u32>() - 1);
    }
+
+    u32* cmdbuf;
+    u32 index = 0;
 };

 /// Pop ///
@@ -407,7 +346,7 @@ inline u32 RequestParser::Pop() {

 template <>
 inline s32 RequestParser::Pop() {
-    return static_cast<s32>(Pop<u32>());
+    return s32(Pop<u32>());
 }

 // Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
@@ -417,8 +356,7 @@ inline s32 RequestParser::Pop() {
 #endif
 template <typename T>
 void RequestParser::PopRaw(T& value) {
-    static_assert(std::is_trivially_copyable_v<T>,
-                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
+    static_assert(std::is_trivially_copyable_v<T>, "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(&value, cmdbuf + index, sizeof(T));
    index += (sizeof(T) + 3) / 4; // round up to word length
 }
@@ -353,7 +353,7 @@ private:

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

@@ -151,7 +151,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IAm>(system);
+        rb.PushIpcInterface<IAm>(ctx, system);
    }
 };

@@ -173,7 +173,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<MFIUser>(system);
+        rb.PushIpcInterface<MFIUser>(ctx, system);
    }
 };

@@ -195,7 +195,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IUser>(system);
+        rb.PushIpcInterface<IUser>(ctx, system);
    }
 };

@@ -217,7 +217,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISystem>(system);
+        rb.PushIpcInterface<ISystem>(ctx, system);
    }
 };

@@ -143,7 +143,7 @@ void NfcInterface::AttachAvailabilityChangeEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(GetManager()->AttachAvailabilityChangeEvent());
+    rb.PushCopyObjects(ctx, GetManager()->AttachAvailabilityChangeEvent());
 }

 void NfcInterface::StartDetection(HLERequestContext& ctx) {
@@ -203,7 +203,7 @@ void NfcInterface::AttachActivateEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.PushCopyObjects(ctx, out_event);
 }

 void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
@@ -217,7 +217,7 @@ void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.PushCopyObjects(ctx, out_event);
 }

 void NfcInterface::SetNfcEnabled(HLERequestContext& ctx) {
@@ -157,7 +157,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IUser>(system);
+        rb.PushIpcInterface<IUser>(ctx, system);
    }
 };

@@ -179,7 +179,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISystem>(system);
+        rb.PushIpcInterface<ISystem>(ctx, system);
    }
 };

@@ -201,7 +201,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IDebug>(system);
+        rb.PushIpcInterface<IDebug>(ctx, system);
    }
 };

@@ -307,7 +307,7 @@ private:
    void GetSystemEventReadableHandle(HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 2};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(evt_scan_complete->GetReadableEvent(),
+        rb.PushCopyObjects(ctx, evt_scan_complete->GetReadableEvent(),
                           evt_processing->GetReadableEvent());
    }

@@ -452,7 +452,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 2};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(event1->GetReadableEvent(), event2->GetReadableEvent());
+        rb.PushCopyObjects(ctx, event1->GetReadableEvent(), event2->GetReadableEvent());
    }

    void Cancel(HLERequestContext& ctx) {
@@ -528,7 +528,7 @@ void IGeneralService::CreateScanRequest(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};

    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IScanRequest>(system);
+    rb.PushIpcInterface<IScanRequest>(ctx, system);
 }

 void IGeneralService::CreateRequest(HLERequestContext& ctx) {
@@ -537,7 +537,7 @@ void IGeneralService::CreateRequest(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};

    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IRequest>(system);
+    rb.PushIpcInterface<IRequest>(ctx, system);
 }

 void IGeneralService::GetCurrentNetworkProfile(HLERequestContext& ctx) {
@@ -716,7 +716,7 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INetworkProfile>(system);
+    rb.PushIpcInterface<INetworkProfile>(ctx, system);
 }

 void IGeneralService::SetNetworkProfile(HLERequestContext& ctx) {
@@ -869,7 +869,7 @@ void IGeneralService::CreateTemporaryNetworkProfile(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 6, 0, 1};

    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<INetworkProfile>(system);
+    rb.PushIpcInterface<INetworkProfile>(ctx, system);
    rb.PushRaw<u128>(uuid);
 }

@@ -1124,7 +1124,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IGeneralService>(system);
+        rb.PushIpcInterface<IGeneralService>(ctx, system);
    }

    void CreateGeneralService(HLERequestContext& ctx) {
@@ -1132,7 +1132,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IGeneralService>(system);
+        rb.PushIpcInterface<IGeneralService>(ctx, system);
    }
 };

@@ -53,7 +53,7 @@ private:
        LOG_WARNING(Service_NIM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAsync>(system);
+        rb.PushIpcInterface<IShopServiceAsync>(ctx, system);
    }
 };

@@ -75,7 +75,7 @@ private:
        LOG_WARNING(Service_NIM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessor>(system);
+        rb.PushIpcInterface<IShopServiceAccessor>(ctx, system);
    }
 };

@@ -336,7 +336,7 @@ private:
        LOG_DEBUG(Service_NIM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessServer>(system);
+        rb.PushIpcInterface<IShopServiceAccessServer>(ctx, system);
    }

    void IsLargeResourceAvailable(HLERequestContext& ctx) {
@@ -356,7 +356,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IShopServiceAccessServer>(system);
+        rb.PushIpcInterface<IShopServiceAccessServer>(ctx, system);
    }
 };

@@ -439,7 +439,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(finished_event->GetReadableEvent());
+        rb.PushCopyObjects(ctx, finished_event->GetReadableEvent());
    }

    void GetResult(HLERequestContext& ctx) {
@@ -500,7 +500,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>(system);
+        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>(ctx, system);
    }

    // TODO(ogniK): Do we need these?
@@ -359,8 +359,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo

    IPC::ResponseBuilder rb{ctx, 2, 1, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(async_value->ReadableEvent());
-    rb.PushIpcInterface(std::move(async_value));
+    rb.PushCopyObjects(ctx, async_value->ReadableEvent());
+    rb.PushIpcInterface(ctx, std::move(async_value));
 }

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

 #pragma once

+#include <utility>
+
 #include "common/common_types.h"

 namespace Core {
@@ -28,6 +30,15 @@ public:
    inline explicit Process(Core::System& system) noexcept : m_system(system) {}
    inline ~Process() { this->Finalize(); }

+    Process(const Process&) = delete;
+    Process& operator=(const Process&) = delete;
+    Process& operator=(Process&&) = delete;
+    inline Process(Process&& other) noexcept
+        : m_system(other.m_system), m_process(std::exchange(other.m_process, nullptr)),
+          m_main_thread_stack_size(std::exchange(other.m_main_thread_stack_size, 0)),
+          m_main_thread_priority(std::exchange(other.m_main_thread_priority, 0)),
+          m_process_started(std::exchange(other.m_process_started, false)) {}
+
    bool Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result);
    void Finalize();

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -124,7 +127,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IClkrstSession>(system, device_code);
+        rb.PushIpcInterface<IClkrstSession>(ctx, system, device_code);
    }
 };

@@ -161,7 +161,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 10, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(*process);
+        rb.PushCopyObjects(ctx, *process);
        rb.PushRaw(program_location);
        rb.PushRaw(override_status);
    }
@@ -147,7 +147,7 @@ void IAlarmService::CreateWakeupAlarm(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISteadyClockAlarm>(system, m_alarms, AlarmType::WakeupAlarm);
+    rb.PushIpcInterface<ISteadyClockAlarm>(ctx, system, m_alarms, AlarmType::WakeupAlarm);
 }

 void IAlarmService::CreateBackgroundTaskAlarm(HLERequestContext& ctx) {
@@ -155,7 +155,7 @@ void IAlarmService::CreateBackgroundTaskAlarm(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISteadyClockAlarm>(system, m_alarms, AlarmType::BackgroundTaskAlarm);
+    rb.PushIpcInterface<ISteadyClockAlarm>(ctx, system, m_alarms, AlarmType::BackgroundTaskAlarm);
 }

 ISteadyClockAlarm::ISteadyClockAlarm(Core::System& system_, Alarms& alarms, AlarmType type)
@@ -179,7 +179,7 @@ void ISteadyClockAlarm::GetAlarmEvent(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(m_alarm.GetEventHandle());
+    rb.PushCopyObjects(ctx, m_alarm.GetEventHandle());
 }

 void ISteadyClockAlarm::Enable(HLERequestContext& ctx) {
@@ -67,7 +67,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(state_change_event->GetReadableEvent());
+        rb.PushCopyObjects(ctx, state_change_event->GetReadableEvent());
    }

    void UnbindStateChangeEvent(HLERequestContext& ctx) {
@@ -186,7 +186,7 @@ void PSM::OpenSession(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IPsmSession>(system);
+    rb.PushIpcInterface<IPsmSession>(ctx, system);
 }

 void PSM::GetBatteryVoltageState(HLERequestContext& ctx) {
@@ -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-3.0-or-later

@@ -82,7 +85,7 @@ void TS::OpenSession(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(system);
+    rb.PushIpcInterface<ISession>(ctx, system);
 }

 } // namespace Service::PTM
@@ -140,7 +140,7 @@ void SM::GetServiceCmif(HLERequestContext& ctx) {
    if (result == ResultSuccess) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
        rb.Push(result);
-        rb.PushMoveObjects(client_session);
+        rb.PushMoveObjects(ctx, client_session);
    } else {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(result);
@@ -157,7 +157,7 @@ void SM::GetServiceTipc(HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
    rb.Push(result);
-    rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr);
+    rb.PushMoveObjects(ctx, result == ResultSuccess ? client_session : nullptr);
 }

 static std::string PopServiceName(IPC::RequestParser& rp) {
@@ -230,8 +230,7 @@ void SM::RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_s
              max_session_count, is_light);

    Kernel::KServerPort* server_port{};
-    if (const auto result = service_manager.RegisterService(std::addressof(server_port), name,
-                                                            max_session_count, nullptr);
+    if (const auto result = service_manager.RegisterService(std::addressof(server_port), name, max_session_count, nullptr);
        result.IsError()) {
        LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}", result.raw);
        IPC::ResponseBuilder rb{ctx, 2};
@@ -241,7 +240,7 @@ void SM::RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_s

    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
    rb.Push(ResultSuccess);
-    rb.PushMoveObjects(server_port);
+    rb.PushMoveObjects(ctx, server_port);
 }

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

 void Controller::CloneCurrentObjectEx(HLERequestContext& ctx) {
@@ -543,8 +543,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(res);
        if (res == ResultSuccess) {
-            rb.PushIpcInterface<ISslConnection>(system, ssl_version, shared_data,
-                                                std::move(backend));
+            rb.PushIpcInterface<ISslConnection>(ctx, system, ssl_version, shared_data, std::move(backend));
        }
    }

@@ -624,12 +623,11 @@ private:
        IPC::RequestParser rp{ctx};
        const auto parameters = rp.PopRaw<Parameters>();

-        LOG_WARNING(Service_SSL, "(STUBBED) called, api_version={}, pid_placeholder={}",
-                    parameters.ssl_version.api_version, parameters.pid_placeholder);
+        LOG_WARNING(Service_SSL, "(STUBBED) called, api_version={}, pid_placeholder={}", parameters.ssl_version.api_version, parameters.pid_placeholder);

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISslContext>(system, parameters.ssl_version);
+        rb.PushIpcInterface<ISslContext>(ctx, system, parameters.ssl_version);
    }

    void SetInterfaceVersion(HLERequestContext& ctx) {
@@ -155,7 +155,7 @@ private:

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

@@ -199,7 +199,7 @@ private:

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

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

 IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
                             Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info) {
+    HostTranslateInfo normalized_host_info{host_info};
+    normalized_host_info.ApplyDescriptorLimitPolicy();
+
    IR::Program program;
-    program.syntax_list = BuildASL(inst_pool, block_pool, env, cfg, host_info);
+    program.syntax_list = BuildASL(inst_pool, block_pool, env, cfg, normalized_host_info);
    program.blocks = GenerateBlocks(program.syntax_list);
    program.post_order_blocks = PostOrder(program.syntax_list.front());
    program.stage = env.ShaderStage();
@@ -260,9 +263,9 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
                program.info.passthrough.mask[i] = ((mask[i / 32] >> (i % 32)) & 1) == 0;
            }

-            if (!host_info.support_geometry_shader_passthrough) {
+            if (!normalized_host_info.support_geometry_shader_passthrough) {
                program.output_vertices = GetOutputTopologyVertices(program.output_topology);
-                LowerGeometryPassthrough(program, host_info);
+                LowerGeometryPassthrough(program, normalized_host_info);
            }
        }
        break;
@@ -277,16 +280,16 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
    RemoveUnreachableBlocks(program);

    // Replace instructions before the SSA rewrite
-    if (!host_info.support_float64) {
+    if (!normalized_host_info.support_float64) {
        Optimization::LowerFp64ToFp32(program);
    }
-    if (!host_info.support_float16) {
+    if (!normalized_host_info.support_float16) {
        Optimization::LowerFp16ToFp32(program);
    }
-    if (!host_info.support_int64) {
+    if (!normalized_host_info.support_int64) {
        Optimization::LowerInt64ToInt32(program);
    }
-    if (!host_info.support_conditional_barrier) {
+    if (!normalized_host_info.support_conditional_barrier) {
        Optimization::ConditionalBarrierPass(program);
    }
    Optimization::SsaRewritePass(program);
@@ -295,8 +298,8 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo

    Optimization::PositionPass(env, program);

-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
-    Optimization::TexturePass(env, program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program, normalized_host_info);
+    Optimization::TexturePass(env, program, normalized_host_info);

    if (Settings::values.resolution_info.active || Settings::values.rescale_hack.GetValue()) {
        Optimization::RescalingPass(program);
@@ -306,7 +309,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
        Optimization::VerificationPass(program);
    }
    Optimization::CollectShaderInfoPass(env, program);
-    Optimization::LayerPass(program, host_info);
+    Optimization::LayerPass(program, normalized_host_info);
    Optimization::VendorWorkaroundPass(program);

    CollectInterpolationInfo(env, program);
@@ -6,6 +6,8 @@

 #pragma once

+#include "common/common_types.h"
+
 namespace Shader {

 // Try to keep entries here to a minimum
@@ -13,20 +15,52 @@ namespace Shader {

 /// Misc information about the host
 struct HostTranslateInfo {
+    static constexpr u32 DEFAULT_DESCRIPTOR_LIMIT = 1024;
+
+    u64 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
+    u32 max_per_stage_descriptor_sampled_images{}; ///< maximum sampled descriptors per stage
+    u32 max_per_stage_resources{};                 ///< maximum resources per stage
+    u32 max_descriptor_set_samplers{};
+    u32 max_descriptor_set_uniform_buffers{};
+    u32 max_descriptor_set_uniform_buffers_dynamic{};
+    u32 max_descriptor_set_storage_buffers{};
+    u32 max_descriptor_set_storage_buffers_dynamic{};
+    u32 max_descriptor_set_sampled_images{};
+    u32 max_descriptor_set_storage_images{};
+    u32 max_descriptor_set_input_attachements{};
    bool support_float64{};      ///< True when the device supports 64-bit floats
    bool support_float16{};      ///< True when the device supports 16-bit floats
    bool support_int64{};        ///< True when the device supports 64-bit integers
    bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
    bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
    bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
-    u32 max_per_stage_descriptor_sampled_images{1024}; ///< maximum sampled descriptors per stage
-    u32 max_per_stage_resources{4096};                 ///< maximum resources per stage
-    u32 max_descriptor_set_sampled_images{1024};        ///< maximum sampled descriptors per set
    bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                ///< passthrough shaders
    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
                                        ///< control flow
+
+    void ApplyDescriptorLimitPolicy() noexcept {
+        if (min_ssbo_alignment == 0) {
+            min_ssbo_alignment = 1;
+        }
+        ApplyDescriptorLimitFallback(max_per_stage_descriptor_sampled_images);
+        ApplyDescriptorLimitFallback(max_per_stage_resources);
+        ApplyDescriptorLimitFallback(max_descriptor_set_samplers);
+        ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers);
+        ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers_dynamic);
+        ApplyDescriptorLimitFallback(max_descriptor_set_storage_buffers);
+        ApplyDescriptorLimitFallback(max_descriptor_set_storage_buffers_dynamic);
+        ApplyDescriptorLimitFallback(max_descriptor_set_sampled_images);
+        ApplyDescriptorLimitFallback(max_descriptor_set_storage_images);
+        ApplyDescriptorLimitFallback(max_descriptor_set_input_attachements);
+    }
+
+private:
+    static void ApplyDescriptorLimitFallback(u32& limit) noexcept {
+        if (limit == 0) {
+            limit = DEFAULT_DESCRIPTOR_LIMIT;
+        }
+    }
 };

 } // namespace Shader
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -545,7 +548,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
        IR::Block* const block{storage_inst.block};
        IR::Inst* const inst{storage_inst.inst};
        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+            StorageOffset(*block, *inst, storage_buffer, u32(host_info.min_ssbo_alignment))};
        Replace(*block, *inst, index, offset);
    }
 }
@@ -32,71 +32,62 @@ struct TextureInst {
 using TextureInstVector = boost::container::small_vector<TextureInst, 24>;

 constexpr u32 DESCRIPTOR_SIZE = 8;
-constexpr u32 DESCRIPTOR_SIZE_SHIFT = static_cast<u32>(std::countr_zero(DESCRIPTOR_SIZE));
-constexpr u32 DYNAMIC_DESCRIPTOR_CBUF_BYTES = 16 * 1024;
-constexpr u32 MAX_DYNAMIC_DESCRIPTOR_COUNT = 1024;
+constexpr u32 DESCRIPTOR_SIZE_SHIFT = u32(std::countr_zero(DESCRIPTOR_SIZE));
+constexpr u32 DESCRIPTOR_MAX_COUNT = 1024;

 u32 DynamicDescriptorSizeShift(const IR::U32& dynamic_offset) {
-    const IR::Inst* const inst{dynamic_offset.InstRecursive()};
-    if (!inst || inst->GetOpcode() != IR::Opcode::ShiftLeftLogical32) {
+    const IR::Inst* const inst = dynamic_offset.InstRecursive();
+    if (!inst || inst->GetOpcode() != IR::Opcode::ShiftLeftLogical32)
        return DESCRIPTOR_SIZE_SHIFT;
-    }
-    const IR::Value shift{inst->Arg(1)};
-    if (!shift.IsImmediate()) {
+    const IR::Value shift = inst->Arg(1);
+    if (!shift.IsImmediate())
        return DESCRIPTOR_SIZE_SHIFT;
-    }
-    const u32 size_shift{shift.U32()};
-    return size_shift >= DESCRIPTOR_SIZE_SHIFT && size_shift < 31 ? size_shift
-                                                                  : DESCRIPTOR_SIZE_SHIFT;
+    const u32 size_shift = shift.U32();
+    return size_shift >= DESCRIPTOR_SIZE_SHIFT && size_shift < 31 ? size_shift : DESCRIPTOR_SIZE_SHIFT;
 }

-u32 DynamicDescriptorCount(u32 base_offset, u32 size_shift) {
-    if (size_shift >= 31 || base_offset >= DYNAMIC_DESCRIPTOR_CBUF_BYTES) {
+u32 DynamicDescriptorCount(u32 base_offset, u32 size_shift, u32 max_descriptors) {
+    auto const descriptor_limit = (std::max)(1U, max_descriptors);
+    auto const max_cbuf_bytes = 16 * descriptor_limit;
+    if (size_shift >= 31 || base_offset >= max_cbuf_bytes)
        return 1;
-    }
-    const u32 stride{1U << size_shift};
-    const u32 available{DYNAMIC_DESCRIPTOR_CBUF_BYTES - base_offset};
-    if (available < DESCRIPTOR_SIZE) {
+    auto const stride = 1U << size_shift;
+    auto const available = max_cbuf_bytes - base_offset;
+    if (available < DESCRIPTOR_SIZE)
        return 1;
-    }
-    const u32 available_count{1U + (available - DESCRIPTOR_SIZE) / stride};
-    return std::min(MAX_DYNAMIC_DESCRIPTOR_COUNT, available_count);
+    auto const available_count = 1U + (available - DESCRIPTOR_SIZE) / stride;
+    return std::min(descriptor_limit, available_count);
 }

 u32 SaturatingSub(u32 lhs, u32 rhs) {
    return lhs > rhs ? lhs - rhs : 0;
 }

-template <typename Descriptors>
-u32 StaticDescriptorCount(const Descriptors& descriptors) {
-    u32 count{};
-    for (const auto& desc : descriptors) {
-        if (desc.count <= 1) {
-            count += desc.count;
-        }
-    }
-    return count;
+template <typename T>
+[[nodiscard]] u32 StaticDescriptorCount(T const& descriptors) noexcept {
+    return std::accumulate(descriptors.cbegin(), descriptors.cend(), 0U, [](auto const& acc, auto const& e) {
+        return acc + (e.count <= 1 ? e.count : 0);
+    });
 }

-u32 DynamicSampledTextureCap(const Info& info, const HostTranslateInfo& host_info,
-                             u32 dynamic_arrays) {
-    if (dynamic_arrays == 0) {
-        return MAX_DYNAMIC_DESCRIPTOR_COUNT;
+u32 DynamicSampledTextureCap(const Info& info, const HostTranslateInfo& host_info, u32 dynamic_arrays) {
+    auto const sampled_limit = (std::max)(1U, std::min(host_info.max_per_stage_descriptor_sampled_images,
+                                                       host_info.max_descriptor_set_sampled_images));
+    auto const resource_limit = (std::max)(1U, host_info.max_per_stage_resources);
+    if (dynamic_arrays > 0) {
+        auto const sampled_static_count = StaticDescriptorCount(info.texture_buffer_descriptors) + StaticDescriptorCount(info.texture_descriptors);
+        auto const resource_static_count =
+            NumDescriptors(info.constant_buffer_descriptors)
+            + NumDescriptors(info.storage_buffers_descriptors)
+            + sampled_static_count + NumDescriptors(info.image_buffer_descriptors)
+            + NumDescriptors(info.image_descriptors);
+        auto const sampled_budget = SaturatingSub(sampled_limit, sampled_static_count);
+        auto const resource_budget = SaturatingSub(resource_limit, resource_static_count);
+        auto const sampled_cap = sampled_budget / dynamic_arrays;
+        auto const resource_cap = resource_budget / dynamic_arrays;
+        return (std::max)(1U, (std::min)(sampled_cap, resource_cap));
    }
-    const u32 sampled_static_count{StaticDescriptorCount(info.texture_buffer_descriptors) +
-                                   StaticDescriptorCount(info.texture_descriptors)};
-    const u32 resource_static_count{
-        NumDescriptors(info.constant_buffer_descriptors) +
-        NumDescriptors(info.storage_buffers_descriptors) + sampled_static_count +
-        NumDescriptors(info.image_buffer_descriptors) + NumDescriptors(info.image_descriptors)};
-    const u32 sampled_limit{std::min(host_info.max_per_stage_descriptor_sampled_images,
-                                     host_info.max_descriptor_set_sampled_images)};
-    const u32 sampled_budget{SaturatingSub(sampled_limit, sampled_static_count)};
-    const u32 resource_budget{SaturatingSub(host_info.max_per_stage_resources,
-                                            resource_static_count)};
-    const u32 sampled_cap{sampled_budget / dynamic_arrays};
-    const u32 resource_cap{resource_budget / dynamic_arrays};
-    return std::max(1U, std::min({MAX_DYNAMIC_DESCRIPTOR_COUNT, sampled_cap, resource_cap}));
+    return (std::min)({DESCRIPTOR_MAX_COUNT, sampled_limit, resource_limit});
 }

 IR::Opcode IndexedInstruction(const IR::Inst& inst) {
@@ -304,21 +295,23 @@ static inline bool IsTexturePixelFormatIntegerCached(Environment& env,
 }


-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env);
-static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env) {
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info);
+static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Environment& env, const HostTranslateInfo& host_info) {
    if (const IR::Inst* key = v.InstRecursive()) {
        if (auto it = env.track_cache.find(key); it != env.track_cache.end()) return it->second;
-        auto found = Track(v, env);
+        auto found = Track(v, env, host_info);
        if (found) env.track_cache.emplace(key, *found);
        return found;
    }
-    return Track(v, env);
+    return Track(v, env, host_info);
 }

-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env);
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info);

-std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env) {
-    return IR::BreadthFirstSearch(value, [&env](const IR::Inst* inst) { return TryGetConstBuffer(inst, env); });
+std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info) {
+    return IR::BreadthFirstSearch(value, [&env, &host_info](const IR::Inst* inst) {
+        return TryGetConstBuffer(inst, env, host_info);
+    });
 }

 std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
@@ -342,13 +335,13 @@ std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
    return ReadCbufCached(env, index_number, offset_number);
 }

-std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env) {
+std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info) {
    switch (inst->GetOpcode()) {
    default:
        return std::nullopt;
    case IR::Opcode::BitwiseOr32: {
-        std::optional lhs{TrackCached(inst->Arg(0), env)};
-        std::optional rhs{TrackCached(inst->Arg(1), env)};
+        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
+        std::optional rhs{TrackCached(inst->Arg(1), env, host_info)};
        if (!lhs || !rhs) {
            return std::nullopt;
        }
@@ -378,12 +371,11 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
        if (!shift.IsImmediate()) {
            return std::nullopt;
        }
-        std::optional lhs{TrackCached(inst->Arg(0), env)};
+        std::optional lhs{TrackCached(inst->Arg(0), env, host_info)};
        if (lhs) {
            lhs->shift_left = shift.U32();
        }
        return lhs;
-        break;
    }
    case IR::Opcode::BitwiseAnd32: {
        IR::Value op1{inst->Arg(0)};
@@ -407,7 +399,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
                return std::nullopt;
            } while (false);
        }
-        std::optional lhs{TrackCached(op1, env)};
+        std::optional lhs{TrackCached(op1, env, host_info)};
        if (lhs) {
            lhs->shift_left = static_cast<u32>(std::countr_zero(op2.U32()));
        }
@@ -453,7 +445,10 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
    } else {
        return std::nullopt;
    }
-    const u32 size_shift{DynamicDescriptorSizeShift(dynamic_offset)};
+    auto const size_shift = DynamicDescriptorSizeShift(dynamic_offset);
+    auto const sampled_limit = (std::max)(1U, (std::min)(host_info.max_per_stage_descriptor_sampled_images,
+                                                         host_info.max_descriptor_set_sampled_images));
+    auto const resource_limit = (std::max)(1U, host_info.max_per_stage_resources);
    return ConstBufferAddr{
        .index = index.U32(),
        .offset = base_offset,
@@ -462,15 +457,15 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
        .secondary_offset = 0,
        .secondary_shift_left = 0,
        .dynamic_offset = dynamic_offset,
-        .count = DynamicDescriptorCount(base_offset, size_shift),
+        .count = DynamicDescriptorCount(base_offset, size_shift, (std::min)({DESCRIPTOR_MAX_COUNT, sampled_limit, resource_limit})),
        .has_secondary = false,
    };
 }

-TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst) {
+TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst, const HostTranslateInfo& host_info) {
    ConstBufferAddr addr;
    if (IsBindless(inst)) {
-        const std::optional<ConstBufferAddr> track_addr{TrackCached(inst.Arg(0), env)};
+        const std::optional<ConstBufferAddr> track_addr{TrackCached(inst.Arg(0), env, host_info)};

        if (!track_addr) {
            throw NotImplementedException("Failed to track bindless texture constant buffer");
@@ -506,15 +501,15 @@ u32 GetTextureHandle(Environment& env, const ConstBufferAddr& cbuf) {
    return lhs_raw | rhs_raw;
 }

-    [[maybe_unused]]TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]] TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
    return env.ReadTextureType(GetTextureHandle(env, cbuf));
 }

-    [[maybe_unused]]TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]] TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
    return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }

-    [[maybe_unused]]bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]] bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
    return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }

@@ -675,7 +670,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
            if (!IsTextureInstruction(inst)) {
                continue;
            }
-            to_replace.push_back(MakeInst(env, block, inst));
+            to_replace.push_back(MakeInst(env, block, inst, host_info));
        }
    }
    // Sort instructions to visit textures by constant buffer index, then by offset
@@ -689,8 +684,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
        program.info.texture_descriptors,
        program.info.image_descriptors,
    };
-    const u32 sampled_dynamic_cap{
-        DynamicSampledTextureCap(program.info, host_info, DynamicSampledTextureArrayCount(to_replace))};
+    const u32 sampled_dynamic_cap = DynamicSampledTextureCap(program.info, host_info, DynamicSampledTextureArrayCount(to_replace));
    for (TextureInst& texture_inst : to_replace) {
        // TODO: Handle arrays
        IR::Inst* const inst{texture_inst.inst};
@@ -92,7 +92,6 @@ struct Profile {
    bool has_broken_robust{};

    u64 min_ssbo_alignment{};
-
    u32 max_user_clip_distances{};
 };

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -15,12 +18,19 @@ static constexpr auto PERMS = Common::MemoryPermission::ReadWrite;
 static constexpr auto HEAP = false;

 TEST_CASE("HostMemory: Initialize and deinitialize", "[common]") {
-    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
-    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
+    {
+        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+        REQUIRE(mem.BackingBasePointer() != nullptr);
+    }
+    {
+        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+        REQUIRE(mem.BackingBasePointer() != nullptr);
+    }
 }

 TEST_CASE("HostMemory: Simple map", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x5000, 0x8000, 0x1000, PERMS, HEAP);

    volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -30,6 +40,7 @@ TEST_CASE("HostMemory: Simple map", "[common]") {

 TEST_CASE("HostMemory: Simple mirror map", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
    mem.Map(0x8000, 0x4000, 0x1000, PERMS, HEAP);

@@ -41,6 +52,7 @@ TEST_CASE("HostMemory: Simple mirror map", "[common]") {

 TEST_CASE("HostMemory: Simple unmap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);

    volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -52,6 +64,7 @@ TEST_CASE("HostMemory: Simple unmap", "[common]") {

 TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);

    volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -69,6 +82,7 @@ TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {

 TEST_CASE("HostMemory: Nieche allocation", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x0000, 0, 0x20000, PERMS, HEAP);
    mem.Unmap(0x0000, 0x4000, HEAP);
    mem.Map(0x1000, 0, 0x2000, PERMS, HEAP);
@@ -78,6 +92,7 @@ TEST_CASE("HostMemory: Nieche allocation", "[common]") {

 TEST_CASE("HostMemory: Full unmap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x8000, 0x4000, HEAP);
    mem.Map(0x6000, 0, 0x16000, PERMS, HEAP);
@@ -85,6 +100,7 @@ TEST_CASE("HostMemory: Full unmap", "[common]") {

 TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x2000, 0x4000, HEAP);
    mem.Map(0x2000, 0x80000, 0x4000, PERMS, HEAP);
@@ -92,6 +108,7 @@ TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {

 TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+
    mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x6000, 0x4000, HEAP);
    mem.Map(0x8000, 0, 0x2000, PERMS, HEAP);
@@ -99,6 +116,7 @@ TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {

 TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
    mem.Map(0x4000, 0, 0x1b000, PERMS, HEAP);
    mem.Unmap(0x3000, 0x1c000, HEAP);
@@ -107,6 +125,7 @@ TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {

 TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
    mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x2000, 0x4000, HEAP);
@@ -115,6 +134,7 @@ TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {

 TEST_CASE("HostMemory: Unmap to origin", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
    mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x4000, 0x4000, HEAP);
@@ -124,6 +144,7 @@ TEST_CASE("HostMemory: Unmap to origin", "[common]") {

 TEST_CASE("HostMemory: Unmap to right", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
    mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
    mem.Unmap(0x8000, 0x4000, HEAP);
@@ -132,6 +153,7 @@ TEST_CASE("HostMemory: Unmap to right", "[common]") {

 TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);

    volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -144,6 +166,7 @@ TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {

 TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);

    volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -158,6 +181,7 @@ TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {

 TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);

    volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -172,6 +196,7 @@ TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {

 TEST_CASE("HostMemory: Partial sparse middle unmap and check bindings", "[common]") {
    HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
    mem.Map(0x4000, 0x10000, 0x2000, PERMS, HEAP);
    mem.Map(0x6000, 0x20000, 0x2000, PERMS, HEAP);

@@ -245,16 +245,31 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
              std::min<u32>(device.GetMaxUserClipDistances(), Maxwell::Regs::NumClipDistances),
      },
      host_info{
-          .support_float64 = true,
-          .support_float16 = false,
-          .support_int64 = device.HasShaderInt64(),
-          .needs_demote_reorder = device.IsAmd(),
-          .support_snorm_render_buffer = false,
-          .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
-          .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
-          .support_conditional_barrier = device.SupportsConditionalBarriers(),
+        .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
+        .max_per_stage_descriptor_sampled_images =
+            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_per_stage_resources = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_samplers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_uniform_buffers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_uniform_buffers_dynamic =
+            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_storage_buffers = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_storage_buffers_dynamic =
+            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_sampled_images = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_storage_images = Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .max_descriptor_set_input_attachements =
+            Shader::HostTranslateInfo::DEFAULT_DESCRIPTOR_LIMIT,
+        .support_float64 = true,
+        .support_float16 = false,
+        .support_int64 = device.HasShaderInt64(),
+        .needs_demote_reorder = device.IsAmd(),
+        .support_snorm_render_buffer = false,
+        .support_viewport_index_layer = device.HasVertexViewportLayer(),
+        .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
+        .support_conditional_barrier = device.SupportsConditionalBarriers(),
      } {
+    host_info.ApplyDescriptorLimitPolicy();
    if (use_asynchronous_shaders) {
        workers = CreateWorkers();
    }
@@ -22,6 +22,15 @@ namespace Vulkan {

 using Shader::Backend::SPIRV::NUM_TEXTURE_AND_IMAGE_SCALING_WORDS;

+[[nodiscard]] inline u32 NumDescriptorEntries(const Shader::Info& info) {
+    return Shader::NumDescriptors(info.constant_buffer_descriptors) +
+           Shader::NumDescriptors(info.storage_buffers_descriptors) +
+           Shader::NumDescriptors(info.texture_buffer_descriptors) +
+           Shader::NumDescriptors(info.image_buffer_descriptors) +
+           Shader::NumDescriptors(info.texture_descriptors) +
+           Shader::NumDescriptors(info.image_descriptors);
+}
+
 class DescriptorLayoutBuilder {
 public:
    DescriptorLayoutBuilder(const Device& device_) : device{&device_} {}
@@ -326,7 +326,7 @@ std::pair<VkBuffer, VkDeviceSize> Uint8Pass::Assemble(u32 num_vertices, VkBuffer
    const u32 staging_size = static_cast<u32>(num_vertices * sizeof(u16));
    const auto staging = staging_buffer_pool.Request(staging_size, MemoryUsage::DeviceLocal);

-    compute_pass_descriptor_queue.Acquire();
+    compute_pass_descriptor_queue.Acquire(scheduler, 2);
    compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, num_vertices);
    compute_pass_descriptor_queue.AddBuffer(staging.buffer, staging.offset, staging_size);
    const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -384,7 +384,7 @@ std::pair<VkBuffer, VkDeviceSize> QuadIndexedPass::Assemble(
    const std::size_t staging_size = num_tri_vertices * sizeof(u32);
    const auto staging = staging_buffer_pool.Request(staging_size, MemoryUsage::DeviceLocal);

-    compute_pass_descriptor_queue.Acquire();
+    compute_pass_descriptor_queue.Acquire(scheduler, 2);
    compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, input_size);
    compute_pass_descriptor_queue.AddBuffer(staging.buffer, staging.offset, staging_size);
    const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -429,7 +429,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
    }
    const size_t compare_size = compare_to_zero ? 8 : 24;

-    compute_pass_descriptor_queue.Acquire();
+    compute_pass_descriptor_queue.Acquire(scheduler, 2);
    compute_pass_descriptor_queue.AddBuffer(src_buffer, src_offset, compare_size);
    compute_pass_descriptor_queue.AddBuffer(dst_buffer, 0, sizeof(u32));
    const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
@@ -498,7 +498,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
        static constexpr size_t DISPATCH_SIZE = 2048U;
        size_t runs_to_do = std::min<size_t>(current_runs, DISPATCH_SIZE);
        current_runs -= runs_to_do;
-        compute_pass_descriptor_queue.Acquire();
+        compute_pass_descriptor_queue.Acquire(scheduler, 3);
        compute_pass_descriptor_queue.AddBuffer(src_buffer, 0, number_of_sums * sizeof(u64));
        compute_pass_descriptor_queue.AddBuffer(dst_buffer, 0, number_of_sums * sizeof(u64));
        compute_pass_descriptor_queue.AddBuffer(accumulation_buffer, 0, sizeof(u64));
@@ -600,7 +600,7 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
        const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 8U);
        const u32 num_dispatches_z = image.info.resources.layers;

-        compute_pass_descriptor_queue.Acquire();
+        compute_pass_descriptor_queue.Acquire(scheduler, 2);
        compute_pass_descriptor_queue.AddBuffer(map.buffer, input_offset,
                                                image.guest_size_bytes - swizzle.buffer_offset);
        compute_pass_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
@@ -821,7 +821,7 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
    pc.blocks_dim[1] = blocks_y;
    pc.blocks_dim[2] = z_count; // Only process the count

-    compute_pass_descriptor_queue.Acquire();
+    compute_pass_descriptor_queue.Acquire(scheduler, 3);
    compute_pass_descriptor_queue.AddBuffer(*image.runtime->swizzle_table_buffer, 0,
                                           image.runtime->swizzle_table_size);
    compute_pass_descriptor_queue.AddBuffer(swizzled.buffer,
@@ -989,7 +989,7 @@ void MSAACopyPass::CopyImage(Image& dst_image, Image& src_image,
        ASSERT(copy.dst_subresource.base_layer == 0);
        ASSERT(copy.dst_subresource.num_layers == 1);

-        compute_pass_descriptor_queue.Acquire();
+        compute_pass_descriptor_queue.Acquire(scheduler, 2);
        compute_pass_descriptor_queue.AddImage(
            src_image.StorageImageView(copy.src_subresource.base_level));
        compute_pass_descriptor_queue.AddImage(
@@ -45,6 +45,7 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
    }
    std::copy_n(info.constant_buffer_used_sizes.begin(), uniform_buffer_sizes.size(),
                uniform_buffer_sizes.begin());
+    num_descriptor_entries = NumDescriptorEntries(info);

    auto func{[this, &scheduler, &descriptor_pool, shader_notify, pipeline_statistics] {
        DescriptorLayoutBuilder builder{device};
@@ -113,7 +114,7 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
 void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                Tegra::MemoryManager& gpu_memory, Scheduler& scheduler,
                                BufferCache& buffer_cache, TextureCache& texture_cache) {
-    guest_descriptor_queue.Acquire();
+    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);

    buffer_cache.SetComputeUniformBufferState(info.constant_buffer_mask, &uniform_buffer_sizes);
    buffer_cache.UnbindComputeStorageBuffers();
@@ -53,6 +53,7 @@ private:
    vk::PipelineCache& pipeline_cache;
    GuestDescriptorQueue& guest_descriptor_queue;
    Shader::Info info;
+    u32 num_descriptor_entries{};

    VideoCommon::ComputeUniformBufferSizes uniform_buffer_sizes{};

@@ -268,6 +268,7 @@ GraphicsPipeline::GraphicsPipeline(
        num_textures += Shader::NumDescriptors(info->texture_descriptors);
        num_image_elements += Shader::NumDescriptors(info->texture_descriptors);
        num_image_elements += Shader::NumDescriptors(info->image_descriptors);
+        num_descriptor_entries += NumDescriptorEntries(*info);
    }
    fragment_has_color0_output = stage_infos[NUM_STAGES - 1].stores_frag_color[0];
    auto func{[this, shader_notify, &render_pass_cache, &descriptor_pool, pipeline_statistics] {
@@ -473,7 +474,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
    buffer_cache.UpdateGraphicsBuffers(is_indexed);
    buffer_cache.BindHostGeometryBuffers(is_indexed);

-    guest_descriptor_queue.Acquire();
+    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);

    RescalingPushConstant rescaling;
    RenderAreaPushConstant render_area;
@@ -159,6 +159,7 @@ private:
    std::array<Shader::Info, NUM_STAGES> stage_infos;
    std::array<u32, 5> enabled_uniform_buffer_masks{};
    VideoCommon::UniformBufferSizes uniform_buffer_sizes{};
+    u32 num_descriptor_entries{};
    size_t num_image_elements{};
    u32 num_textures{};
    bool fragment_has_color0_output{};
@@ -439,10 +439,21 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_robust =
            device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
-        .max_user_clip_distances = device.GetMaxUserClipDistances(),
+        .max_user_clip_distances = device.GetMaxUserClipDistances()
    };

    host_info = Shader::HostTranslateInfo{
+        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
+        .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
+        .max_per_stage_resources = device.GetMaxPerStageResources(),
+        .max_descriptor_set_samplers = device.GetMaxDescriptorSetSamplers(),
+        .max_descriptor_set_uniform_buffers = device.GetMaxDescriptorSetUniformBuffers(),
+        .max_descriptor_set_uniform_buffers_dynamic = device.GetMaxDescriptorSetUniformBuffersDynamic(),
+        .max_descriptor_set_storage_buffers = device.GetMaxDescriptorSetStorageBuffers(),
+        .max_descriptor_set_storage_buffers_dynamic = device.GetMaxDescriptorSetStorageBuffersDynamic(),
+        .max_descriptor_set_sampled_images = device.GetMaxDescriptorSetSampledImages(),
+        .max_descriptor_set_storage_images = device.GetMaxDescriptorSetStorageImages(),
+        .max_descriptor_set_input_attachements = device.GetMaxDescriptorSetInputAttachments(),
        .support_float64 = device.IsFloat64Supported(),
        .support_float16 = device.IsFloat16Supported(),
        .support_int64 = device.IsShaderInt64Supported(),
@@ -451,13 +462,10 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                                driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY,
        .support_snorm_render_buffer = true,
        .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
-        .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
-        .max_per_stage_resources = device.GetMaxPerStageResources(),
-        .max_descriptor_set_sampled_images = device.GetMaxDescriptorSetSampledImages(),
        .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
        .support_conditional_barrier = device.SupportsConditionalBarriers(),
    };
+    host_info.ApplyDescriptorLimitPolicy();

    if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {
        LOG_WARNING(Render_Vulkan, "maxVertexInputAttributes is too low: {} < {}",
@@ -492,10 +500,14 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        device.IsExtExtendedDynamicState3BlendingSupported();
    dynamic_features.has_extended_dynamic_state_3_enables =
        device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
+    dynamic_features.has_dynamic_state3_depth_clamp_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
+        device.SupportsDynamicState3DepthClampEnable();
    dynamic_features.has_dynamic_state3_logic_op_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
        device.SupportsDynamicState3LogicOpEnable();
    dynamic_features.has_dynamic_state3_line_stipple_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
        device.SupportsDynamicState3LineStippleEnable();

    // VIDS: Independent toggle (not affected by dyna_state levels)
@@ -218,8 +218,7 @@ public:
        }
        PauseCounter();
        const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
            pending_sync.clear();
            sync_values_stash.clear();
            return;
@@ -203,7 +203,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
    : gpu{gpu_}, device_memory{device_memory_}, device{device_},
      memory_allocator{memory_allocator_}, state_tracker{state_tracker_}, scheduler{scheduler_},
      staging_pool(device, memory_allocator, scheduler), descriptor_pool(device, scheduler),
-      guest_descriptor_queue(device, scheduler), compute_pass_descriptor_queue(device, scheduler),
+      guest_descriptor_queue(device), compute_pass_descriptor_queue(device),
      blit_image(device, scheduler, state_tracker, descriptor_pool), render_pass_cache(device),
      texture_cache_runtime{
          device,     scheduler,         memory_allocator, staging_pool,
@@ -155,15 +155,14 @@ void Scheduler::WaitWorker() {
 }

 void Scheduler::DispatchWork() {
-    if (chunk->Empty()) {
-        return;
+    if (chunk && !chunk->Empty()) {
+        {
+            std::scoped_lock ql{queue_mutex};
+            work_queue.push(std::move(chunk));
+        }
+        event_cv.notify_all();
+        AcquireNewChunk();
    }
-    {
-        std::scoped_lock ql{queue_mutex};
-        work_queue.push(std::move(chunk));
-    }
-    event_cv.notify_all();
-    AcquireNewChunk();
 }

 void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {
@@ -2314,29 +2314,46 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
 }

 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
-    const auto& device = runtime.device;
-    const bool has_custom_border_extension = runtime.device.IsExtCustomBorderColorSupported();
-    const bool has_format_undefined =
-        has_custom_border_extension && runtime.device.IsCustomBorderColorWithoutFormatSupported();
-    const bool has_custom_border_colors =
-        has_format_undefined && runtime.device.IsCustomBorderColorsSupported();
+    const bool has_custom_border_ext = runtime.device.IsExtCustomBorderColorSupported();
+    const bool has_format_undefined = has_custom_border_ext && runtime.device.IsCustomBorderColorWithoutFormatSupported();
+    const bool has_custom_border_colors = has_format_undefined && runtime.device.IsCustomBorderColorsSupported();
+    const bool has_border_color_swizzle = has_custom_border_ext && runtime.device.IsExtBorderColorSwizzleSupported();
    const auto color = tsc.BorderColor();
+    const void* pnext = nullptr;

    const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
-        .pNext = nullptr,
+        .pNext = pnext,
        .customBorderColor = std::bit_cast<VkClearColorValue>(color),
        .format = VK_FORMAT_UNDEFINED,
    };
-    const void* pnext = nullptr;
    if (has_custom_border_colors) {
        pnext = &border_ci;
        // Log extension usage for custom border color
        if (GPU::Logging::IsActive()) {
-            GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
-                "VK_EXT_custom_border_color", "Sampler::Sampler");
+            GPU::Logging::GPULogger::GetInstance().LogExtensionUsage("VK_EXT_custom_border_color", "Sampler::Sampler");
        }
    }
+
+    const VkSamplerBorderColorComponentMappingCreateInfoEXT border_swizzle_ci{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
+        .pNext = pnext,
+        .components = VkComponentMapping{
+            .r = VK_COMPONENT_SWIZZLE_IDENTITY,
+            .g = VK_COMPONENT_SWIZZLE_IDENTITY,
+            .b = VK_COMPONENT_SWIZZLE_IDENTITY,
+            .a = VK_COMPONENT_SWIZZLE_IDENTITY,
+        },
+        .srgb = tsc.srgb_conversion
+    };
+    if (has_border_color_swizzle) {
+        pnext = &border_swizzle_ci;
+        // Log extension usage for custom border color
+        if (GPU::Logging::IsActive()) {
+            GPU::Logging::GPULogger::GetInstance().LogExtensionUsage("VK_EXT_border_color_swizzle", "Sampler::Sampler");
+        }
+    }
+
    const VkSamplerReductionModeCreateInfoEXT reduction_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
        .pNext = pnext,
@@ -2347,36 +2364,33 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
    } else if (reduction_ci.reductionMode != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT) {
        LOG_WARNING(Render_Vulkan, "VK_EXT_sampler_filter_minmax is required");
    }
+
    // Some games have samplers with garbage. Sanitize them here.
    const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);
-
    const auto create_sampler = [&](const f32 anisotropy) {
-        return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
+        return runtime.device.GetLogical().CreateSampler(VkSamplerCreateInfo{
            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
            .pNext = pnext,
            .flags = 0,
            .magFilter = MaxwellToVK::Sampler::Filter(tsc.mag_filter),
            .minFilter = MaxwellToVK::Sampler::Filter(tsc.min_filter),
            .mipmapMode = MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter),
-            .addressModeU = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter),
-            .addressModeV = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter),
-            .addressModeW = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter),
+            .addressModeU = MaxwellToVK::Sampler::WrapMode(runtime.device, tsc.wrap_u, tsc.mag_filter),
+            .addressModeV = MaxwellToVK::Sampler::WrapMode(runtime.device, tsc.wrap_v, tsc.mag_filter),
+            .addressModeW = MaxwellToVK::Sampler::WrapMode(runtime.device, tsc.wrap_p, tsc.mag_filter),
            .mipLodBias = tsc.LodBias(),
-            .anisotropyEnable = static_cast<VkBool32>(anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
+            .anisotropyEnable = VkBool32(anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
            .maxAnisotropy = anisotropy,
            .compareEnable = tsc.depth_compare_enabled,
            .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
            .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
            .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
-            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
-                                                    : ConvertBorderColor(color),
+            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT : ConvertBorderColor(color),
            .unnormalizedCoordinates = VK_FALSE,
        });
    };
-
    sampler = create_sampler(max_anisotropy);
-
-    const f32 max_anisotropy_default = static_cast<f32>(1U << tsc.max_anisotropy);
+    const f32 max_anisotropy_default = f32(1U << tsc.max_anisotropy);
    if (max_anisotropy > max_anisotropy_default) {
        sampler_default_anisotropy = create_sampler(max_anisotropy_default);
    }
@@ -7,6 +7,7 @@
 #include <variant>
 #include <boost/container/static_vector.hpp>

+#include "common/assert.h"
 #include "common/logging.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
@@ -15,8 +16,9 @@

 namespace Vulkan {

-UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_)
-    : device{device_}, scheduler{scheduler_} {
+UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_)
+    : device{device_}
+{
    payload_start = payload.data();
    payload_cursor = payload.data();
 }
@@ -31,13 +33,15 @@ void UpdateDescriptorQueue::TickFrame() {
    payload_cursor = payload_start;
 }

-void UpdateDescriptorQueue::Acquire() {
-    // Minimum number of entries required.
-    // This is the maximum number of entries a single draw call might use.
-    static constexpr size_t MIN_ENTRIES = 0x400;
-
-    if (std::distance(payload_start, payload_cursor) + MIN_ENTRIES >= FRAME_PAYLOAD_SIZE) {
-        LOG_WARNING(Render_Vulkan, "Payload overflow, waiting for worker thread");
+void UpdateDescriptorQueue::Acquire(Scheduler& scheduler, size_t required_entries) {
+    static constexpr size_t DEFAULT_REQUIRED_ENTRIES = 0x400;
+    const size_t reserve = required_entries > 0 ? required_entries : DEFAULT_REQUIRED_ENTRIES;
+    ASSERT_MSG(reserve < FRAME_PAYLOAD_SIZE, "Descriptor reservation {} >= frame capacity {}",
+               reserve, FRAME_PAYLOAD_SIZE);
+    const size_t used = static_cast<size_t>(std::distance(payload_start, payload_cursor));
+    if (used + reserve >= FRAME_PAYLOAD_SIZE) {
+        LOG_WARNING(Render_Vulkan, "Payload overflow (used={}, reserve={}, capacity={})",
+                    used, reserve, FRAME_PAYLOAD_SIZE);
        scheduler.WaitWorker();
        payload_cursor = payload_start;
    }
@@ -34,12 +34,11 @@ class UpdateDescriptorQueue final {
    static constexpr size_t PAYLOAD_SIZE = FRAME_PAYLOAD_SIZE * FRAMES_IN_FLIGHT;

 public:
-    explicit UpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_);
+    explicit UpdateDescriptorQueue(const Device& device_);
    ~UpdateDescriptorQueue();

    void TickFrame();
-
-    void Acquire();
+    void Acquire(Scheduler& scheduler, size_t required_entries = 0);

    const DescriptorUpdateEntry* UpdateData() const noexcept {
        return upload_start;
@@ -75,8 +74,6 @@ public:

 private:
    const Device& device;
-    Scheduler& scheduler;
-
    size_t frame_index{0};
    DescriptorUpdateEntry* payload_cursor = nullptr;
    DescriptorUpdateEntry* payload_start = nullptr;
@@ -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 2020 yuzu Emulator Project
@@ -55,13 +55,16 @@ namespace {
 } // Anonymous namespace

 std::array<float, 4> TSCEntry::BorderColor() const noexcept {
-    // TODO: Handle SRGB correctly. Using this breaks shadows in some games (Xenoblade).
-    // if (!srgb_conversion) {
-    //    return border_color;
-    //}
-    // return {SRGB_CONVERSION_LUT[srgb_border_color_r], SRGB_CONVERSION_LUT[srgb_border_color_g],
-    //        SRGB_CONVERSION_LUT[srgb_border_color_b], border_color[3]};
-    return border_color;
+    if (!srgb_conversion)
+       return border_color;
+    // SRGB will be handled by custom border color swizzle
+    // if not, we are in big, big trouble and may break shadows on Xenoblade
+    return {
+        f32(srgb_border_color_r) / 255.f,
+        f32(srgb_border_color_g) / 255.f,
+        f32(srgb_border_color_b) / 255.f,
+        border_color[3]
+    };
 }

 float TSCEntry::MaxAnisotropy() const noexcept {
@@ -1172,12 +1172,10 @@ bool Device::GetSuitability(bool requires_swapchain) {
 void Device::RemoveUnsuitableExtensions() {
    // VK_EXT_custom_border_color
    if (extensions.custom_border_color) {
-        extensions.custom_border_color =
-            features.custom_border_color.customBorderColors &&
-            features.custom_border_color.customBorderColorWithoutFormat;
+        extensions.custom_border_color = features.custom_border_color.customBorderColors
+            && features.custom_border_color.customBorderColorWithoutFormat;
    }
-    RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color,
-                                       VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+    RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);

    // VK_EXT_depth_bias_control
    extensions.depth_bias_control =
@@ -50,6 +50,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
 // Define all features which may be used by the implementation and require an extension here.
 #define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
+    FEATURE(EXT, BorderColorSwizzle, BORDER_COLOR_SWIZZLE, border_color_swizzle)                      \
    FEATURE(EXT, DepthBiasControl, DEPTH_BIAS_CONTROL, depth_bias_control)                         \
    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
@@ -321,32 +322,23 @@ public:
        return properties.properties.limits.maxPushConstantsSize;
    }

-    /// Returns the maximum size for shared memory.
-    u32 GetMaxComputeSharedMemorySize() const {
-        return properties.properties.limits.maxComputeSharedMemorySize;
-    }
-
-    /// Returns the maximum number of dynamic storage buffer descriptors per set.
-    u32 GetMaxDescriptorSetStorageBuffersDynamic() const {
-        return properties.properties.limits.maxDescriptorSetStorageBuffersDynamic;
-    }
-
-    /// Returns the maximum number of dynamic uniform buffer descriptors per set.
-    u32 GetMaxDescriptorSetUniformBuffersDynamic() const {
-        return properties.properties.limits.maxDescriptorSetUniformBuffersDynamic;
-    }
-
-    u32 GetMaxPerStageDescriptorSampledImages() const {
-        return properties.properties.limits.maxPerStageDescriptorSampledImages;
-    }
-
-    u32 GetMaxPerStageResources() const {
-        return properties.properties.limits.maxPerStageResources;
-    }
-
-    u32 GetMaxDescriptorSetSampledImages() const {
-        return properties.properties.limits.maxDescriptorSetSampledImages;
-    }
+#define FN_MAX_LIMIT_LIST \
+    FN_MAX_LIMIT_ELEM(ComputeSharedMemorySize) \
+    FN_MAX_LIMIT_ELEM(PerStageDescriptorSampledImages) \
+    FN_MAX_LIMIT_ELEM(PerStageResources) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetSamplers) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffers) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffersDynamic) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetStorageBuffers) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetStorageBuffersDynamic) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetSampledImages) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetStorageImages) \
+    FN_MAX_LIMIT_ELEM(DescriptorSetInputAttachments)
+#define FN_MAX_LIMIT_ELEM(name) \
+    u32 GetMax##name() const { return properties.properties.limits.max##name; }
+FN_MAX_LIMIT_LIST
+#undef FN_MAX_LIMIT_ELEM
+#undef FN_MAX_LIMIT_LIST

    /// Returns float control properties of the device.
    const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
@@ -591,6 +583,11 @@ public:
        return features.custom_border_color.customBorderColorWithoutFormat;
    }

+    /// Returns true if the device supports VK_EXT_border_color_swizzle .
+    bool IsExtBorderColorSwizzleSupported() const {
+        return extensions.border_color_swizzle;
+    }
+
    /// Returns true if the device supports VK_EXT_extended_dynamic_state.
    bool IsExtExtendedDynamicStateSupported() const {
        return extensions.extended_dynamic_state;
@@ -44,6 +44,7 @@ int IrShaderRecompilerImpl(int argc, char *argv[]) {
    host_info.support_geometry_shader_passthrough = true;
    host_info.support_conditional_barrier = true;
    host_info.min_ssbo_alignment = 0;
+    host_info.ApplyDescriptorLimitPolicy();
    auto program = Shader::Maxwell::TranslateProgram(inst_pool, block_pool, env, cfg, host_info);
    auto const dumped_ir = Shader::IR::DumpProgram(program);
    std::printf("%s\n", dumped_ir.c_str());
@@ -52,6 +52,7 @@ int SpirvShaderRecompilerImpl(int argc, char *argv[]) {
    host_info.support_geometry_shader_passthrough = true;
    host_info.support_conditional_barrier = true;
    host_info.min_ssbo_alignment = 0;
+    host_info.ApplyDescriptorLimitPolicy();
    auto program = Shader::Maxwell::TranslateProgram(inst_pool, block_pool, env, cfg, host_info);

    // IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
Author	SHA1	Message	Date
lizzie	b92ca83fa5	L;ICENSES	2026-07-01 06:32:09 +00:00
lizzie	f768ba4170	ploo	2026-07-01 06:31:43 +00:00
lizzie	7dff851245	[vk] implement VK_EXT_border_color_swizzle Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-07-01 05:22:23 +00:00
lizzie	2068b5d452	[vk] Clamp dynamic descriptors based on device limits (#4115 ) Should fix this specific crash ``` * thread #82, name = 'GPU', stop reason = Exception 0xc0000005 encountered at address 0x7ff7e5193e89: Access violation reading location 0x00000098 * frame #0: 0x00007ff7e5193e89 eden.exe`std::unique_ptr<Vulkan::Scheduler::CommandChunk,std::default_delete<Vulkan::Scheduler::CommandChunk> >::operator->(this=<unavailable>) at memory:3453 [inlined] frame #1: 0x00007ff7e5193e81 eden.exe`void Vulkan::Scheduler::DispatchWork(this=0x0000000000000000) at vk_scheduler.cpp:146 frame #2: 0x00007ff7e5193d8f eden.exe`void Vulkan::Scheduler::WaitWorker(this=<unavailable>) at vk_scheduler.cpp:133 frame #3: 0x00007ff7e54f472e eden.exe`void Vulkan::UpdateDescriptorQueue::Acquire(this=0x0000026c77cfb4b8) at vk_update_descriptor.cpp:41 frame #4: 0x00007ff7e5537a43 eden.exe`void Vulkan::ASTCDecoderPass::Assemble(this=0x0000026c794fba10, image=0x0000026cfb794850, map=0x00000025e28fcb30, swizzles=<unavailable>) at vk_compute_pass.cpp:603 frame #5: 0x00007ff7e55043e1 eden.exe`void Vulkan::TextureCacheRuntime::AccelerateImageUpload(this=<unavailable>, image=0x0000026cfb794850, map=0x00000025e28fcb30, swizzles=size=10, z_start=0, z_count=0) at vk_texture_cache.cpp:2482 frame #6: 0x00007ff7e5516592 eden.exe`void VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::UploadImageContents<struct Vulkan::StagingBufferRef>(this=<unavailable>, image=0x0000026cfb794850, staging=0x00000025e28fcb30) at texture_cache.h:1147 frame #7: 0x00007ff7e551523d eden.exe`void VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::RefreshContents(this=0x0000026c794fd800, image=0x0000026cfb794850, image_id=(index = 3801072224)) at texture_cache.h:1133 frame #8: 0x00007ff7e5517b50 eden.exe`struct Common::SlotId VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::JoinImages(this=0x0000026c794fd800, info=<unavailable>, gpu_addr=25374426112, cpu_addr=2254181376) at texture_cache.h:1644 frame #9: 0x00007ff7e5516ff6 eden.exe`struct Common::SlotId VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::InsertImage(this=0x0000026c794fd800, info=0x00000025e28fd270, gpu_addr=25374426112, options=0x0) at texture_cache.h:1513 frame #10: 0x00007ff7e5516a60 eden.exe`struct Common::SlotId VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::FindOrInsertImage(this=0x0000026c794fd800, info=0x00000025e28fd270, gpu_addr=25374426112, options=0x0) at texture_cache.h:1194 frame #11: 0x00007ff7e5515a13 eden.exe`struct Common::SlotId VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::CreateImageView(this=0x0000026c794fd800, config=0x00000025e28fd370) at texture_cache.h:1173 frame #12: 0x00007ff7e550cd64 eden.exe`struct Common::SlotId VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::VisitImageView(this=0x0000026c794fd800, index=4586, compute=<unavailable>) at texture_cache.h:554 frame #13: 0x00007ff7e550d181 eden.exe`void VideoCommon::TextureCache<struct Vulkan::TextureCacheParams>::FillImageViews(this=0x0000026c794fd800, views=size=5, compute=<unavailable>, blacklist=<unavailable>) at texture_cache.h:227 frame #14: 0x00007ff7e58896e4 eden.exe`Vulkan::GraphicsPipeline::ConfigureImpl<Vulkan::(anonymous namespace)::SimpleStorageSpec>(this=0x0000026f865c1a60, is_indexed=<unavailable>) at vk_graphics_pipeline.cpp:415 frame #15: 0x00007ff7e5889479 eden.exe`<lambda_1>::operator(pl=<unavailable>, is_indexed=<unavailable>) at vk_graphics_pipeline.h:123 [inlined] frame #16: 0x00007ff7e5889474 eden.exe`<lambda_1>::__invoke(pl=<unavailable>, is_indexed=<unavailable>) at vk_graphics_pipeline.h:123 frame #17: 0x00007ff7e519d2a8 eden.exe`Vulkan::GraphicsPipeline::Configure(this=0x0000026f865c1a60, is_indexed=<unavailable>) at vk_graphics_pipeline.h:105 [inlined] frame #18: 0x00007ff7e519d29d eden.exe`Vulkan::RasterizerVulkan::PrepareDraw<`lambda at D:\a\g\g\eden-source\src\video_core\renderer_vulkan\vk_rasterizer.cpp:256:29'>(this=0x0000026c764f9368, is_indexed=<unavailable>, draw_func=0x00000025e28fdb80) at vk_rasterizer.cpp:244 frame #19: 0x00007ff7e519d1db eden.exe`void Vulkan::RasterizerVulkan::Draw(this=<unavailable>, is_indexed=<unavailable>, instance_count=<unavailable>) at vk_rasterizer.cpp:256 frame #20: 0x00007ff7e50d9025 eden.exe`void Tegra::HLE_DrawIndexedIndirect::Fallback(this=0x0000026f2af85118, maxwell3d=0x0000026ccbf9eb00, parameters=size=6) at macro.cpp:178 frame #21: 0x00007ff7e50d8f21 eden.exe`void Tegra::HLE_DrawIndexedIndirect::Execute(this=0x0000026f2af85118, maxwell3d=0x0000026ccbf9eb00, parameters=size=6) at macro.cpp:129 frame #22: 0x00007ff7e50db607 eden.exe`Tegra::MacroEngine::Execute::<lambda_0>::operator(this=0x00000025e28fde70, acm= Active Type = Tegra::HLE_DrawIndexedIndirect ) at macro.cpp:1362 frame #23: 0x00007ff7e50dada0 eden.exe`void Tegra::MacroEngine::Execute(this=0x0000026ccbfaa020, maxwell3d=0x0000026ccbf9eb00, method=418, parameters=<unavailable>) at macro.cpp:1392 frame #24: 0x00007ff7e4ef062b eden.exe`void Tegra::Engines::Maxwell3D::CallMacroMethod(this=0x0000026ccbf9eb00, method=<unavailable>, parameters=<unavailable>) at maxwell_3d.cpp:390 frame #25: 0x00007ff7e4ef04be eden.exe`void Tegra::Engines::Maxwell3D::ProcessMacro(this=0x0000026ccbf9eb00, method=<unavailable>, base_start=<unavailable>, amount=5, is_last_call=<unavailable>) at maxwell_3d.cpp:223 frame #26: 0x00007ff7e4ef1673 eden.exe`void Tegra::Engines::Maxwell3D::CallMultiMethod(this=<unavailable>, method=<unavailable>, base_start=0x000001ea398e22f4, amount=<unavailable>, methods_pending=5) at maxwell_3d.cpp:419 frame #27: 0x00007ff7e4ef535a eden.exe`void Tegra::DmaPusher::CallMultiMethod(this=<unavailable>, base_start=0x000001ea398e22f4, num_methods=<unavailable>) const at dma_pusher.cpp:201 frame #28: 0x00007ff7e4ef5023 eden.exe`void Tegra::DmaPusher::ProcessCommands(this=0x0000026ccbfba698, commands=size=36) at dma_pusher.cpp:120 frame #29: 0x00007ff7e4ef4ced eden.exe`bool Tegra::DmaPusher::Step(this=0x0000026ccbfba698) at dma_pusher.cpp:88 frame #30: 0x00007ff7e4ef49f8 eden.exe`void Tegra::DmaPusher::DispatchCalls(this=0x0000026ccbfba698) at dma_pusher.cpp:40 frame #31: 0x00007ff7e4ede797 eden.exe`void Tegra::Control::Scheduler::Push(this=<unavailable>, channel=-493895072, entries=0x00000025e28fe2e0) at scheduler.cpp:31 frame #32: 0x00007ff7e4eedc7b eden.exe`VideoCommon::GPUThread::ThreadManager::StartThread::<lambda_0>::operator(this=<unavailable>, stop_token=stop_token @ 0x00000025e28ffb40) at gpu_thread.cpp:42 [inlined] frame #33: 0x00007ff7e4eedae8 eden.exe`std::invoke(_Obj=<unavailable>, _Arg1=0x0000026ccb3edef0) at type_traits:1680 [inlined] frame #34: 0x00007ff7e4eedac1 eden.exe`std::thread::_Invoke<std::tuple<`lambda at D:\a\g\g\eden-source\src\video_core\gpu_thread.cpp:29:27',std::stop_token>,0,1>(_RawVals=0x0000026ccb3edef0) at thread:60 frame #35: 0x00007ff8e87a37b0 ucrtbase.dll`wcsrchr + 336 ``` Signed-off-by: lizzie <lizzie@eden-emu.dev> Co-authored-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4115 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-06-30 04:33:30 +02:00
lizzie	1b482fa99b	[hle] remove parent object reference data on Request/Response builders, pass by argument (#3774 ) anyways this should remove a bunch of redundant code/stack usage for response builders (ahem, msvc) SHOULD help games that use IPC heavily like PKZA and whatnot biblical levels of performance greed Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3774 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-06-29 08:11:12 +02:00
xbzk	b6ee847947	[hle/am] make Service::Process move-only to fix #3908 KProcess use-after-free (#4137 ) #3908 changed process_creation., CreateProcess/CreateApplicationProcess, to return std::optional<Process> instead of std::unique_ptr<Process>, so the AM sites now transfer a Process by value via make_unique<Service::Process>(std::move(opt)). The consequence: Process owns a refcounted KProcess* but its user-declared dtor suppressed the implicit move ctor, so that "move" silently shallow-copied and the temporary's dtor Close()/RemoveProcess()'d the shared handle -> use-after-free. It's seems to be user end based, so whether it crashes may depend on machine, compiler, allocator reuse, refcount slack, and the AM event-observer thread race, idk. It reliably crashed my MSVC build at launching games (cstack: ProcessHolder -> MultiWait -> KSynchronizationObject::Wait -> null) multiple times. Fix: give Process a move ctor that steals the handle (nulling the source so the moved-from dtor is a no-op) and delete copy/move-assign, making the optional<->unique_ptr transfer safe. Bonus: explicited delete for the 3 kinds of assignment: copy ctor (the one used in eden), copy assign and move assign (currently unused) to force compile error if they ever come to use. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4137 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-06-29 02:39:11 +02:00
wildcard	6c16440996	[vulkan] Fix EDS 0-2 (#4117 ) EDS3 states were dynamic just because the driver supports them. But in EDS0-EDS2, we does not actually emit the EDS3 dynamic commands for them. So the pipeline builder skipped baking some fixed graphics state into the Vulkan pipeline, but the runtime also did not set that state dynamically. That leaves wrong Vulkan state during rendering causing rendering glitches in XC2. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4117 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-06-28 15:07:54 +02:00
lizzie	09c583506b	[tests] Require backing base pointer to be nonnull for HostMemory tests (#4138 ) A basic requirement, probably more helpful than outright crashing in the middle of a test. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4138 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-06-28 08:01:41 +02:00
lizzie	894add43f3	[vk] fix PR5R black screen on qcom driver (#4120 ) Different approach proposed by gido. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4120 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-06-28 04:29:28 +02:00
Lizzie	d142b5dd6a	[android] Add Enable GPU Buffer Readback option to Android (#4132 ) Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4132 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-06-28 03:37:23 +02:00
maufeat	0c2894eabf	[hle] add: (re)winding application and revert option<Process> back to unique_ptr (#4134 ) This add winding application function. Test this by opening qlaunch -> top left Profile -> edit profile picture -> go back (do not save if you are on fw21+, it corrupts the image) And reverts in #3908 added `optional<Process>` to `unique_ptr<Process>` Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4134 Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-06-27 16:47:46 +02:00