npad: Disable vibration check if disabled

core,common,yuzu qt: Add CPU accuracy option 'Auto'

dist/qt_themes/default/style.qss

@@ -38,26 +38,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #0066ff;
 }
 
-QPushButton#GPUStatusBarButton {
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 21px;
     min-height: 21px;

dist/qt_themes/qdarkstyle/style.qss

@@ -1283,27 +1283,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 23px;
     min-height: 23px;

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -2186,27 +2186,6 @@ QPushButton#RendererStatusBarButton:!checked {
   color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-  min-width: 0px;
-  color: #656565;
-  border: 1px solid transparent;
-  background-color: transparent;
-  padding: 0px 3px 0px 3px;
-  text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-  border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-  color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-  color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
   min-width: 19px;
   min-height: 19px;

src/common/CMakeLists.txt

@@ -180,7 +180,6 @@ add_library(common STATIC
     thread.cpp
     thread.h
     thread_queue_list.h
-    thread_worker.cpp
     thread_worker.h
     threadsafe_queue.h
     time_zone.cpp
@@ -188,6 +187,7 @@ add_library(common STATIC
     tiny_mt.h
     tree.h
     uint128.h
+    unique_function.h
     uuid.cpp
     uuid.h
     vector_math.h

src/common/settings.cpp

@@ -93,7 +93,7 @@ bool IsGPULevelHigh() {
 }
 
 bool IsFastmemEnabled() {
-    if (values.cpu_accuracy.GetValue() == CPUAccuracy::DebugMode) {
+    if (values.cpu_debug_mode) {
         return static_cast<bool>(values.cpuopt_fastmem);
     }
     return true;

src/common/settings.h

@@ -31,9 +31,9 @@ enum class GPUAccuracy : u32 {
 };
 
 enum class CPUAccuracy : u32 {
-    Accurate = 0,
-    Unsafe = 1,
-    DebugMode = 2,
+    Auto = 0,
+    Accurate = 1,
+    Unsafe = 2,
 };
 
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
@@ -284,7 +284,10 @@ struct Values {
     Setting<bool> use_multi_core{true, "use_multi_core"};
 
     // Cpu
-    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Accurate, "cpu_accuracy"};
+    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, "cpu_accuracy"};
+    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
+    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
+    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
 
     BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
     BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};

src/common/thread_worker.cpp

@@ -1,58 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/thread.h"
-#include "common/thread_worker.h"
-
-namespace Common {
-
-ThreadWorker::ThreadWorker(std::size_t num_workers, const std::string& name) {
-    for (std::size_t i = 0; i < num_workers; ++i)
-        threads.emplace_back([this, thread_name{std::string{name}}] {
-            Common::SetCurrentThreadName(thread_name.c_str());
-
-            // Wait for first request
-            {
-                std::unique_lock lock{queue_mutex};
-                condition.wait(lock, [this] { return stop || !requests.empty(); });
-            }
-
-            while (true) {
-                std::function<void()> task;
-
-                {
-                    std::unique_lock lock{queue_mutex};
-                    condition.wait(lock, [this] { return stop || !requests.empty(); });
-                    if (stop || requests.empty()) {
-                        return;
-                    }
-                    task = std::move(requests.front());
-                    requests.pop();
-                }
-
-                task();
-            }
-        });
-}
-
-ThreadWorker::~ThreadWorker() {
-    {
-        std::unique_lock lock{queue_mutex};
-        stop = true;
-    }
-    condition.notify_all();
-    for (std::thread& thread : threads) {
-        thread.join();
-    }
-}
-
-void ThreadWorker::QueueWork(std::function<void()>&& work) {
-    {
-        std::unique_lock lock{queue_mutex};
-        requests.emplace(work);
-    }
-    condition.notify_one();
-}
-
-} // namespace Common

src/common/thread_worker.h

@@ -7,24 +7,110 @@
 #include <atomic>
 #include <functional>
 #include <mutex>
+#include <stop_token>
 #include <string>
+#include <thread>
+#include <type_traits>
 #include <vector>
 #include <queue>
 
+#include "common/thread.h"
+#include "common/unique_function.h"
+
 namespace Common {
 
-class ThreadWorker final {
+template <class StateType = void>
+class StatefulThreadWorker {
+    static constexpr bool with_state = !std::is_same_v<StateType, void>;
+
+    struct DummyCallable {
+        int operator()() const noexcept {
+            return 0;
+        }
+    };
+
+    using Task =
+        std::conditional_t<with_state, UniqueFunction<void, StateType*>, UniqueFunction<void>>;
+    using StateMaker = std::conditional_t<with_state, std::function<StateType()>, DummyCallable>;
+
 public:
-    explicit ThreadWorker(std::size_t num_workers, const std::string& name);
-    ~ThreadWorker();
-    void QueueWork(std::function<void()>&& work);
+    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})
+        : workers_queued{num_workers}, thread_name{std::move(name)} {
+        const auto lambda = [this, func](std::stop_token stop_token) {
+            Common::SetCurrentThreadName(thread_name.c_str());
+            {
+                std::conditional_t<with_state, StateType, int> state{func()};
+                while (!stop_token.stop_requested()) {
+                    Task task;
+                    {
+                        std::unique_lock lock{queue_mutex};
+                        if (requests.empty()) {
+                            wait_condition.notify_all();
+                        }
+                        condition.wait(lock, stop_token, [this] { return !requests.empty(); });
+                        if (stop_token.stop_requested()) {
+                            break;
+                        }
+                        task = std::move(requests.front());
+                        requests.pop();
+                    }
+                    if constexpr (with_state) {
+                        task(&state);
+                    } else {
+                        task();
+                    }
+                    ++work_done;
+                }
+            }
+            ++workers_stopped;
+            wait_condition.notify_all();
+        };
+        threads.reserve(num_workers);
+        for (size_t i = 0; i < num_workers; ++i) {
+            threads.emplace_back(lambda);
+        }
+    }
+
+    StatefulThreadWorker& operator=(const StatefulThreadWorker&) = delete;
+    StatefulThreadWorker(const StatefulThreadWorker&) = delete;
+
+    StatefulThreadWorker& operator=(StatefulThreadWorker&&) = delete;
+    StatefulThreadWorker(StatefulThreadWorker&&) = delete;
+
+    void QueueWork(Task work) {
+        {
+            std::unique_lock lock{queue_mutex};
+            requests.emplace(std::move(work));
+            ++work_scheduled;
+        }
+        condition.notify_one();
+    }
+
+    void WaitForRequests(std::stop_token stop_token = {}) {
+        std::stop_callback callback(stop_token, [this] {
+            for (auto& thread : threads) {
+                thread.request_stop();
+            }
+        });
+        std::unique_lock lock{queue_mutex};
+        wait_condition.wait(lock, [this] {
+            return workers_stopped >= workers_queued || work_done >= work_scheduled;
+        });
+    }
 
 private:
-    std::vector<std::thread> threads;
-    std::queue<std::function<void()>> requests;
+    std::queue<Task> requests;
     std::mutex queue_mutex;
-    std::condition_variable condition;
-    std::atomic_bool stop{};
+    std::condition_variable_any condition;
+    std::condition_variable wait_condition;
+    std::atomic<size_t> work_scheduled{};
+    std::atomic<size_t> work_done{};
+    std::atomic<size_t> workers_stopped{};
+    std::atomic<size_t> workers_queued{};
+    std::string thread_name;
+    std::vector<std::jthread> threads;
 };
 
+using ThreadWorker = StatefulThreadWorker<>;
+
 } // namespace Common

src/common/unique_function.h

@@ -0,0 +1,62 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+namespace Common {
+
+/// General purpose function wrapper similar to std::function.
+/// Unlike std::function, the captured values don't have to be copyable.
+/// This class can be moved but not copied.
+template <typename ResultType, typename... Args>
+class UniqueFunction {
+    class CallableBase {
+    public:
+        virtual ~CallableBase() = default;
+        virtual ResultType operator()(Args&&...) = 0;
+    };
+
+    template <typename Functor>
+    class Callable final : public CallableBase {
+    public:
+        Callable(Functor&& functor_) : functor{std::move(functor_)} {}
+        ~Callable() override = default;
+
+        ResultType operator()(Args&&... args) override {
+            return functor(std::forward<Args>(args)...);
+        }
+
+    private:
+        Functor functor;
+    };
+
+public:
+    UniqueFunction() = default;
+
+    template <typename Functor>
+    UniqueFunction(Functor&& functor)
+        : callable{std::make_unique<Callable<Functor>>(std::move(functor))} {}
+
+    UniqueFunction& operator=(UniqueFunction&& rhs) noexcept = default;
+    UniqueFunction(UniqueFunction&& rhs) noexcept = default;
+
+    UniqueFunction& operator=(const UniqueFunction&) = delete;
+    UniqueFunction(const UniqueFunction&) = delete;
+
+    ResultType operator()(Args&&... args) const {
+        return (*callable)(std::forward<Args>(args)...);
+    }
+
+    explicit operator bool() const noexcept {
+        return static_cast<bool>(callable);
+    }
+
+private:
+    std::unique_ptr<CallableBase> callable;
+};
+
+} // namespace Common

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -150,7 +150,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.far_code_offset = 400_MiB;
 
     // Safe optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
+    if (Settings::values.cpu_debug_mode) {
         if (!Settings::values.cpuopt_page_tables) {
             config.page_table = nullptr;
         }
@@ -183,20 +183,28 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     // Unsafe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
         config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
         }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
     }
 
+    // Curated optimizations
+    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
+        config.unsafe_optimizations = true;
+        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
+        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
+        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
+    }
+
     return std::make_unique<Dynarmic::A32::Jit>(config);
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -190,7 +190,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     config.far_code_offset = 400_MiB;
 
     // Safe optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
+    if (Settings::values.cpu_debug_mode) {
         if (!Settings::values.cpuopt_page_tables) {
             config.page_table = nullptr;
         }
@@ -223,20 +223,28 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     // Unsafe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
         config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
-        if (Settings::values.cpuopt_unsafe_fastmem_check.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_fastmem_check) {
             config.fastmem_address_space_bits = 64;
         }
     }
 
+    // Curated optimizations
+    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
+        config.unsafe_optimizations = true;
+        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
+        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
+        config.fastmem_address_space_bits = 64;
+    }
+
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
 

src/core/hle/service/hid/controllers/npad.cpp

@@ -941,6 +941,11 @@ void Controller_NPad::InitializeVibrationDevice(const DeviceHandle& vibration_de
 
 void Controller_NPad::InitializeVibrationDeviceAtIndex(std::size_t npad_index,
                                                        std::size_t device_index) {
+    if (!Settings::values.vibration_enabled.GetValue()) {
+        vibration_devices_mounted[npad_index][device_index] = false;
+        return;
+    }
+
     if (vibrations[npad_index][device_index]) {
         vibration_devices_mounted[npad_index][device_index] =
             vibrations[npad_index][device_index]->GetStatus() == 1;

src/tests/CMakeLists.txt

@@ -5,6 +5,7 @@ add_executable(tests
     common/host_memory.cpp
     common/param_package.cpp
     common/ring_buffer.cpp
+    common/unique_function.cpp
     core/core_timing.cpp
     core/network/network.cpp
     tests.cpp

src/tests/common/unique_function.cpp

@@ -0,0 +1,108 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+
+#include <catch2/catch.hpp>
+
+#include "common/unique_function.h"
+
+namespace {
+struct Noisy {
+    Noisy() : state{"Default constructed"} {}
+    Noisy(Noisy&& rhs) noexcept : state{"Move constructed"} {
+        rhs.state = "Moved away";
+    }
+    Noisy& operator=(Noisy&& rhs) noexcept {
+        state = "Move assigned";
+        rhs.state = "Moved away";
+    }
+    Noisy(const Noisy&) : state{"Copied constructed"} {}
+    Noisy& operator=(const Noisy&) {
+        state = "Copied assigned";
+    }
+
+    std::string state;
+};
+} // Anonymous namespace
+
+TEST_CASE("UniqueFunction", "[common]") {
+    SECTION("Capture reference") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Capture pointer") {
+        int value = 0;
+        int* pointer = &value;
+        Common::UniqueFunction<void> func = [pointer] { *pointer = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Move object") {
+        Noisy noisy;
+        REQUIRE(noisy.state == "Default constructed");
+
+        Common::UniqueFunction<void> func = [noisy = std::move(noisy)] {
+            REQUIRE(noisy.state == "Move constructed");
+        };
+        REQUIRE(noisy.state == "Moved away");
+        func();
+    }
+    SECTION("Move construct function") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        Common::UniqueFunction<void> new_func = std::move(func);
+        new_func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Move assign function") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        Common::UniqueFunction<void> new_func;
+        new_func = std::move(func);
+        new_func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Default construct then assign function") {
+        int value = 0;
+        Common::UniqueFunction<void> func;
+        func = [&value] { value = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Pass arguments") {
+        int result = 0;
+        Common::UniqueFunction<void, int, int> func = [&result](int a, int b) { result = a + b; };
+        func(5, 4);
+        REQUIRE(result == 9);
+    }
+    SECTION("Pass arguments and return value") {
+        Common::UniqueFunction<int, int, int> func = [](int a, int b) { return a + b; };
+        REQUIRE(func(5, 4) == 9);
+    }
+    SECTION("Destructor") {
+        int num_destroyed = 0;
+        struct Foo {
+            Foo(int* num_) : num{num_} {}
+            Foo(Foo&& rhs) : num{std::exchange(rhs.num, nullptr)} {}
+            Foo(const Foo&) = delete;
+
+            ~Foo() {
+                if (num) {
+                    ++*num;
+                }
+            }
+
+            int* num = nullptr;
+        };
+        Foo object{&num_destroyed};
+        {
+            Common::UniqueFunction<void> func = [object = std::move(object)] {};
+            REQUIRE(num_destroyed == 0);
+        }
+        REQUIRE(num_destroyed == 1);
+    }
+}

src/yuzu/CMakeLists.txt

@@ -52,6 +52,9 @@ add_executable(yuzu
     configuration/configure_debug_controller.cpp
     configuration/configure_debug_controller.h
     configuration/configure_debug_controller.ui
+    configuration/configure_debug_tab.cpp
+    configuration/configure_debug_tab.h
+    configuration/configure_debug_tab.ui
     configuration/configure_dialog.cpp
     configuration/configure_dialog.h
     configuration/configure_filesystem.cpp

src/yuzu/configuration/config.cpp

@@ -793,7 +793,13 @@ void Config::ReadPathValues() {
 void Config::ReadCpuValues() {
     qt_config->beginGroup(QStringLiteral("Cpu"));
 
-    ReadGlobalSetting(Settings::values.cpu_accuracy);
+    ReadBasicSetting(Settings::values.cpu_accuracy_first_time);
+    if (Settings::values.cpu_accuracy_first_time) {
+        Settings::values.cpu_accuracy.SetValue(Settings::values.cpu_accuracy.GetDefault());
+        Settings::values.cpu_accuracy_first_time.SetValue(false);
+    } else {
+        ReadGlobalSetting(Settings::values.cpu_accuracy);
+    }
 
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_unfuse_fma);
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_reduce_fp_error);
@@ -802,6 +808,7 @@ void Config::ReadCpuValues() {
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
 
     if (global) {
+        ReadBasicSetting(Settings::values.cpu_debug_mode);
         ReadBasicSetting(Settings::values.cpuopt_page_tables);
         ReadBasicSetting(Settings::values.cpuopt_block_linking);
         ReadBasicSetting(Settings::values.cpuopt_return_stack_buffer);
@@ -820,7 +827,6 @@ void Config::ReadRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
     ReadGlobalSetting(Settings::values.renderer_backend);
-    ReadBasicSetting(Settings::values.renderer_debug);
     ReadGlobalSetting(Settings::values.vulkan_device);
     ReadGlobalSetting(Settings::values.fullscreen_mode);
     ReadGlobalSetting(Settings::values.aspect_ratio);
@@ -842,6 +848,10 @@ void Config::ReadRendererValues() {
     ReadGlobalSetting(Settings::values.bg_green);
     ReadGlobalSetting(Settings::values.bg_blue);
 
+    if (global) {
+        ReadBasicSetting(Settings::values.renderer_debug);
+    }
+
     qt_config->endGroup();
 }
 
@@ -1309,6 +1319,7 @@ void Config::SavePathValues() {
 void Config::SaveCpuValues() {
     qt_config->beginGroup(QStringLiteral("Cpu"));
 
+    WriteBasicSetting(Settings::values.cpu_accuracy_first_time);
     WriteSetting(QStringLiteral("cpu_accuracy"),
                  static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)),
                  static_cast<u32>(Settings::values.cpu_accuracy.GetDefault()),
@@ -1321,6 +1332,7 @@ void Config::SaveCpuValues() {
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
 
     if (global) {
+        WriteBasicSetting(Settings::values.cpu_debug_mode);
         WriteBasicSetting(Settings::values.cpuopt_page_tables);
         WriteBasicSetting(Settings::values.cpuopt_block_linking);
         WriteBasicSetting(Settings::values.cpuopt_return_stack_buffer);
@@ -1342,7 +1354,6 @@ void Config::SaveRendererValues() {
                  static_cast<u32>(Settings::values.renderer_backend.GetValue(global)),
                  static_cast<u32>(Settings::values.renderer_backend.GetDefault()),
                  Settings::values.renderer_backend.UsingGlobal());
-    WriteBasicSetting(Settings::values.renderer_debug);
     WriteGlobalSetting(Settings::values.vulkan_device);
     WriteGlobalSetting(Settings::values.fullscreen_mode);
     WriteGlobalSetting(Settings::values.aspect_ratio);
@@ -1367,6 +1378,10 @@ void Config::SaveRendererValues() {
     WriteGlobalSetting(Settings::values.bg_green);
     WriteGlobalSetting(Settings::values.bg_blue);
 
+    if (global) {
+        WriteBasicSetting(Settings::values.renderer_debug);
+    }
+
     qt_config->endGroup();
 }
 

src/yuzu/configuration/configure.ui

@@ -41,7 +41,7 @@
      <item>
       <widget class="QTabWidget" name="tabWidget">
        <property name="currentIndex">
-        <number>0</number>
+        <number>11</number>
        </property>
        <widget class="ConfigureGeneral" name="generalTab">
         <property name="accessibleName">
@@ -107,14 +107,6 @@
          <string>CPU</string>
         </attribute>
        </widget>
-       <widget class="ConfigureCpuDebug" name="cpuDebugTab">
-        <property name="accessibleName">
-         <string>Debug</string>
-        </property>
-        <attribute name="title">
-         <string>Debug</string>
-        </attribute>
-       </widget>
        <widget class="ConfigureGraphics" name="graphicsTab">
         <property name="accessibleName">
          <string>Graphics</string>
@@ -139,7 +131,7 @@
          <string>Audio</string>
         </attribute>
        </widget>
-       <widget class="ConfigureDebug" name="debugTab">
+       <widget class="ConfigureDebugTab" name="debugTab">
         <property name="accessibleName">
          <string>Debug</string>
         </property>
@@ -207,24 +199,12 @@
    <header>configuration/configure_audio.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureDebug</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_debug.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureCpu</class>
    <extends>QWidget</extends>
    <header>configuration/configure_cpu.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureCpuDebug</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_cpu_debug.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureGraphics</class>
    <extends>QWidget</extends>
@@ -267,6 +247,12 @@
    <header>configuration/configure_service.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>ConfigureDebugTab</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_debug_tab.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections>
@@ -275,12 +261,32 @@
    <signal>accepted()</signal>
    <receiver>ConfigureDialog</receiver>
    <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+   </hints>
   </connection>
   <connection>
    <sender>buttonBox</sender>
    <signal>rejected()</signal>
    <receiver>ConfigureDialog</receiver>
    <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+   </hints>
   </connection>
  </connections>
 </ui>

src/yuzu/configuration/configure_cpu.cpp

@@ -20,8 +20,6 @@ ConfigureCpu::ConfigureCpu(QWidget* parent) : QWidget(parent), ui(new Ui::Config
 
     SetConfiguration();
 
-    connect(ui->accuracy, qOverload<int>(&QComboBox::activated), this,
-            &ConfigureCpu::AccuracyUpdated);
     connect(ui->accuracy, qOverload<int>(&QComboBox::currentIndexChanged), this,
             &ConfigureCpu::UpdateGroup);
 }
@@ -58,20 +56,6 @@ void ConfigureCpu::SetConfiguration() {
     UpdateGroup(ui->accuracy->currentIndex());
 }
 
-void ConfigureCpu::AccuracyUpdated(int index) {
-    if (Settings::IsConfiguringGlobal() &&
-        static_cast<Settings::CPUAccuracy>(index) == Settings::CPUAccuracy::DebugMode) {
-        const auto result = QMessageBox::warning(this, tr("Setting CPU to Debug Mode"),
-                                                 tr("CPU Debug Mode is only intended for developer "
-                                                    "use. Are you sure you want to enable this?"),
-                                                 QMessageBox::Yes | QMessageBox::No);
-        if (result == QMessageBox::No) {
-            ui->accuracy->setCurrentIndex(static_cast<int>(Settings::CPUAccuracy::Accurate));
-            UpdateGroup(static_cast<int>(Settings::CPUAccuracy::Accurate));
-        }
-    }
-}
-
 void ConfigureCpu::UpdateGroup(int index) {
     if (!Settings::IsConfiguringGlobal()) {
         index -= ConfigurationShared::USE_GLOBAL_OFFSET;
@@ -134,8 +118,6 @@ void ConfigureCpu::SetupPerGameUI() {
     ConfigurationShared::SetColoredComboBox(
         ui->accuracy, ui->widget_accuracy,
         static_cast<u32>(Settings::values.cpu_accuracy.GetValue(true)));
-    ui->accuracy->removeItem(static_cast<u32>(Settings::CPUAccuracy::DebugMode) +
-                             ConfigurationShared::USE_GLOBAL_OFFSET);
 
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_unfuse_fma,
                                             Settings::values.cpuopt_unsafe_unfuse_fma,

src/yuzu/configuration/configure_cpu.h

@@ -29,7 +29,6 @@ private:
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
-    void AccuracyUpdated(int index);
     void UpdateGroup(int index);
 
     void SetConfiguration();

src/yuzu/configuration/configure_cpu.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>321</height>
+    <width>448</width>
+    <height>433</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,7 +17,7 @@
    <item>
     <layout class="QVBoxLayout">
      <item>
-      <widget class="QGroupBox">
+      <widget class="QGroupBox" name="groupBox">
        <property name="title">
         <string>General</string>
        </property>
@@ -34,6 +34,11 @@
            </item>
            <item>
             <widget class="QComboBox" name="accuracy">
+             <item>
+              <property name="text">
+               <string>Auto</string>
+              </property>
+             </item>
              <item>
               <property name="text">
                <string>Accurate</string>
@@ -44,11 +49,6 @@
                <string>Unsafe</string>
               </property>
              </item>
-             <item>
-              <property name="text">
-               <string>Enable Debug Mode</string>
-              </property>
-             </item>
             </widget>
            </item>
           </layout>
@@ -57,7 +57,7 @@
         <item>
          <widget class="QLabel" name="label_recommended_accuracy">
           <property name="text">
-           <string>We recommend setting accuracy to &quot;Accurate&quot;.</string>
+           <string>We recommend setting accuracy to &quot;Auto&quot;.</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>

src/yuzu/configuration/configure_cpu_debug.h

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <QWidget>
-#include "common/settings.h"
 
 namespace Ui {
 class ConfigureCpuDebug;

src/yuzu/configuration/configure_cpu_debug.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>321</height>
+    <width>592</width>
+    <height>503</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,140 +17,132 @@
    <item>
     <layout class="QVBoxLayout">
      <item>
-      <widget class="QGroupBox">
+      <widget class="QGroupBox" name="groupBox">
        <property name="title">
         <string>Toggle CPU Optimizations</string>
        </property>
        <layout class="QVBoxLayout">
         <item>
-         <widget class="QLabel">
-          <property name="wordWrap">
-            <bool>1</bool>
-          </property>
+         <widget class="QLabel" name="label">
           <property name="text">
-           <string>
-            &lt;div&gt;
-            &lt;b&gt;For debugging only.&lt;/b&gt;
-            &lt;br&gt;
-            If you're not sure what these do, keep all of these enabled.
-            &lt;br&gt;
-            These settings, when disabled, only take effect when CPU Accuracy is "Debug Mode".
-            &lt;/div&gt;
-           </string>
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;For debugging only.&lt;/span&gt;&lt;br/&gt;If you're not sure what these do, keep all of these enabled. &lt;br/&gt;These settings, when disabled, only take effect when CPU Debugging is enabled. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="wordWrap">
+           <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_page_tables">
-          <property name="text">
-           <string>Enable inline page tables</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Enabling it inlines accesses to PageTable::pointers into emitted code.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Disabling this forces all memory accesses to go through the Memory::Read/Memory::Write functions.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it inlines accesses to PageTable::pointers into emitted code.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all memory accesses to go through the Memory::Read/Memory::Write functions.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable inline page tables</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_block_linking">
-          <property name="text">
-           <string>Enable block linking</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;This optimization avoids dispatcher lookups by allowing emitted basic blocks to jump directly to other basic blocks if the destination PC is static.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable block linking</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_return_stack_buffer">
-          <property name="text">
-           <string>Enable return stack buffer</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;This optimization avoids dispatcher lookups by keeping track potential return addresses of BL instructions. This approximates what happens with a return stack buffer on a real CPU.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable return stack buffer</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_fast_dispatcher">
-          <property name="text">
-           <string>Enable fast dispatcher</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enable a two-tiered dispatch system. A faster dispatcher written in assembly has a small MRU cache of jump destinations is used first. If that fails, dispatch falls back to the slower C++ dispatcher.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable fast dispatcher</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_context_elimination">
-          <property name="text">
-           <string>Enable context elimination</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables an IR optimization that reduces unnecessary accesses to the CPU context structure.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable context elimination</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_const_prop">
-          <property name="text">
-           <string>Enable constant propagation</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables IR optimizations that involve constant propagation.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable constant propagation</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_misc_ir">
-          <property name="text">
-           <string>Enable miscellaneous optimizations</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables miscellaneous IR optimizations.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable miscellaneous optimizations</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_reduce_misalign_checks">
-          <property name="text">
-           <string>Enable misalignment check reduction</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;When enabled, a misalignment is only triggered when an access crosses a page boundary.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;When disabled, a misalignment is triggered on all misaligned accesses.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;When enabled, a misalignment is only triggered when an access crosses a page boundary.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;When disabled, a misalignment is triggered on all misaligned accesses.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable misalignment check reduction</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_fastmem">
-          <property name="text">
-           <string>Enable Host MMU Emulation</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Enabling it causes guest memory reads/writes to be done directly into memory and make use of Host's MMU.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Disabling this forces all memory accesses to use Software MMU Emulation.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it causes guest memory reads/writes to be done directly into memory and make use of Host's MMU.&lt;/div&gt;
+            &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all memory accesses to use Software MMU Emulation.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable Host MMU Emulation</string>
+          </property>
          </widget>
         </item>
        </layout>

src/yuzu/configuration/configure_debug.cpp

@@ -43,6 +43,8 @@ void ConfigureDebug::SetConfiguration() {
     ui->use_auto_stub->setChecked(Settings::values.use_auto_stub.GetValue());
     ui->enable_graphics_debugging->setEnabled(runtime_lock);
     ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug.GetValue());
+    ui->enable_cpu_debugging->setEnabled(runtime_lock);
+    ui->enable_cpu_debugging->setChecked(Settings::values.cpu_debug_mode.GetValue());
     ui->disable_macro_jit->setEnabled(runtime_lock);
     ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit.GetValue());
     ui->extended_logging->setChecked(Settings::values.extended_logging.GetValue());
@@ -58,6 +60,7 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.use_debug_asserts = ui->use_debug_asserts->isChecked();
     Settings::values.use_auto_stub = ui->use_auto_stub->isChecked();
     Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
+    Settings::values.cpu_debug_mode = ui->enable_cpu_debugging->isChecked();
     Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();
     Settings::values.extended_logging = ui->extended_logging->isChecked();
     Debugger::ToggleConsole();

src/yuzu/configuration/configure_debug.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>400</width>
-    <height>486</height>
+    <height>777</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -192,34 +192,41 @@
         </property>
        </widget>
       </item>
-       <item>
-         <widget class="QCheckBox" name="use_debug_asserts">
-           <property name="text">
-             <string>Enable Debug Asserts</string>
-           </property>
-         </widget>
-       </item>
-       <item>
-         <widget class="QCheckBox" name="use_auto_stub">
-           <property name="text">
-             <string>Enable Auto-Stub</string>
-           </property>
-         </widget>
-       </item>
       <item>
-        <widget class="QLabel" name="label_5">
-          <property name="font">
-            <font>
-              <italic>true</italic>
-            </font>
-          </property>
-          <property name="text">
-            <string>This will be reset automatically when yuzu closes.</string>
-          </property>
-          <property name="indent">
-            <number>20</number>
-          </property>
-        </widget>
+       <widget class="QCheckBox" name="enable_cpu_debugging">
+        <property name="text">
+         <string>Enable CPU Debugging</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QCheckBox" name="use_debug_asserts">
+        <property name="text">
+         <string>Enable Debug Asserts</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QCheckBox" name="use_auto_stub">
+        <property name="text">
+         <string>Enable Auto-Stub</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="label_5">
+        <property name="font">
+         <font>
+          <italic>true</italic>
+         </font>
+        </property>
+        <property name="text">
+         <string>This will be reset automatically when yuzu closes.</string>
+        </property>
+        <property name="indent">
+         <number>20</number>
+        </property>
+       </widget>
       </item>
      </layout>
     </widget>

src/yuzu/configuration/configure_debug_tab.cpp

@@ -0,0 +1,38 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "ui_configure_debug_tab.h"
+#include "yuzu/configuration/configure_debug_tab.h"
+
+ConfigureDebugTab::ConfigureDebugTab(QWidget* parent)
+    : QWidget(parent), ui(new Ui::ConfigureDebugTab) {
+    ui->setupUi(this);
+
+    SetConfiguration();
+}
+
+ConfigureDebugTab::~ConfigureDebugTab() = default;
+
+void ConfigureDebugTab::ApplyConfiguration() {
+    ui->debugTab->ApplyConfiguration();
+    ui->cpuDebugTab->ApplyConfiguration();
+}
+
+void ConfigureDebugTab::SetCurrentIndex(int index) {
+    ui->tabWidget->setCurrentIndex(index);
+}
+
+void ConfigureDebugTab::changeEvent(QEvent* event) {
+    if (event->type() == QEvent::LanguageChange) {
+        RetranslateUI();
+    }
+
+    QWidget::changeEvent(event);
+}
+
+void ConfigureDebugTab::RetranslateUI() {
+    ui->retranslateUi(this);
+}
+
+void ConfigureDebugTab::SetConfiguration() {}

src/yuzu/configuration/configure_debug_tab.h

@@ -0,0 +1,32 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <QWidget>
+
+namespace Ui {
+class ConfigureDebugTab;
+}
+
+class ConfigureDebugTab : public QWidget {
+    Q_OBJECT
+
+public:
+    explicit ConfigureDebugTab(QWidget* parent = nullptr);
+    ~ConfigureDebugTab() override;
+
+    void ApplyConfiguration();
+
+    void SetCurrentIndex(int index);
+
+private:
+    void changeEvent(QEvent* event) override;
+    void RetranslateUI();
+
+    void SetConfiguration();
+
+    std::unique_ptr<Ui::ConfigureDebugTab> ui;
+};

src/yuzu/configuration/configure_debug_tab.ui

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConfigureDebugTab</class>
+ <widget class="QWidget" name="ConfigureDebugTab">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>320</width>
+    <height>240</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QTabWidget" name="tabWidget">
+     <property name="currentIndex">
+      <number>1</number>
+     </property>
+     <widget class="ConfigureDebug" name="debugTab">
+      <attribute name="title">
+       <string>General</string>
+      </attribute>
+     </widget>
+     <widget class="ConfigureCpuDebug" name="cpuDebugTab">
+      <attribute name="title">
+       <string>CPU</string>
+      </attribute>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ConfigureDebug</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_debug.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>ConfigureCpuDebug</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_cpu_debug.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

src/yuzu/configuration/configure_dialog.cpp

@@ -8,6 +8,7 @@
 #include <QListWidgetItem>
 #include <QPushButton>
 #include <QSignalBlocker>
+#include <QTabWidget>
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure.h"
@@ -32,6 +33,8 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     SetConfiguration();
     PopulateSelectionList();
 
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this,
+            [this]() { ui->debugTab->SetCurrentIndex(0); });
     connect(ui->uiTab, &ConfigureUi::LanguageChanged, this, &ConfigureDialog::OnLanguageChanged);
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);
@@ -59,7 +62,6 @@ void ConfigureDialog::ApplyConfiguration() {
     ui->inputTab->ApplyConfiguration();
     ui->hotkeysTab->ApplyConfiguration(registry);
     ui->cpuTab->ApplyConfiguration();
-    ui->cpuDebugTab->ApplyConfiguration();
     ui->graphicsTab->ApplyConfiguration();
     ui->graphicsAdvancedTab->ApplyConfiguration();
     ui->audioTab->ApplyConfiguration();
@@ -102,7 +104,7 @@ void ConfigureDialog::PopulateSelectionList() {
     const std::array<std::pair<QString, QList<QWidget*>>, 6> items{
         {{tr("General"), {ui->generalTab, ui->hotkeysTab, ui->uiTab, ui->webTab, ui->debugTab}},
          {tr("System"), {ui->systemTab, ui->profileManagerTab, ui->serviceTab, ui->filesystemTab}},
-         {tr("CPU"), {ui->cpuTab, ui->cpuDebugTab}},
+         {tr("CPU"), {ui->cpuTab}},
          {tr("Graphics"), {ui->graphicsTab, ui->graphicsAdvancedTab}},
          {tr("Audio"), {ui->audioTab}},
          {tr("Controls"), ui->inputTab->GetSubTabs()}},

src/yuzu/main.cpp

@@ -789,28 +789,41 @@ void GMainWindow::InitializeWidgets() {
     dock_status_button->setChecked(Settings::values.use_docked_mode.GetValue());
     statusBar()->insertPermanentWidget(0, dock_status_button);
 
-    gpu_accuracy_button = new QPushButton();
-    gpu_accuracy_button->setObjectName(QStringLiteral("GPUStatusBarButton"));
-    gpu_accuracy_button->setCheckable(true);
-    gpu_accuracy_button->setFocusPolicy(Qt::NoFocus);
-    connect(gpu_accuracy_button, &QPushButton::clicked, [this] {
-        switch (Settings::values.gpu_accuracy.GetValue()) {
-        case Settings::GPUAccuracy::High: {
-            Settings::values.gpu_accuracy.SetValue(Settings::GPUAccuracy::Normal);
-            break;
+    // Setup ASync button
+    async_status_button = new QPushButton();
+    async_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
+    async_status_button->setFocusPolicy(Qt::NoFocus);
+    connect(async_status_button, &QPushButton::clicked, [&] {
+        if (emulation_running) {
+            return;
         }
-        case Settings::GPUAccuracy::Normal:
-        case Settings::GPUAccuracy::Extreme:
-        default: {
-            Settings::values.gpu_accuracy.SetValue(Settings::GPUAccuracy::High);
-        }
-        }
-
+        Settings::values.use_asynchronous_gpu_emulation.SetValue(
+            !Settings::values.use_asynchronous_gpu_emulation.GetValue());
+        async_status_button->setChecked(Settings::values.use_asynchronous_gpu_emulation.GetValue());
         Core::System::GetInstance().ApplySettings();
-        UpdateGPUAccuracyButton();
     });
-    UpdateGPUAccuracyButton();
-    statusBar()->insertPermanentWidget(0, gpu_accuracy_button);
+    async_status_button->setText(tr("ASYNC"));
+    async_status_button->setCheckable(true);
+    async_status_button->setChecked(Settings::values.use_asynchronous_gpu_emulation.GetValue());
+
+    // Setup Multicore button
+    multicore_status_button = new QPushButton();
+    multicore_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
+    multicore_status_button->setFocusPolicy(Qt::NoFocus);
+    connect(multicore_status_button, &QPushButton::clicked, [&] {
+        if (emulation_running) {
+            return;
+        }
+        Settings::values.use_multi_core.SetValue(!Settings::values.use_multi_core.GetValue());
+        multicore_status_button->setChecked(Settings::values.use_multi_core.GetValue());
+        Core::System::GetInstance().ApplySettings();
+    });
+    multicore_status_button->setText(tr("MULTICORE"));
+    multicore_status_button->setCheckable(true);
+    multicore_status_button->setChecked(Settings::values.use_multi_core.GetValue());
+
+    statusBar()->insertPermanentWidget(0, multicore_status_button);
+    statusBar()->insertPermanentWidget(0, async_status_button);
 
     // Setup Renderer API button
     renderer_status_button = new QPushButton();
@@ -1384,6 +1397,8 @@ void GMainWindow::BootGame(const QString& filename, std::size_t program_index, S
         game_list_placeholder->hide();
     }
     status_bar_update_timer.start(500);
+    async_status_button->setDisabled(true);
+    multicore_status_button->setDisabled(true);
     renderer_status_button->setDisabled(true);
 
     if (UISettings::values.hide_mouse || Settings::values.mouse_panning) {
@@ -1485,6 +1500,8 @@ void GMainWindow::ShutdownGame() {
     emu_speed_label->setVisible(false);
     game_fps_label->setVisible(false);
     emu_frametime_label->setVisible(false);
+    async_status_button->setEnabled(true);
+    multicore_status_button->setEnabled(true);
     renderer_status_button->setEnabled(true);
 
     emulation_running = false;
@@ -2904,35 +2921,12 @@ void GMainWindow::UpdateStatusBar() {
     emu_frametime_label->setVisible(true);
 }
 
-void GMainWindow::UpdateGPUAccuracyButton() {
-    switch (Settings::values.gpu_accuracy.GetValue()) {
-    case Settings::GPUAccuracy::Normal: {
-        gpu_accuracy_button->setText(tr("GPU NORMAL"));
-        gpu_accuracy_button->setChecked(false);
-        break;
-    }
-    case Settings::GPUAccuracy::High: {
-        gpu_accuracy_button->setText(tr("GPU HIGH"));
-        gpu_accuracy_button->setChecked(true);
-        break;
-    }
-    case Settings::GPUAccuracy::Extreme: {
-        gpu_accuracy_button->setText(tr("GPU EXTREME"));
-        gpu_accuracy_button->setChecked(true);
-        break;
-    }
-    default: {
-        gpu_accuracy_button->setText(tr("GPU ERROR"));
-        gpu_accuracy_button->setChecked(true);
-    }
-    }
-}
-
 void GMainWindow::UpdateStatusButtons() {
     dock_status_button->setChecked(Settings::values.use_docked_mode.GetValue());
+    multicore_status_button->setChecked(Settings::values.use_multi_core.GetValue());
+    async_status_button->setChecked(Settings::values.use_asynchronous_gpu_emulation.GetValue());
     renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() ==
                                        Settings::RendererBackend::Vulkan);
-    UpdateGPUAccuracyButton();
 }
 
 void GMainWindow::UpdateUISettings() {

src/yuzu/main.h

@@ -291,7 +291,6 @@ private:
     void UpdateWindowTitle(std::string_view title_name = {}, std::string_view title_version = {},
                            std::string_view gpu_vendor = {});
     void UpdateStatusBar();
-    void UpdateGPUAccuracyButton();
     void UpdateStatusButtons();
     void UpdateUISettings();
     void HideMouseCursor();
@@ -317,7 +316,8 @@ private:
     QLabel* emu_speed_label = nullptr;
     QLabel* game_fps_label = nullptr;
     QLabel* emu_frametime_label = nullptr;
-    QPushButton* gpu_accuracy_button = nullptr;
+    QPushButton* async_status_button = nullptr;
+    QPushButton* multicore_status_button = nullptr;
     QPushButton* renderer_status_button = nullptr;
     QPushButton* dock_status_button = nullptr;
     QTimer status_bar_update_timer;