[hw_composer]: Add "Respect present interval 0 for unlocked FPS"

Co-authored-by: Zephyron <zephyron@citron-emu.org>

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

@@ -53,6 +53,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
 
     SOC_OVERLAY_BACKGROUND("soc_overlay_background"),
     ENABLE_INPUT_OVERLAY_AUTO_HIDE("enable_input_overlay_auto_hide"),
+    RESPECT_PRESENT_INTERVAL_ZERO("respect_present_interval_zero"),
 
     PERF_OVERLAY_BACKGROUND("perf_overlay_background"),
     SHOW_PERFORMANCE_OVERLAY("show_performance_overlay"),

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

@@ -237,6 +237,13 @@ abstract class SettingsItem(
                 override fun reset() = BooleanSetting.USE_DOCKED_MODE.reset()
             }
 
+            put(
+                SwitchSetting(
+                    BooleanSetting.RESPECT_PRESENT_INTERVAL_ZERO,
+                    titleId = R.string.respect_present_interval_zero,
+                    descriptionId = R.string.respect_present_interval_zero_description
+                )
+            )
             put(
                 SwitchSetting(
                     dockedModeSetting,

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

@@ -460,6 +460,7 @@ class SettingsFragmentPresenter(
             add(IntSetting.RENDERER_SAMPLE_SHADING_FRACTION.key)
 
             add(HeaderSetting(R.string.veil_renderer))
+            add(BooleanSetting.RESPECT_PRESENT_INTERVAL_ZERO.key)
             add(BooleanSetting.RENDERER_EARLY_RELEASE_FENCES.key)
             add(IntSetting.DMA_ACCURACY.key)
             add(BooleanSetting.BUFFER_REORDER_DISABLE.key)

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

@@ -105,6 +105,8 @@
     <string name="sample_shading_fraction_description">The intensity of the sample shading pass. Higher values improve quality more but also reduce performance to a greater extent.</string>
 
     <string name="veil_renderer">Renderer</string>
+    <string name="respect_present_interval_zero">Respect present interval 0 for unlocked FPS</string>
+    <string name="respect_present_interval_zero_description">When enabled, present interval 0 will be used for games requesting unlocked FPS. This matches console behavior more closely, but may cause higher battery usage and frame pacing issues. When disabled (default), present interval 0 is capped at 120FPS to conserve battery.</string>
     <string name="renderer_early_release_fences">Release Fences Early</string>
     <string name="renderer_early_release_fences_description">Helps fix 0 FPS in games like DKCR:HD, Subnautica Below Zero and Ori 2, but may break loading or performance in Unreal Engine games.</string>
     <string name="sync_memory_operations">Sync Memory Operations</string>

src/common/settings.h

@@ -342,6 +342,9 @@ struct Values {
                                                                      Category::Renderer};
     SwitchableSetting<bool> use_asynchronous_gpu_emulation{
                                                            linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
+    SwitchableSetting<bool> respect_present_interval_zero{
+                                                          linkage, false, "respect_present_interval_zero", Category::Renderer};
+
     SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
 #ifdef ANDROID
                                                             AstcDecodeMode::Cpu,

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -8,6 +8,8 @@
 
 #include <boost/container/small_vector.hpp>
 
+#include "common/settings.h"
+
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvnflinger/buffer_item.h"
 #include "core/hle/service/nvnflinger/buffer_item_consumer.h"
@@ -21,6 +23,14 @@ namespace {
 
 s32 NormalizeSwapInterval(f32* out_speed_scale, s32 swap_interval) {
     if (swap_interval <= 0) {
+        // If swap_interval is 0 and setting enabled, respect it as unlocked FPS
+        if (swap_interval == 0 && Settings::values.respect_present_interval_zero.GetValue()) {
+            if (out_speed_scale) {
+                *out_speed_scale = 1.0f;
+            }
+            return 0;
+        }
+
         // As an extension, treat nonpositive swap interval as speed multiplier.
         if (out_speed_scale) {
             *out_speed_scale = 2.f * static_cast<f32>(1 - swap_interval);

src/network/announce_multiplayer_session.cpp

@@ -19,6 +19,9 @@
 
 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(),
@@ -50,58 +53,18 @@ WebService::WebResult AnnounceMultiplayerSession::Register() {
 }
 
 void AnnounceMultiplayerSession::Start() {
-    if (announce_multiplayer_thread.has_value()) {
+    if (announce_multiplayer_thread) {
         Stop();
     }
-    announce_multiplayer_thread.emplace([&](std::stop_token stoken) {
+    shutdown_event.Reset();
-        // Invokes all current bound error callbacks.
+    announce_multiplayer_thread =
-        const auto ErrorCallback = [this](WebService::WebResult result) {
+        std::make_unique<std::thread>(&AnnounceMultiplayerSession::AnnounceMultiplayerLoop, this);
-            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.has_value()) {
+    if (announce_multiplayer_thread) {
         shutdown_event.Set();
+        announce_multiplayer_thread->join();
         announce_multiplayer_thread.reset();
         backend->Delete();
         registered = false;
@@ -138,10 +101,58 @@ 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,9 +72,7 @@ public:
     /**
      * Whether the announce session is still running
      */
-    [[nodiscard]] bool IsRunning() const {
+    bool IsRunning() const;
-        return announce_multiplayer_thread.has_value();
-    }
 
     /**
      * Recreates the backend, updating the credentials.
@@ -84,13 +82,16 @@ 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::optional<std::jthread> announce_multiplayer_thread;
+    std::unique_ptr<std::thread> 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,5 +1,6 @@
 // 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
 
@@ -12,7 +13,6 @@
 #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,11 +54,13 @@ public:
     RoomImpl() : random_gen(std::random_device()()) {}
 
     /// Thread that receives and dispatches network packets
-    std::optional<std::jthread> room_thread;
+    std::unique_ptr<std::thread> 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();
 
     /**
@@ -238,57 +240,59 @@ public:
 };
 
 // RoomImpl
-void Room::RoomImpl::StartLoop() {
+void Room::RoomImpl::ServerLoop() {
-    room_thread.emplace([&](std::stop_token stoken) {
+    while (state != State::Closed) {
-        while (state != State::Closed) {
+        ENetEvent event;
-            ENetEvent event;
+        if (enet_host_service(server, &event, 5) > 0) {
-            if (enet_host_service(server, &event, 5) > 0) {
+            switch (event.type) {
-                switch (event.type) {
+            case ENET_EVENT_TYPE_RECEIVE:
-                case ENET_EVENT_TYPE_RECEIVE:
+                switch (event.packet->data[0]) {
-                    switch (event.packet->data[0]) {
+                case IdJoinRequest:
-                    case IdJoinRequest:
+                    HandleJoinRequest(&event);
-                        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 ENET_EVENT_TYPE_DISCONNECT:
+                case IdSetGameInfo:
-                    HandleClientDisconnection(event.peer);
+                    HandleGameInfoPacket(&event);
                     break;
-                case ENET_EVENT_TYPE_NONE:
+                case IdProxyPacket:
-                case ENET_EVENT_TYPE_CONNECT:
+                    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 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:
+    }
-        SendCloseMessage();
+    // Close the connection to all members:
-    });
+    SendCloseMessage();
+}
+
+void Room::RoomImpl::StartLoop() {
+    room_thread = std::make_unique<std::thread>(&Room::RoomImpl::ServerLoop, this);
 }
 
 void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
@@ -1129,6 +1133,7 @@ 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,5 +1,3 @@
-// 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
 
@@ -9,7 +7,6 @@
 #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"
@@ -21,21 +18,6 @@ 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
 
@@ -48,6 +30,9 @@ 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.
 
@@ -58,9 +43,9 @@ public:
 
     std::mutex network_mutex; ///< Mutex that controls access to the `client` variable.
     /// Thread that receives and dispatches network packets
-    std::optional<std::jthread> loop_thread;
+    std::unique_ptr<std::thread> loop_thread;
     std::mutex send_list_mutex;  ///< Mutex that controls access to the `send_list` variable.
-    std::vector<Packet> send_list; ///< A list that stores all packets to send the async
+    std::list<Packet> send_list; ///< A list that stores all packets to send the async
 
     template <typename T>
     using CallbackSet = std::set<CallbackHandle<T>>;
@@ -83,6 +68,8 @@ public:
     };
     Callbacks callbacks; ///< All CallbackSets to all events
 
+    void MemberLoop();
+
     void StartLoop();
 
     /**
@@ -159,117 +146,134 @@ public:
 };
 
 // RoomMemberImpl
-void RoomMember::RoomMemberImpl::StartLoop() {
+void RoomMember::RoomMemberImpl::SetState(const State new_state) {
-    loop_thread.emplace([&](std::stop_token stoken) {
+    if (state != new_state) {
-        // Receive packets while the connection is open
+        state = new_state;
-        while (IsConnected()) {
+        Invoke<State>(state);
-            std::lock_guard lock(network_mutex);
+    }
-            ENetEvent event;
+}
-            if (enet_host_service(client, &event, 5) > 0) {
+
-                switch (event.type) {
+void RoomMember::RoomMemberImpl::SetError(const Error new_error) {
-                case ENET_EVENT_TYPE_RECEIVE:
+    Invoke<Error>(new_error);
-                    switch (event.packet->data[0]) {
+}
-                    case IdProxyPacket:
+
-                        HandleProxyPackets(&event);
+bool RoomMember::RoomMemberImpl::IsConnected() const {
-                        break;
+    return state == State::Joining || state == State::Joined || state == State::Moderator;
-                    case IdLdnPacket:
+}
-                        HandleLdnPackets(&event);
+
-                        break;
+void RoomMember::RoomMemberImpl::MemberLoop() {
-                    case IdChatMessage:
+    // Receive packets while the connection is open
-                        HandleChatPacket(&event);
+    while (IsConnected()) {
-                        break;
+        std::lock_guard lock(network_mutex);
-                    case IdStatusMessage:
+        ENetEvent event;
-                        HandleStatusMessagePacket(&event);
+        if (enet_host_service(client, &event, 5) > 0) {
-                        break;
+            switch (event.type) {
-                    case IdRoomInformation:
+            case ENET_EVENT_TYPE_RECEIVE:
-                        HandleRoomInformationPacket(&event);
+                switch (event.packet->data[0]) {
-                        break;
+                case IdProxyPacket:
-                    case IdJoinSuccess:
+                    HandleProxyPackets(&event);
-                    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 ENET_EVENT_TYPE_DISCONNECT:
+                case IdLdnPacket:
-                    if (state == State::Joined || state == State::Moderator) {
+                    HandleLdnPackets(&event);
-                        SetState(State::Idle);
+                    break;
-                        SetError(Error::LostConnection);
+                case IdChatMessage:
+                    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 ENET_EVENT_TYPE_NONE:
+                case IdModBanListResponse:
+                    HandleModBanListResponsePacket(&event);
                     break;
-                case ENET_EVENT_TYPE_CONNECT:
+                case IdRoomIsFull:
-                    // The ENET_EVENT_TYPE_CONNECT event can not possibly happen here because we're
+                    SetState(State::Idle);
-                    // already connected
+                    SetError(Error::RoomIsFull);
-                    ASSERT_MSG(false, "Received unexpected connect event while already connected");
+                    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 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);
         }
-        Disconnect();
+        std::list<Packet> packets;
-    });
+        {
+            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) {
@@ -743,7 +747,9 @@ 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/config/shared_translation.cpp

@@ -213,6 +213,11 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
         use_asynchronous_gpu_emulation,
         tr("Use asynchronous GPU emulation"),
         tr("Uses an extra CPU thread for rendering.\nThis option should always remain enabled."));
+    INSERT(
+        Settings, respect_present_interval_zero, tr("Respect present interval 0 for unlocked FPS"),
+        tr("When enabled, present interval 0 will be used for games requesting unlocked FPS.\n"
+           "This matches console behavior more closely, but may cause higher battery usage and frame pacing issues.\n"
+           "When disabled (default), present interval 0 is capped at 120FPS to conserve battery."));
     INSERT(Settings,
            nvdec_emulation,
            tr("NVDEC emulation:"),

src/tests/input_common/calibration_configuration_job.cpp

@@ -22,9 +22,13 @@ 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,9 +45,10 @@ public:
             sizeof(InputCommon::CemuhookUDP::Message<InputCommon::CemuhookUDP::Response::PadData>);
 
         REQUIRE(touch_movement_path.size() > 0);
-        handler = std::jthread([touch_movement_path, this](std::stop_token stoken) {
+        is_running = true;
+        handler = std::thread([touch_movement_path, this]() {
             auto current_touch_position = touch_movement_path.begin();
-            while (!stoken.stop_requested()) {
+            while (is_running) {
                 boost::asio::ip::udp::endpoint sender_endpoint;
                 boost::system::error_code error_code;
                 auto received_size = socket.receive_from(boost::asio::buffer(receive_buffer),
@@ -86,7 +91,8 @@ 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;
-    std::jthread handler;
+    bool is_running = false;
+    std::thread handler;
 };
 
 TEST_CASE("CalibrationConfigurationJob completed", "[input_common]") {

src/yuzu/applets/qt_software_keyboard.cpp

@@ -1,5 +1,6 @@
 // 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
 
@@ -1494,36 +1495,53 @@ void QtSoftwareKeyboardDialog::MoveTextCursorDirection(Direction direction) {
 }
 
 void QtSoftwareKeyboardDialog::StartInputThread() {
-    input_thread = std::jthread([&](std::stop_token stoken) {
+    if (input_thread_running) {
-        while (!stoken.stop_requested()) {
+        return;
-            input_interpreter->PollInput();
+    }
-            HandleButtonPressedOnce<
+
-                Core::HID::NpadButton::A, Core::HID::NpadButton::B, Core::HID::NpadButton::X,
+    input_thread_running = true;
-                Core::HID::NpadButton::Y, Core::HID::NpadButton::StickL, Core::HID::NpadButton::StickR,
+
-                Core::HID::NpadButton::L, Core::HID::NpadButton::R, Core::HID::NpadButton::Plus,
+    input_thread = std::thread(&QtSoftwareKeyboardDialog::InputThread, this);
-                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.request_stop();
+    input_thread_running = false;
-    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(MainWindow& main_window) {

src/yuzu/applets/qt_software_keyboard.h

@@ -1,5 +1,6 @@
 // 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
 
@@ -184,6 +185,9 @@ 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;
@@ -219,7 +223,10 @@ 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

@@ -285,41 +285,54 @@ void QtNXWebEngineView::SendKeyPressEvent(int key) {
 }
 
 void QtNXWebEngineView::StartInputThread() {
-    input_thread = std::jthread([&](std::stop_token stoken) {
+    if (input_thread_running) {
-        // Wait for 1 second before allowing any inputs to be processed.
+        return;
-        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
-        if (is_local) {
-            QWidget::grabKeyboard();
-        }
-        while (!stoken.stop_requested()) {
-            input_interpreter->PollInput();
 
-            HandleWindowFooterButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
+    input_thread_running = true;
-                                                Core::HID::NpadButton::X, Core::HID::NpadButton::Y,
+    input_thread = std::thread(&QtNXWebEngineView::InputThread, this);
-                                                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

@@ -158,6 +158,9 @@ 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,13 +168,24 @@ 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/util/overlay_dialog.cpp

@@ -1,5 +1,3 @@
-// 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
 
@@ -233,20 +231,34 @@ void OverlayDialog::TranslateButtonPress(Core::HID::NpadButton button) {
 }
 
 void OverlayDialog::StartInputThread() {
-    input_thread = std::jthread([&](std::stop_token stoken) {
+    if (input_thread_running) {
-        while (!stoken.stop_requested()) {
+        return;
-            input_interpreter->PollInput();
+    }
-            HandleButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
+
-                                    Core::HID::NpadButton::Left, Core::HID::NpadButton::Right,
+    input_thread_running = true;
-                                    Core::HID::NpadButton::StickLLeft,
+
-                                    Core::HID::NpadButton::StickLRight>();
+    input_thread = std::thread(&OverlayDialog::InputThread, this);
-            std::this_thread::sleep_for(std::chrono::milliseconds(50));
-        }
-    });
 }
 
 void OverlayDialog::StopInputThread() {
-    input_thread.request_stop();
+    input_thread_running = false;
+
+    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,10 +1,9 @@
-// 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>
 
@@ -92,6 +91,9 @@ 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;
@@ -99,5 +101,8 @@ 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{};
 };