config: Unify config handling under frontend_common

Replaces every way of handling config for each frontend with SimpleIni. frontend_common's Config class is at the center where it saves and loads all of the cross-platform settings and provides a set of pure virtual functions for platform specific settings.

As a result of making config handling platform specific, several parts had to be moved to each platform's own config class or to other parts. Default keys were put in platform specific config classes and translatable strings for Qt were moved to shared_translation. Default hotkeys, default_theme, window geometry, and qt metatypes were moved to uisettings. Additionally, to reduce dependence on Qt, QStrings were converted to std::strings where applicable.

20 files changed, 701 insertions, 1535 deletions

diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
deleted file mode 100644
index c0ae6468b..000000000
--- a/src/yuzu/configuration/config.cpp
+++ /dev/null
@@ -1,1309 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <algorithm>
-#include <array>
-#include <QKeySequence>
-#include <QSettings>
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/settings.h"
-#include "common/settings_common.h"
-#include "common/settings_enums.h"
-#include "core/core.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/hid/controllers/npad.h"
-#include "input_common/main.h"
-#include "network/network.h"
-#include "yuzu/configuration/config.h"
-
-namespace FS = Common::FS;
-
-Config::Config(const std::string& config_name, ConfigType config_type)
-    : type(config_type), global{config_type == ConfigType::GlobalConfig} {
-    Initialize(config_name);
-}
-
-Config::~Config() {
-    if (global) {
-        Save();
-    }
-}
-
-const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
-    Qt::Key_C,    Qt::Key_X, Qt::Key_V,    Qt::Key_Z,  Qt::Key_F,
-    Qt::Key_G,    Qt::Key_Q, Qt::Key_E,    Qt::Key_R,  Qt::Key_T,
-    Qt::Key_M,    Qt::Key_N, Qt::Key_Left, Qt::Key_Up, Qt::Key_Right,
-    Qt::Key_Down, Qt::Key_Q, Qt::Key_E,    0,          0,
-    Qt::Key_Q,    Qt::Key_E,
-};
-
-const std::array<int, Settings::NativeMotion::NumMotions> Config::default_motions = {
-    Qt::Key_7,
-    Qt::Key_8,
-};
-
-const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> Config::default_analogs{{
-    {
-        Qt::Key_W,
-        Qt::Key_S,
-        Qt::Key_A,
-        Qt::Key_D,
-    },
-    {
-        Qt::Key_I,
-        Qt::Key_K,
-        Qt::Key_J,
-        Qt::Key_L,
-    },
-}};
-
-const std::array<int, 2> Config::default_stick_mod = {
-    Qt::Key_Shift,
-    0,
-};
-
-const std::array<int, 2> Config::default_ringcon_analogs{{
-    Qt::Key_A,
-    Qt::Key_D,
-}};
-
-const std::map<Settings::AntiAliasing, QString> Config::anti_aliasing_texts_map = {
-    {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "None"))},
-    {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FXAA"))},
-    {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SMAA"))},
-};
-
-const std::map<Settings::ScalingFilter, QString> Config::scaling_filter_texts_map = {
-    {Settings::ScalingFilter::NearestNeighbor,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Nearest"))},
-    {Settings::ScalingFilter::Bilinear,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
-    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
-    {Settings::ScalingFilter::Gaussian,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Gaussian"))},
-    {Settings::ScalingFilter::ScaleForce,
-     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
-    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
-};
-
-const std::map<Settings::ConsoleMode, QString> Config::use_docked_mode_texts_map = {
-    {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Docked"))},
-    {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Handheld"))},
-};
-
-const std::map<Settings::GpuAccuracy, QString> Config::gpu_accuracy_texts_map = {
-    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Normal"))},
-    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "High"))},
-    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Extreme"))},
-};
-
-const std::map<Settings::RendererBackend, QString> Config::renderer_backend_texts_map = {
-    {Settings::RendererBackend::Vulkan, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Vulkan"))},
-    {Settings::RendererBackend::OpenGL, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "OpenGL"))},
-    {Settings::RendererBackend::Null, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Null"))},
-};
-
-const std::map<Settings::ShaderBackend, QString> Config::shader_backend_texts_map = {
-    {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},
-    {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},
-    {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},
-};
-
-// This shouldn't have anything except static initializers (no functions). So
-// QKeySequence(...).toString() is NOT ALLOWED HERE.
-// This must be in alphabetical order according to action name as it must have the same order as
-// UISetting::values.shortcuts, which is alphabetically ordered.
-// clang-format off
-const std::array<UISettings::Shortcut, 23> Config::default_hotkeys{{
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Mute/Unmute")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+M"),  QStringLiteral("Home+Dpad_Right"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Volume Down")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("-"),       QStringLiteral("Home+Dpad_Down"), Qt::ApplicationShortcut, true}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Volume Up")),          QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("="),       QStringLiteral("Home+Dpad_Up"), Qt::ApplicationShortcut, true}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Capture Screenshot")),       QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+P"),  QStringLiteral("Screenshot"), Qt::WidgetWithChildrenShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Change Adapting Filter")),   QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F8"),      QStringLiteral("Home+L"), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Change Docked Mode")),       QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F10"),     QStringLiteral("Home+X"), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Change GPU Accuracy")),      QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F9"),      QStringLiteral("Home+R"), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Continue/Pause Emulation")), QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F4"),      QStringLiteral("Home+Plus"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Exit Fullscreen")),          QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Esc"),     QStringLiteral(""), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Exit yuzu")),                QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+Q"),  QStringLiteral("Home+Minus"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Fullscreen")),               QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F11"),     QStringLiteral("Home+B"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Load File")),                QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+O"),  QStringLiteral(""), Qt::WidgetWithChildrenShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Load/Remove Amiibo")),       QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F2"),      QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Restart Emulation")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F6"),      QStringLiteral("R+Plus+Minus"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Stop Emulation")),           QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("F5"),      QStringLiteral("L+Plus+Minus"), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "TAS Record")),               QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F7"), QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "TAS Reset")),                QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F6"), QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "TAS Start/Stop")),           QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F5"), QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Filter Bar")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F"),  QStringLiteral(""), Qt::WindowShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Framerate Limit")),   QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+U"),  QStringLiteral("Home+Y"), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Mouse Panning")),     QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Renderdoc Capture")), QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral(""),        QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Status Bar")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+S"),  QStringLiteral(""), Qt::WindowShortcut, false}},
-}};
-// clang-format on
-
-void Config::Initialize(const std::string& config_name) {
-    const auto fs_config_loc = FS::GetYuzuPath(FS::YuzuPath::ConfigDir);
-    const auto config_file = fmt::format("{}.ini", config_name);
-
-    switch (type) {
-    case ConfigType::GlobalConfig:
-        qt_config_loc = FS::PathToUTF8String(fs_config_loc / config_file);
-        void(FS::CreateParentDir(qt_config_loc));
-        qt_config = std::make_unique<QSettings>(QString::fromStdString(qt_config_loc),
-                                                QSettings::IniFormat);
-        Reload();
-        break;
-    case ConfigType::PerGameConfig:
-        qt_config_loc =
-            FS::PathToUTF8String(fs_config_loc / "custom" / FS::ToU8String(config_file));
-        void(FS::CreateParentDir(qt_config_loc));
-        qt_config = std::make_unique<QSettings>(QString::fromStdString(qt_config_loc),
-                                                QSettings::IniFormat);
-        Reload();
-        break;
-    case ConfigType::InputProfile:
-        qt_config_loc = FS::PathToUTF8String(fs_config_loc / "input" / config_file);
-        void(FS::CreateParentDir(qt_config_loc));
-        qt_config = std::make_unique<QSettings>(QString::fromStdString(qt_config_loc),
-                                                QSettings::IniFormat);
-        break;
-    }
-}
-
-bool Config::IsCustomConfig() {
-    return type == ConfigType::PerGameConfig;
-}
-
-void Config::ReadPlayerValue(std::size_t player_index) {
-    const QString player_prefix = [this, player_index] {
-        if (type == ConfigType::InputProfile) {
-            return QString{};
-        } else {
-            return QStringLiteral("player_%1_").arg(player_index);
-        }
-    }();
-
-    auto& player = Settings::values.players.GetValue()[player_index];
-    if (IsCustomConfig()) {
-        const auto profile_name =
-            qt_config->value(QStringLiteral("%1profile_name").arg(player_prefix), QString{})
-                .toString()
-                .toStdString();
-        if (profile_name.empty()) {
-            // Use the global input config
-            player = Settings::values.players.GetValue(true)[player_index];
-            return;
-        }
-        player.profile_name = profile_name;
-    }
-
-    if (player_prefix.isEmpty() && Settings::IsConfiguringGlobal()) {
-        const auto controller = static_cast<Settings::ControllerType>(
-            qt_config
-                ->value(QStringLiteral("%1type").arg(player_prefix),
-                        static_cast<u8>(Settings::ControllerType::ProController))
-                .toUInt());
-
-        if (controller == Settings::ControllerType::LeftJoycon ||
-            controller == Settings::ControllerType::RightJoycon) {
-            player.controller_type = controller;
-        }
-    } else {
-        player.connected =
-            ReadSetting(QStringLiteral("%1connected").arg(player_prefix), player_index == 0)
-                .toBool();
-
-        player.controller_type = static_cast<Settings::ControllerType>(
-            qt_config
-                ->value(QStringLiteral("%1type").arg(player_prefix),
-                        static_cast<u8>(Settings::ControllerType::ProController))
-                .toUInt());
-
-        player.vibration_enabled =
-            qt_config->value(QStringLiteral("%1vibration_enabled").arg(player_prefix), true)
-                .toBool();
-
-        player.vibration_strength =
-            qt_config->value(QStringLiteral("%1vibration_strength").arg(player_prefix), 100)
-                .toInt();
-
-        player.body_color_left = qt_config
-                                     ->value(QStringLiteral("%1body_color_left").arg(player_prefix),
-                                             Settings::JOYCON_BODY_NEON_BLUE)
-                                     .toUInt();
-        player.body_color_right =
-            qt_config
-                ->value(QStringLiteral("%1body_color_right").arg(player_prefix),
-                        Settings::JOYCON_BODY_NEON_RED)
-                .toUInt();
-        player.button_color_left =
-            qt_config
-                ->value(QStringLiteral("%1button_color_left").arg(player_prefix),
-                        Settings::JOYCON_BUTTONS_NEON_BLUE)
-                .toUInt();
-        player.button_color_right =
-            qt_config
-                ->value(QStringLiteral("%1button_color_right").arg(player_prefix),
-                        Settings::JOYCON_BUTTONS_NEON_RED)
-                .toUInt();
-    }
-
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        auto& player_buttons = player.buttons[i];
-
-        player_buttons = qt_config
-                             ->value(QStringLiteral("%1").arg(player_prefix) +
-                                         QString::fromUtf8(Settings::NativeButton::mapping[i]),
-                                     QString::fromStdString(default_param))
-                             .toString()
-                             .toStdString();
-        if (player_buttons.empty()) {
-            player_buttons = default_param;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        auto& player_analogs = player.analogs[i];
-
-        player_analogs = qt_config
-                             ->value(QStringLiteral("%1").arg(player_prefix) +
-                                         QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
-                                     QString::fromStdString(default_param))
-                             .toString()
-                             .toStdString();
-        if (player_analogs.empty()) {
-            player_analogs = default_param;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
-        auto& player_motions = player.motions[i];
-
-        player_motions = qt_config
-                             ->value(QStringLiteral("%1").arg(player_prefix) +
-                                         QString::fromUtf8(Settings::NativeMotion::mapping[i]),
-                                     QString::fromStdString(default_param))
-                             .toString()
-                             .toStdString();
-        if (player_motions.empty()) {
-            player_motions = default_param;
-        }
-    }
-}
-
-void Config::ReadDebugValues() {
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
-
-        debug_pad_buttons = qt_config
-                                ->value(QStringLiteral("debug_pad_") +
-                                            QString::fromUtf8(Settings::NativeButton::mapping[i]),
-                                        QString::fromStdString(default_param))
-                                .toString()
-                                .toStdString();
-        if (debug_pad_buttons.empty()) {
-            debug_pad_buttons = default_param;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
-
-        debug_pad_analogs = qt_config
-                                ->value(QStringLiteral("debug_pad_") +
-                                            QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
-                                        QString::fromStdString(default_param))
-                                .toString()
-                                .toStdString();
-        if (debug_pad_analogs.empty()) {
-            debug_pad_analogs = default_param;
-        }
-    }
-}
-
-void Config::ReadTouchscreenValues() {
-    Settings::values.touchscreen.enabled =
-        ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool();
-
-    Settings::values.touchscreen.rotation_angle =
-        ReadSetting(QStringLiteral("touchscreen_angle"), 0).toUInt();
-    Settings::values.touchscreen.diameter_x =
-        ReadSetting(QStringLiteral("touchscreen_diameter_x"), 15).toUInt();
-    Settings::values.touchscreen.diameter_y =
-        ReadSetting(QStringLiteral("touchscreen_diameter_y"), 15).toUInt();
-}
-
-void Config::ReadHidbusValues() {
-    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    auto& ringcon_analogs = Settings::values.ringcon_analogs;
-
-    ringcon_analogs =
-        qt_config->value(QStringLiteral("ring_controller"), QString::fromStdString(default_param))
-            .toString()
-            .toStdString();
-    if (ringcon_analogs.empty()) {
-        ringcon_analogs = default_param;
-    }
-}
-
-void Config::ReadAudioValues() {
-    qt_config->beginGroup(QStringLiteral("Audio"));
-
-    ReadCategory(Settings::Category::Audio);
-    ReadCategory(Settings::Category::UiAudio);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadControlValues() {
-    qt_config->beginGroup(QStringLiteral("Controls"));
-
-    ReadCategory(Settings::Category::Controls);
-
-    Settings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
-        ReadPlayerValue(p);
-    }
-
-    // Disable docked mode if handheld is selected
-    const auto controller_type = Settings::values.players.GetValue()[0].controller_type;
-    if (controller_type == Settings::ControllerType::Handheld) {
-        Settings::values.use_docked_mode.SetGlobal(!IsCustomConfig());
-        Settings::values.use_docked_mode.SetValue(Settings::ConsoleMode::Handheld);
-    }
-
-    if (IsCustomConfig()) {
-        qt_config->endGroup();
-        return;
-    }
-    ReadDebugValues();
-    ReadTouchscreenValues();
-    ReadMotionTouchValues();
-    ReadHidbusValues();
-
-    qt_config->endGroup();
-}
-
-void Config::ReadMotionTouchValues() {
-    int num_touch_from_button_maps =
-        qt_config->beginReadArray(QStringLiteral("touch_from_button_maps"));
-
-    if (num_touch_from_button_maps > 0) {
-        const auto append_touch_from_button_map = [this] {
-            Settings::TouchFromButtonMap map;
-            map.name = ReadSetting(QStringLiteral("name"), QStringLiteral("default"))
-                           .toString()
-                           .toStdString();
-            const int num_touch_maps = qt_config->beginReadArray(QStringLiteral("entries"));
-            map.buttons.reserve(num_touch_maps);
-            for (int i = 0; i < num_touch_maps; i++) {
-                qt_config->setArrayIndex(i);
-                std::string touch_mapping =
-                    ReadSetting(QStringLiteral("bind")).toString().toStdString();
-                map.buttons.emplace_back(std::move(touch_mapping));
-            }
-            qt_config->endArray(); // entries
-            Settings::values.touch_from_button_maps.emplace_back(std::move(map));
-        };
-
-        for (int i = 0; i < num_touch_from_button_maps; ++i) {
-            qt_config->setArrayIndex(i);
-            append_touch_from_button_map();
-        }
-    } else {
-        Settings::values.touch_from_button_maps.emplace_back(
-            Settings::TouchFromButtonMap{"default", {}});
-        num_touch_from_button_maps = 1;
-    }
-    qt_config->endArray();
-
-    Settings::values.touch_from_button_map_index = std::clamp(
-        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
-}
-
-void Config::ReadCoreValues() {
-    qt_config->beginGroup(QStringLiteral("Core"));
-
-    ReadCategory(Settings::Category::Core);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadDataStorageValues() {
-    qt_config->beginGroup(QStringLiteral("Data Storage"));
-
-    FS::SetYuzuPath(
-        FS::YuzuPath::NANDDir,
-        qt_config
-            ->value(QStringLiteral("nand_directory"),
-                    QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)))
-            .toString()
-            .toStdString());
-    FS::SetYuzuPath(
-        FS::YuzuPath::SDMCDir,
-        qt_config
-            ->value(QStringLiteral("sdmc_directory"),
-                    QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)))
-            .toString()
-            .toStdString());
-    FS::SetYuzuPath(
-        FS::YuzuPath::LoadDir,
-        qt_config
-            ->value(QStringLiteral("load_directory"),
-                    QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::LoadDir)))
-            .toString()
-            .toStdString());
-    FS::SetYuzuPath(
-        FS::YuzuPath::DumpDir,
-        qt_config
-            ->value(QStringLiteral("dump_directory"),
-                    QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)))
-            .toString()
-            .toStdString());
-    FS::SetYuzuPath(FS::YuzuPath::TASDir,
-                    qt_config
-                        ->value(QStringLiteral("tas_directory"),
-                                QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)))
-                        .toString()
-                        .toStdString());
-
-    ReadCategory(Settings::Category::DataStorage);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadDebuggingValues() {
-    qt_config->beginGroup(QStringLiteral("Debugging"));
-
-    // Intentionally not using the QT default setting as this is intended to be changed in the ini
-    Settings::values.record_frame_times =
-        qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
-
-    ReadCategory(Settings::Category::Debugging);
-    ReadCategory(Settings::Category::DebuggingGraphics);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadServiceValues() {
-    qt_config->beginGroup(QStringLiteral("Services"));
-
-    ReadCategory(Settings::Category::Services);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadDisabledAddOnValues() {
-    const auto size = qt_config->beginReadArray(QStringLiteral("DisabledAddOns"));
-
-    for (int i = 0; i < size; ++i) {
-        qt_config->setArrayIndex(i);
-        const auto title_id = ReadSetting(QStringLiteral("title_id"), 0).toULongLong();
-        std::vector<std::string> out;
-        const auto d_size = qt_config->beginReadArray(QStringLiteral("disabled"));
-        for (int j = 0; j < d_size; ++j) {
-            qt_config->setArrayIndex(j);
-            out.push_back(ReadSetting(QStringLiteral("d"), QString{}).toString().toStdString());
-        }
-        qt_config->endArray();
-        Settings::values.disabled_addons.insert_or_assign(title_id, out);
-    }
-
-    qt_config->endArray();
-}
-
-void Config::ReadMiscellaneousValues() {
-    qt_config->beginGroup(QStringLiteral("Miscellaneous"));
-
-    ReadCategory(Settings::Category::Miscellaneous);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadPathValues() {
-    qt_config->beginGroup(QStringLiteral("Paths"));
-
-    UISettings::values.roms_path = ReadSetting(QStringLiteral("romsPath")).toString();
-    UISettings::values.symbols_path = ReadSetting(QStringLiteral("symbolsPath")).toString();
-    UISettings::values.game_dir_deprecated =
-        ReadSetting(QStringLiteral("gameListRootDir"), QStringLiteral(".")).toString();
-    UISettings::values.game_dir_deprecated_deepscan =
-        ReadSetting(QStringLiteral("gameListDeepScan"), false).toBool();
-    const int gamedirs_size = qt_config->beginReadArray(QStringLiteral("gamedirs"));
-    for (int i = 0; i < gamedirs_size; ++i) {
-        qt_config->setArrayIndex(i);
-        UISettings::GameDir game_dir;
-        game_dir.path = ReadSetting(QStringLiteral("path")).toString();
-        game_dir.deep_scan = ReadSetting(QStringLiteral("deep_scan"), false).toBool();
-        game_dir.expanded = ReadSetting(QStringLiteral("expanded"), true).toBool();
-        UISettings::values.game_dirs.append(game_dir);
-    }
-    qt_config->endArray();
-    // create NAND and SD card directories if empty, these are not removable through the UI,
-    // also carries over old game list settings if present
-    if (UISettings::values.game_dirs.isEmpty()) {
-        UISettings::GameDir game_dir;
-        game_dir.path = QStringLiteral("SDMC");
-        game_dir.expanded = true;
-        UISettings::values.game_dirs.append(game_dir);
-        game_dir.path = QStringLiteral("UserNAND");
-        UISettings::values.game_dirs.append(game_dir);
-        game_dir.path = QStringLiteral("SysNAND");
-        UISettings::values.game_dirs.append(game_dir);
-        if (UISettings::values.game_dir_deprecated != QStringLiteral(".")) {
-            game_dir.path = UISettings::values.game_dir_deprecated;
-            game_dir.deep_scan = UISettings::values.game_dir_deprecated_deepscan;
-            UISettings::values.game_dirs.append(game_dir);
-        }
-    }
-    UISettings::values.recent_files = ReadSetting(QStringLiteral("recentFiles")).toStringList();
-    UISettings::values.language = ReadSetting(QStringLiteral("language"), QString{}).toString();
-
-    qt_config->endGroup();
-}
-
-void Config::ReadCpuValues() {
-    qt_config->beginGroup(QStringLiteral("Cpu"));
-
-    ReadCategory(Settings::Category::Cpu);
-    ReadCategory(Settings::Category::CpuDebug);
-    ReadCategory(Settings::Category::CpuUnsafe);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadRendererValues() {
-    qt_config->beginGroup(QStringLiteral("Renderer"));
-
-    ReadCategory(Settings::Category::Renderer);
-    ReadCategory(Settings::Category::RendererAdvanced);
-    ReadCategory(Settings::Category::RendererDebug);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadScreenshotValues() {
-    qt_config->beginGroup(QStringLiteral("Screenshots"));
-
-    ReadCategory(Settings::Category::Screenshots);
-    FS::SetYuzuPath(
-        FS::YuzuPath::ScreenshotsDir,
-        qt_config
-            ->value(QStringLiteral("screenshot_path"),
-                    QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir)))
-            .toString()
-            .toStdString());
-
-    qt_config->endGroup();
-}
-
-void Config::ReadShortcutValues() {
-    qt_config->beginGroup(QStringLiteral("Shortcuts"));
-
-    for (const auto& [name, group, shortcut] : default_hotkeys) {
-        qt_config->beginGroup(group);
-        qt_config->beginGroup(name);
-        // No longer using ReadSetting for shortcut.second as it inaccurately returns a value of 1
-        // for WidgetWithChildrenShortcut which is a value of 3. Needed to fix shortcuts the open
-        // a file dialog in windowed mode
-        UISettings::values.shortcuts.push_back(
-            {name,
-             group,
-             {ReadSetting(QStringLiteral("KeySeq"), shortcut.keyseq).toString(),
-              ReadSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq)
-                  .toString(),
-              shortcut.context, ReadSetting(QStringLiteral("Repeat"), shortcut.repeat).toBool()}});
-        qt_config->endGroup();
-        qt_config->endGroup();
-    }
-
-    qt_config->endGroup();
-}
-
-void Config::ReadSystemValues() {
-    qt_config->beginGroup(QStringLiteral("System"));
-
-    ReadCategory(Settings::Category::System);
-    ReadCategory(Settings::Category::SystemAudio);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadUIValues() {
-    qt_config->beginGroup(QStringLiteral("UI"));
-
-    UISettings::values.theme =
-        ReadSetting(
-            QStringLiteral("theme"),
-            QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second))
-            .toString();
-
-    ReadUIGamelistValues();
-    ReadUILayoutValues();
-    ReadPathValues();
-    ReadScreenshotValues();
-    ReadShortcutValues();
-    ReadMultiplayerValues();
-
-    ReadCategory(Settings::Category::Ui);
-    ReadCategory(Settings::Category::UiGeneral);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadUIGamelistValues() {
-    qt_config->beginGroup(QStringLiteral("UIGameList"));
-
-    ReadCategory(Settings::Category::UiGameList);
-
-    const int favorites_size = qt_config->beginReadArray(QStringLiteral("favorites"));
-    for (int i = 0; i < favorites_size; i++) {
-        qt_config->setArrayIndex(i);
-        UISettings::values.favorited_ids.append(
-            ReadSetting(QStringLiteral("program_id")).toULongLong());
-    }
-    qt_config->endArray();
-
-    qt_config->endGroup();
-}
-
-void Config::ReadUILayoutValues() {
-    qt_config->beginGroup(QStringLiteral("UILayout"));
-
-    UISettings::values.geometry = ReadSetting(QStringLiteral("geometry")).toByteArray();
-    UISettings::values.state = ReadSetting(QStringLiteral("state")).toByteArray();
-    UISettings::values.renderwindow_geometry =
-        ReadSetting(QStringLiteral("geometryRenderWindow")).toByteArray();
-    UISettings::values.gamelist_header_state =
-        ReadSetting(QStringLiteral("gameListHeaderState")).toByteArray();
-    UISettings::values.microprofile_geometry =
-        ReadSetting(QStringLiteral("microProfileDialogGeometry")).toByteArray();
-
-    ReadCategory(Settings::Category::UiLayout);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadWebServiceValues() {
-    qt_config->beginGroup(QStringLiteral("WebService"));
-
-    ReadCategory(Settings::Category::WebService);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadMultiplayerValues() {
-    qt_config->beginGroup(QStringLiteral("Multiplayer"));
-
-    ReadCategory(Settings::Category::Multiplayer);
-
-    // Read ban list back
-    int size = qt_config->beginReadArray(QStringLiteral("username_ban_list"));
-    UISettings::values.multiplayer_ban_list.first.resize(size);
-    for (int i = 0; i < size; ++i) {
-        qt_config->setArrayIndex(i);
-        UISettings::values.multiplayer_ban_list.first[i] =
-            ReadSetting(QStringLiteral("username")).toString().toStdString();
-    }
-    qt_config->endArray();
-    size = qt_config->beginReadArray(QStringLiteral("ip_ban_list"));
-    UISettings::values.multiplayer_ban_list.second.resize(size);
-    for (int i = 0; i < size; ++i) {
-        qt_config->setArrayIndex(i);
-        UISettings::values.multiplayer_ban_list.second[i] =
-            ReadSetting(QStringLiteral("ip")).toString().toStdString();
-    }
-    qt_config->endArray();
-
-    qt_config->endGroup();
-}
-
-void Config::ReadNetworkValues() {
-    qt_config->beginGroup(QString::fromStdString("Services"));
-
-    ReadCategory(Settings::Category::Network);
-
-    qt_config->endGroup();
-}
-
-void Config::ReadValues() {
-    if (global) {
-        ReadDataStorageValues();
-        ReadDebuggingValues();
-        ReadDisabledAddOnValues();
-        ReadNetworkValues();
-        ReadServiceValues();
-        ReadUIValues();
-        ReadWebServiceValues();
-        ReadMiscellaneousValues();
-    }
-    ReadControlValues();
-    ReadCoreValues();
-    ReadCpuValues();
-    ReadRendererValues();
-    ReadAudioValues();
-    ReadSystemValues();
-}
-
-void Config::SavePlayerValue(std::size_t player_index) {
-    const QString player_prefix = [this, player_index] {
-        if (type == ConfigType::InputProfile) {
-            return QString{};
-        } else {
-            return QStringLiteral("player_%1_").arg(player_index);
-        }
-    }();
-
-    const auto& player = Settings::values.players.GetValue()[player_index];
-    if (IsCustomConfig()) {
-        if (player.profile_name.empty()) {
-            // No custom profile selected
-            return;
-        }
-        WriteSetting(QStringLiteral("%1profile_name").arg(player_prefix),
-                     QString::fromStdString(player.profile_name), QString{});
-    }
-
-    WriteSetting(QStringLiteral("%1type").arg(player_prefix),
-                 static_cast<u8>(player.controller_type),
-                 static_cast<u8>(Settings::ControllerType::ProController));
-
-    if (!player_prefix.isEmpty() || !Settings::IsConfiguringGlobal()) {
-        WriteSetting(QStringLiteral("%1connected").arg(player_prefix), player.connected,
-                     player_index == 0);
-        WriteSetting(QStringLiteral("%1vibration_enabled").arg(player_prefix),
-                     player.vibration_enabled, true);
-        WriteSetting(QStringLiteral("%1vibration_strength").arg(player_prefix),
-                     player.vibration_strength, 100);
-        WriteSetting(QStringLiteral("%1body_color_left").arg(player_prefix), player.body_color_left,
-                     Settings::JOYCON_BODY_NEON_BLUE);
-        WriteSetting(QStringLiteral("%1body_color_right").arg(player_prefix),
-                     player.body_color_right, Settings::JOYCON_BODY_NEON_RED);
-        WriteSetting(QStringLiteral("%1button_color_left").arg(player_prefix),
-                     player.button_color_left, Settings::JOYCON_BUTTONS_NEON_BLUE);
-        WriteSetting(QStringLiteral("%1button_color_right").arg(player_prefix),
-                     player.button_color_right, Settings::JOYCON_BUTTONS_NEON_RED);
-    }
-
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteSetting(QStringLiteral("%1").arg(player_prefix) +
-                         QString::fromStdString(Settings::NativeButton::mapping[i]),
-                     QString::fromStdString(player.buttons[i]),
-                     QString::fromStdString(default_param));
-    }
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteSetting(QStringLiteral("%1").arg(player_prefix) +
-                         QString::fromStdString(Settings::NativeAnalog::mapping[i]),
-                     QString::fromStdString(player.analogs[i]),
-                     QString::fromStdString(default_param));
-    }
-    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
-        WriteSetting(QStringLiteral("%1").arg(player_prefix) +
-                         QString::fromStdString(Settings::NativeMotion::mapping[i]),
-                     QString::fromStdString(player.motions[i]),
-                     QString::fromStdString(default_param));
-    }
-}
-
-void Config::SaveDebugValues() {
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteSetting(QStringLiteral("debug_pad_") +
-                         QString::fromStdString(Settings::NativeButton::mapping[i]),
-                     QString::fromStdString(Settings::values.debug_pad_buttons[i]),
-                     QString::fromStdString(default_param));
-    }
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteSetting(QStringLiteral("debug_pad_") +
-                         QString::fromStdString(Settings::NativeAnalog::mapping[i]),
-                     QString::fromStdString(Settings::values.debug_pad_analogs[i]),
-                     QString::fromStdString(default_param));
-    }
-}
-
-void Config::SaveTouchscreenValues() {
-    const auto& touchscreen = Settings::values.touchscreen;
-
-    WriteSetting(QStringLiteral("touchscreen_enabled"), touchscreen.enabled, true);
-
-    WriteSetting(QStringLiteral("touchscreen_angle"), touchscreen.rotation_angle, 0);
-    WriteSetting(QStringLiteral("touchscreen_diameter_x"), touchscreen.diameter_x, 15);
-    WriteSetting(QStringLiteral("touchscreen_diameter_y"), touchscreen.diameter_y, 15);
-}
-
-void Config::SaveMotionTouchValues() {
-    qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
-    for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
-        qt_config->setArrayIndex(static_cast<int>(p));
-        WriteSetting(QStringLiteral("name"),
-                     QString::fromStdString(Settings::values.touch_from_button_maps[p].name),
-                     QStringLiteral("default"));
-        qt_config->beginWriteArray(QStringLiteral("entries"));
-        for (std::size_t q = 0; q < Settings::values.touch_from_button_maps[p].buttons.size();
-             ++q) {
-            qt_config->setArrayIndex(static_cast<int>(q));
-            WriteSetting(
-                QStringLiteral("bind"),
-                QString::fromStdString(Settings::values.touch_from_button_maps[p].buttons[q]));
-        }
-        qt_config->endArray();
-    }
-    qt_config->endArray();
-}
-
-void Config::SaveHidbusValues() {
-    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    WriteSetting(QStringLiteral("ring_controller"),
-                 QString::fromStdString(Settings::values.ringcon_analogs),
-                 QString::fromStdString(default_param));
-}
-
-void Config::SaveValues() {
-    if (global) {
-        SaveDataStorageValues();
-        SaveDebuggingValues();
-        SaveDisabledAddOnValues();
-        SaveNetworkValues();
-        SaveUIValues();
-        SaveWebServiceValues();
-        SaveMiscellaneousValues();
-    }
-    SaveControlValues();
-    SaveCoreValues();
-    SaveCpuValues();
-    SaveRendererValues();
-    SaveAudioValues();
-    SaveSystemValues();
-
-    qt_config->sync();
-}
-
-void Config::SaveAudioValues() {
-    qt_config->beginGroup(QStringLiteral("Audio"));
-
-    WriteCategory(Settings::Category::Audio);
-    WriteCategory(Settings::Category::UiAudio);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveControlValues() {
-    qt_config->beginGroup(QStringLiteral("Controls"));
-
-    WriteCategory(Settings::Category::Controls);
-
-    Settings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
-        SavePlayerValue(p);
-    }
-    if (IsCustomConfig()) {
-        qt_config->endGroup();
-        return;
-    }
-    SaveDebugValues();
-    SaveTouchscreenValues();
-    SaveMotionTouchValues();
-    SaveHidbusValues();
-
-    qt_config->endGroup();
-}
-
-void Config::SaveCoreValues() {
-    qt_config->beginGroup(QStringLiteral("Core"));
-
-    WriteCategory(Settings::Category::Core);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveDataStorageValues() {
-    qt_config->beginGroup(QStringLiteral("Data Storage"));
-
-    WriteSetting(QStringLiteral("nand_directory"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
-    WriteSetting(QStringLiteral("sdmc_directory"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)));
-    WriteSetting(QStringLiteral("load_directory"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::LoadDir)),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::LoadDir)));
-    WriteSetting(QStringLiteral("dump_directory"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    WriteSetting(QStringLiteral("tas_directory"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)));
-
-    WriteCategory(Settings::Category::DataStorage);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveDebuggingValues() {
-    qt_config->beginGroup(QStringLiteral("Debugging"));
-
-    // Intentionally not using the QT default setting as this is intended to be changed in the ini
-    qt_config->setValue(QStringLiteral("record_frame_times"), Settings::values.record_frame_times);
-
-    WriteCategory(Settings::Category::Debugging);
-    WriteCategory(Settings::Category::DebuggingGraphics);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveNetworkValues() {
-    qt_config->beginGroup(QStringLiteral("Services"));
-
-    WriteCategory(Settings::Category::Network);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveDisabledAddOnValues() {
-    qt_config->beginWriteArray(QStringLiteral("DisabledAddOns"));
-
-    int i = 0;
-    for (const auto& elem : Settings::values.disabled_addons) {
-        qt_config->setArrayIndex(i);
-        WriteSetting(QStringLiteral("title_id"), QVariant::fromValue<u64>(elem.first), 0);
-        qt_config->beginWriteArray(QStringLiteral("disabled"));
-        for (std::size_t j = 0; j < elem.second.size(); ++j) {
-            qt_config->setArrayIndex(static_cast<int>(j));
-            WriteSetting(QStringLiteral("d"), QString::fromStdString(elem.second[j]), QString{});
-        }
-        qt_config->endArray();
-        ++i;
-    }
-
-    qt_config->endArray();
-}
-
-void Config::SaveMiscellaneousValues() {
-    qt_config->beginGroup(QStringLiteral("Miscellaneous"));
-
-    WriteCategory(Settings::Category::Miscellaneous);
-
-    qt_config->endGroup();
-}
-
-void Config::SavePathValues() {
-    qt_config->beginGroup(QStringLiteral("Paths"));
-
-    WriteSetting(QStringLiteral("romsPath"), UISettings::values.roms_path);
-    WriteSetting(QStringLiteral("symbolsPath"), UISettings::values.symbols_path);
-    qt_config->beginWriteArray(QStringLiteral("gamedirs"));
-    for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
-        qt_config->setArrayIndex(i);
-        const auto& game_dir = UISettings::values.game_dirs[i];
-        WriteSetting(QStringLiteral("path"), game_dir.path);
-        WriteSetting(QStringLiteral("deep_scan"), game_dir.deep_scan, false);
-        WriteSetting(QStringLiteral("expanded"), game_dir.expanded, true);
-    }
-    qt_config->endArray();
-    WriteSetting(QStringLiteral("recentFiles"), UISettings::values.recent_files);
-    WriteSetting(QStringLiteral("language"), UISettings::values.language, QString{});
-
-    qt_config->endGroup();
-}
-
-void Config::SaveCpuValues() {
-    qt_config->beginGroup(QStringLiteral("Cpu"));
-
-    WriteCategory(Settings::Category::Cpu);
-    WriteCategory(Settings::Category::CpuDebug);
-    WriteCategory(Settings::Category::CpuUnsafe);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveRendererValues() {
-    qt_config->beginGroup(QStringLiteral("Renderer"));
-
-    WriteCategory(Settings::Category::Renderer);
-    WriteCategory(Settings::Category::RendererAdvanced);
-    WriteCategory(Settings::Category::RendererDebug);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveScreenshotValues() {
-    qt_config->beginGroup(QStringLiteral("Screenshots"));
-
-    WriteSetting(QStringLiteral("screenshot_path"),
-                 QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir)));
-    WriteCategory(Settings::Category::Screenshots);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveShortcutValues() {
-    qt_config->beginGroup(QStringLiteral("Shortcuts"));
-
-    // Lengths of UISettings::values.shortcuts & default_hotkeys are same.
-    // However, their ordering must also be the same.
-    for (std::size_t i = 0; i < default_hotkeys.size(); i++) {
-        const auto& [name, group, shortcut] = UISettings::values.shortcuts[i];
-        const auto& default_hotkey = default_hotkeys[i].shortcut;
-
-        qt_config->beginGroup(group);
-        qt_config->beginGroup(name);
-        WriteSetting(QStringLiteral("KeySeq"), shortcut.keyseq, default_hotkey.keyseq);
-        WriteSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq,
-                     default_hotkey.controller_keyseq);
-        WriteSetting(QStringLiteral("Context"), shortcut.context, default_hotkey.context);
-        WriteSetting(QStringLiteral("Repeat"), shortcut.repeat, default_hotkey.repeat);
-        qt_config->endGroup();
-        qt_config->endGroup();
-    }
-
-    qt_config->endGroup();
-}
-
-void Config::SaveSystemValues() {
-    qt_config->beginGroup(QStringLiteral("System"));
-
-    WriteCategory(Settings::Category::System);
-    WriteCategory(Settings::Category::SystemAudio);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveUIValues() {
-    qt_config->beginGroup(QStringLiteral("UI"));
-
-    WriteCategory(Settings::Category::Ui);
-    WriteCategory(Settings::Category::UiGeneral);
-
-    WriteSetting(QStringLiteral("theme"), UISettings::values.theme,
-                 QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second));
-
-    SaveUIGamelistValues();
-    SaveUILayoutValues();
-    SavePathValues();
-    SaveScreenshotValues();
-    SaveShortcutValues();
-    SaveMultiplayerValues();
-
-    qt_config->endGroup();
-}
-
-void Config::SaveUIGamelistValues() {
-    qt_config->beginGroup(QStringLiteral("UIGameList"));
-
-    WriteCategory(Settings::Category::UiGameList);
-
-    qt_config->beginWriteArray(QStringLiteral("favorites"));
-    for (int i = 0; i < UISettings::values.favorited_ids.size(); i++) {
-        qt_config->setArrayIndex(i);
-        WriteSetting(QStringLiteral("program_id"),
-                     QVariant::fromValue(UISettings::values.favorited_ids[i]));
-    }
-    qt_config->endArray();
-
-    qt_config->endGroup();
-}
-
-void Config::SaveUILayoutValues() {
-    qt_config->beginGroup(QStringLiteral("UILayout"));
-
-    WriteSetting(QStringLiteral("geometry"), UISettings::values.geometry);
-    WriteSetting(QStringLiteral("state"), UISettings::values.state);
-    WriteSetting(QStringLiteral("geometryRenderWindow"), UISettings::values.renderwindow_geometry);
-    WriteSetting(QStringLiteral("gameListHeaderState"), UISettings::values.gamelist_header_state);
-    WriteSetting(QStringLiteral("microProfileDialogGeometry"),
-                 UISettings::values.microprofile_geometry);
-
-    WriteCategory(Settings::Category::UiLayout);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveWebServiceValues() {
-    qt_config->beginGroup(QStringLiteral("WebService"));
-
-    WriteCategory(Settings::Category::WebService);
-
-    qt_config->endGroup();
-}
-
-void Config::SaveMultiplayerValues() {
-    qt_config->beginGroup(QStringLiteral("Multiplayer"));
-
-    WriteCategory(Settings::Category::Multiplayer);
-
-    // Write ban list
-    qt_config->beginWriteArray(QStringLiteral("username_ban_list"));
-    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.first.size(); ++i) {
-        qt_config->setArrayIndex(static_cast<int>(i));
-        WriteSetting(QStringLiteral("username"),
-                     QString::fromStdString(UISettings::values.multiplayer_ban_list.first[i]));
-    }
-    qt_config->endArray();
-    qt_config->beginWriteArray(QStringLiteral("ip_ban_list"));
-    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.second.size(); ++i) {
-        qt_config->setArrayIndex(static_cast<int>(i));
-        WriteSetting(QStringLiteral("ip"),
-                     QString::fromStdString(UISettings::values.multiplayer_ban_list.second[i]));
-    }
-    qt_config->endArray();
-
-    qt_config->endGroup();
-}
-
-QVariant Config::ReadSetting(const QString& name) const {
-    return qt_config->value(name);
-}
-
-QVariant Config::ReadSetting(const QString& name, const QVariant& default_value) const {
-    QVariant result;
-    if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
-        result = default_value;
-    } else {
-        result = qt_config->value(name, default_value);
-    }
-    return result;
-}
-
-void Config::WriteSetting(const QString& name, const QVariant& value) {
-    qt_config->setValue(name, value);
-}
-
-void Config::WriteSetting(const QString& name, const QVariant& value,
-                          const QVariant& default_value) {
-    qt_config->setValue(name + QStringLiteral("/default"), value == default_value);
-    qt_config->setValue(name, value);
-}
-
-void Config::WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
-                          bool use_global) {
-    if (!global) {
-        qt_config->setValue(name + QStringLiteral("/use_global"), use_global);
-    }
-    if (global || !use_global) {
-        qt_config->setValue(name + QStringLiteral("/default"), value == default_value);
-        qt_config->setValue(name, value);
-    }
-}
-
-void Config::Reload() {
-    ReadValues();
-    // To apply default value changes
-    SaveValues();
-}
-
-void Config::Save() {
-    SaveValues();
-}
-
-void Config::ReadControlPlayerValue(std::size_t player_index) {
-    qt_config->beginGroup(QStringLiteral("Controls"));
-    ReadPlayerValue(player_index);
-    qt_config->endGroup();
-}
-
-void Config::SaveControlPlayerValue(std::size_t player_index) {
-    qt_config->beginGroup(QStringLiteral("Controls"));
-    SavePlayerValue(player_index);
-    qt_config->endGroup();
-}
-
-void Config::ClearControlPlayerValues() {
-    qt_config->beginGroup(QStringLiteral("Controls"));
-    // If key is an empty string, all keys in the current group() are removed.
-    qt_config->remove(QString{});
-    qt_config->endGroup();
-}
-
-const std::string& Config::GetConfigFilePath() const {
-    return qt_config_loc;
-}
-
-static auto FindRelevantList(Settings::Category category) {
-    auto& map = Settings::values.linkage.by_category;
-    if (map.contains(category)) {
-        return Settings::values.linkage.by_category[category];
-    }
-    return UISettings::values.linkage.by_category[category];
-}
-
-void Config::ReadCategory(Settings::Category category) {
-    const auto& settings = FindRelevantList(category);
-    std::for_each(settings.begin(), settings.end(),
-                  [&](const auto& setting) { ReadSettingGeneric(setting); });
-}
-
-void Config::WriteCategory(Settings::Category category) {
-    const auto& settings = FindRelevantList(category);
-    std::for_each(settings.begin(), settings.end(),
-                  [&](const auto& setting) { WriteSettingGeneric(setting); });
-}
-
-void Config::ReadSettingGeneric(Settings::BasicSetting* const setting) {
-    if (!setting->Save() || (!setting->Switchable() && !global)) {
-        return;
-    }
-    const QString name = QString::fromStdString(setting->GetLabel());
-    const auto default_value =
-        QVariant::fromValue<QString>(QString::fromStdString(setting->DefaultToString()));
-
-    bool use_global = true;
-    if (setting->Switchable() && !global) {
-        use_global = qt_config->value(name + QStringLiteral("/use_global"), true).value<bool>();
-        setting->SetGlobal(use_global);
-    }
-
-    if (global || !use_global) {
-        const bool is_default =
-            qt_config->value(name + QStringLiteral("/default"), true).value<bool>();
-        if (!is_default) {
-            setting->LoadString(
-                qt_config->value(name, default_value).value<QString>().toStdString());
-        } else {
-            // Empty string resets the Setting to default
-            setting->LoadString("");
-        }
-    }
-}
-
-void Config::WriteSettingGeneric(Settings::BasicSetting* const setting) const {
-    if (!setting->Save()) {
-        return;
-    }
-    const QVariant value = QVariant::fromValue(QString::fromStdString(setting->ToString()));
-    const QVariant default_value =
-        QVariant::fromValue(QString::fromStdString(setting->DefaultToString()));
-    const QString label = QString::fromStdString(setting->GetLabel());
-    if (setting->Switchable()) {
-        if (!global) {
-            qt_config->setValue(label + QStringLiteral("/use_global"), setting->UsingGlobal());
-        }
-        if (global || !setting->UsingGlobal()) {
-            qt_config->setValue(label + QStringLiteral("/default"), value == default_value);
-            qt_config->setValue(label, value);
-        }
-    } else if (global) {
-        qt_config->setValue(label + QStringLiteral("/default"), value == default_value);
-        qt_config->setValue(label, value);
-    }
-}
diff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.h
deleted file mode 100644
index 1589ba057..000000000
--- a/src/yuzu/configuration/config.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-#include <QMetaType>
-#include <QVariant>
-#include "common/settings.h"
-#include "common/settings_enums.h"
-#include "yuzu/uisettings.h"
-
-class QSettings;
-
-namespace Core {
-class System;
-}
-
-class Config {
-public:
-    enum class ConfigType {
-        GlobalConfig,
-        PerGameConfig,
-        InputProfile,
-    };
-
-    explicit Config(const std::string& config_name = "qt-config",
-                    ConfigType config_type = ConfigType::GlobalConfig);
-    ~Config();
-
-    void Reload();
-    void Save();
-
-    void ReadControlPlayerValue(std::size_t player_index);
-    void SaveControlPlayerValue(std::size_t player_index);
-    void ClearControlPlayerValues();
-
-    const std::string& GetConfigFilePath() const;
-
-    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
-    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
-    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
-    static const std::array<int, 2> default_stick_mod;
-    static const std::array<int, 2> default_ringcon_analogs;
-    static const std::array<int, Settings::NativeMouseButton::NumMouseButtons>
-        default_mouse_buttons;
-    static const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> default_keyboard_keys;
-    static const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> default_keyboard_mods;
-    static const std::array<UISettings::Shortcut, 23> default_hotkeys;
-
-    static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map;
-    static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map;
-    static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map;
-    static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map;
-    static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map;
-    static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map;
-
-    static constexpr UISettings::Theme default_theme{
-#ifdef _WIN32
-        UISettings::Theme::DarkColorful
-#else
-        UISettings::Theme::DefaultColorful
-#endif
-    };
-
-private:
-    void Initialize(const std::string& config_name);
-    bool IsCustomConfig();
-
-    void ReadValues();
-    void ReadPlayerValue(std::size_t player_index);
-    void ReadDebugValues();
-    void ReadKeyboardValues();
-    void ReadMouseValues();
-    void ReadTouchscreenValues();
-    void ReadMotionTouchValues();
-    void ReadHidbusValues();
-    void ReadIrCameraValues();
-
-    // Read functions bases off the respective config section names.
-    void ReadAudioValues();
-    void ReadControlValues();
-    void ReadCoreValues();
-    void ReadDataStorageValues();
-    void ReadDebuggingValues();
-    void ReadServiceValues();
-    void ReadDisabledAddOnValues();
-    void ReadMiscellaneousValues();
-    void ReadPathValues();
-    void ReadCpuValues();
-    void ReadRendererValues();
-    void ReadScreenshotValues();
-    void ReadShortcutValues();
-    void ReadSystemValues();
-    void ReadUIValues();
-    void ReadUIGamelistValues();
-    void ReadUILayoutValues();
-    void ReadWebServiceValues();
-    void ReadMultiplayerValues();
-    void ReadNetworkValues();
-
-    void SaveValues();
-    void SavePlayerValue(std::size_t player_index);
-    void SaveDebugValues();
-    void SaveMouseValues();
-    void SaveTouchscreenValues();
-    void SaveMotionTouchValues();
-    void SaveHidbusValues();
-    void SaveIrCameraValues();
-
-    // Save functions based off the respective config section names.
-    void SaveAudioValues();
-    void SaveControlValues();
-    void SaveCoreValues();
-    void SaveDataStorageValues();
-    void SaveDebuggingValues();
-    void SaveNetworkValues();
-    void SaveDisabledAddOnValues();
-    void SaveMiscellaneousValues();
-    void SavePathValues();
-    void SaveCpuValues();
-    void SaveRendererValues();
-    void SaveScreenshotValues();
-    void SaveShortcutValues();
-    void SaveSystemValues();
-    void SaveUIValues();
-    void SaveUIGamelistValues();
-    void SaveUILayoutValues();
-    void SaveWebServiceValues();
-    void SaveMultiplayerValues();
-
-    /**
-     * Reads a setting from the qt_config.
-     *
-     * @param name The setting's identifier
-     * @param default_value The value to use when the setting is not already present in the config
-     */
-    QVariant ReadSetting(const QString& name) const;
-    QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
-
-    /**
-     * Writes a setting to the qt_config.
-     *
-     * @param name The setting's idetentifier
-     * @param value Value of the setting
-     * @param default_value Default of the setting if not present in qt_config
-     * @param use_global Specifies if the custom or global config should be in use, for custom
-     * configs
-     */
-    void WriteSetting(const QString& name, const QVariant& value);
-    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value);
-    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
-                      bool use_global);
-
-    void ReadCategory(Settings::Category category);
-    void WriteCategory(Settings::Category category);
-    void ReadSettingGeneric(Settings::BasicSetting* const setting);
-    void WriteSettingGeneric(Settings::BasicSetting* const setting) const;
-
-    const ConfigType type;
-    std::unique_ptr<QSettings> qt_config;
-    std::string qt_config_loc;
-    const bool global;
-};
-
-// These metatype declarations cannot be in common/settings.h because core is devoid of QT
-Q_DECLARE_METATYPE(Settings::CpuAccuracy);
-Q_DECLARE_METATYPE(Settings::GpuAccuracy);
-Q_DECLARE_METATYPE(Settings::FullscreenMode);
-Q_DECLARE_METATYPE(Settings::NvdecEmulation);
-Q_DECLARE_METATYPE(Settings::ResolutionSetup);
-Q_DECLARE_METATYPE(Settings::ScalingFilter);
-Q_DECLARE_METATYPE(Settings::AntiAliasing);
-Q_DECLARE_METATYPE(Settings::RendererBackend);
-Q_DECLARE_METATYPE(Settings::ShaderBackend);
-Q_DECLARE_METATYPE(Settings::AstcRecompression);
-Q_DECLARE_METATYPE(Settings::AstcDecodeMode);
diff --git a/src/yuzu/configuration/configure_camera.cpp b/src/yuzu/configuration/configure_camera.cpp
index d95e96696..3368f53f3 100644
--- a/src/yuzu/configuration/configure_camera.cpp
+++ b/src/yuzu/configuration/configure_camera.cpp
@@ -10,10 +10,10 @@
 #include <QStandardItemModel>
 #include <QTimer>
 
+#include "common/settings.h"
 #include "input_common/drivers/camera.h"
 #include "input_common/main.h"
 #include "ui_configure_camera.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_camera.h"
 
 ConfigureCamera::ConfigureCamera(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_)
diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp
index 0ad95cc02..aab54a1cc 100644
--- a/src/yuzu/configuration/configure_dialog.cpp
+++ b/src/yuzu/configuration/configure_dialog.cpp
@@ -8,7 +8,6 @@
 #include "core/core.h"
 #include "ui_configure.h"
 #include "vk_device_info.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
 #include "yuzu/configuration/configure_debug_tab.h"
diff --git a/src/yuzu/configuration/configure_hotkeys.cpp b/src/yuzu/configuration/configure_hotkeys.cpp
index 68e21cd84..76fc33e49 100644
--- a/src/yuzu/configuration/configure_hotkeys.cpp
+++ b/src/yuzu/configuration/configure_hotkeys.cpp
@@ -9,10 +9,11 @@
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 
+#include "frontend_common/config.h"
 #include "ui_configure_hotkeys.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_hotkeys.h"
 #include "yuzu/hotkeys.h"
+#include "yuzu/uisettings.h"
 #include "yuzu/util/sequence_dialog/sequence_dialog.h"
 
 constexpr int name_column = 0;
@@ -62,18 +63,21 @@ ConfigureHotkeys::~ConfigureHotkeys() = default;
 
 void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) {
     for (const auto& group : registry.hotkey_groups) {
+        QString parent_item_data = QString::fromStdString(group.first);
         auto* parent_item =
-            new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(group.first)));
+            new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(parent_item_data)));
         parent_item->setEditable(false);
-        parent_item->setData(group.first);
+        parent_item->setData(parent_item_data);
         for (const auto& hotkey : group.second) {
-            auto* action =
-                new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(hotkey.first)));
+            QString hotkey_action_data = QString::fromStdString(hotkey.first);
+            auto* action = new QStandardItem(
+                QCoreApplication::translate("Hotkeys", qPrintable(hotkey_action_data)));
             auto* keyseq =
                 new QStandardItem(hotkey.second.keyseq.toString(QKeySequence::NativeText));
-            auto* controller_keyseq = new QStandardItem(hotkey.second.controller_keyseq);
+            auto* controller_keyseq =
+                new QStandardItem(QString::fromStdString(hotkey.second.controller_keyseq));
             action->setEditable(false);
-            action->setData(hotkey.first);
+            action->setData(hotkey_action_data);
             keyseq->setEditable(false);
             controller_keyseq->setEditable(false);
             parent_item->appendRow({action, keyseq, controller_keyseq});
@@ -301,13 +305,13 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
             const QStandardItem* controller_keyseq =
                 parent->child(key_column_id, controller_column);
             for (auto& [group, sub_actions] : registry.hotkey_groups) {
-                if (group != parent->data())
+                if (group != parent->data().toString().toStdString())
                     continue;
                 for (auto& [action_name, hotkey] : sub_actions) {
-                    if (action_name != action->data())
+                    if (action_name != action->data().toString().toStdString())
                         continue;
                     hotkey.keyseq = QKeySequence(keyseq->text());
-                    hotkey.controller_keyseq = controller_keyseq->text();
+                    hotkey.controller_keyseq = controller_keyseq->text().toStdString();
                 }
             }
         }
@@ -319,7 +323,7 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
 void ConfigureHotkeys::RestoreDefaults() {
     for (int r = 0; r < model->rowCount(); ++r) {
         const QStandardItem* parent = model->item(r, 0);
-        const int hotkey_size = static_cast<int>(Config::default_hotkeys.size());
+        const int hotkey_size = static_cast<int>(UISettings::default_hotkeys.size());
 
         if (hotkey_size != parent->rowCount()) {
             QMessageBox::warning(this, tr("Invalid hotkey settings"),
@@ -330,10 +334,11 @@ void ConfigureHotkeys::RestoreDefaults() {
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
             model->item(r, 0)
                 ->child(r2, hotkey_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.keyseq);
+                ->setText(QString::fromStdString(UISettings::default_hotkeys[r2].shortcut.keyseq));
             model->item(r, 0)
                 ->child(r2, controller_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.controller_keyseq);
+                ->setText(QString::fromStdString(
+                    UISettings::default_hotkeys[r2].shortcut.controller_keyseq));
         }
     }
 }
@@ -379,7 +384,7 @@ void ConfigureHotkeys::PopupContextMenu(const QPoint& menu_location) {
 
 void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) {
     const QString& default_key_sequence =
-        Config::default_hotkeys[index.row()].shortcut.controller_keyseq;
+        QString::fromStdString(UISettings::default_hotkeys[index.row()].shortcut.controller_keyseq);
     const auto [key_sequence_used, used_action] = IsUsedControllerKey(default_key_sequence);
 
     if (key_sequence_used && default_key_sequence != model->data(index).toString()) {
@@ -393,7 +398,8 @@ void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) {
 
 void ConfigureHotkeys::RestoreHotkey(QModelIndex index) {
     const QKeySequence& default_key_sequence = QKeySequence::fromString(
-        Config::default_hotkeys[index.row()].shortcut.keyseq, QKeySequence::NativeText);
+        QString::fromStdString(UISettings::default_hotkeys[index.row()].shortcut.keyseq),
+        QKeySequence::NativeText);
     const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence);
 
     if (key_sequence_used && default_key_sequence != QKeySequence(model->data(index).toString())) {
diff --git a/src/yuzu/configuration/configure_input_per_game.cpp b/src/yuzu/configuration/configure_input_per_game.cpp
index 78e65d468..8d9f65a05 100644
--- a/src/yuzu/configuration/configure_input_per_game.cpp
+++ b/src/yuzu/configuration/configure_input_per_game.cpp
@@ -5,12 +5,12 @@
 #include "core/core.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
+#include "frontend_common/config.h"
 #include "ui_configure_input_per_game.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input_per_game.h"
 #include "yuzu/configuration/input_profiles.h"
 
-ConfigureInputPerGame::ConfigureInputPerGame(Core::System& system_, Config* config_,
+ConfigureInputPerGame::ConfigureInputPerGame(Core::System& system_, QtConfig* config_,
                                              QWidget* parent)
     : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPerGame>()),
       profiles(std::make_unique<InputProfiles>()), system{system_}, config{config_} {
@@ -110,6 +110,6 @@ void ConfigureInputPerGame::SaveConfiguration() {
     // Clear all controls from the config in case the user reverted back to globals
     config->ClearControlPlayerValues();
     for (size_t index = 0; index < Settings::values.players.GetValue().size(); ++index) {
-        config->SaveControlPlayerValue(index);
+        config->SaveQtControlPlayerValues(index);
     }
 }
diff --git a/src/yuzu/configuration/configure_input_per_game.h b/src/yuzu/configuration/configure_input_per_game.h
index 660faf574..4420e856c 100644
--- a/src/yuzu/configuration/configure_input_per_game.h
+++ b/src/yuzu/configuration/configure_input_per_game.h
@@ -9,6 +9,7 @@
 
 #include "ui_configure_input_per_game.h"
 #include "yuzu/configuration/input_profiles.h"
+#include "yuzu/configuration/qt_config.h"
 
 class QComboBox;
 
@@ -22,7 +23,7 @@ class ConfigureInputPerGame : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureInputPerGame(Core::System& system_, Config* config_,
+    explicit ConfigureInputPerGame(Core::System& system_, QtConfig* config_,
                                    QWidget* parent = nullptr);
 
     /// Load and Save configurations to settings file.
@@ -41,5 +42,5 @@ private:
     std::array<QComboBox*, 8> profile_comboboxes;
 
     Core::System& system;
-    Config* config;
+    QtConfig* config;
 };
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 9259e2a5d..0f7b3714e 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -12,15 +12,16 @@
 #include <QTimer>
 #include "common/assert.h"
 #include "common/param_package.h"
+#include "configuration/qt_config.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hid/hid_types.h"
+#include "frontend_common/config.h"
 #include "input_common/drivers/keyboard.h"
 #include "input_common/drivers/mouse.h"
 #include "input_common/main.h"
 #include "ui_configure_input_player.h"
 #include "yuzu/bootmanager.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input_player.h"
 #include "yuzu/configuration/configure_input_player_widget.h"
 #include "yuzu/configuration/configure_mouse_panning.h"
@@ -1397,25 +1398,25 @@ void ConfigureInputPlayer::UpdateMappingWithDefaults() {
         for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
             emulated_controller->SetButtonParam(
                 button_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_buttons[button_id])});
+                               QtConfig::default_buttons[button_id])});
         }
         for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
             Common::ParamPackage analog_param{};
             for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
                 Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
-                    Config::default_analogs[analog_id][sub_button_id])};
+                    QtConfig::default_analogs[analog_id][sub_button_id])};
                 SetAnalogParam(params, analog_param, analog_sub_buttons[sub_button_id]);
             }
 
             analog_param.Set("modifier", InputCommon::GenerateKeyboardParam(
-                                             Config::default_stick_mod[analog_id]));
+                                             QtConfig::default_stick_mod[analog_id]));
             emulated_controller->SetStickParam(analog_id, analog_param);
         }
 
         for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
             emulated_controller->SetMotionParam(
                 motion_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_motions[motion_id])});
+                               QtConfig::default_motions[motion_id])});
         }
 
         // If mouse is selected we want to override with mappings from the driver
diff --git a/src/yuzu/configuration/configure_per_game.cpp b/src/yuzu/configuration/configure_per_game.cpp
index b91d6ad4a..b274a3321 100644
--- a/src/yuzu/configuration/configure_per_game.cpp
+++ b/src/yuzu/configuration/configure_per_game.cpp
@@ -25,8 +25,8 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/xts_archive.h"
 #include "core/loader/loader.h"
+#include "frontend_common/config.h"
 #include "ui_configure_per_game.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
@@ -50,8 +50,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
     const auto file_path = std::filesystem::path(Common::FS::ToU8String(file_name));
     const auto config_file_name = title_id == 0 ? Common::FS::PathToUTF8String(file_path.filename())
                                                 : fmt::format("{:016X}", title_id);
-    game_config = std::make_unique<Config>(config_file_name, Config::ConfigType::PerGameConfig);
-
+    game_config = std::make_unique<QtConfig>(config_file_name, Config::ConfigType::PerGameConfig);
     addons_tab = std::make_unique<ConfigurePerGameAddons>(system_, this);
     audio_tab = std::make_unique<ConfigureAudio>(system_, tab_group, *builder, this);
     cpu_tab = std::make_unique<ConfigureCpu>(system_, tab_group, *builder, this);
@@ -108,7 +107,7 @@ void ConfigurePerGame::ApplyConfiguration() {
     system.ApplySettings();
     Settings::LogSettings();
 
-    game_config->Save();
+    game_config->SaveAllValues();
 }
 
 void ConfigurePerGame::changeEvent(QEvent* event) {
diff --git a/src/yuzu/configuration/configure_per_game.h b/src/yuzu/configuration/configure_per_game.h
index cc2513001..c8ee46c04 100644
--- a/src/yuzu/configuration/configure_per_game.h
+++ b/src/yuzu/configuration/configure_per_game.h
@@ -12,9 +12,10 @@
 
 #include "configuration/shared_widget.h"
 #include "core/file_sys/vfs_types.h"
+#include "frontend_common/config.h"
 #include "vk_device_info.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
+#include "yuzu/configuration/qt_config.h"
 #include "yuzu/configuration/shared_translation.h"
 
 namespace Core {
@@ -72,7 +73,7 @@ private:
 
     QGraphicsScene* scene;
 
-    std::unique_ptr<Config> game_config;
+    std::unique_ptr<QtConfig> game_config;
 
     Core::System& system;
     std::unique_ptr<ConfigurationShared::Builder> builder;
diff --git a/src/yuzu/configuration/configure_per_game_addons.cpp b/src/yuzu/configuration/configure_per_game_addons.cpp
index 674a75a62..140a7fe5d 100644
--- a/src/yuzu/configuration/configure_per_game_addons.cpp
+++ b/src/yuzu/configuration/configure_per_game_addons.cpp
@@ -19,7 +19,6 @@
 #include "core/file_sys/xts_archive.h"
 #include "core/loader/loader.h"
 #include "ui_configure_per_game_addons.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input.h"
 #include "yuzu/configuration/configure_per_game_addons.h"
 #include "yuzu/uisettings.h"
diff --git a/src/yuzu/configuration/configure_ringcon.cpp b/src/yuzu/configuration/configure_ringcon.cpp
index f83705544..9572ff43c 100644
--- a/src/yuzu/configuration/configure_ringcon.cpp
+++ b/src/yuzu/configuration/configure_ringcon.cpp
@@ -8,6 +8,7 @@
 #include <QTimer>
 #include <fmt/format.h>
 
+#include "configuration/qt_config.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "input_common/drivers/keyboard.h"
@@ -15,7 +16,6 @@
 #include "input_common/main.h"
 #include "ui_configure_ringcon.h"
 #include "yuzu/bootmanager.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_ringcon.h"
 
 const std::array<std::string, ConfigureRingController::ANALOG_SUB_BUTTONS_NUM>
@@ -270,7 +270,7 @@ void ConfigureRingController::LoadConfiguration() {
 
 void ConfigureRingController::RestoreDefaults() {
     const std::string default_ring_string = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, Config::default_ringcon_analogs[0], Config::default_ringcon_analogs[1], 0, 0.05f);
+        0, 0, QtConfig::default_ringcon_analogs[0], QtConfig::default_ringcon_analogs[1], 0, 0.05f);
     emulated_controller->SetRingParam(Common::ParamPackage(default_ring_string));
     UpdateUI();
 }
diff --git a/src/yuzu/configuration/configure_system.cpp b/src/yuzu/configuration/configure_system.cpp
index 0c8e5c8b4..7cbf43775 100644
--- a/src/yuzu/configuration/configure_system.cpp
+++ b/src/yuzu/configuration/configure_system.cpp
@@ -16,7 +16,6 @@
 #include "core/core.h"
 #include "core/hle/service/time/time_manager.h"
 #include "ui_configure_system.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_system.h"
 #include "yuzu/configuration/shared_widget.h"
diff --git a/src/yuzu/configuration/configure_touchscreen_advanced.cpp b/src/yuzu/configuration/configure_touchscreen_advanced.cpp
index 5a03e48df..94df6d9d3 100644
--- a/src/yuzu/configuration/configure_touchscreen_advanced.cpp
+++ b/src/yuzu/configuration/configure_touchscreen_advanced.cpp
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <memory>
+#include "common/settings.h"
 #include "ui_configure_touchscreen_advanced.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_touchscreen_advanced.h"
 
 ConfigureTouchscreenAdvanced::ConfigureTouchscreenAdvanced(QWidget* parent)
diff --git a/src/yuzu/configuration/configure_ui.cpp b/src/yuzu/configuration/configure_ui.cpp
index 82f3b6e78..dd43f0a0e 100644
--- a/src/yuzu/configuration/configure_ui.cpp
+++ b/src/yuzu/configuration/configure_ui.cpp
@@ -164,7 +164,7 @@ ConfigureUi::~ConfigureUi() = default;
 
 void ConfigureUi::ApplyConfiguration() {
     UISettings::values.theme =
-        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
+        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString().toStdString();
     UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
     UISettings::values.show_compat = ui->show_compat->isChecked();
     UISettings::values.show_size = ui->show_size->isChecked();
@@ -191,9 +191,10 @@ void ConfigureUi::RequestGameListUpdate() {
 }
 
 void ConfigureUi::SetConfiguration() {
-    ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
+    ui->theme_combobox->setCurrentIndex(
+        ui->theme_combobox->findData(QString::fromStdString(UISettings::values.theme)));
     ui->language_combobox->setCurrentIndex(
-        ui->language_combobox->findData(UISettings::values.language));
+        ui->language_combobox->findData(QString::fromStdString(UISettings::values.language)));
     ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());
diff --git a/src/yuzu/configuration/input_profiles.cpp b/src/yuzu/configuration/input_profiles.cpp
index 41ef4250a..716efbccd 100644
--- a/src/yuzu/configuration/input_profiles.cpp
+++ b/src/yuzu/configuration/input_profiles.cpp
@@ -5,7 +5,7 @@
 
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
-#include "yuzu/configuration/config.h"
+#include "frontend_common/config.h"
 #include "yuzu/configuration/input_profiles.h"
 
 namespace FS = Common::FS;
@@ -44,7 +44,7 @@ InputProfiles::InputProfiles() {
             if (IsINI(filename) && IsProfileNameValid(name_without_ext)) {
                 map_profiles.insert_or_assign(
                     name_without_ext,
-                    std::make_unique<Config>(name_without_ext, Config::ConfigType::InputProfile));
+                    std::make_unique<QtConfig>(name_without_ext, Config::ConfigType::InputProfile));
             }
 
             return true;
@@ -85,7 +85,7 @@ bool InputProfiles::CreateProfile(const std::string& profile_name, std::size_t p
     }
 
     map_profiles.insert_or_assign(
-        profile_name, std::make_unique<Config>(profile_name, Config::ConfigType::InputProfile));
+        profile_name, std::make_unique<QtConfig>(profile_name, Config::ConfigType::InputProfile));
 
     return SaveProfile(profile_name, player_index);
 }
@@ -113,7 +113,7 @@ bool InputProfiles::LoadProfile(const std::string& profile_name, std::size_t pla
         return false;
     }
 
-    map_profiles[profile_name]->ReadControlPlayerValue(player_index);
+    map_profiles[profile_name]->ReadQtControlPlayerValues(player_index);
     return true;
 }
 
@@ -122,7 +122,7 @@ bool InputProfiles::SaveProfile(const std::string& profile_name, std::size_t pla
         return false;
     }
 
-    map_profiles[profile_name]->SaveControlPlayerValue(player_index);
+    map_profiles[profile_name]->SaveQtControlPlayerValues(player_index);
     return true;
 }
 
diff --git a/src/yuzu/configuration/input_profiles.h b/src/yuzu/configuration/input_profiles.h
index 2bf3e4250..023ec74a6 100644
--- a/src/yuzu/configuration/input_profiles.h
+++ b/src/yuzu/configuration/input_profiles.h
@@ -6,6 +6,8 @@
 #include <string>
 #include <unordered_map>
 
+#include "configuration/qt_config.h"
+
 namespace Core {
 class System;
 }
@@ -30,5 +32,5 @@ public:
 private:
     bool ProfileExistsInMap(const std::string& profile_name) const;
 
-    std::unordered_map<std::string, std::unique_ptr<Config>> map_profiles;
+    std::unordered_map<std::string, std::unique_ptr<QtConfig>> map_profiles;
 };
diff --git a/src/yuzu/configuration/qt_config.cpp b/src/yuzu/configuration/qt_config.cpp
new file mode 100644
index 000000000..82402ec70
--- /dev/null
+++ b/src/yuzu/configuration/qt_config.cpp
@@ -0,0 +1,548 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "input_common/main.h"
+#include "qt_config.h"
+#include "uisettings.h"
+
+const std::array<int, Settings::NativeButton::NumButtons> QtConfig::default_buttons = {
+    Qt::Key_C,    Qt::Key_X, Qt::Key_V,    Qt::Key_Z,  Qt::Key_F,
+    Qt::Key_G,    Qt::Key_Q, Qt::Key_E,    Qt::Key_R,  Qt::Key_T,
+    Qt::Key_M,    Qt::Key_N, Qt::Key_Left, Qt::Key_Up, Qt::Key_Right,
+    Qt::Key_Down, Qt::Key_Q, Qt::Key_E,    0,          0,
+    Qt::Key_Q,    Qt::Key_E,
+};
+
+const std::array<int, Settings::NativeMotion::NumMotions> QtConfig::default_motions = {
+    Qt::Key_7,
+    Qt::Key_8,
+};
+
+const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> QtConfig::default_analogs{{
+    {
+        Qt::Key_W,
+        Qt::Key_S,
+        Qt::Key_A,
+        Qt::Key_D,
+    },
+    {
+        Qt::Key_I,
+        Qt::Key_K,
+        Qt::Key_J,
+        Qt::Key_L,
+    },
+}};
+
+const std::array<int, 2> QtConfig::default_stick_mod = {
+    Qt::Key_Shift,
+    0,
+};
+
+const std::array<int, 2> QtConfig::default_ringcon_analogs{{
+    Qt::Key_A,
+    Qt::Key_D,
+}};
+
+QtConfig::QtConfig(const std::string& config_name, const ConfigType config_type)
+    : Config(config_type) {
+    Initialize(config_name);
+    if (config_type != ConfigType::InputProfile) {
+        ReadQtValues();
+        SaveQtValues();
+    }
+}
+
+QtConfig::~QtConfig() {
+    if (global) {
+        QtConfig::SaveAllValues();
+    }
+}
+
+void QtConfig::ReloadAllValues() {
+    Reload();
+    ReadQtValues();
+    SaveQtValues();
+}
+
+void QtConfig::SaveAllValues() {
+    Save();
+    SaveQtValues();
+}
+
+void QtConfig::ReadQtValues() {
+    if (global) {
+        ReadUIValues();
+    }
+    ReadQtControlValues();
+}
+
+void QtConfig::ReadQtPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix.append("player_").append(ToString(player_index)).append("_");
+    }
+
+    auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig()) {
+        const auto profile_name =
+            ReadStringSetting(std::string(player_prefix).append("profile_name"));
+        if (profile_name.empty()) {
+            // Use the global input config
+            player = Settings::values.players.GetValue(true)[player_index];
+            return;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& player_buttons = player.buttons[i];
+
+        player_buttons = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeButton::mapping[i]), default_param);
+        if (player_buttons.empty()) {
+            player_buttons = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& player_analogs = player.analogs[i];
+
+        player_analogs = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (player_analogs.empty()) {
+            player_analogs = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        auto& player_motions = player.motions[i];
+
+        player_motions = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeMotion::mapping[i]), default_param);
+        if (player_motions.empty()) {
+            player_motions = default_param;
+        }
+    }
+}
+
+void QtConfig::ReadHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    auto& ringcon_analogs = Settings::values.ringcon_analogs;
+
+    ringcon_analogs = ReadStringSetting(std::string("ring_controller"), default_param);
+    if (ringcon_analogs.empty()) {
+        ringcon_analogs = default_param;
+    }
+}
+
+void QtConfig::ReadDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
+
+        debug_pad_buttons = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeButton::mapping[i]), default_param);
+        if (debug_pad_buttons.empty()) {
+            debug_pad_buttons = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
+
+        debug_pad_analogs = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (debug_pad_analogs.empty()) {
+            debug_pad_analogs = default_param;
+        }
+    }
+}
+
+void QtConfig::ReadQtControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        ReadQtPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    ReadDebugControlValues();
+    ReadHidbusValues();
+
+    EndGroup();
+}
+
+void QtConfig::ReadPathValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
+
+    UISettings::values.roms_path = ReadStringSetting(std::string("romsPath"));
+    UISettings::values.symbols_path = ReadStringSetting(std::string("symbolsPath"));
+    UISettings::values.game_dir_deprecated =
+        ReadStringSetting(std::string("gameListRootDir"), std::string("."));
+    UISettings::values.game_dir_deprecated_deepscan =
+        ReadBooleanSetting(std::string("gameListDeepScan"), std::make_optional(false));
+
+    const int gamedirs_size = BeginArray(std::string("gamedirs"));
+    for (int i = 0; i < gamedirs_size; ++i) {
+        SetArrayIndex(i);
+        UISettings::GameDir game_dir;
+        game_dir.path = ReadStringSetting(std::string("path"));
+        game_dir.deep_scan =
+            ReadBooleanSetting(std::string("deep_scan"), std::make_optional(false));
+        game_dir.expanded = ReadBooleanSetting(std::string("expanded"), std::make_optional(true));
+        UISettings::values.game_dirs.append(game_dir);
+    }
+    EndArray();
+
+    // Create NAND and SD card directories if empty, these are not removable through the UI,
+    // also carries over old game list settings if present
+    if (UISettings::values.game_dirs.empty()) {
+        UISettings::GameDir game_dir;
+        game_dir.path = std::string("SDMC");
+        game_dir.expanded = true;
+        UISettings::values.game_dirs.append(game_dir);
+        game_dir.path = std::string("UserNAND");
+        UISettings::values.game_dirs.append(game_dir);
+        game_dir.path = std::string("SysNAND");
+        UISettings::values.game_dirs.append(game_dir);
+        if (UISettings::values.game_dir_deprecated != std::string(".")) {
+            game_dir.path = UISettings::values.game_dir_deprecated;
+            game_dir.deep_scan = UISettings::values.game_dir_deprecated_deepscan;
+            UISettings::values.game_dirs.append(game_dir);
+        }
+    }
+    UISettings::values.recent_files =
+        QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
+            .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
+    UISettings::values.language = ReadStringSetting(std::string("language"), std::string(""));
+
+    EndGroup();
+}
+
+void QtConfig::ReadShortcutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Shortcuts));
+
+    for (const auto& [name, group, shortcut] : UISettings::default_hotkeys) {
+        BeginGroup(group);
+        BeginGroup(name);
+
+        // No longer using ReadSetting for shortcut.second as it inaccurately returns a value of 1
+        // for WidgetWithChildrenShortcut which is a value of 3. Needed to fix shortcuts the open
+        // a file dialog in windowed mode
+        UISettings::values.shortcuts.push_back(
+            {name,
+             group,
+             {ReadStringSetting(std::string("KeySeq"), shortcut.keyseq),
+              ReadStringSetting(std::string("Controller_KeySeq"), shortcut.controller_keyseq),
+              shortcut.context,
+              ReadBooleanSetting(std::string("Repeat"), std::optional(shortcut.repeat))}});
+
+        EndGroup(); // name
+        EndGroup(); // group
+    }
+
+    EndGroup();
+}
+
+void QtConfig::ReadUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Ui));
+
+    UISettings::values.theme = ReadStringSetting(
+        std::string("theme"),
+        std::string(UISettings::themes[static_cast<size_t>(UISettings::default_theme)].second));
+
+    ReadUIGamelistValues();
+    ReadUILayoutValues();
+    ReadPathValues();
+    ReadScreenshotValues();
+    ReadShortcutValues();
+    ReadMultiplayerValues();
+
+    ReadCategory(Settings::Category::Ui);
+    ReadCategory(Settings::Category::UiGeneral);
+
+    EndGroup();
+}
+
+void QtConfig::ReadUIGamelistValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    ReadCategory(Settings::Category::UiGameList);
+
+    const int favorites_size = BeginArray("favorites");
+    for (int i = 0; i < favorites_size; i++) {
+        SetArrayIndex(i);
+        UISettings::values.favorited_ids.append(ReadIntegerSetting(std::string("program_id")));
+    }
+    EndArray();
+
+    EndGroup();
+}
+
+void QtConfig::ReadUILayoutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    ReadCategory(Settings::Category::UiLayout);
+
+    EndGroup();
+}
+
+void QtConfig::ReadMultiplayerValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Multiplayer));
+
+    ReadCategory(Settings::Category::Multiplayer);
+
+    // Read ban list back
+    int size = BeginArray(std::string("username_ban_list"));
+    UISettings::values.multiplayer_ban_list.first.resize(size);
+    for (int i = 0; i < size; ++i) {
+        SetArrayIndex(i);
+        UISettings::values.multiplayer_ban_list.first[i] =
+            ReadStringSetting(std::string("username"), std::string(""));
+    }
+    EndArray();
+
+    size = BeginArray(std::string("ip_ban_list"));
+    UISettings::values.multiplayer_ban_list.second.resize(size);
+    for (int i = 0; i < size; ++i) {
+        UISettings::values.multiplayer_ban_list.second[i] =
+            ReadStringSetting("username", std::string(""));
+    }
+    EndArray();
+
+    EndGroup();
+}
+
+void QtConfig::SaveQtValues() {
+    if (global) {
+        SaveUIValues();
+    }
+    SaveQtControlValues();
+
+    WriteToIni();
+}
+
+void QtConfig::SaveQtPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix = std::string("player_").append(ToString(player_index)).append("_");
+    }
+
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig() && player.profile_name.empty()) {
+        // No custom profile selected
+        return;
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeButton::mapping[i]),
+                     player.buttons[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]),
+                     player.analogs[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeMotion::mapping[i]),
+                     player.motions[i], std::make_optional(default_param));
+    }
+}
+
+void QtConfig::SaveDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteSetting(std::string("debug_pad_").append(Settings::NativeButton::mapping[i]),
+                     Settings::values.debug_pad_buttons[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteSetting(std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]),
+                     Settings::values.debug_pad_analogs[i], std::make_optional(default_param));
+    }
+}
+
+void QtConfig::SaveHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    WriteSetting(std::string("ring_controller"), Settings::values.ringcon_analogs,
+                 std::make_optional(default_param));
+}
+
+void QtConfig::SaveQtControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        SaveQtPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    SaveDebugControlValues();
+    SaveHidbusValues();
+
+    EndGroup();
+}
+
+void QtConfig::SavePathValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
+
+    WriteSetting(std::string("romsPath"), UISettings::values.roms_path);
+    WriteSetting(std::string("symbolsPath"), UISettings::values.symbols_path);
+    BeginArray(std::string("gamedirs"));
+    for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
+        SetArrayIndex(i);
+        const auto& game_dir = UISettings::values.game_dirs[i];
+        WriteSetting(std::string("path"), game_dir.path);
+        WriteSetting(std::string("deep_scan"), game_dir.deep_scan, std::make_optional(false));
+        WriteSetting(std::string("expanded"), game_dir.expanded, std::make_optional(true));
+    }
+    EndArray();
+
+    WriteSetting(std::string("recentFiles"),
+                 UISettings::values.recent_files.join(QStringLiteral(", ")).toStdString());
+    WriteSetting(std::string("language"), UISettings::values.language);
+
+    EndGroup();
+}
+
+void QtConfig::SaveShortcutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Shortcuts));
+
+    // Lengths of UISettings::values.shortcuts & default_hotkeys are same.
+    // However, their ordering must also be the same.
+    for (std::size_t i = 0; i < UISettings::default_hotkeys.size(); i++) {
+        const auto& [name, group, shortcut] = UISettings::values.shortcuts[i];
+        const auto& default_hotkey = UISettings::default_hotkeys[i].shortcut;
+
+        BeginGroup(group);
+        BeginGroup(name);
+
+        WriteSetting(std::string("KeySeq"), shortcut.keyseq,
+                     std::make_optional(default_hotkey.keyseq));
+        WriteSetting(std::string("Controller_KeySeq"), shortcut.controller_keyseq,
+                     std::make_optional(default_hotkey.controller_keyseq));
+        WriteSetting(std::string("Context"), shortcut.context,
+                     std::make_optional(default_hotkey.context));
+        WriteSetting(std::string("Repeat"), shortcut.repeat,
+                     std::make_optional(default_hotkey.repeat));
+
+        EndGroup(); // name
+        EndGroup(); // group
+    }
+
+    EndGroup();
+}
+
+void QtConfig::SaveUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Ui));
+
+    WriteCategory(Settings::Category::Ui);
+    WriteCategory(Settings::Category::UiGeneral);
+
+    WriteSetting(std::string("theme"), UISettings::values.theme,
+                 std::make_optional(std::string(
+                     UISettings::themes[static_cast<size_t>(UISettings::default_theme)].second)));
+
+    SaveUIGamelistValues();
+    SaveUILayoutValues();
+    SavePathValues();
+    SaveScreenshotValues();
+    SaveShortcutValues();
+    SaveMultiplayerValues();
+
+    EndGroup();
+}
+
+void QtConfig::SaveUIGamelistValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    WriteCategory(Settings::Category::UiGameList);
+
+    BeginArray(std::string("favorites"));
+    for (int i = 0; i < UISettings::values.favorited_ids.size(); i++) {
+        SetArrayIndex(i);
+        WriteSetting(std::string("program_id"), UISettings::values.favorited_ids[i]);
+    }
+    EndArray(); // favorites
+
+    EndGroup();
+}
+
+void QtConfig::SaveUILayoutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiLayout));
+
+    WriteCategory(Settings::Category::UiLayout);
+
+    EndGroup();
+}
+
+void QtConfig::SaveMultiplayerValues() {
+    BeginGroup(std::string("Multiplayer"));
+
+    WriteCategory(Settings::Category::Multiplayer);
+
+    // Write ban list
+    BeginArray(std::string("username_ban_list"));
+    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.first.size(); ++i) {
+        SetArrayIndex(static_cast<int>(i));
+        WriteSetting(std::string("username"), UISettings::values.multiplayer_ban_list.first[i]);
+    }
+    EndArray(); // username_ban_list
+
+    BeginArray(std::string("ip_ban_list"));
+    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.second.size(); ++i) {
+        SetArrayIndex(static_cast<int>(i));
+        WriteSetting(std::string("ip"), UISettings::values.multiplayer_ban_list.second[i]);
+    }
+    EndArray(); // ip_ban_list
+
+    EndGroup();
+}
+
+std::vector<Settings::BasicSetting*>& QtConfig::FindRelevantList(Settings::Category category) {
+    auto& map = Settings::values.linkage.by_category;
+    if (map.contains(category)) {
+        return Settings::values.linkage.by_category[category];
+    }
+    return UISettings::values.linkage.by_category[category];
+}
+
+void QtConfig::ReadQtControlPlayerValues(std::size_t player_index) {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    ReadPlayerValues(player_index);
+    ReadQtPlayerValues(player_index);
+
+    EndGroup();
+}
+
+void QtConfig::SaveQtControlPlayerValues(std::size_t player_index) {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    SavePlayerValues(player_index);
+    SaveQtPlayerValues(player_index);
+
+    EndGroup();
+
+    WriteToIni();
+}
diff --git a/src/yuzu/configuration/qt_config.h b/src/yuzu/configuration/qt_config.h
new file mode 100644
index 000000000..dc2dceb4d
--- /dev/null
+++ b/src/yuzu/configuration/qt_config.h
@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QMetaType>
+
+#include "frontend_common/config.h"
+
+class QtConfig final : public Config {
+public:
+    explicit QtConfig(const std::string& config_name = "qt-config",
+                      ConfigType config_type = ConfigType::GlobalConfig);
+    ~QtConfig() override;
+
+    void ReloadAllValues() override;
+    void SaveAllValues() override;
+
+    void ReadQtControlPlayerValues(std::size_t player_index);
+    void SaveQtControlPlayerValues(std::size_t player_index);
+
+protected:
+    void ReadQtValues();
+    void ReadQtPlayerValues(std::size_t player_index);
+    void ReadQtControlValues();
+    void ReadHidbusValues() override;
+    void ReadDebugControlValues() override;
+    void ReadPathValues() override;
+    void ReadShortcutValues() override;
+    void ReadUIValues() override;
+    void ReadUIGamelistValues() override;
+    void ReadUILayoutValues() override;
+    void ReadMultiplayerValues() override;
+
+    void SaveQtValues();
+    void SaveQtPlayerValues(std::size_t player_index);
+    void SaveQtControlValues();
+    void SaveHidbusValues() override;
+    void SaveDebugControlValues() override;
+    void SavePathValues() override;
+    void SaveShortcutValues() override;
+    void SaveUIValues() override;
+    void SaveUIGamelistValues() override;
+    void SaveUILayoutValues() override;
+    void SaveMultiplayerValues() override;
+
+    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
+
+public:
+    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
+    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
+    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
+    static const std::array<int, 2> default_stick_mod;
+    static const std::array<int, 2> default_ringcon_analogs;
+};
diff --git a/src/yuzu/configuration/shared_translation.h b/src/yuzu/configuration/shared_translation.h
index 99a0e808c..d5fc3b8de 100644
--- a/src/yuzu/configuration/shared_translation.h
+++ b/src/yuzu/configuration/shared_translation.h
@@ -10,6 +10,7 @@
 #include <vector>
 #include <QString>
 #include "common/common_types.h"
+#include "common/settings.h"
 
 class QWidget;
 
@@ -22,4 +23,46 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent);
 
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent);
 
+static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map = {
+    {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "None"))},
+    {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FXAA"))},
+    {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SMAA"))},
+};
+
+static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map = {
+    {Settings::ScalingFilter::NearestNeighbor,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Nearest"))},
+    {Settings::ScalingFilter::Bilinear,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
+    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
+    {Settings::ScalingFilter::Gaussian,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Gaussian"))},
+    {Settings::ScalingFilter::ScaleForce,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
+    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
+};
+
+static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {
+    {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Docked"))},
+    {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Handheld"))},
+};
+
+static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map = {
+    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Normal"))},
+    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "High"))},
+    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Extreme"))},
+};
+
+static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map = {
+    {Settings::RendererBackend::Vulkan, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Vulkan"))},
+    {Settings::RendererBackend::OpenGL, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "OpenGL"))},
+    {Settings::RendererBackend::Null, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Null"))},
+};
+
+static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map = {
+    {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},
+    {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},
+    {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},
+};
+
 } // namespace ConfigurationShared