[qt] use std::jthread instead of playing around with std::thread

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

src/core/device_memory_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -109,6 +112,9 @@ public:
 
     void ReadBlock(DAddr address, void* dest_pointer, size_t size);
     void ReadBlockUnsafe(DAddr address, void* dest_pointer, size_t size);
+#ifdef YUZU_DEBUG
+    bool ReadBlockFastChecked(DAddr address, void* dest_pointer, size_t size);
+#endif
     void WriteBlock(DAddr address, const void* src_pointer, size_t size);
     void WriteBlockUnsafe(DAddr address, const void* src_pointer, size_t size);
 

src/core/device_memory_manager.inc

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -467,6 +470,29 @@ void DeviceMemoryManager<Traits>::ReadBlockUnsafe(DAddr address, void* dest_poin
         });
 }
 
+#ifdef YUZU_DEBUG
+template <typename Traits>
+bool DeviceMemoryManager<Traits>::ReadBlockFastChecked(DAddr address, void* dest_pointer,
+                                                       size_t size) {
+    bool success = true;
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", current_vaddr,
+                         size);
+            std::memset(dest_pointer, 0, copy_amount);
+            success = false;
+        },
+        [&](size_t copy_amount, const u8* const src_ptr) {
+            std::memcpy(dest_pointer, src_ptr, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            dest_pointer = static_cast<u8*>(dest_pointer) + copy_amount;
+        });
+    return success;
+}
+#endif
+
 template <typename Traits>
 void DeviceMemoryManager<Traits>::WriteBlockUnsafe(DAddr address, const void* src_pointer,
                                                    size_t size) {

src/core/hle/service/acc/profile_manager.cpp

@@ -509,9 +509,6 @@ std::vector<std::string> ProfileManager::FindOrphanedProfiles()
         good_uuids.emplace_back(uuid_string);
     }
 
-    // used for acnh, etc
-    good_uuids.emplace_back("00000000000000000000000000000000");
-
     // TODO: fetch save_id programmatically
     const auto path = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir)
                       / "user/save/0000000000000000";

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,6 +68,42 @@ std::string ResolveURL(const std::string& url) {
     return url.substr(0, index) + "lp1" + url.substr(index + 1);
 }
 
+WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
+    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
+
+    if (web_arg.size() == sizeof(WebArgHeader)) {
+        return {};
+    }
+
+    WebArgInputTLVMap input_tlv_map;
+
+    u64 current_offset = sizeof(WebArgHeader);
+
+    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
+        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
+            return input_tlv_map;
+        }
+
+        WebArgInputTLV input_tlv;
+        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
+
+        current_offset += sizeof(WebArgInputTLV);
+
+        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
+            return input_tlv_map;
+        }
+
+        std::vector<u8> data(input_tlv.arg_data_size);
+        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
+
+        current_offset += input_tlv.arg_data_size;
+
+        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
+    }
+
+    return input_tlv_map;
+}
+
 FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
                                      FileSys::ContentRecordType nca_type) {
     if (nca_type == FileSys::ContentRecordType::Data) {
@@ -111,43 +144,6 @@ FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
     }
 }
 
-#ifdef YUZU_USE_QT_WEB_ENGINE
-WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
-    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
-
-    if (web_arg.size() == sizeof(WebArgHeader)) {
-        return {};
-    }
-
-    WebArgInputTLVMap input_tlv_map;
-
-    u64 current_offset = sizeof(WebArgHeader);
-
-    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
-        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
-            return input_tlv_map;
-        }
-
-        WebArgInputTLV input_tlv;
-        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
-
-        current_offset += sizeof(WebArgInputTLV);
-
-        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
-            return input_tlv_map;
-        }
-
-        std::vector<u8> data(input_tlv.arg_data_size);
-        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
-
-        current_offset += input_tlv.arg_data_size;
-
-        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
-    }
-
-    return input_tlv_map;
-}
-
 void ExtractSharedFonts(Core::System& system) {
     static constexpr std::array<const char*, 7> DECRYPTED_SHARED_FONTS{
         "FontStandard.ttf",
@@ -225,7 +221,6 @@ void ExtractSharedFonts(Core::System& system) {
         FileSys::VfsRawCopy(decrypted_font, out_file);
     }
 }
-#endif
 
 } // namespace
 
@@ -237,7 +232,6 @@ WebBrowser::WebBrowser(Core::System& system_, std::shared_ptr<Applet> applet_,
 WebBrowser::~WebBrowser() = default;
 
 void WebBrowser::Initialize() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     FrontendApplet::Initialize();
 
     LOG_INFO(Service_AM, "Initializing Web Browser Applet.");
@@ -290,7 +284,6 @@ void WebBrowser::Initialize() {
         ASSERT_MSG(false, "Invalid ShimKind={}", web_arg_header.shim_kind);
         break;
     }
-#endif
 }
 
 Result WebBrowser::GetStatus() const {
@@ -302,7 +295,6 @@ void WebBrowser::ExecuteInteractive() {
 }
 
 void WebBrowser::Execute() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     switch (web_arg_header.shim_kind) {
     case ShimKind::Shop:
         ExecuteShop();
@@ -330,10 +322,6 @@ void WebBrowser::Execute() {
         WebBrowserExit(WebExitReason::EndButtonPressed);
         break;
     }
-#else
-    LOG_INFO(Service_AM, "Web Browser Applet disabled, skipping.");
-    WebBrowserExit(WebExitReason::EndButtonPressed);
-#endif
 }
 
 void WebBrowser::ExtractOfflineRomFS() {

src/network/announce_multiplayer_session.cpp

@@ -19,9 +19,6 @@
 
 namespace Core {
 
-// Time between room is announced to web_service
-static constexpr std::chrono::seconds announce_time_interval(15);
-
 AnnounceMultiplayerSession::AnnounceMultiplayerSession() {
 #ifdef ENABLE_WEB_SERVICE
     backend = std::make_unique<WebService::RoomJson>(Settings::values.web_api_url.GetValue(),
@@ -53,18 +50,58 @@ WebService::WebResult AnnounceMultiplayerSession::Register() {
 }
 
 void AnnounceMultiplayerSession::Start() {
-    if (announce_multiplayer_thread) {
+    if (announce_multiplayer_thread.has_value()) {
         Stop();
     }
-    shutdown_event.Reset();
+    announce_multiplayer_thread.emplace([&](std::stop_token stoken) {
-    announce_multiplayer_thread =
+        // Invokes all current bound error callbacks.
-        std::make_unique<std::thread>(&AnnounceMultiplayerSession::AnnounceMultiplayerLoop, this);
+        const auto ErrorCallback = [this](WebService::WebResult result) {
+            std::lock_guard lock(callback_mutex);
+            for (auto callback : error_callbacks)
+                (*callback)(result);
+        };
+
+        if (!registered) {
+            WebService::WebResult result = Register();
+            if (result.result_code != WebService::WebResult::Code::Success) {
+                ErrorCallback(result);
+                return;
+            }
+        }
+
+        // Time between room is announced to web_service
+        std::chrono::seconds const announce_timeslice(15);
+        auto update_time = std::chrono::steady_clock::now();
+        std::future<WebService::WebResult> future;
+        while (!shutdown_event.WaitUntil(update_time)) {
+            update_time = std::chrono::steady_clock::now() + announce_timeslice;
+            auto room = Network::GetRoom().lock();
+            if (!room) {
+                break;
+            }
+            if (room->GetState() != Network::Room::State::Open) {
+                break;
+            }
+            UpdateBackendData(room);
+            WebService::WebResult result = backend->Update();
+            if (result.result_code != WebService::WebResult::Code::Success) {
+                ErrorCallback(result);
+            }
+            if (result.result_string == "404") {
+                registered = false;
+                // Needs to register the room again
+                WebService::WebResult register_result = Register();
+                if (register_result.result_code != WebService::WebResult::Code::Success) {
+                    ErrorCallback(register_result);
+                }
+            }
+        }
+    });
 }
 
 void AnnounceMultiplayerSession::Stop() {
-    if (announce_multiplayer_thread) {
+    if (announce_multiplayer_thread.has_value()) {
         shutdown_event.Set();
-        announce_multiplayer_thread->join();
         announce_multiplayer_thread.reset();
         backend->Delete();
         registered = false;
@@ -101,58 +138,10 @@ void AnnounceMultiplayerSession::UpdateBackendData(std::shared_ptr<Network::Room
     }
 }
 
-void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
-    // Invokes all current bound error callbacks.
-    const auto ErrorCallback = [this](WebService::WebResult result) {
-        std::lock_guard lock(callback_mutex);
-        for (auto callback : error_callbacks) {
-            (*callback)(result);
-        }
-    };
-
-    if (!registered) {
-        WebService::WebResult result = Register();
-        if (result.result_code != WebService::WebResult::Code::Success) {
-            ErrorCallback(result);
-            return;
-        }
-    }
-
-    auto update_time = std::chrono::steady_clock::now();
-    std::future<WebService::WebResult> future;
-    while (!shutdown_event.WaitUntil(update_time)) {
-        update_time += announce_time_interval;
-        auto room = Network::GetRoom().lock();
-        if (!room) {
-            break;
-        }
-        if (room->GetState() != Network::Room::State::Open) {
-            break;
-        }
-        UpdateBackendData(room);
-        WebService::WebResult result = backend->Update();
-        if (result.result_code != WebService::WebResult::Code::Success) {
-            ErrorCallback(result);
-        }
-        if (result.result_string == "404") {
-            registered = false;
-            // Needs to register the room again
-            WebService::WebResult register_result = Register();
-            if (register_result.result_code != WebService::WebResult::Code::Success) {
-                ErrorCallback(register_result);
-            }
-        }
-    }
-}
-
 AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() {
     return backend->GetRoomList();
 }
 
-bool AnnounceMultiplayerSession::IsRunning() const {
-    return announce_multiplayer_thread != nullptr;
-}
-
 void AnnounceMultiplayerSession::UpdateCredentials() {
     ASSERT_MSG(!IsRunning(), "Credentials can only be updated when session is not running");
 #ifdef ENABLE_WEB_SERVICE

src/network/announce_multiplayer_session.h

@@ -72,7 +72,9 @@ public:
     /**
      * Whether the announce session is still running
      */
-    bool IsRunning() const;
+    [[nodiscard]] bool IsRunning() const {
+        return announce_multiplayer_thread.has_value();
+    }
 
     /**
      * Recreates the backend, updating the credentials.
@@ -82,16 +84,13 @@ public:
 
 private:
     void UpdateBackendData(std::shared_ptr<Network::Room> room);
-    void AnnounceMultiplayerLoop();
 
     Common::Event shutdown_event;
-    std::mutex callback_mutex;
     std::set<CallbackHandle> error_callbacks;
-    std::unique_ptr<std::thread> announce_multiplayer_thread;
+    std::optional<std::jthread> announce_multiplayer_thread;
-
     /// Backend interface that logs fields
     std::unique_ptr<AnnounceMultiplayerRoom::Backend> backend;
-
+    std::mutex callback_mutex;
     std::atomic_bool registered = false; ///< Whether the room has been registered
 };
 

src/network/room.cpp

@@ -1,6 +1,5 @@
 // SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,6 +12,7 @@
 #include <shared_mutex>
 #include <sstream>
 #include <thread>
+#include "common/polyfill_thread.h"
 #include "common/logging/log.h"
 #include "enet/enet.h"
 #include "network/packet.h"
@@ -54,13 +54,11 @@ public:
     RoomImpl() : random_gen(std::random_device()()) {}
 
     /// Thread that receives and dispatches network packets
-    std::unique_ptr<std::thread> room_thread;
+    std::optional<std::jthread> room_thread;
 
     /// Verification backend of the room
     std::unique_ptr<VerifyUser::Backend> verify_backend;
 
-    /// Thread function that will receive and dispatch messages until the room is destroyed.
-    void ServerLoop();
     void StartLoop();
 
     /**
@@ -240,59 +238,57 @@ public:
 };
 
 // RoomImpl
-void Room::RoomImpl::ServerLoop() {
+void Room::RoomImpl::StartLoop() {
-    while (state != State::Closed) {
+    room_thread.emplace([&](std::stop_token stoken) {
-        ENetEvent event;
+        while (state != State::Closed) {
-        if (enet_host_service(server, &event, 5) > 0) {
+            ENetEvent event;
-            switch (event.type) {
+            if (enet_host_service(server, &event, 5) > 0) {
-            case ENET_EVENT_TYPE_RECEIVE:
+                switch (event.type) {
-                switch (event.packet->data[0]) {
+                case ENET_EVENT_TYPE_RECEIVE:
-                case IdJoinRequest:
+                    switch (event.packet->data[0]) {
-                    HandleJoinRequest(&event);
+                    case IdJoinRequest:
+                        HandleJoinRequest(&event);
+                        break;
+                    case IdSetGameInfo:
+                        HandleGameInfoPacket(&event);
+                        break;
+                    case IdProxyPacket:
+                        HandleProxyPacket(&event);
+                        break;
+                    case IdLdnPacket:
+                        HandleLdnPacket(&event);
+                        break;
+                    case IdChatMessage:
+                        HandleChatPacket(&event);
+                        break;
+                    // Moderation
+                    case IdModKick:
+                        HandleModKickPacket(&event);
+                        break;
+                    case IdModBan:
+                        HandleModBanPacket(&event);
+                        break;
+                    case IdModUnban:
+                        HandleModUnbanPacket(&event);
+                        break;
+                    case IdModGetBanList:
+                        HandleModGetBanListPacket(&event);
+                        break;
+                    }
+                    enet_packet_destroy(event.packet);
                     break;
-                case IdSetGameInfo:
+                case ENET_EVENT_TYPE_DISCONNECT:
-                    HandleGameInfoPacket(&event);
+                    HandleClientDisconnection(event.peer);
                     break;
-                case IdProxyPacket:
+                case ENET_EVENT_TYPE_NONE:
-                    HandleProxyPacket(&event);
+                case ENET_EVENT_TYPE_CONNECT:
-                    break;
-                case IdLdnPacket:
-                    HandleLdnPacket(&event);
-                    break;
-                case IdChatMessage:
-                    HandleChatPacket(&event);
-                    break;
-                // Moderation
-                case IdModKick:
-                    HandleModKickPacket(&event);
-                    break;
-                case IdModBan:
-                    HandleModBanPacket(&event);
-                    break;
-                case IdModUnban:
-                    HandleModUnbanPacket(&event);
-                    break;
-                case IdModGetBanList:
-                    HandleModGetBanListPacket(&event);
                     break;
                 }
-                enet_packet_destroy(event.packet);
-                break;
-            case ENET_EVENT_TYPE_DISCONNECT:
-                HandleClientDisconnection(event.peer);
-                break;
-            case ENET_EVENT_TYPE_NONE:
-            case ENET_EVENT_TYPE_CONNECT:
-                break;
             }
         }
-    }
+        // Close the connection to all members:
-    // Close the connection to all members:
+        SendCloseMessage();
-    SendCloseMessage();
+    });
-}
-
-void Room::RoomImpl::StartLoop() {
-    room_thread = std::make_unique<std::thread>(&Room::RoomImpl::ServerLoop, this);
 }
 
 void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
@@ -1132,7 +1128,6 @@ void Room::SetVerifyUID(const std::string& uid) {
 
 void Room::Destroy() {
     room_impl->state = State::Closed;
-    room_impl->room_thread->join();
     room_impl->room_thread.reset();
 
     if (room_impl->server) {

src/network/room_member.cpp

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,6 +9,7 @@
 #include <set>
 #include <thread>
 #include "common/assert.h"
+#include "common/polyfill_thread.h"
 #include "common/socket_types.h"
 #include "enet/enet.h"
 #include "network/packet.h"
@@ -18,6 +21,21 @@ constexpr u32 ConnectionTimeoutMs = 5000;
 
 class RoomMember::RoomMemberImpl {
 public:
+    void SetState(const State new_state) noexcept {
+        if (state != new_state) {
+            state = new_state;
+            Invoke<State>(state);
+        }
+    }
+
+    void SetError(const Error new_error) noexcept {
+        Invoke<Error>(new_error);
+    }
+
+    [[nodiscard]] bool IsConnected() const noexcept {
+        return state == State::Joining || state == State::Joined || state == State::Moderator;
+    }
+
     ENetHost* client = nullptr; ///< ENet network interface.
     ENetPeer* server = nullptr; ///< The server peer the client is connected to
 
@@ -30,9 +48,6 @@ public:
     GameInfo current_game_info;
 
     std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember.
-    void SetState(const State new_state);
-    void SetError(const Error new_error);
-    bool IsConnected() const;
 
     std::string nickname; ///< The nickname of this member.
 
@@ -43,9 +58,9 @@ public:
 
     std::mutex network_mutex; ///< Mutex that controls access to the `client` variable.
     /// Thread that receives and dispatches network packets
-    std::unique_ptr<std::thread> loop_thread;
+    std::optional<std::jthread> loop_thread;
     std::mutex send_list_mutex;  ///< Mutex that controls access to the `send_list` variable.
-    std::list<Packet> send_list; ///< A list that stores all packets to send the async
+    std::vector<Packet> send_list; ///< A list that stores all packets to send the async
 
     template <typename T>
     using CallbackSet = std::set<CallbackHandle<T>>;
@@ -68,8 +83,6 @@ public:
     };
     Callbacks callbacks; ///< All CallbackSets to all events
 
-    void MemberLoop();
-
     void StartLoop();
 
     /**
@@ -146,134 +159,117 @@ public:
 };
 
 // RoomMemberImpl
-void RoomMember::RoomMemberImpl::SetState(const State new_state) {
+void RoomMember::RoomMemberImpl::StartLoop() {
-    if (state != new_state) {
+    loop_thread.emplace([&](std::stop_token stoken) {
-        state = new_state;
+        // Receive packets while the connection is open
-        Invoke<State>(state);
+        while (IsConnected()) {
-    }
+            std::lock_guard lock(network_mutex);
-}
+            ENetEvent event;
-
+            if (enet_host_service(client, &event, 5) > 0) {
-void RoomMember::RoomMemberImpl::SetError(const Error new_error) {
+                switch (event.type) {
-    Invoke<Error>(new_error);
+                case ENET_EVENT_TYPE_RECEIVE:
-}
+                    switch (event.packet->data[0]) {
-
+                    case IdProxyPacket:
-bool RoomMember::RoomMemberImpl::IsConnected() const {
+                        HandleProxyPackets(&event);
-    return state == State::Joining || state == State::Joined || state == State::Moderator;
+                        break;
-}
+                    case IdLdnPacket:
-
+                        HandleLdnPackets(&event);
-void RoomMember::RoomMemberImpl::MemberLoop() {
+                        break;
-    // Receive packets while the connection is open
+                    case IdChatMessage:
-    while (IsConnected()) {
+                        HandleChatPacket(&event);
-        std::lock_guard lock(network_mutex);
+                        break;
-        ENetEvent event;
+                    case IdStatusMessage:
-        if (enet_host_service(client, &event, 5) > 0) {
+                        HandleStatusMessagePacket(&event);
-            switch (event.type) {
+                        break;
-            case ENET_EVENT_TYPE_RECEIVE:
+                    case IdRoomInformation:
-                switch (event.packet->data[0]) {
+                        HandleRoomInformationPacket(&event);
-                case IdProxyPacket:
+                        break;
-                    HandleProxyPackets(&event);
+                    case IdJoinSuccess:
+                    case IdJoinSuccessAsMod:
+                        // The join request was successful, we are now in the room.
+                        // If we joined successfully, there must be at least one client in the room: us.
+                        ASSERT_MSG(member_information.size() > 0,
+                                "We have not yet received member information.");
+                        HandleJoinPacket(&event); // Get the MAC Address for the client
+                        if (event.packet->data[0] == IdJoinSuccessAsMod) {
+                            SetState(State::Moderator);
+                        } else {
+                            SetState(State::Joined);
+                        }
+                        break;
+                    case IdModBanListResponse:
+                        HandleModBanListResponsePacket(&event);
+                        break;
+                    case IdRoomIsFull:
+                        SetState(State::Idle);
+                        SetError(Error::RoomIsFull);
+                        break;
+                    case IdNameCollision:
+                        SetState(State::Idle);
+                        SetError(Error::NameCollision);
+                        break;
+                    case IdIpCollision:
+                        SetState(State::Idle);
+                        SetError(Error::IpCollision);
+                        break;
+                    case IdVersionMismatch:
+                        SetState(State::Idle);
+                        SetError(Error::WrongVersion);
+                        break;
+                    case IdWrongPassword:
+                        SetState(State::Idle);
+                        SetError(Error::WrongPassword);
+                        break;
+                    case IdCloseRoom:
+                        SetState(State::Idle);
+                        SetError(Error::LostConnection);
+                        break;
+                    case IdHostKicked:
+                        SetState(State::Idle);
+                        SetError(Error::HostKicked);
+                        break;
+                    case IdHostBanned:
+                        SetState(State::Idle);
+                        SetError(Error::HostBanned);
+                        break;
+                    case IdModPermissionDenied:
+                        SetError(Error::PermissionDenied);
+                        break;
+                    case IdModNoSuchUser:
+                        SetError(Error::NoSuchUser);
+                        break;
+                    }
+                    enet_packet_destroy(event.packet);
                     break;
-                case IdLdnPacket:
+                case ENET_EVENT_TYPE_DISCONNECT:
-                    HandleLdnPackets(&event);
+                    if (state == State::Joined || state == State::Moderator) {
-                    break;
+                        SetState(State::Idle);
-                case IdChatMessage:
+                        SetError(Error::LostConnection);
-                    HandleChatPacket(&event);
-                    break;
-                case IdStatusMessage:
-                    HandleStatusMessagePacket(&event);
-                    break;
-                case IdRoomInformation:
-                    HandleRoomInformationPacket(&event);
-                    break;
-                case IdJoinSuccess:
-                case IdJoinSuccessAsMod:
-                    // The join request was successful, we are now in the room.
-                    // If we joined successfully, there must be at least one client in the room: us.
-                    ASSERT_MSG(member_information.size() > 0,
-                               "We have not yet received member information.");
-                    HandleJoinPacket(&event); // Get the MAC Address for the client
-                    if (event.packet->data[0] == IdJoinSuccessAsMod) {
-                        SetState(State::Moderator);
-                    } else {
-                        SetState(State::Joined);
                     }
                     break;
-                case IdModBanListResponse:
+                case ENET_EVENT_TYPE_NONE:
-                    HandleModBanListResponsePacket(&event);
                     break;
-                case IdRoomIsFull:
+                case ENET_EVENT_TYPE_CONNECT:
-                    SetState(State::Idle);
+                    // The ENET_EVENT_TYPE_CONNECT event can not possibly happen here because we're
-                    SetError(Error::RoomIsFull);
+                    // already connected
-                    break;
+                    ASSERT_MSG(false, "Received unexpected connect event while already connected");
-                case IdNameCollision:
-                    SetState(State::Idle);
-                    SetError(Error::NameCollision);
-                    break;
-                case IdIpCollision:
-                    SetState(State::Idle);
-                    SetError(Error::IpCollision);
-                    break;
-                case IdVersionMismatch:
-                    SetState(State::Idle);
-                    SetError(Error::WrongVersion);
-                    break;
-                case IdWrongPassword:
-                    SetState(State::Idle);
-                    SetError(Error::WrongPassword);
-                    break;
-                case IdCloseRoom:
-                    SetState(State::Idle);
-                    SetError(Error::LostConnection);
-                    break;
-                case IdHostKicked:
-                    SetState(State::Idle);
-                    SetError(Error::HostKicked);
-                    break;
-                case IdHostBanned:
-                    SetState(State::Idle);
-                    SetError(Error::HostBanned);
-                    break;
-                case IdModPermissionDenied:
-                    SetError(Error::PermissionDenied);
-                    break;
-                case IdModNoSuchUser:
-                    SetError(Error::NoSuchUser);
                     break;
                 }
-                enet_packet_destroy(event.packet);
-                break;
-            case ENET_EVENT_TYPE_DISCONNECT:
-                if (state == State::Joined || state == State::Moderator) {
-                    SetState(State::Idle);
-                    SetError(Error::LostConnection);
-                }
-                break;
-            case ENET_EVENT_TYPE_NONE:
-                break;
-            case ENET_EVENT_TYPE_CONNECT:
-                // The ENET_EVENT_TYPE_CONNECT event can not possibly happen here because we're
-                // already connected
-                ASSERT_MSG(false, "Received unexpected connect event while already connected");
-                break;
             }
+            std::vector<Packet> packets;
+            {
+                std::lock_guard send_lock(send_list_mutex);
+                packets.swap(send_list);
+            }
+            for (auto const& packet : packets) {
+                ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(),
+                                                            ENET_PACKET_FLAG_RELIABLE);
+                enet_peer_send(server, 0, enetPacket);
+            }
+            enet_host_flush(client);
         }
-        std::list<Packet> packets;
+        Disconnect();
-        {
+    });
-            std::lock_guard send_lock(send_list_mutex);
-            packets.swap(send_list);
-        }
-        for (const auto& packet : packets) {
-            ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(),
-                                                        ENET_PACKET_FLAG_RELIABLE);
-            enet_peer_send(server, 0, enetPacket);
-        }
-        enet_host_flush(client);
-    }
-    Disconnect();
-};
-
-void RoomMember::RoomMemberImpl::StartLoop() {
-    loop_thread = std::make_unique<std::thread>(&RoomMember::RoomMemberImpl::MemberLoop, this);
 }
 
 void RoomMember::RoomMemberImpl::Send(Packet&& packet) {
@@ -747,9 +743,7 @@ void RoomMember::Unbind(CallbackHandle<T> handle) {
 
 void RoomMember::Leave() {
     room_member_impl->SetState(State::Idle);
-    room_member_impl->loop_thread->join();
     room_member_impl->loop_thread.reset();
-
     enet_host_destroy(room_member_impl->client);
     room_member_impl->client = nullptr;
 }

src/qt_common/CMakeLists.txt

@@ -45,10 +45,6 @@ if (NOT APPLE AND ENABLE_OPENGL)
     target_compile_definitions(qt_common PUBLIC HAS_OPENGL)
 endif()
 
-if (UNIX AND NOT APPLE)
+if (NOT WIN32)
-    if (TARGET Qt6::GuiPrivate)
+    target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
-        target_link_libraries(qt_common PRIVATE Qt6::GuiPrivate)
-    else()
-        target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
-    endif()
 endif()

src/tests/input_common/calibration_configuration_job.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,13 +21,9 @@ public:
         : socket(io_context, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 0)) {}
 
     ~FakeCemuhookServer() {
-        is_running = false;
         boost::system::error_code error_code;
         socket.shutdown(boost::asio::socket_base::shutdown_both, error_code);
         socket.close();
-        if (handler.joinable()) {
-            handler.join();
-        }
     }
 
     u16 GetPort() {
@@ -41,10 +40,9 @@ public:
             sizeof(InputCommon::CemuhookUDP::Message<InputCommon::CemuhookUDP::Response::PadData>);
 
         REQUIRE(touch_movement_path.size() > 0);
-        is_running = true;
+        handler = std::jthread([touch_movement_path, this](std::stop_token stoken) {
-        handler = std::thread([touch_movement_path, this]() {
             auto current_touch_position = touch_movement_path.begin();
-            while (is_running) {
+            while (!stoken.stop_requested()) {
                 boost::asio::ip::udp::endpoint sender_endpoint;
                 boost::system::error_code error_code;
                 auto received_size = socket.receive_from(boost::asio::buffer(receive_buffer),
@@ -87,8 +85,7 @@ private:
     boost::asio::ip::udp::socket socket;
     std::array<u8, InputCommon::CemuhookUDP::MAX_PACKET_SIZE> send_buffer;
     std::array<u8, InputCommon::CemuhookUDP::MAX_PACKET_SIZE> receive_buffer;
-    bool is_running = false;
+    std::jthread handler;
-    std::thread handler;
 };
 
 TEST_CASE("CalibrationConfigurationJob completed", "[input_common]") {

src/video_core/buffer_cache/buffer_cache.h

@@ -386,7 +386,8 @@ void BufferCache<P>::BindHostComputeBuffers() {
 template <class P>
 void BufferCache<P>::SetUniformBuffersState(const std::array<u32, NUM_STAGES>& mask,
                                             const UniformBufferSizes* sizes) {
-    if (channel_state->enabled_uniform_buffer_masks != mask) {
+    const bool mask_changed = channel_state->enabled_uniform_buffer_masks != mask;
+    if (mask_changed) {
         channel_state->fast_bound_uniform_buffers.fill(0);
         if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
             channel_state->dirty_uniform_buffers.fill(~u32{0});
@@ -817,7 +818,18 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
         channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
         // Stream buffer path to avoid stalling on non-Nvidia drivers or Vulkan
         const std::span<u8> span = runtime.BindMappedUniformBuffer(stage, binding_index, size);
+#ifdef YUZU_DEBUG
+        ASSERT(binding_index < NUM_GRAPHICS_UNIFORM_BUFFERS);
+        ASSERT(span.size() >= size && "UBO stream span too small");
+        if (!device_memory.ReadBlockFastChecked(device_addr, span.data(), size)) {
+            LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", device_addr, size);
+            channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
+            ASSERT(false);
+            return;
+        }
+#else
         device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
+#endif
         return;
     }
     // Classic cached path
@@ -826,7 +838,8 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     }
     // Skip binding if it's not needed and if the bound buffer is not the fast version
     // This exists to avoid instances where the fast buffer is bound and a GPU write happens
-    needs_bind |= HasFastUniformBufferBound(stage, binding_index);
+    const bool was_fast_bound = HasFastUniformBufferBound(stage, binding_index);
+    needs_bind |= was_fast_bound;
     if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
         needs_bind |= channel_state->uniform_buffer_binding_sizes[stage][binding_index] != size;
     }

src/video_core/buffer_cache/buffer_cache_base.h

@@ -53,7 +53,6 @@ constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
 constexpr u32 NUM_STORAGE_BUFFERS = 16;
 constexpr u32 NUM_TEXTURE_BUFFERS = 32;
 constexpr u32 NUM_STAGES = 5;
-
 static_assert(NUM_GRAPHICS_UNIFORM_BUFFERS <= 32, "fast bitmask must fit u32");
 
 using UniformBufferSizes = std::array<std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES>;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -337,11 +337,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
         uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
                                                  compute_pass_descriptor_queue);
     }
-    const u32 ubo_align = static_cast<u32>(
-            device.GetUniformBufferAlignment() //check if the device has it
-    );
-    // add the ability to change the size in settings in future
-    uniform_ring.Init(device, memory_allocator, 8 * 1024 * 1024 /* 8 MiB */, ubo_align ? ubo_align : 256);
     quad_array_index_buffer = std::make_shared<QuadArrayIndexBuffer>(device_, memory_allocator_,
                                                                      scheduler_, staging_pool_);
     quad_strip_index_buffer = std::make_shared<QuadStripIndexBuffer>(device_, memory_allocator_,
@@ -360,42 +355,6 @@ void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
     staging_pool.FreeDeferred(ref);
 }
 
-void BufferCacheRuntime::UniformRing::Init(const Device& device,
-                                           MemoryAllocator& alloc,
-                                           u64 bytes, u32 alignment) {
-    for (size_t i = 0; i < NUM_FRAMES; ++i) {
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size  = bytes,
-            .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        buffers[i] = alloc.CreateBuffer(ci, MemoryUsage::Upload);
-        mapped[i] = buffers[i].Mapped().data();
-    }
-    size   = bytes;
-    align  = alignment ? alignment : 256;
-    head   = 0;
-    current_frame = 0;
-}
-
-std::span<u8> BufferCacheRuntime::UniformRing::Alloc(u32 bytes, u32& out_offset) {
-    const u64 aligned = Common::AlignUp(head, static_cast<u64>(align));
-    u64 end = aligned + bytes;
-
-    if (end > size) {
-       return {}; // Fallback to staging pool
-    }
-
-    out_offset = static_cast<u32>(aligned);
-    head = end;
-    return {mapped[current_frame] + out_offset, bytes};
-}
-
 u64 BufferCacheRuntime::GetDeviceLocalMemory() const {
     return device.GetDeviceLocalMemory();
 }
@@ -416,7 +375,6 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         it->ResetUsageTracking();
     }
-    uniform_ring.BeginFrame();
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -127,15 +124,8 @@ public:
 
     void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);
 
-    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
+    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t stage,
-                                          [[maybe_unused]] u32 /*binding_index*/,
+                                          [[maybe_unused]] u32 binding_index, u32 size) {
-                                          u32 size) {
-        u32 offset = 0;
-        if (auto span = uniform_ring.Alloc(size, offset); !span.empty()) {
-            BindBuffer(*uniform_ring.buffers[uniform_ring.current_frame], offset, size);
-            return span;
-        }
-        // Fallback for giant requests
         const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
         BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
         return ref.mapped_span;
@@ -163,24 +153,6 @@ private:
     void ReserveNullBuffer();
     vk::Buffer CreateNullBuffer();
 
-    struct UniformRing {
-        static constexpr size_t NUM_FRAMES = 3;
-        std::array<vk::Buffer, NUM_FRAMES> buffers{};
-        std::array<u8*, NUM_FRAMES> mapped{};
-        u64 size = 0;
-        u64 head = 0;
-        u32 align = 256;
-        size_t current_frame = 0;
-
-        void Init(const Device& device, MemoryAllocator& alloc, u64 bytes, u32 alignment);
-        void BeginFrame() {
-            current_frame = (current_frame + 1) % NUM_FRAMES;
-            head = 0;
-        }
-        std::span<u8> Alloc(u32 bytes, u32& out_offset);
-    };
-    UniformRing uniform_ring;
-
     const Device& device;
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -25,35 +25,48 @@ namespace {
 
 using namespace Common::Literals;
 
-// Maximum potential alignment of a Vulkan buffer
+// Minimum alignment we want to enforce for the streaming ring
-constexpr VkDeviceSize MAX_ALIGNMENT = 256;
+constexpr VkDeviceSize MIN_STREAM_ALIGNMENT = 256;
 // Stream buffer size in bytes
 constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
 
-size_t GetStreamBufferSize(const Device& device) {
+size_t GetStreamBufferSize(const Device& device, VkDeviceSize alignment) {
     VkDeviceSize size{0};
     if (device.HasDebuggingToolAttached()) {
-        ForEachDeviceLocalHostVisibleHeap(device, [&size](size_t index, VkMemoryHeap& heap) {
+        bool found_heap = false;
+        ForEachDeviceLocalHostVisibleHeap(device, [&size, &found_heap](size_t /*index*/, VkMemoryHeap& heap) {
             size = (std::max)(size, heap.size);
+            found_heap = true;
         });
-        // If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
+        // If no suitable heap was found fall back to the default cap to avoid creating a zero-sized stream buffer.
-        // loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
+        if (!found_heap) {
-        // as the heap will be much larger.
+            size = MAX_STREAM_BUFFER_SIZE;
-        if (size <= 256_MiB) {
+        } else if (size <= 256_MiB) {
+            // If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
+            // loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
+            // as the heap will be much larger.
             size = size * 40 / 100;
         }
     } else {
         size = MAX_STREAM_BUFFER_SIZE;
     }
-    return (std::min)(Common::AlignUp(size, MAX_ALIGNMENT), MAX_STREAM_BUFFER_SIZE);
+
+    // Clamp to the configured maximum, align up for safety, and ensure a sane minimum so
+    // region_size (stream_buffer_size / NUM_SYNCS) never becomes zero.
+    const VkDeviceSize aligned =
+        (std::min)(Common::AlignUp(size, alignment), MAX_STREAM_BUFFER_SIZE);
+    const VkDeviceSize min_size = alignment * StagingBufferPool::NUM_SYNCS;
+    return static_cast<size_t>((std::max)(aligned, min_size));
 }
 } // Anonymous namespace
 
 StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
                                      Scheduler& scheduler_)
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
-      stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
+      stream_alignment{std::max<VkDeviceSize>(device_.GetUniformBufferAlignment(),
-                                                                   StagingBufferPool::NUM_SYNCS} {
+                                              MIN_STREAM_ALIGNMENT)},
+      stream_buffer_size{GetStreamBufferSize(device_, stream_alignment)},
+      region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} {
     VkBufferCreateInfo stream_ci = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -106,31 +119,54 @@ void StagingBufferPool::TickFrame() {
 }
 
 StagingBufferRef StagingBufferPool::GetStreamBuffer(size_t size) {
-    if (AreRegionsActive(Region(free_iterator) + 1,
+    const size_t alignment = static_cast<size_t>(stream_alignment);
-                         (std::min)(Region(iterator + size) + 1, NUM_SYNCS))) {
+    const size_t aligned_size = Common::AlignUp(size, alignment);
+    const bool wraps = iterator + size >= stream_buffer_size;
+    const size_t new_iterator =
+        wraps ? aligned_size : Common::AlignUp(iterator + size, alignment);
+    const size_t begin_region = wraps ? 0 : Region(iterator);
+    const size_t last_byte = new_iterator == 0 ? 0 : new_iterator - 1;
+    const size_t end_region = (std::min)(Region(last_byte) + 1, NUM_SYNCS);
+    const size_t guard_begin = (std::min)(Region(free_iterator) + 1, NUM_SYNCS);
+
+    if (!wraps) {
+        if (guard_begin < end_region && AreRegionsActive(guard_begin, end_region)) {
+            // Avoid waiting for the previous usages to be free
+            return GetStagingBuffer(size, MemoryUsage::Upload);
+        }
+    } else if (guard_begin < NUM_SYNCS && AreRegionsActive(guard_begin, NUM_SYNCS)) {
         // Avoid waiting for the previous usages to be free
         return GetStagingBuffer(size, MemoryUsage::Upload);
     }
+
     const u64 current_tick = scheduler.CurrentTick();
     std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + Region(iterator),
               current_tick);
     used_iterator = iterator;
-    free_iterator = (std::max)(free_iterator, iterator + size);
 
-    if (iterator + size >= stream_buffer_size) {
+    if (wraps) {
         std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + NUM_SYNCS,
                   current_tick);
         used_iterator = 0;
         iterator = 0;
-        free_iterator = size;
+        free_iterator = aligned_size;
-
+        const size_t head_last_byte = aligned_size == 0 ? 0 : aligned_size - 1;
-        if (AreRegionsActive(0, Region(size) + 1)) {
+        const size_t head_end_region = (std::min)(Region(head_last_byte) + 1, NUM_SYNCS);
+        if (AreRegionsActive(0, head_end_region)) {
             // Avoid waiting for the previous usages to be free
             return GetStagingBuffer(size, MemoryUsage::Upload);
         }
     }
-    const size_t offset = iterator;
+
-    iterator = Common::AlignUp(iterator + size, MAX_ALIGNMENT);
+    std::fill(sync_ticks.begin() + begin_region, sync_ticks.begin() + end_region, current_tick);
+
+    const size_t offset = wraps ? 0 : iterator;
+    iterator = new_iterator;
+
+    if (!wraps) {
+        free_iterator = (std::max)(free_iterator, offset + aligned_size);
+    }
+
     return StagingBufferRef{
         .buffer = *stream_buffer,
         .offset = static_cast<VkDeviceSize>(offset),

src/video_core/renderer_vulkan/vk_staging_buffer_pool.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -102,6 +105,7 @@ private:
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
 
+    VkDeviceSize stream_alignment;
     vk::Buffer stream_buffer;
     std::span<u8> stream_pointer;
     VkDeviceSize stream_buffer_size;

src/yuzu/CMakeLists.txt

@@ -393,8 +393,16 @@ target_link_libraries(yuzu PRIVATE common core input_common frontend_common netw
 target_link_libraries(yuzu PRIVATE Boost::headers glad Qt6::Widgets)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
+if (NOT WIN32)
+    target_include_directories(yuzu PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
+endif()
+
 if (UNIX AND NOT APPLE)
     target_link_libraries(yuzu PRIVATE Qt6::DBus)
+
+    if (TARGET Qt6::GuiPrivate)
+        target_link_libraries(yuzu PRIVATE Qt6::GuiPrivate)
+    endif()
 endif()
 
 target_compile_definitions(yuzu PRIVATE

src/yuzu/applets/qt_software_keyboard.cpp

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -1492,53 +1494,36 @@ void QtSoftwareKeyboardDialog::MoveTextCursorDirection(Direction direction) {
 }
 
 void QtSoftwareKeyboardDialog::StartInputThread() {
-    if (input_thread_running) {
+    input_thread = std::jthread([&](std::stop_token stoken) {
-        return;
+        while (!stoken.stop_requested()) {
-    }
+            input_interpreter->PollInput();
-
+            HandleButtonPressedOnce<
-    input_thread_running = true;
+                Core::HID::NpadButton::A, Core::HID::NpadButton::B, Core::HID::NpadButton::X,
-
+                Core::HID::NpadButton::Y, Core::HID::NpadButton::StickL, Core::HID::NpadButton::StickR,
-    input_thread = std::thread(&QtSoftwareKeyboardDialog::InputThread, this);
+                Core::HID::NpadButton::L, Core::HID::NpadButton::R, Core::HID::NpadButton::Plus,
+                Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
+                Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
+                Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
+                Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
+                Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
+                Core::HID::NpadButton::StickRDown>();
+            HandleButtonHold<Core::HID::NpadButton::B, Core::HID::NpadButton::L,
+                Core::HID::NpadButton::R, Core::HID::NpadButton::Left,
+                Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
+                Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
+                Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
+                Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
+                Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
+                Core::HID::NpadButton::StickRDown>();
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+    });
 }
 
 void QtSoftwareKeyboardDialog::StopInputThread() {
-    input_thread_running = false;
+    input_thread.request_stop();
-
+    if (input_interpreter)
-    if (input_thread.joinable()) {
-        input_thread.join();
-    }
-
-    if (input_interpreter) {
         input_interpreter->ResetButtonStates();
-    }
-}
-
-void QtSoftwareKeyboardDialog::InputThread() {
-    while (input_thread_running) {
-        input_interpreter->PollInput();
-
-        HandleButtonPressedOnce<
-            Core::HID::NpadButton::A, Core::HID::NpadButton::B, Core::HID::NpadButton::X,
-            Core::HID::NpadButton::Y, Core::HID::NpadButton::StickL, Core::HID::NpadButton::StickR,
-            Core::HID::NpadButton::L, Core::HID::NpadButton::R, Core::HID::NpadButton::Plus,
-            Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
-            Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
-            Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
-            Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
-            Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
-            Core::HID::NpadButton::StickRDown>();
-
-        HandleButtonHold<Core::HID::NpadButton::B, Core::HID::NpadButton::L,
-                         Core::HID::NpadButton::R, Core::HID::NpadButton::Left,
-                         Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
-                         Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
-                         Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
-                         Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
-                         Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
-                         Core::HID::NpadButton::StickRDown>();
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
 }
 
 QtSoftwareKeyboard::QtSoftwareKeyboard(GMainWindow& main_window) {

src/yuzu/applets/qt_software_keyboard.h

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -182,9 +184,6 @@ private:
     void StartInputThread();
     void StopInputThread();
 
-    /// The thread where input is being polled and processed.
-    void InputThread();
-
     std::unique_ptr<Ui::QtSoftwareKeyboardDialog> ui;
 
     Core::System& system;
@@ -220,10 +219,7 @@ private:
     std::atomic<bool> caps_lock_enabled{false};
 
     std::unique_ptr<InputInterpreter> input_interpreter;
-
+    std::jthread input_thread;
-    std::thread input_thread;
-
-    std::atomic<bool> input_thread_running{};
 };
 
 class QtSoftwareKeyboard final : public QObject, public Core::Frontend::SoftwareKeyboardApplet {

src/yuzu/applets/qt_web_browser.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -282,54 +285,41 @@ void QtNXWebEngineView::SendKeyPressEvent(int key) {
 }
 
 void QtNXWebEngineView::StartInputThread() {
-    if (input_thread_running) {
+    input_thread = std::jthread([&](std::stop_token stoken) {
-        return;
+        // Wait for 1 second before allowing any inputs to be processed.
-    }
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        if (is_local) {
+            QWidget::grabKeyboard();
+        }
+        while (!stoken.stop_requested()) {
+            input_interpreter->PollInput();
 
-    input_thread_running = true;
+            HandleWindowFooterButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
-    input_thread = std::thread(&QtNXWebEngineView::InputThread, this);
+                                                Core::HID::NpadButton::X, Core::HID::NpadButton::Y,
+                                                Core::HID::NpadButton::L, Core::HID::NpadButton::R>();
+
+            HandleWindowKeyButtonPressedOnce<
+                Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
+                Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
+                Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
+                Core::HID::NpadButton::StickLDown>();
+
+            HandleWindowKeyButtonHold<
+                Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
+                Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
+                Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
+                Core::HID::NpadButton::StickLDown>();
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+    });
 }
 
 void QtNXWebEngineView::StopInputThread() {
     if (is_local) {
         QWidget::releaseKeyboard();
     }
-
+    input_thread.request_stop();
-    input_thread_running = false;
-    if (input_thread.joinable()) {
-        input_thread.join();
-    }
-}
-
-void QtNXWebEngineView::InputThread() {
-    // Wait for 1 second before allowing any inputs to be processed.
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-
-    if (is_local) {
-        QWidget::grabKeyboard();
-    }
-
-    while (input_thread_running) {
-        input_interpreter->PollInput();
-
-        HandleWindowFooterButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
-                                            Core::HID::NpadButton::X, Core::HID::NpadButton::Y,
-                                            Core::HID::NpadButton::L, Core::HID::NpadButton::R>();
-
-        HandleWindowKeyButtonPressedOnce<
-            Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
-            Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
-            Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
-            Core::HID::NpadButton::StickLDown>();
-
-        HandleWindowKeyButtonHold<
-            Core::HID::NpadButton::Left, Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
-            Core::HID::NpadButton::Down, Core::HID::NpadButton::StickLLeft,
-            Core::HID::NpadButton::StickLUp, Core::HID::NpadButton::StickLRight,
-            Core::HID::NpadButton::StickLDown>();
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
 }
 
 void QtNXWebEngineView::LoadExtractedFonts() {

src/yuzu/applets/qt_web_browser.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -155,9 +158,6 @@ private:
     void StartInputThread();
     void StopInputThread();
 
-    /// The thread where input is being polled and processed.
-    void InputThread();
-
     /// Loads the extracted fonts using JavaScript.
     void LoadExtractedFonts();
 
@@ -165,24 +165,13 @@ private:
     void FocusFirstLinkElement();
 
     InputCommon::InputSubsystem* input_subsystem;
-
     std::unique_ptr<UrlRequestInterceptor> url_interceptor;
-
     std::unique_ptr<InputInterpreter> input_interpreter;
-
+    std::jthread input_thread;
-    std::thread input_thread;
-
-    std::atomic<bool> input_thread_running{};
-
     std::atomic<bool> finished{};
-
+    Service::AM::Frontend::WebExitReason exit_reason{Service::AM::Frontend::WebExitReason::EndButtonPressed};
-    Service::AM::Frontend::WebExitReason exit_reason{
-        Service::AM::Frontend::WebExitReason::EndButtonPressed};
-
     std::string last_url{"http://localhost/"};
-
     bool is_local{};
-
     QWebEngineProfile* default_profile;
     QWebEngineSettings* global_settings;
 };

src/yuzu/configuration/configure_debug.cpp

@@ -83,7 +83,8 @@ void ConfigureDebug::SetConfiguration() {
 #ifdef YUZU_USE_QT_WEB_ENGINE
     ui->disable_web_applet->setChecked(UISettings::values.disable_web_applet.GetValue());
 #else
-    ui->disable_web_applet->setVisible(false);
+    ui->disable_web_applet->setEnabled(false);
+    ui->disable_web_applet->setText(tr("Web applet not compiled"));
 #endif
 }
 

src/yuzu/util/overlay_dialog.cpp

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -231,34 +233,20 @@ void OverlayDialog::TranslateButtonPress(Core::HID::NpadButton button) {
 }
 
 void OverlayDialog::StartInputThread() {
-    if (input_thread_running) {
+    input_thread = std::jthread([&](std::stop_token stoken) {
-        return;
+        while (!stoken.stop_requested()) {
-    }
+            input_interpreter->PollInput();
-
+            HandleButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
-    input_thread_running = true;
+                                    Core::HID::NpadButton::Left, Core::HID::NpadButton::Right,
-
+                                    Core::HID::NpadButton::StickLLeft,
-    input_thread = std::thread(&OverlayDialog::InputThread, this);
+                                    Core::HID::NpadButton::StickLRight>();
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+    });
 }
 
 void OverlayDialog::StopInputThread() {
-    input_thread_running = false;
+    input_thread.request_stop();
-
-    if (input_thread.joinable()) {
-        input_thread.join();
-    }
-}
-
-void OverlayDialog::InputThread() {
-    while (input_thread_running) {
-        input_interpreter->PollInput();
-
-        HandleButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
-                                Core::HID::NpadButton::Left, Core::HID::NpadButton::Right,
-                                Core::HID::NpadButton::StickLLeft,
-                                Core::HID::NpadButton::StickLRight>();
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
 }
 
 void OverlayDialog::keyPressEvent(QKeyEvent* e) {

src/yuzu/util/overlay_dialog.h

@@ -1,9 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
 #pragma once
 
-#include <atomic>
 #include <memory>
 #include <thread>
 
@@ -91,9 +92,6 @@ private:
 
     void StartInputThread();
     void StopInputThread();
-
-    /// The thread where input is being polled and processed.
-    void InputThread();
     void keyPressEvent(QKeyEvent* e) override;
 
     std::unique_ptr<Ui::OverlayDialog> ui;
@@ -101,8 +99,5 @@ private:
     bool use_rich_text;
 
     std::unique_ptr<InputInterpreter> input_interpreter;
-
+    std::jthread input_thread;
-    std::thread input_thread;
-
-    std::atomic<bool> input_thread_running{};
 };