25 files changed, 255 insertions, 201 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index d314ff1ce..4e39649a8 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -6,8 +6,6 @@ add_library(core STATIC
     announce_multiplayer_session.h
     arm/arm_interface.h
     arm/arm_interface.cpp
-    arm/cpu_interrupt_handler.cpp
-    arm/cpu_interrupt_handler.h
     arm/dynarmic/arm_dynarmic_32.cpp
     arm/dynarmic/arm_dynarmic_32.h
     arm/dynarmic/arm_dynarmic_64.cpp
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 73f259525..7d62d030e 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -27,7 +27,6 @@ namespace Core {
 class System;
 class CPUInterruptHandler;
 
-using CPUInterrupts = std::array<CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>;
 using WatchpointArray = std::array<Kernel::DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>;
 
 /// Generic ARMv8 CPU interface
@@ -36,10 +35,8 @@ public:
     YUZU_NON_COPYABLE(ARM_Interface);
     YUZU_NON_MOVEABLE(ARM_Interface);
 
-    explicit ARM_Interface(System& system_, CPUInterrupts& interrupt_handlers_,
-                           bool uses_wall_clock_)
-        : system{system_}, interrupt_handlers{interrupt_handlers_}, uses_wall_clock{
-                                                                        uses_wall_clock_} {}
+    explicit ARM_Interface(System& system_, bool uses_wall_clock_)
+        : system{system_}, uses_wall_clock{uses_wall_clock_} {}
     virtual ~ARM_Interface() = default;
 
     struct ThreadContext32 {
@@ -181,6 +178,9 @@ public:
     /// Signal an interrupt and ask the core to halt as soon as possible.
     virtual void SignalInterrupt() = 0;
 
+    /// Clear a previous interrupt.
+    virtual void ClearInterrupt() = 0;
+
     struct BacktraceEntry {
         std::string module;
         u64 address;
@@ -208,7 +208,6 @@ public:
 protected:
     /// System context that this ARM interface is running under.
     System& system;
-    CPUInterrupts& interrupt_handlers;
     const WatchpointArray* watchpoints;
     bool uses_wall_clock;
 
diff --git a/src/core/arm/cpu_interrupt_handler.cpp b/src/core/arm/cpu_interrupt_handler.cpp
deleted file mode 100644
index 77b6194d7..000000000
--- a/src/core/arm/cpu_interrupt_handler.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/thread.h"
-#include "core/arm/cpu_interrupt_handler.h"
-
-namespace Core {
-
-CPUInterruptHandler::CPUInterruptHandler() : interrupt_event{std::make_unique<Common::Event>()} {}
-
-CPUInterruptHandler::~CPUInterruptHandler() = default;
-
-void CPUInterruptHandler::SetInterrupt(bool is_interrupted_) {
-    if (is_interrupted_) {
-        interrupt_event->Set();
-    }
-    is_interrupted = is_interrupted_;
-}
-
-void CPUInterruptHandler::AwaitInterrupt() {
-    interrupt_event->Wait();
-}
-
-} // namespace Core
diff --git a/src/core/arm/cpu_interrupt_handler.h b/src/core/arm/cpu_interrupt_handler.h
deleted file mode 100644
index 286e12e53..000000000
--- a/src/core/arm/cpu_interrupt_handler.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <memory>
-
-namespace Common {
-class Event;
-}
-
-namespace Core {
-
-class CPUInterruptHandler {
-public:
-    CPUInterruptHandler();
-    ~CPUInterruptHandler();
-
-    CPUInterruptHandler(const CPUInterruptHandler&) = delete;
-    CPUInterruptHandler& operator=(const CPUInterruptHandler&) = delete;
-
-    CPUInterruptHandler(CPUInterruptHandler&&) = delete;
-    CPUInterruptHandler& operator=(CPUInterruptHandler&&) = delete;
-
-    bool IsInterrupted() const {
-        return is_interrupted;
-    }
-
-    void SetInterrupt(bool is_interrupted);
-
-    void AwaitInterrupt();
-
-private:
-    std::unique_ptr<Common::Event> interrupt_event;
-    std::atomic_bool is_interrupted{false};
-};
-
-} // namespace Core
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
index b8d2ce224..1638bc41d 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -11,7 +11,6 @@
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
-#include "core/arm/cpu_interrupt_handler.h"
 #include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
@@ -125,7 +124,9 @@ public:
     }
 
     void AddTicks(u64 ticks) override {
-        ASSERT_MSG(!parent.uses_wall_clock, "This should never happen - dynarmic ticking disabled");
+        if (parent.uses_wall_clock) {
+            return;
+        }
 
         // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
         // rough approximation of the amount of executed ticks in the system, it may be thrown off
@@ -142,7 +143,12 @@ public:
     }
 
     u64 GetTicksRemaining() override {
-        ASSERT_MSG(!parent.uses_wall_clock, "This should never happen - dynarmic ticking disabled");
+        if (parent.uses_wall_clock) {
+            if (!IsInterrupted()) {
+                return minimum_run_cycles;
+            }
+            return 0U;
+        }
 
         return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
     }
@@ -168,11 +174,15 @@ public:
         parent.jit.load()->HaltExecution(hr);
     }
 
+    bool IsInterrupted() {
+        return parent.system.Kernel().PhysicalCore(parent.core_index).IsInterrupted();
+    }
+
     ARM_Dynarmic_32& parent;
     Core::Memory::Memory& memory;
     std::size_t num_interpreted_instructions{};
     bool debugger_enabled{};
-    static constexpr u64 minimum_run_cycles = 1000U;
+    static constexpr u64 minimum_run_cycles = 10000U;
 };
 
 std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* page_table) const {
@@ -200,7 +210,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
 
     // Timing
     config.wall_clock_cntpct = uses_wall_clock;
-    config.enable_cycle_counting = !uses_wall_clock;
+    config.enable_cycle_counting = true;
 
     // Code cache size
     config.code_cache_size = 512_MiB;
@@ -311,11 +321,9 @@ void ARM_Dynarmic_32::RewindBreakpointInstruction() {
     LoadContext(breakpoint_context);
 }
 
-ARM_Dynarmic_32::ARM_Dynarmic_32(System& system_, CPUInterrupts& interrupt_handlers_,
-                                 bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
-                                 std::size_t core_index_)
-    : ARM_Interface{system_, interrupt_handlers_, uses_wall_clock_},
-      cb(std::make_unique<DynarmicCallbacks32>(*this)),
+ARM_Dynarmic_32::ARM_Dynarmic_32(System& system_, bool uses_wall_clock_,
+                                 ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_)
+    : ARM_Interface{system_, uses_wall_clock_}, cb(std::make_unique<DynarmicCallbacks32>(*this)),
       cp15(std::make_shared<DynarmicCP15>(*this)), core_index{core_index_},
       exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor_)},
       null_jit{MakeJit(nullptr)}, jit{null_jit.get()} {}
@@ -394,6 +402,10 @@ void ARM_Dynarmic_32::SignalInterrupt() {
     jit.load()->HaltExecution(break_loop);
 }
 
+void ARM_Dynarmic_32::ClearInterrupt() {
+    jit.load()->ClearHalt(break_loop);
+}
+
 void ARM_Dynarmic_32::ClearInstructionCache() {
     jit.load()->ClearCache();
 }
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.h b/src/core/arm/dynarmic/arm_dynarmic_32.h
index 346e9abf8..d24ba2289 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@@ -28,8 +28,8 @@ class System;
 
 class ARM_Dynarmic_32 final : public ARM_Interface {
 public:
-    ARM_Dynarmic_32(System& system_, CPUInterrupts& interrupt_handlers_, bool uses_wall_clock_,
-                    ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_);
+    ARM_Dynarmic_32(System& system_, bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
+                    std::size_t core_index_);
     ~ARM_Dynarmic_32() override;
 
     void SetPC(u64 pc) override;
@@ -56,6 +56,7 @@ public:
     void LoadContext(const ThreadContext64& ctx) override {}
 
     void SignalInterrupt() override;
+    void ClearInterrupt() override;
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
index 1a4d37cbc..921a5a734 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -10,7 +10,6 @@
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
-#include "core/arm/cpu_interrupt_handler.h"
 #include "core/arm/dynarmic/arm_dynarmic_64.h"
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/core.h"
@@ -166,7 +165,9 @@ public:
     }
 
     void AddTicks(u64 ticks) override {
-        ASSERT_MSG(!parent.uses_wall_clock, "This should never happen - dynarmic ticking disabled");
+        if (parent.uses_wall_clock) {
+            return;
+        }
 
         // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
         // rough approximation of the amount of executed ticks in the system, it may be thrown off
@@ -181,7 +182,12 @@ public:
     }
 
     u64 GetTicksRemaining() override {
-        ASSERT_MSG(!parent.uses_wall_clock, "This should never happen - dynarmic ticking disabled");
+        if (parent.uses_wall_clock) {
+            if (!IsInterrupted()) {
+                return minimum_run_cycles;
+            }
+            return 0U;
+        }
 
         return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
     }
@@ -211,12 +217,16 @@ public:
         parent.jit.load()->HaltExecution(hr);
     }
 
+    bool IsInterrupted() {
+        return parent.system.Kernel().PhysicalCore(parent.core_index).IsInterrupted();
+    }
+
     ARM_Dynarmic_64& parent;
     Core::Memory::Memory& memory;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
     bool debugger_enabled{};
-    static constexpr u64 minimum_run_cycles = 1000U;
+    static constexpr u64 minimum_run_cycles = 10000U;
 };
 
 std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* page_table,
@@ -260,7 +270,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
 
     // Timing
     config.wall_clock_cntpct = uses_wall_clock;
-    config.enable_cycle_counting = !uses_wall_clock;
+    config.enable_cycle_counting = true;
 
     // Code cache size
     config.code_cache_size = 512_MiB;
@@ -371,10 +381,9 @@ void ARM_Dynarmic_64::RewindBreakpointInstruction() {
     LoadContext(breakpoint_context);
 }
 
-ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,
-                                 bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
-                                 std::size_t core_index_)
-    : ARM_Interface{system_, interrupt_handlers_, uses_wall_clock_},
+ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, bool uses_wall_clock_,
+                                 ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_)
+    : ARM_Interface{system_, uses_wall_clock_},
       cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index_},
       exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor_)},
       null_jit{MakeJit(nullptr, 48)}, jit{null_jit.get()} {}
@@ -461,6 +470,10 @@ void ARM_Dynarmic_64::SignalInterrupt() {
     jit.load()->HaltExecution(break_loop);
 }
 
+void ARM_Dynarmic_64::ClearInterrupt() {
+    jit.load()->ClearHalt(break_loop);
+}
+
 void ARM_Dynarmic_64::ClearInstructionCache() {
     jit.load()->ClearCache();
 }
diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.h b/src/core/arm/dynarmic/arm_dynarmic_64.h
index c77a83ad7..ed1a5eb96 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_64.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h
@@ -20,14 +20,13 @@ class Memory;
 namespace Core {
 
 class DynarmicCallbacks64;
-class CPUInterruptHandler;
 class DynarmicExclusiveMonitor;
 class System;
 
 class ARM_Dynarmic_64 final : public ARM_Interface {
 public:
-    ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_, bool uses_wall_clock_,
-                    ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_);
+    ARM_Dynarmic_64(System& system_, bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
+                    std::size_t core_index_);
     ~ARM_Dynarmic_64() override;
 
     void SetPC(u64 pc) override;
@@ -50,6 +49,7 @@ public:
     void LoadContext(const ThreadContext64& ctx) override;
 
     void SignalInterrupt() override;
+    void ClearInterrupt() override;
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
diff --git a/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp b/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
index e9123c13d..200efe4db 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
@@ -8,6 +8,10 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
 using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords;
@@ -47,12 +51,31 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
         switch (opc2) {
         case 4:
             // CP15_DATA_SYNC_BARRIER
-            // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            return Callback{
+                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#ifdef _MSC_VER
+                    _mm_mfence();
+                    _mm_lfence();
+#else
+                    asm volatile("mfence\n\tlfence\n\t" : : : "memory");
+#endif
+                    return 0;
+                },
+                std::nullopt,
+            };
         case 5:
             // CP15_DATA_MEMORY_BARRIER
-            // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            return Callback{
+                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#ifdef _MSC_VER
+                    _mm_mfence();
+#else
+                    asm volatile("mfence\n\t" : : : "memory");
+#endif
+                    return 0;
+                },
+                std::nullopt,
+            };
         }
     }
 
diff --git a/src/core/arm/dynarmic/arm_dynarmic_cp15.h b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
index 5b2a51636..d90b3e568 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
@@ -35,6 +35,8 @@ public:
     ARM_Dynarmic_32& parent;
     u32 uprw = 0;
     u32 uro = 0;
+
+    friend class ARM_Dynarmic_32;
 };
 
 } // namespace Core
diff --git a/src/core/debugger/debugger.cpp b/src/core/debugger/debugger.cpp
index ac64d2f9d..e42bdd17d 100644
--- a/src/core/debugger/debugger.cpp
+++ b/src/core/debugger/debugger.cpp
@@ -15,6 +15,7 @@
 #include "core/debugger/debugger_interface.h"
 #include "core/debugger/gdbstub.h"
 #include "core/hle/kernel/global_scheduler_context.h"
+#include "core/hle/kernel/k_scheduler.h"
 
 template <typename Readable, typename Buffer, typename Callback>
 static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) {
@@ -230,13 +231,12 @@ private:
     }
 
     void PauseEmulation() {
+        Kernel::KScopedSchedulerLock sl{system.Kernel()};
+
         // Put all threads to sleep on next scheduler round.
         for (auto* thread : ThreadList()) {
             thread->RequestSuspend(Kernel::SuspendType::Debug);
         }
-
-        // Signal an interrupt so that scheduler will fire.
-        system.Kernel().InterruptAllPhysicalCores();
     }
 
     void ResumeEmulation(Kernel::KThread* except = nullptr) {
@@ -253,7 +253,8 @@ private:
 
     template <typename Callback>
     void MarkResumed(Callback&& cb) {
-        std::scoped_lock lk{connection_lock};
+        Kernel::KScopedSchedulerLock sl{system.Kernel()};
+        std::scoped_lock cl{connection_lock};
         stopped = false;
         cb();
     }
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 8c3895937..049602e7d 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
 
@@ -84,18 +85,19 @@ void EmulatedController::ReloadFromSettings() {
         motion_params[index] = Common::ParamPackage(player.motions[index]);
     }
 
+    controller.colors_state.fullkey = {
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
+    };
     controller.colors_state.left = {
-        .body = player.body_color_left,
-        .button = player.button_color_left,
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
     };
-
-    controller.colors_state.right = {
-        .body = player.body_color_right,
-        .button = player.button_color_right,
+    controller.colors_state.left = {
+        .body = GetNpadColor(player.body_color_right),
+        .button = GetNpadColor(player.button_color_right),
     };
 
-    controller.colors_state.fullkey = controller.colors_state.left;
-
     // Other or debug controller should always be a pro controller
     if (npad_id_type != NpadIdType::Other) {
         SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
@@ -949,6 +951,9 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
     // Send a slight vibration to test for rumble support
     output_devices[device_index]->SetVibration(test_vibration);
 
+    // Wait for about 15ms to ensure the controller is ready for the stop command
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
+
     // Stop any vibration and return the result
     return output_devices[device_index]->SetVibration(zero_vibration) ==
            Common::Input::VibrationError::None;
@@ -1310,6 +1315,15 @@ const CameraState& EmulatedController::GetCamera() const {
     return controller.camera_state;
 }
 
+NpadColor EmulatedController::GetNpadColor(u32 color) {
+    return {
+        .r = static_cast<u8>((color >> 16) & 0xFF),
+        .g = static_cast<u8>((color >> 8) & 0xFF),
+        .b = static_cast<u8>(color & 0xFF),
+        .a = 0xff,
+    };
+}
+
 void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
     std::scoped_lock lock{callback_mutex};
     for (const auto& poller_pair : callback_list) {
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index 823c1700c..cbd7c26d3 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -425,6 +425,13 @@ private:
     void SetCamera(const Common::Input::CallbackStatus& callback);
 
     /**
+     * Converts a color format from bgra to rgba
+     * @param color in bgra format
+     * @return NpadColor in rgba format
+     */
+    NpadColor GetNpadColor(u32 color);
+
+    /**
      * Triggers a callback that something has changed on the controller status
      * @param type Input type of the event to trigger
      * @param is_service_update indicates if this event should only be sent to HID services
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index e49223016..e3b1cfbc6 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -327,10 +327,18 @@ struct TouchState {
 };
 static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
 
+struct NpadColor {
+    u8 r{};
+    u8 g{};
+    u8 b{};
+    u8 a{};
+};
+static_assert(sizeof(NpadColor) == 4, "NpadColor is an invalid size");
+
 // This is nn::hid::NpadControllerColor
 struct NpadControllerColor {
-    u32 body{};
-    u32 button{};
+    NpadColor body{};
+    NpadColor button{};
 };
 static_assert(sizeof(NpadControllerColor) == 8, "NpadControllerColor is an invalid size");
 
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index f4072e1c3..ce7fa8275 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -17,7 +17,6 @@
 #include "common/thread.h"
 #include "common/thread_worker.h"
 #include "core/arm/arm_interface.h"
-#include "core/arm/cpu_interrupt_handler.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
@@ -82,7 +81,7 @@ struct KernelCore::Impl {
 
     void InitializeCores() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            cores[core_id].Initialize((*current_process).Is64BitProcess());
+            cores[core_id]->Initialize((*current_process).Is64BitProcess());
             system.Memory().SetCurrentPageTable(*current_process, core_id);
         }
     }
@@ -100,7 +99,9 @@ struct KernelCore::Impl {
         next_user_process_id = KProcess::ProcessIDMin;
         next_thread_id = 1;
 
-        cores.clear();
+        for (auto& core : cores) {
+            core = nullptr;
+        }
 
         global_handle_table->Finalize();
         global_handle_table.reset();
@@ -199,7 +200,7 @@ struct KernelCore::Impl {
             const s32 core{static_cast<s32>(i)};
 
             schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel());
-            cores.emplace_back(i, system, *schedulers[i], interrupts);
+            cores[i] = std::make_unique<Kernel::PhysicalCore>(i, system, *schedulers[i]);
 
             auto* main_thread{Kernel::KThread::Create(system.Kernel())};
             main_thread->SetName(fmt::format("MainThread:{}", core));
@@ -761,7 +762,7 @@ struct KernelCore::Impl {
     std::unordered_set<KAutoObject*> registered_in_use_objects;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
-    std::vector<Kernel::PhysicalCore> cores;
+    std::array<std::unique_ptr<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores;
 
     // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
     std::atomic<u32> next_host_thread_id{Core::Hardware::NUM_CPU_CORES};
@@ -785,7 +786,6 @@ struct KernelCore::Impl {
     Common::ThreadWorker service_threads_manager;
 
     std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads;
-    std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
     bool is_multicore{};
@@ -874,11 +874,11 @@ const Kernel::KScheduler& KernelCore::Scheduler(std::size_t id) const {
 }
 
 Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) {
-    return impl->cores[id];
+    return *impl->cores[id];
 }
 
 const Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) const {
-    return impl->cores[id];
+    return *impl->cores[id];
 }
 
 size_t KernelCore::CurrentPhysicalCoreIndex() const {
@@ -890,11 +890,11 @@ size_t KernelCore::CurrentPhysicalCoreIndex() const {
 }
 
 Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() {
-    return impl->cores[CurrentPhysicalCoreIndex()];
+    return *impl->cores[CurrentPhysicalCoreIndex()];
 }
 
 const Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() const {
-    return impl->cores[CurrentPhysicalCoreIndex()];
+    return *impl->cores[CurrentPhysicalCoreIndex()];
 }
 
 Kernel::KScheduler* KernelCore::CurrentScheduler() {
@@ -906,15 +906,6 @@ Kernel::KScheduler* KernelCore::CurrentScheduler() {
     return impl->schedulers[core_id].get();
 }
 
-std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& KernelCore::Interrupts() {
-    return impl->interrupts;
-}
-
-const std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& KernelCore::Interrupts()
-    const {
-    return impl->interrupts;
-}
-
 Kernel::TimeManager& KernelCore::TimeManager() {
     return impl->time_manager;
 }
@@ -939,24 +930,18 @@ const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const {
     return *impl->global_object_list_container;
 }
 
-void KernelCore::InterruptAllPhysicalCores() {
-    for (auto& physical_core : impl->cores) {
-        physical_core.Interrupt();
-    }
-}
-
 void KernelCore::InvalidateAllInstructionCaches() {
     for (auto& physical_core : impl->cores) {
-        physical_core.ArmInterface().ClearInstructionCache();
+        physical_core->ArmInterface().ClearInstructionCache();
     }
 }
 
 void KernelCore::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
     for (auto& physical_core : impl->cores) {
-        if (!physical_core.IsInitialized()) {
+        if (!physical_core->IsInitialized()) {
             continue;
         }
-        physical_core.ArmInterface().InvalidateCacheRange(addr, size);
+        physical_core->ArmInterface().InvalidateCacheRange(addr, size);
     }
 }
 
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 6c7cf6af2..bcf016a97 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -9,14 +9,12 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
-#include "core/arm/cpu_interrupt_handler.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_slab_heap.h"
 #include "core/hle/kernel/svc_common.h"
 
 namespace Core {
-class CPUInterruptHandler;
 class ExclusiveMonitor;
 class System;
 } // namespace Core
@@ -183,12 +181,6 @@ public:
 
     const KAutoObjectWithListContainer& ObjectListContainer() const;
 
-    std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& Interrupts();
-
-    const std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& Interrupts() const;
-
-    void InterruptAllPhysicalCores();
-
     void InvalidateAllInstructionCaches();
 
     void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp
index 6e7dacf97..d4375962f 100644
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -1,7 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/arm/cpu_interrupt_handler.h"
 #include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/arm_dynarmic_64.h"
 #include "core/core.h"
@@ -11,16 +10,14 @@
 
 namespace Kernel {
 
-PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_,
-                           Core::CPUInterrupts& interrupts_)
-    : core_index{core_index_}, system{system_}, scheduler{scheduler_},
-      interrupts{interrupts_}, guard{std::make_unique<std::mutex>()} {
+PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_)
+    : core_index{core_index_}, system{system_}, scheduler{scheduler_} {
 #ifdef ARCHITECTURE_x86_64
     // TODO(bunnei): Initialization relies on a core being available. We may later replace this with
     // a 32-bit instance of Dynarmic. This should be abstracted out to a CPU manager.
     auto& kernel = system.Kernel();
     arm_interface = std::make_unique<Core::ARM_Dynarmic_64>(
-        system, interrupts, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);
+        system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);
 #else
 #error Platform not supported yet.
 #endif
@@ -34,7 +31,7 @@ void PhysicalCore::Initialize([[maybe_unused]] bool is_64_bit) {
     if (!is_64_bit) {
         // We already initialized a 64-bit core, replace with a 32-bit one.
         arm_interface = std::make_unique<Core::ARM_Dynarmic_32>(
-            system, interrupts, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);
+            system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);
     }
 #else
 #error Platform not supported yet.
@@ -47,24 +44,26 @@ void PhysicalCore::Run() {
 }
 
 void PhysicalCore::Idle() {
-    interrupts[core_index].AwaitInterrupt();
+    std::unique_lock lk{guard};
+    on_interrupt.wait(lk, [this] { return is_interrupted; });
 }
 
 bool PhysicalCore::IsInterrupted() const {
-    return interrupts[core_index].IsInterrupted();
+    return is_interrupted;
 }
 
 void PhysicalCore::Interrupt() {
-    guard->lock();
-    interrupts[core_index].SetInterrupt(true);
+    std::unique_lock lk{guard};
+    is_interrupted = true;
     arm_interface->SignalInterrupt();
-    guard->unlock();
+    on_interrupt.notify_all();
 }
 
 void PhysicalCore::ClearInterrupt() {
-    guard->lock();
-    interrupts[core_index].SetInterrupt(false);
-    guard->unlock();
+    std::unique_lock lk{guard};
+    is_interrupted = false;
+    arm_interface->ClearInterrupt();
+    on_interrupt.notify_all();
 }
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
index 898d1e5db..2fc8d4be2 100644
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -14,7 +14,6 @@ class KScheduler;
 } // namespace Kernel
 
 namespace Core {
-class CPUInterruptHandler;
 class ExclusiveMonitor;
 class System;
 } // namespace Core
@@ -23,15 +22,11 @@ namespace Kernel {
 
 class PhysicalCore {
 public:
-    PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_,
-                 Core::CPUInterrupts& interrupts_);
+    PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_);
     ~PhysicalCore();
 
-    PhysicalCore(const PhysicalCore&) = delete;
-    PhysicalCore& operator=(const PhysicalCore&) = delete;
-
-    PhysicalCore(PhysicalCore&&) = default;
-    PhysicalCore& operator=(PhysicalCore&&) = delete;
+    YUZU_NON_COPYABLE(PhysicalCore);
+    YUZU_NON_MOVEABLE(PhysicalCore);
 
     /// Initialize the core for the specified parameters.
     void Initialize(bool is_64_bit);
@@ -86,9 +81,11 @@ private:
     const std::size_t core_index;
     Core::System& system;
     Kernel::KScheduler& scheduler;
-    Core::CPUInterrupts& interrupts;
-    std::unique_ptr<std::mutex> guard;
+
+    std::mutex guard;
+    std::condition_variable on_interrupt;
     std::unique_ptr<Core::ARM_Interface> arm_interface;
+    bool is_interrupted;
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 3c28dee76..cb29004e8 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -163,28 +163,51 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
     }
     LOG_DEBUG(Service_HID, "Npad connected {}", npad_id);
     const auto controller_type = controller.device->GetNpadStyleIndex();
+    const auto& body_colors = controller.device->GetColors();
+    const auto& battery_level = controller.device->GetBattery();
     auto* shared_memory = controller.shared_memory;
     if (controller_type == Core::HID::NpadStyleIndex::None) {
         controller.styleset_changed_event->GetWritableEvent().Signal();
         return;
     }
+
+    // Reset memory values
     shared_memory->style_tag.raw = Core::HID::NpadStyleSet::None;
     shared_memory->device_type.raw = 0;
     shared_memory->system_properties.raw = 0;
+    shared_memory->joycon_color.attribute = ColorAttribute::NoController;
+    shared_memory->joycon_color.attribute = ColorAttribute::NoController;
+    shared_memory->fullkey_color = {};
+    shared_memory->joycon_color.left = {};
+    shared_memory->joycon_color.right = {};
+    shared_memory->battery_level_dual = {};
+    shared_memory->battery_level_left = {};
+    shared_memory->battery_level_right = {};
+
     switch (controller_type) {
     case Core::HID::NpadStyleIndex::None:
         ASSERT(false);
         break;
     case Core::HID::NpadStyleIndex::ProController:
+        shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
+        shared_memory->fullkey_color.fullkey = body_colors.fullkey;
+        shared_memory->battery_level_dual = battery_level.dual.battery_level;
         shared_memory->style_tag.fullkey.Assign(1);
         shared_memory->device_type.fullkey.Assign(1);
         shared_memory->system_properties.is_vertical.Assign(1);
         shared_memory->system_properties.use_plus.Assign(1);
         shared_memory->system_properties.use_minus.Assign(1);
+        shared_memory->system_properties.is_charging_joy_dual.Assign(
+            battery_level.dual.is_charging);
         shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::SwitchProController;
         shared_memory->sixaxis_fullkey_properties.is_newly_assigned.Assign(1);
         break;
     case Core::HID::NpadStyleIndex::Handheld:
+        shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
+        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
+        shared_memory->fullkey_color.fullkey = body_colors.fullkey;
+        shared_memory->joycon_color.left = body_colors.left;
+        shared_memory->joycon_color.right = body_colors.right;
         shared_memory->style_tag.handheld.Assign(1);
         shared_memory->device_type.handheld_left.Assign(1);
         shared_memory->device_type.handheld_right.Assign(1);
@@ -192,47 +215,86 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         shared_memory->system_properties.use_plus.Assign(1);
         shared_memory->system_properties.use_minus.Assign(1);
         shared_memory->system_properties.use_directional_buttons.Assign(1);
+        shared_memory->system_properties.is_charging_joy_dual.Assign(
+            battery_level.left.is_charging);
+        shared_memory->system_properties.is_charging_joy_left.Assign(
+            battery_level.left.is_charging);
+        shared_memory->system_properties.is_charging_joy_right.Assign(
+            battery_level.right.is_charging);
         shared_memory->assignment_mode = NpadJoyAssignmentMode::Dual;
         shared_memory->applet_nfc_xcd.applet_footer.type =
             AppletFooterUiType::HandheldJoyConLeftJoyConRight;
         shared_memory->sixaxis_handheld_properties.is_newly_assigned.Assign(1);
         break;
     case Core::HID::NpadStyleIndex::JoyconDual:
+        shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
+        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
         shared_memory->style_tag.joycon_dual.Assign(1);
         if (controller.is_dual_left_connected) {
+            shared_memory->joycon_color.left = body_colors.left;
+            shared_memory->battery_level_left = battery_level.left.battery_level;
             shared_memory->device_type.joycon_left.Assign(1);
             shared_memory->system_properties.use_minus.Assign(1);
+            shared_memory->system_properties.is_charging_joy_left.Assign(
+                battery_level.left.is_charging);
             shared_memory->sixaxis_dual_left_properties.is_newly_assigned.Assign(1);
         }
         if (controller.is_dual_right_connected) {
+            shared_memory->joycon_color.right = body_colors.right;
+            shared_memory->battery_level_right = battery_level.right.battery_level;
             shared_memory->device_type.joycon_right.Assign(1);
             shared_memory->system_properties.use_plus.Assign(1);
+            shared_memory->system_properties.is_charging_joy_right.Assign(
+                battery_level.right.is_charging);
             shared_memory->sixaxis_dual_right_properties.is_newly_assigned.Assign(1);
         }
         shared_memory->system_properties.use_directional_buttons.Assign(1);
         shared_memory->system_properties.is_vertical.Assign(1);
         shared_memory->assignment_mode = NpadJoyAssignmentMode::Dual;
+
         if (controller.is_dual_left_connected && controller.is_dual_right_connected) {
             shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDual;
+            shared_memory->fullkey_color.fullkey = body_colors.left;
+            shared_memory->battery_level_dual = battery_level.left.battery_level;
+            shared_memory->system_properties.is_charging_joy_dual.Assign(
+                battery_level.left.is_charging);
         } else if (controller.is_dual_left_connected) {
             shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDualLeftOnly;
+            shared_memory->fullkey_color.fullkey = body_colors.left;
+            shared_memory->battery_level_dual = battery_level.left.battery_level;
+            shared_memory->system_properties.is_charging_joy_dual.Assign(
+                battery_level.left.is_charging);
         } else {
             shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDualRightOnly;
+            shared_memory->fullkey_color.fullkey = body_colors.right;
+            shared_memory->battery_level_dual = battery_level.right.battery_level;
+            shared_memory->system_properties.is_charging_joy_dual.Assign(
+                battery_level.right.is_charging);
         }
         break;
     case Core::HID::NpadStyleIndex::JoyconLeft:
+        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
+        shared_memory->joycon_color.left = body_colors.left;
+        shared_memory->battery_level_dual = battery_level.left.battery_level;
         shared_memory->style_tag.joycon_left.Assign(1);
         shared_memory->device_type.joycon_left.Assign(1);
         shared_memory->system_properties.is_horizontal.Assign(1);
         shared_memory->system_properties.use_minus.Assign(1);
+        shared_memory->system_properties.is_charging_joy_left.Assign(
+            battery_level.left.is_charging);
         shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyLeftHorizontal;
         shared_memory->sixaxis_left_properties.is_newly_assigned.Assign(1);
         break;
     case Core::HID::NpadStyleIndex::JoyconRight:
+        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
+        shared_memory->joycon_color.right = body_colors.right;
+        shared_memory->battery_level_right = battery_level.right.battery_level;
         shared_memory->style_tag.joycon_right.Assign(1);
         shared_memory->device_type.joycon_right.Assign(1);
         shared_memory->system_properties.is_horizontal.Assign(1);
         shared_memory->system_properties.use_plus.Assign(1);
+        shared_memory->system_properties.is_charging_joy_right.Assign(
+            battery_level.right.is_charging);
         shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyRightHorizontal;
         shared_memory->sixaxis_right_properties.is_newly_assigned.Assign(1);
         break;
@@ -269,21 +331,6 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         break;
     }
 
-    const auto& body_colors = controller.device->GetColors();
-
-    shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
-    shared_memory->fullkey_color.fullkey = body_colors.fullkey;
-
-    shared_memory->joycon_color.attribute = ColorAttribute::Ok;
-    shared_memory->joycon_color.left = body_colors.left;
-    shared_memory->joycon_color.right = body_colors.right;
-
-    // TODO: Investigate when we should report all batery types
-    const auto& battery_level = controller.device->GetBattery();
-    shared_memory->battery_level_dual = battery_level.dual.battery_level;
-    shared_memory->battery_level_left = battery_level.left.battery_level;
-    shared_memory->battery_level_right = battery_level.right.battery_level;
-
     controller.is_connected = true;
     controller.device->Connect();
     SignalStyleSetChangedEvent(npad_id);
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index fa8efd22e..a69ae7725 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -33,9 +33,10 @@ VkSurfaceFormatKHR ChooseSwapSurfaceFormat(vk::Span<VkSurfaceFormatKHR> formats)
 }
 
 VkPresentModeKHR ChooseSwapPresentMode(vk::Span<VkPresentModeKHR> modes) {
-    // Mailbox doesn't lock the application like fifo (vsync), prefer it
+    // Mailbox (triple buffering) doesn't lock the application like fifo (vsync),
+    // prefer it if vsync option is not selected
     const auto found_mailbox = std::find(modes.begin(), modes.end(), VK_PRESENT_MODE_MAILBOX_KHR);
-    if (found_mailbox != modes.end()) {
+    if (found_mailbox != modes.end() && !Settings::values.use_vsync.GetValue()) {
         return VK_PRESENT_MODE_MAILBOX_KHR;
     }
     if (!Settings::values.use_speed_limit.GetValue()) {
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index f6b389ede..50007338f 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -221,6 +221,9 @@ if (ENABLE_QT_TRANSLATION)
     # Update source TS file if enabled
     if (GENERATE_QT_TRANSLATION)
         get_target_property(SRCS yuzu SOURCES)
+        # these calls to qt_create_translation also creates a rule to generate en.qm which conflicts with providing english plurals
+        # so we have to set a OUTPUT_LOCATION so that we don't have multiple rules to generate en.qm
+        set_source_files_properties(${YUZU_QT_LANGUAGES}/en.ts PROPERTIES OUTPUT_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/translations")
         qt_create_translation(QM_FILES
             ${SRCS}
             ${UIS}
@@ -229,7 +232,13 @@ if (ENABLE_QT_TRANSLATION)
             -source-language en_US
             -target-language en_US
         )
-        add_custom_target(translation ALL DEPENDS ${YUZU_QT_LANGUAGES}/en.ts)
+
+        # Generate plurals into dist/english_plurals/generated_en.ts so it can be used to revise dist/english_plurals/en.ts
+        set(GENERATED_PLURALS_FILE ${PROJECT_SOURCE_DIR}/dist/english_plurals/generated_en.ts)
+        set_source_files_properties(${GENERATED_PLURALS_FILE} PROPERTIES OUTPUT_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/plurals")
+        qt_create_translation(QM_FILES ${SRCS} ${UIS} ${GENERATED_PLURALS_FILE} OPTIONS -pluralonly -source-language en_US -target-language en_US)
+
+        add_custom_target(translation ALL DEPENDS ${YUZU_QT_LANGUAGES}/en.ts ${GENERATED_PLURALS_FILE})
     endif()
 
     # Find all TS files except en.ts
@@ -239,6 +248,9 @@ if (ENABLE_QT_TRANSLATION)
     # Compile TS files to QM files
     qt_add_translation(LANGUAGES_QM ${LANGUAGES_TS})
 
+    # Compile english plurals TS file to en.qm
+    qt_add_translation(LANGUAGES_QM ${PROJECT_SOURCE_DIR}/dist/english_plurals/en.ts)
+
     # Build a QRC file from the QM file list
     set(LANGUAGES_QRC ${CMAKE_CURRENT_BINARY_DIR}/languages.qrc)
     file(WRITE ${LANGUAGES_QRC} "<RCC><qresource prefix=\"languages\">\n")
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index ef3bdfb1a..c262d0a2b 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -1089,8 +1089,8 @@ QStringList GRenderWindow::GetUnsupportedGLExtensions() const {
     }
 
     if (!unsupported_ext.empty()) {
-        LOG_ERROR(Frontend, "GPU does not support all required extensions: {}",
-                  glGetString(GL_RENDERER));
+        const std::string gl_renderer{reinterpret_cast<const char*>(glGetString(GL_RENDERER))};
+        LOG_ERROR(Frontend, "GPU does not support all required extensions: {}", gl_renderer);
     }
     for (const QString& ext : unsupported_ext) {
         LOG_ERROR(Frontend, "Unsupported GL extension: {}", ext.toStdString());
diff --git a/src/yuzu/configuration/configure_graphics_advanced.ui b/src/yuzu/configuration/configure_graphics_advanced.ui
index 96de0b3d1..d6d819364 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.ui
+++ b/src/yuzu/configuration/configure_graphics_advanced.ui
@@ -75,7 +75,7 @@
            <string>VSync prevents the screen from tearing, but some graphics cards have lower performance with VSync enabled. Keep it enabled if you don't notice a performance difference.</string>
           </property>
           <property name="text">
-           <string>Use VSync (OpenGL only)</string>
+           <string>Use VSync</string>
           </property>
          </widget>
         </item>
diff --git a/src/yuzu/configuration/configure_ui.cpp b/src/yuzu/configuration/configure_ui.cpp
index 2e98ede8e..48f71b53c 100644
--- a/src/yuzu/configuration/configure_ui.cpp
+++ b/src/yuzu/configuration/configure_ui.cpp
@@ -219,6 +219,7 @@ void ConfigureUi::InitializeLanguageComboBox() {
     for (const auto& lang : languages) {
         if (QString::fromLatin1(lang.id) == QStringLiteral("en")) {
             ui->language_combobox->addItem(lang.name, QStringLiteral("en"));
+            language_files.removeOne(QStringLiteral("en.qm"));
             continue;
         }
         for (int i = 0; i < language_files.size(); ++i) {
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index dc7b343d9..f82bec3b7 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -3338,7 +3338,8 @@ void GMainWindow::MigrateConfigFiles() {
         }
         const auto origin = config_dir_fs_path / filename;
         const auto destination = config_dir_fs_path / "custom" / filename;
-        LOG_INFO(Frontend, "Migrating config file from {} to {}", origin, destination);
+        LOG_INFO(Frontend, "Migrating config file from {} to {}", origin.string(),
+                 destination.string());
         if (!Common::FS::RenameFile(origin, destination)) {
             // Delete the old config file if one already exists in the new location.
             Common::FS::RemoveFile(origin);
@@ -3979,11 +3980,6 @@ void GMainWindow::UpdateUITheme() {
 }
 
 void GMainWindow::LoadTranslation() {
-    // If the selected language is English, no need to install any translation
-    if (UISettings::values.language == QStringLiteral("en")) {
-        return;
-    }
-
     bool loaded;
 
     if (UISettings::values.language.isEmpty()) {
@@ -4071,6 +4067,15 @@ int main(int argc, char* argv[]) {
     QCoreApplication::setAttribute(Qt::AA_DontCheckOpenGLContextThreadAffinity);
     QApplication app(argc, argv);
 
+    // Workaround for QTBUG-85409, for Suzhou numerals the number 1 is actually \u3021
+    // so we can see if we get \u3008 instead
+    // TL;DR all other number formats are consecutive in unicode code points
+    // This bug is fixed in Qt6, specifically 6.0.0-alpha1
+    const QLocale locale = QLocale::system();
+    if (QStringLiteral("\u3008") == locale.toString(1)) {
+        QLocale::setDefault(QLocale::system().name());
+    }
+
     // Qt changes the locale and causes issues in float conversion using std::to_string() when
     // generating shaders
     setlocale(LC_ALL, "C");