diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index f751a1e244..b13eea0169 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -66,6 +66,7 @@ const std::array<const char*, NumMouseButtons> mapping = {{
 Values global_values;
 Values game_values;
 Values *values = &global_values;
+Values *config_values = &global_values;
 
 void CopyValues(Values& dst, const Values& src) {
     dst.udp_input_address = src.udp_input_address;
@@ -115,6 +116,16 @@ void SwapValues(ValuesSwapTarget target) {
     }
 }
 
+void SwapConfigValues(ValuesSwapTarget target) {
+    if (target == ValuesSwapTarget::ToGlobal) {
+        config_values = &global_values;
+    }
+    else {
+        CopyValues(game_values, global_values);
+        config_values = &game_values;
+    }
+}
+
 std::string GetTimeZoneString() {
     static constexpr std::array<const char*, 46> timezones{{
         "auto",      "default",   "CET", "CST6CDT", "Cuba",    "EET",    "Egypt",     "Eire",
diff --git a/src/core/settings.h b/src/core/settings.h
index 004e0caf4e..2551e7574b 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -497,16 +497,18 @@ struct Values {
 extern Values global_values;
 extern Values game_values;
 extern Values *values;
+extern Values *config_values;
 
 float Volume();
-void CopyValues(Values& dst, const Values& src);
 
 enum class ValuesSwapTarget {
     ToGlobal,
     ToGame,
 };
 
+void CopyValues(Values& dst, const Values& src);
 void SwapValues(ValuesSwapTarget target);
+void SwapConfigValues(ValuesSwapTarget target);
 
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 4de4dbb638..9448f07ea3 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -234,8 +234,8 @@ const std::array<UISettings::Shortcut, 16> Config::default_hotkeys{{
 // clang-format on
 
 void Config::ReadPlayerValues() {
-    for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
-        auto& player = Settings::values->players[p];
+    for (std::size_t p = 0; p < Settings::config_values->players.size(); ++p) {
+        auto& player = Settings::config_values->players[p];
 
         player.connected =
             ReadSetting(QStringLiteral("player_%1_connected").arg(p), false).toBool();
@@ -299,19 +299,19 @@ void Config::ReadPlayerValues() {
     }
 
     std::stable_partition(
-        Settings::values->players.begin(),
-        Settings::values->players.begin() +
+        Settings::config_values->players.begin(),
+        Settings::config_values->players.begin() +
             Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
         [](const auto& player) { return player.connected; });
 }
 
 void Config::ReadDebugValues() {
-    Settings::values->debug_pad_enabled =
+    Settings::config_values->debug_pad_enabled =
         ReadSetting(QStringLiteral("debug_pad_enabled"), false).toBool();
 
     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];
+        auto& debug_pad_buttons = Settings::config_values->debug_pad_buttons[i];
 
         debug_pad_buttons = qt_config
                                 ->value(QStringLiteral("debug_pad_") +
@@ -328,7 +328,7 @@ void Config::ReadDebugValues() {
         const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
             default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
             default_analogs[i][3], default_analogs[i][4], 0.5f);
-        auto& debug_pad_analogs = Settings::values->debug_pad_analogs[i];
+        auto& debug_pad_analogs = Settings::config_values->debug_pad_analogs[i];
 
         debug_pad_analogs = qt_config
                                 ->value(QStringLiteral("debug_pad_") +
@@ -343,26 +343,29 @@ void Config::ReadDebugValues() {
 }
 
 void Config::ReadKeyboardValues() {
-    Settings::values->keyboard_enabled =
+    Settings::config_values->keyboard_enabled =
         ReadSetting(QStringLiteral("keyboard_enabled"), false).toBool();
 
     std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
-                   Settings::values->keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
+                   Settings::config_values->keyboard_keys.begin(),
+                   InputCommon::GenerateKeyboardParam);
     std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
-                   Settings::values->keyboard_keys.begin() +
+                   Settings::config_values->keyboard_keys.begin() +
                        Settings::NativeKeyboard::LeftControlKey,
                    InputCommon::GenerateKeyboardParam);
     std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
-                   Settings::values->keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
+                   Settings::config_values->keyboard_mods.begin(),
+                   InputCommon::GenerateKeyboardParam);
 }
 
 void Config::ReadMouseValues() {
-    Settings::values->mouse_enabled = ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
+    Settings::config_values->mouse_enabled =
+        ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
 
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         const std::string default_param =
             InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
-        auto& mouse_buttons = Settings::values->mouse_buttons[i];
+        auto& mouse_buttons = Settings::config_values->mouse_buttons[i];
 
         mouse_buttons = qt_config
                             ->value(QStringLiteral("mouse_") +
@@ -377,25 +380,26 @@ void Config::ReadMouseValues() {
 }
 
 void Config::ReadTouchscreenValues() {
-    Settings::values->touchscreen.enabled =
+    Settings::config_values->touchscreen.enabled =
         ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool();
-    Settings::values->touchscreen.device =
+    Settings::config_values->touchscreen.device =
         ReadSetting(QStringLiteral("touchscreen_device"), QStringLiteral("engine:emu_window"))
             .toString()
             .toStdString();
 
-    Settings::values->touchscreen.finger =
+    Settings::config_values->touchscreen.finger =
         ReadSetting(QStringLiteral("touchscreen_finger"), 0).toUInt();
-    Settings::values->touchscreen.rotation_angle =
+    Settings::config_values->touchscreen.rotation_angle =
         ReadSetting(QStringLiteral("touchscreen_angle"), 0).toUInt();
-    Settings::values->touchscreen.diameter_x =
+    Settings::config_values->touchscreen.diameter_x =
         ReadSetting(QStringLiteral("touchscreen_diameter_x"), 15).toUInt();
-    Settings::values->touchscreen.diameter_y =
+    Settings::config_values->touchscreen.diameter_y =
         ReadSetting(QStringLiteral("touchscreen_diameter_y"), 15).toUInt();
 }
 
 void Config::ApplyDefaultProfileIfInputInvalid() {
-    if (!std::any_of(Settings::values->players.begin(), Settings::values->players.end(),
+    if (!std::any_of(Settings::config_values->players.begin(),
+                     Settings::config_values->players.end(),
                      [](const Settings::PlayerInput& in) { return in.connected; })) {
         ApplyInputProfileConfiguration(UISettings::values.profile_index);
     }
@@ -404,16 +408,17 @@ void Config::ApplyDefaultProfileIfInputInvalid() {
 void Config::ReadAudioValues() {
     qt_config->beginGroup(QStringLiteral("Audio"));
 
-    Settings::values->sink_id = ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
-                                   .toString()
-                                   .toStdString();
-    Settings::values->enable_audio_stretching =
+    Settings::config_values->sink_id =
+        ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
+                    .toString()
+                    .toStdString();
+    Settings::config_values->enable_audio_stretching =
         ReadSetting(QStringLiteral("enable_audio_stretching"), true).toBool();
-    Settings::values->audio_device_id =
+    Settings::config_values->audio_device_id =
         ReadSetting(QStringLiteral("output_device"), QStringLiteral("auto"))
             .toString()
             .toStdString();
-    Settings::values->volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
+    Settings::config_values->volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
 
     qt_config->endGroup();
 }
@@ -427,20 +432,20 @@ void Config::ReadControlValues() {
     ReadMouseValues();
     ReadTouchscreenValues();
 
-    Settings::values->motion_device =
+    Settings::config_values->motion_device =
         ReadSetting(QStringLiteral("motion_device"),
                     QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
             .toString()
             .toStdString();
-    Settings::values->udp_input_address =
+    Settings::config_values->udp_input_address =
         ReadSetting(QStringLiteral("udp_input_address"),
                     QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
             .toString()
             .toStdString();
-    Settings::values->udp_input_port = static_cast<u16>(
+    Settings::config_values->udp_input_port = static_cast<u16>(
         ReadSetting(QStringLiteral("udp_input_port"), InputCommon::CemuhookUDP::DEFAULT_PORT)
             .toInt());
-    Settings::values->udp_pad_index =
+    Settings::config_values->udp_pad_index =
         static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
 
     qt_config->endGroup();
@@ -449,7 +454,8 @@ void Config::ReadControlValues() {
 void Config::ReadCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    Settings::values->use_multi_core = ReadSetting(QStringLiteral("use_multi_core"), false).toBool();
+    Settings::config_values->use_multi_core =
+        ReadSetting(QStringLiteral("use_multi_core"), false).toBool();
 
     qt_config->endGroup();
 }
@@ -457,7 +463,8 @@ void Config::ReadCoreValues() {
 void Config::ReadDataStorageValues() {
     qt_config->beginGroup(QStringLiteral("Data Storage"));
 
-    Settings::values->use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
+    Settings::config_values->use_virtual_sd =
+        ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
     FileUtil::GetUserPath(
         FileUtil::UserPath::NANDDir,
         qt_config
@@ -493,25 +500,25 @@ void Config::ReadDataStorageValues() {
                     QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)))
             .toString()
             .toStdString());
-    Settings::values->gamecard_inserted =
+    Settings::config_values->gamecard_inserted =
         ReadSetting(QStringLiteral("gamecard_inserted"), false).toBool();
-    Settings::values->gamecard_current_game =
+    Settings::config_values->gamecard_current_game =
         ReadSetting(QStringLiteral("gamecard_current_game"), false).toBool();
-    Settings::values->gamecard_path =
+    Settings::config_values->gamecard_path =
         ReadSetting(QStringLiteral("gamecard_path"), QStringLiteral("")).toString().toStdString();
-    Settings::values->nand_total_size = static_cast<Settings::NANDTotalSize>(
+    Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
         ReadSetting(QStringLiteral("nand_total_size"),
                     QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDTotalSize::S29_1GB)))
             .toULongLong());
-    Settings::values->nand_user_size = static_cast<Settings::NANDUserSize>(
+    Settings::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
         ReadSetting(QStringLiteral("nand_user_size"),
                     QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDUserSize::S26GB)))
             .toULongLong());
-    Settings::values->nand_system_size = static_cast<Settings::NANDSystemSize>(
+    Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
         ReadSetting(QStringLiteral("nand_system_size"),
                     QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDSystemSize::S2_5GB)))
             .toULongLong());
-    Settings::values->sdmc_size = static_cast<Settings::SDMCSize>(
+    Settings::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
         ReadSetting(QStringLiteral("sdmc_size"),
                     QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)))
             .toULongLong());
@@ -523,20 +530,22 @@ 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 =
+    Settings::config_values->record_frame_times =
         qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
-    Settings::values->use_gdbstub = ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
-    Settings::values->gdbstub_port = ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
-    Settings::values->program_args =
+    Settings::config_values->use_gdbstub =
+        ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
+    Settings::config_values->gdbstub_port =
+        ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
+    Settings::config_values->program_args =
         ReadSetting(QStringLiteral("program_args"), QStringLiteral("")).toString().toStdString();
-    Settings::values->dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
-    Settings::values->dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
-    Settings::values->reporting_services =
+    Settings::config_values->dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
+    Settings::config_values->dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
+    Settings::config_values->reporting_services =
         ReadSetting(QStringLiteral("reporting_services"), false).toBool();
-    Settings::values->quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
-    Settings::values->disable_cpu_opt =
+    Settings::config_values->quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
+    Settings::config_values->disable_cpu_opt =
         ReadSetting(QStringLiteral("disable_cpu_opt"), false).toBool();
-    Settings::values->disable_macro_jit =
+    Settings::config_values->disable_macro_jit =
         ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
 
     qt_config->endGroup();
@@ -544,11 +553,11 @@ void Config::ReadDebuggingValues() {
 
 void Config::ReadServiceValues() {
     qt_config->beginGroup(QStringLiteral("Services"));
-    Settings::values->bcat_backend =
+    Settings::config_values->bcat_backend =
         ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("null"))
             .toString()
             .toStdString();
-    Settings::values->bcat_boxcat_local =
+    Settings::config_values->bcat_boxcat_local =
         ReadSetting(QStringLiteral("bcat_boxcat_local"), false).toBool();
     qt_config->endGroup();
 }
@@ -576,12 +585,13 @@ void Config::ReadDisabledAddOnValues() {
 void Config::ReadMiscellaneousValues() {
     qt_config->beginGroup(QStringLiteral("Miscellaneous"));
 
-    Settings::values->log_filter =
+    Settings::config_values->log_filter =
         ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
             .toString()
             .toStdString();
-    Settings::values->use_dev_keys = ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
-    Settings::values->use_global_values =
+    Settings::config_values->use_dev_keys =
+        ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
+    Settings::config_values->use_global_values =
         ReadSetting(QStringLiteral("use_global_values"), true).toBool();
 
     qt_config->endGroup();
@@ -632,32 +642,35 @@ void Config::ReadPathValues() {
 void Config::ReadRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
-    Settings::values->renderer_backend =
+    Settings::config_values->renderer_backend =
         static_cast<Settings::RendererBackend>(ReadSetting(QStringLiteral("backend"), 0).toInt());
-    Settings::values->renderer_debug = ReadSetting(QStringLiteral("debug"), false).toBool();
-    Settings::values->vulkan_device = ReadSetting(QStringLiteral("vulkan_device"), 0).toInt();
-    Settings::values->aspect_ratio = ReadSetting(QStringLiteral("aspect_ratio"), 0).toInt();
-    Settings::values->max_anisotropy = ReadSetting(QStringLiteral("max_anisotropy"), 0).toInt();
-    Settings::values->use_frame_limit =
+    Settings::config_values->renderer_debug = ReadSetting(QStringLiteral("debug"), false).toBool();
+    Settings::config_values->vulkan_device =
+        ReadSetting(QStringLiteral("vulkan_device"), 0).toInt();
+    Settings::config_values->aspect_ratio =
+        ReadSetting(QStringLiteral("aspect_ratio"), 0).toInt();
+    Settings::config_values->max_anisotropy =
+        ReadSetting(QStringLiteral("max_anisotropy"), 0).toInt();
+    Settings::config_values->use_frame_limit =
         ReadSetting(QStringLiteral("use_frame_limit"), true).toBool();
-    Settings::values->frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
-    Settings::values->use_disk_shader_cache =
+    Settings::config_values->frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
+    Settings::config_values->use_disk_shader_cache =
         ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
     const int gpu_accuracy_level = ReadSetting(QStringLiteral("gpu_accuracy"), 0).toInt();
-    Settings::values->gpu_accuracy = static_cast<Settings::GPUAccuracy>(gpu_accuracy_level);
-    Settings::values->use_asynchronous_gpu_emulation =
+    Settings::config_values->gpu_accuracy = static_cast<Settings::GPUAccuracy>(gpu_accuracy_level);
+    Settings::config_values->use_asynchronous_gpu_emulation =
         ReadSetting(QStringLiteral("use_asynchronous_gpu_emulation"), false).toBool();
-    Settings::values->use_vsync = ReadSetting(QStringLiteral("use_vsync"), true).toBool();
-    Settings::values->use_assembly_shaders =
+    Settings::config_values->use_vsync = ReadSetting(QStringLiteral("use_vsync"), true).toBool();
+    Settings::config_values->use_assembly_shaders =
         ReadSetting(QStringLiteral("use_assembly_shaders"), false).toBool();
-    Settings::values->use_fast_gpu_time =
+    Settings::config_values->use_fast_gpu_time =
         ReadSetting(QStringLiteral("use_fast_gpu_time"), true).toBool();
-    Settings::values->force_30fps_mode =
+    Settings::config_values->force_30fps_mode =
         ReadSetting(QStringLiteral("force_30fps_mode"), false).toBool();
 
-    Settings::values->bg_red = ReadSetting(QStringLiteral("bg_red"), 0.0).toFloat();
-    Settings::values->bg_green = ReadSetting(QStringLiteral("bg_green"), 0.0).toFloat();
-    Settings::values->bg_blue = ReadSetting(QStringLiteral("bg_blue"), 0.0).toFloat();
+    Settings::config_values->bg_red = ReadSetting(QStringLiteral("bg_red"), 0.0).toFloat();
+    Settings::config_values->bg_green = ReadSetting(QStringLiteral("bg_green"), 0.0).toFloat();
+    Settings::config_values->bg_blue = ReadSetting(QStringLiteral("bg_blue"), 0.0).toFloat();
 
     qt_config->endGroup();
 }
@@ -686,35 +699,39 @@ void Config::ReadShortcutValues() {
 void Config::ReadSystemValues() {
     qt_config->beginGroup(QStringLiteral("System"));
 
-    Settings::values->use_docked_mode =
+    Settings::config_values->use_docked_mode =
         ReadSetting(QStringLiteral("use_docked_mode"), false).toBool();
 
-    Settings::values->current_user = std::clamp<int>(
+    Settings::config_values->current_user = std::clamp<int>(
         ReadSetting(QStringLiteral("current_user"), 0).toInt(), 0, Service::Account::MAX_USERS - 1);
 
-    Settings::values->language_index = ReadSetting(QStringLiteral("language_index"), 1).toInt();
+    Settings::config_values->language_index =
+        ReadSetting(QStringLiteral("language_index"), 1).toInt();
 
-    Settings::values->region_index = ReadSetting(QStringLiteral("region_index"), 1).toInt();
+    Settings::config_values->region_index =
+        ReadSetting(QStringLiteral("region_index"), 1).toInt();
 
-    Settings::values->time_zone_index = ReadSetting(QStringLiteral("time_zone_index"), 0).toInt();
+    Settings::config_values->time_zone_index =
+        ReadSetting(QStringLiteral("time_zone_index"), 0).toInt();
 
     const auto rng_seed_enabled = ReadSetting(QStringLiteral("rng_seed_enabled"), false).toBool();
     if (rng_seed_enabled) {
-        Settings::values->rng_seed = ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
+        Settings::config_values->rng_seed =
+            ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
     } else {
-        Settings::values->rng_seed = std::nullopt;
+        Settings::config_values->rng_seed = std::nullopt;
     }
 
     const auto custom_rtc_enabled =
         ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
     if (custom_rtc_enabled) {
-        Settings::values->custom_rtc =
+        Settings::config_values->custom_rtc =
             std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
     } else {
-        Settings::values->custom_rtc = std::nullopt;
+        Settings::config_values->custom_rtc = std::nullopt;
     }
 
-    Settings::values->sound_index = ReadSetting(QStringLiteral("sound_index"), 1).toInt();
+    Settings::config_values->sound_index = ReadSetting(QStringLiteral("sound_index"), 1).toInt();
 
     qt_config->endGroup();
 }
@@ -793,15 +810,15 @@ void Config::ReadUILayoutValues() {
 void Config::ReadWebServiceValues() {
     qt_config->beginGroup(QStringLiteral("WebService"));
 
-    Settings::values->enable_telemetry =
+    Settings::config_values->enable_telemetry =
         ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
-    Settings::values->web_api_url =
+    Settings::config_values->web_api_url =
         ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.yuzu-emu.org"))
             .toString()
             .toStdString();
-    Settings::values->yuzu_username =
+    Settings::config_values->yuzu_username =
         ReadSetting(QStringLiteral("yuzu_username")).toString().toStdString();
-    Settings::values->yuzu_token =
+    Settings::config_values->yuzu_token =
         ReadSetting(QStringLiteral("yuzu_token")).toString().toStdString();
 
     qt_config->endGroup();
@@ -814,8 +831,8 @@ void Config::ReadValues() {
         ReadWebServiceValues();
         ReadDisabledAddOnValues();
         ReadUIValues();
+        ReadControlValues();
     }
-    ReadControlValues();
     ReadCoreValues();
     ReadRendererValues();
     ReadAudioValues();
@@ -825,8 +842,8 @@ void Config::ReadValues() {
 }
 
 void Config::SavePlayerValues() {
-    for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
-        const auto& player = Settings::values->players[p];
+    for (std::size_t p = 0; p < Settings::config_values->players.size(); ++p) {
+        const auto& player = Settings::config_values->players[p];
 
         WriteSetting(QStringLiteral("player_%1_connected").arg(p), player.connected, false);
         WriteSetting(QStringLiteral("player_%1_type").arg(p), static_cast<u8>(player.type),
@@ -862,12 +879,13 @@ void Config::SavePlayerValues() {
 }
 
 void Config::SaveDebugValues() {
-    WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::values->debug_pad_enabled, false);
+    WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::config_values->debug_pad_enabled,
+                 false);
     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(Settings::config_values->debug_pad_buttons[i]),
                      QString::fromStdString(default_param));
     }
     for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
@@ -876,26 +894,26 @@ void Config::SaveDebugValues() {
             default_analogs[i][3], default_analogs[i][4], 0.5f);
         WriteSetting(QStringLiteral("debug_pad_") +
                          QString::fromStdString(Settings::NativeAnalog::mapping[i]),
-                     QString::fromStdString(Settings::values->debug_pad_analogs[i]),
+                     QString::fromStdString(Settings::config_values->debug_pad_analogs[i]),
                      QString::fromStdString(default_param));
     }
 }
 
 void Config::SaveMouseValues() {
-    WriteSetting(QStringLiteral("mouse_enabled"), Settings::values->mouse_enabled, false);
+    WriteSetting(QStringLiteral("mouse_enabled"), Settings::config_values->mouse_enabled, false);
 
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         const std::string default_param =
             InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
         WriteSetting(QStringLiteral("mouse_") +
                          QString::fromStdString(Settings::NativeMouseButton::mapping[i]),
-                     QString::fromStdString(Settings::values->mouse_buttons[i]),
+                     QString::fromStdString(Settings::config_values->mouse_buttons[i]),
                      QString::fromStdString(default_param));
     }
 }
 
 void Config::SaveTouchscreenValues() {
-    const auto& touchscreen = Settings::values->touchscreen;
+    const auto& touchscreen = Settings::config_values->touchscreen;
 
     WriteSetting(QStringLiteral("touchscreen_enabled"), touchscreen.enabled, true);
     WriteSetting(QStringLiteral("touchscreen_device"), QString::fromStdString(touchscreen.device),
@@ -914,8 +932,8 @@ void Config::SaveValues() {
         SaveWebServiceValues();
         SaveDisabledAddOnValues();
         SaveUIValues();
+        SaveControlValues();
     }
-    SaveControlValues();
     SaveCoreValues();
     SaveRendererValues();
     SaveAudioValues();
@@ -927,13 +945,15 @@ void Config::SaveValues() {
 void Config::SaveAudioValues() {
     qt_config->beginGroup(QStringLiteral("Audio"));
 
-    WriteSetting(QStringLiteral("output_engine"), QString::fromStdString(Settings::values->sink_id),
+    WriteSetting(QStringLiteral("output_engine"),
+                 QString::fromStdString(Settings::config_values->sink_id),
                  QStringLiteral("auto"));
     WriteSetting(QStringLiteral("enable_audio_stretching"),
-                 Settings::values->enable_audio_stretching, true);
+                 Settings::config_values->enable_audio_stretching, true);
     WriteSetting(QStringLiteral("output_device"),
-                 QString::fromStdString(Settings::values->audio_device_id), QStringLiteral("auto"));
-    WriteSetting(QStringLiteral("volume"), Settings::values->volume, 1.0f);
+                 QString::fromStdString(Settings::config_values->audio_device_id),
+                 QStringLiteral("auto"));
+    WriteSetting(QStringLiteral("volume"), Settings::config_values->volume, 1.0f);
 
     qt_config->endGroup();
 }
@@ -947,15 +967,16 @@ void Config::SaveControlValues() {
     SaveTouchscreenValues();
 
     WriteSetting(QStringLiteral("motion_device"),
-                 QString::fromStdString(Settings::values->motion_device),
+                 QString::fromStdString(Settings::config_values->motion_device),
                  QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
-    WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values->keyboard_enabled, false);
+    WriteSetting(QStringLiteral("keyboard_enabled"), Settings::config_values->keyboard_enabled,
+                 false);
     WriteSetting(QStringLiteral("udp_input_address"),
-                 QString::fromStdString(Settings::values->udp_input_address),
+                 QString::fromStdString(Settings::config_values->udp_input_address),
                  QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
-    WriteSetting(QStringLiteral("udp_input_port"), Settings::values->udp_input_port,
+    WriteSetting(QStringLiteral("udp_input_port"), Settings::config_values->udp_input_port,
                  InputCommon::CemuhookUDP::DEFAULT_PORT);
-    WriteSetting(QStringLiteral("udp_pad_index"), Settings::values->udp_pad_index, 0);
+    WriteSetting(QStringLiteral("udp_pad_index"), Settings::config_values->udp_pad_index, 0);
 
     qt_config->endGroup();
 }
@@ -963,7 +984,7 @@ void Config::SaveControlValues() {
 void Config::SaveCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    WriteSetting(QStringLiteral("use_multi_core"), Settings::values->use_multi_core, false);
+    WriteSetting(QStringLiteral("use_multi_core"), Settings::config_values->use_multi_core, false);
 
     qt_config->endGroup();
 }
@@ -971,7 +992,7 @@ void Config::SaveCoreValues() {
 void Config::SaveDataStorageValues() {
     qt_config->beginGroup(QStringLiteral("Data Storage"));
 
-    WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values->use_virtual_sd, true);
+    WriteSetting(QStringLiteral("use_virtual_sd"), Settings::config_values->use_virtual_sd, true);
     WriteSetting(QStringLiteral("nand_directory"),
                  QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)),
                  QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
@@ -987,22 +1008,27 @@ void Config::SaveDataStorageValues() {
     WriteSetting(QStringLiteral("cache_directory"),
                  QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)),
                  QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)));
-    WriteSetting(QStringLiteral("gamecard_inserted"), Settings::values->gamecard_inserted, false);
-    WriteSetting(QStringLiteral("gamecard_current_game"), Settings::values->gamecard_current_game,
+    WriteSetting(QStringLiteral("gamecard_inserted"), Settings::config_values->gamecard_inserted,
                  false);
+    WriteSetting(QStringLiteral("gamecard_current_game"),
+                 Settings::config_values->gamecard_current_game, false);
     WriteSetting(QStringLiteral("gamecard_path"),
-                 QString::fromStdString(Settings::values->gamecard_path), QStringLiteral(""));
+                 QString::fromStdString(Settings::config_values->gamecard_path),
+                 QStringLiteral(""));
     WriteSetting(QStringLiteral("nand_total_size"),
-                 QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_total_size)),
+                 QVariant::fromValue<u64>(static_cast<u64>(
+                     Settings::config_values->nand_total_size)),
                  QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDTotalSize::S29_1GB)));
     WriteSetting(QStringLiteral("nand_user_size"),
-                 QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_user_size)),
+                 QVariant::fromValue<u64>(static_cast<u64>(
+                     Settings::config_values->nand_user_size)),
                  QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDUserSize::S26GB)));
     WriteSetting(QStringLiteral("nand_system_size"),
-                 QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_system_size)),
+                 QVariant::fromValue<u64>(
+                     static_cast<u64>(Settings::config_values->nand_system_size)),
                  QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDSystemSize::S2_5GB)));
     WriteSetting(QStringLiteral("sdmc_size"),
-                 QVariant::fromValue<u64>(static_cast<u64>(Settings::values->sdmc_size)),
+                 QVariant::fromValue<u64>(static_cast<u64>(Settings::config_values->sdmc_size)),
                  QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)));
     qt_config->endGroup();
 }
@@ -1011,16 +1037,19 @@ 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);
-    WriteSetting(QStringLiteral("use_gdbstub"), Settings::values->use_gdbstub, false);
-    WriteSetting(QStringLiteral("gdbstub_port"), Settings::values->gdbstub_port, 24689);
+    qt_config->setValue(QStringLiteral("record_frame_times"),
+                        Settings::config_values->record_frame_times);
+    WriteSetting(QStringLiteral("use_gdbstub"), Settings::config_values->use_gdbstub, false);
+    WriteSetting(QStringLiteral("gdbstub_port"), Settings::config_values->gdbstub_port, 24689);
     WriteSetting(QStringLiteral("program_args"),
-                 QString::fromStdString(Settings::values->program_args), QStringLiteral(""));
-    WriteSetting(QStringLiteral("dump_exefs"), Settings::values->dump_exefs, false);
-    WriteSetting(QStringLiteral("dump_nso"), Settings::values->dump_nso, false);
-    WriteSetting(QStringLiteral("quest_flag"), Settings::values->quest_flag, false);
-    WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::values->disable_cpu_opt, false);
-    WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values->disable_macro_jit, false);
+                 QString::fromStdString(Settings::config_values->program_args), QStringLiteral(""));
+    WriteSetting(QStringLiteral("dump_exefs"), Settings::config_values->dump_exefs, false);
+    WriteSetting(QStringLiteral("dump_nso"), Settings::config_values->dump_nso, false);
+    WriteSetting(QStringLiteral("quest_flag"), Settings::config_values->quest_flag, false);
+    WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::config_values->disable_cpu_opt,
+                 false);
+    WriteSetting(QStringLiteral("disable_macro_jit"), Settings::config_values->disable_macro_jit,
+                 false);
 
     qt_config->endGroup();
 }
@@ -1028,8 +1057,10 @@ void Config::SaveDebuggingValues() {
 void Config::SaveServiceValues() {
     qt_config->beginGroup(QStringLiteral("Services"));
     WriteSetting(QStringLiteral("bcat_backend"),
-                 QString::fromStdString(Settings::values->bcat_backend), QStringLiteral("null"));
-    WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::values->bcat_boxcat_local, false);
+                 QString::fromStdString(Settings::config_values->bcat_backend),
+                 QStringLiteral("null"));
+    WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::config_values->bcat_boxcat_local,
+                 false);
     qt_config->endGroup();
 }
 
@@ -1056,10 +1087,12 @@ void Config::SaveDisabledAddOnValues() {
 void Config::SaveMiscellaneousValues() {
     qt_config->beginGroup(QStringLiteral("Miscellaneous"));
 
-    WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values->log_filter),
+    WriteSetting(QStringLiteral("log_filter"),
+                 QString::fromStdString(Settings::config_values->log_filter),
                  QStringLiteral("*:Info"));
-    WriteSetting(QStringLiteral("use_dev_keys"), Settings::values->use_dev_keys, false);
-    WriteSetting(QStringLiteral("use_global_values"), Settings::values->use_global_values, true);
+    WriteSetting(QStringLiteral("use_dev_keys"), Settings::config_values->use_dev_keys, false);
+    WriteSetting(QStringLiteral("use_global_values"), Settings::config_values->use_global_values,
+                 true);
 
     qt_config->endGroup();
 }
@@ -1087,29 +1120,35 @@ void Config::SavePathValues() {
 void Config::SaveRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
-    WriteSetting(QStringLiteral("backend"), static_cast<int>(Settings::values->renderer_backend), 0);
-    WriteSetting(QStringLiteral("debug"), Settings::values->renderer_debug, false);
-    WriteSetting(QStringLiteral("vulkan_device"), Settings::values->vulkan_device, 0);
-    WriteSetting(QStringLiteral("aspect_ratio"), Settings::values->aspect_ratio, 0);
-    WriteSetting(QStringLiteral("max_anisotropy"), Settings::values->max_anisotropy, 0);
-    WriteSetting(QStringLiteral("use_frame_limit"), Settings::values->use_frame_limit, true);
-    WriteSetting(QStringLiteral("frame_limit"), Settings::values->frame_limit, 100);
-    WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values->use_disk_shader_cache,
-                 true);
-    WriteSetting(QStringLiteral("gpu_accuracy"), static_cast<int>(Settings::values->gpu_accuracy),
-                 0);
+    WriteSetting(QStringLiteral("backend"),
+                 static_cast<int>(Settings::config_values->renderer_backend), 0);
+    WriteSetting(QStringLiteral("debug"), Settings::config_values->renderer_debug, false);
+    WriteSetting(QStringLiteral("vulkan_device"), Settings::config_values->vulkan_device, 0);
+    WriteSetting(QStringLiteral("aspect_ratio"), Settings::config_values->aspect_ratio, 0);
+    WriteSetting(QStringLiteral("max_anisotropy"), Settings::config_values->max_anisotropy, 0);
+    WriteSetting(QStringLiteral("use_frame_limit"), Settings::config_values->use_frame_limit, true);
+    WriteSetting(QStringLiteral("frame_limit"), Settings::config_values->frame_limit, 100);
+    WriteSetting(QStringLiteral("use_disk_shader_cache"),
+                 Settings::config_values->use_disk_shader_cache, true);
+    WriteSetting(QStringLiteral("gpu_accuracy"),
+                 static_cast<int>(Settings::config_values->gpu_accuracy), 0);
     WriteSetting(QStringLiteral("use_asynchronous_gpu_emulation"),
-                 Settings::values->use_asynchronous_gpu_emulation, false);
-    WriteSetting(QStringLiteral("use_vsync"), Settings::values->use_vsync, true);
-    WriteSetting(QStringLiteral("use_assembly_shaders"), Settings::values->use_assembly_shaders,
-                 false);
-    WriteSetting(QStringLiteral("use_fast_gpu_time"), Settings::values->use_fast_gpu_time, true);
-    WriteSetting(QStringLiteral("force_30fps_mode"), Settings::values->force_30fps_mode, false);
+                 Settings::config_values->use_asynchronous_gpu_emulation, false);
+    WriteSetting(QStringLiteral("use_vsync"), Settings::config_values->use_vsync, true);
+    WriteSetting(QStringLiteral("use_assembly_shaders"),
+                 Settings::config_values->use_assembly_shaders, false);
+    WriteSetting(QStringLiteral("use_fast_gpu_time"),
+                 Settings::config_values->use_fast_gpu_time, true);
+    WriteSetting(QStringLiteral("force_30fps_mode"),
+                 Settings::config_values->force_30fps_mode, false);
 
     // Cast to double because Qt's written float values are not human-readable
-    WriteSetting(QStringLiteral("bg_red"), static_cast<double>(Settings::values->bg_red), 0.0);
-    WriteSetting(QStringLiteral("bg_green"), static_cast<double>(Settings::values->bg_green), 0.0);
-    WriteSetting(QStringLiteral("bg_blue"), static_cast<double>(Settings::values->bg_blue), 0.0);
+    WriteSetting(QStringLiteral("bg_red"),
+                 static_cast<double>(Settings::config_values->bg_red), 0.0);
+    WriteSetting(QStringLiteral("bg_green"),
+                 static_cast<double>(Settings::config_values->bg_green), 0.0);
+    WriteSetting(QStringLiteral("bg_blue"),
+                 static_cast<double>(Settings::config_values->bg_blue), 0.0);
 
     qt_config->endGroup();
 }
@@ -1137,23 +1176,25 @@ void Config::SaveShortcutValues() {
 void Config::SaveSystemValues() {
     qt_config->beginGroup(QStringLiteral("System"));
 
-    WriteSetting(QStringLiteral("use_docked_mode"), Settings::values->use_docked_mode, false);
-    WriteSetting(QStringLiteral("current_user"), Settings::values->current_user, 0);
-    WriteSetting(QStringLiteral("language_index"), Settings::values->language_index, 1);
-    WriteSetting(QStringLiteral("region_index"), Settings::values->region_index, 1);
-    WriteSetting(QStringLiteral("time_zone_index"), Settings::values->time_zone_index, 0);
-
-    WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::values->rng_seed.has_value(), false);
-    WriteSetting(QStringLiteral("rng_seed"), Settings::values->rng_seed.value_or(0), 0);
-
-    WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values->custom_rtc.has_value(),
+    WriteSetting(QStringLiteral("use_docked_mode"), Settings::config_values->use_docked_mode,
                  false);
+    WriteSetting(QStringLiteral("current_user"), Settings::config_values->current_user, 0);
+    WriteSetting(QStringLiteral("language_index"), Settings::config_values->language_index, 1);
+    WriteSetting(QStringLiteral("region_index"), Settings::config_values->region_index, 1);
+    WriteSetting(QStringLiteral("time_zone_index"), Settings::config_values->time_zone_index, 0);
+
+    WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::config_values->rng_seed.has_value(),
+                 false);
+    WriteSetting(QStringLiteral("rng_seed"), Settings::config_values->rng_seed.value_or(0), 0);
+
+    WriteSetting(QStringLiteral("custom_rtc_enabled"),
+                 Settings::config_values->custom_rtc.has_value(), false);
     WriteSetting(QStringLiteral("custom_rtc"),
                  QVariant::fromValue<long long>(
-                     Settings::values->custom_rtc.value_or(std::chrono::seconds{}).count()),
+                     Settings::config_values->custom_rtc.value_or(std::chrono::seconds{}).count()),
                  0);
 
-    WriteSetting(QStringLiteral("sound_index"), Settings::values->sound_index, 1);
+    WriteSetting(QStringLiteral("sound_index"), Settings::config_values->sound_index, 1);
 
     qt_config->endGroup();
 }
@@ -1220,13 +1261,15 @@ void Config::SaveUILayoutValues() {
 void Config::SaveWebServiceValues() {
     qt_config->beginGroup(QStringLiteral("WebService"));
 
-    WriteSetting(QStringLiteral("enable_telemetry"), Settings::values->enable_telemetry, true);
+    WriteSetting(QStringLiteral("enable_telemetry"),
+                 Settings::config_values->enable_telemetry, true);
     WriteSetting(QStringLiteral("web_api_url"),
-                 QString::fromStdString(Settings::values->web_api_url),
+                 QString::fromStdString(Settings::config_values->web_api_url),
                  QStringLiteral("https://api.yuzu-emu.org"));
     WriteSetting(QStringLiteral("yuzu_username"),
-                 QString::fromStdString(Settings::values->yuzu_username));
-    WriteSetting(QStringLiteral("yuzu_token"), QString::fromStdString(Settings::values->yuzu_token));
+                 QString::fromStdString(Settings::config_values->yuzu_username));
+    WriteSetting(QStringLiteral("yuzu_token"),
+                 QString::fromStdString(Settings::config_values->yuzu_token));
 
     qt_config->endGroup();
 }
diff --git a/src/yuzu/configuration/configure_audio.cpp b/src/yuzu/configuration/configure_audio.cpp
index 9e778b3fa5..2fbac308ae 100644
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@@ -41,8 +41,8 @@ void ConfigureAudio::SetConfiguration() {
 
     SetAudioDeviceFromDeviceID();
 
-    ui->toggle_audio_stretching->setChecked(Settings::values->enable_audio_stretching);
-    ui->volume_slider->setValue(Settings::values->volume * ui->volume_slider->maximum());
+    ui->toggle_audio_stretching->setChecked(Settings::config_values->enable_audio_stretching);
+    ui->volume_slider->setValue(Settings::config_values->volume * ui->volume_slider->maximum());
     SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
 }
 
@@ -50,7 +50,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
     [[maybe_unused]] const QSignalBlocker blocker(ui->output_sink_combo_box);
 
     int new_sink_index = 0;
-    const QString sink_id = QString::fromStdString(Settings::values->sink_id);
+    const QString sink_id = QString::fromStdString(Settings::config_values->sink_id);
     for (int index = 0; index < ui->output_sink_combo_box->count(); index++) {
         if (ui->output_sink_combo_box->itemText(index) == sink_id) {
             new_sink_index = index;
@@ -64,7 +64,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
 void ConfigureAudio::SetAudioDeviceFromDeviceID() {
     int new_device_index = -1;
 
-    const QString device_id = QString::fromStdString(Settings::values->audio_device_id);
+    const QString device_id = QString::fromStdString(Settings::config_values->audio_device_id);
     for (int index = 0; index < ui->audio_device_combo_box->count(); index++) {
         if (ui->audio_device_combo_box->itemText(index) == device_id) {
             new_device_index = index;
@@ -80,14 +80,14 @@ void ConfigureAudio::SetVolumeIndicatorText(int percentage) {
 }
 
 void ConfigureAudio::ApplyConfiguration() {
-    Settings::values->sink_id =
+    Settings::config_values->sink_id =
         ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
             .toStdString();
-    Settings::values->enable_audio_stretching = ui->toggle_audio_stretching->isChecked();
-    Settings::values->audio_device_id =
+    Settings::config_values->enable_audio_stretching = ui->toggle_audio_stretching->isChecked();
+    Settings::config_values->audio_device_id =
         ui->audio_device_combo_box->itemText(ui->audio_device_combo_box->currentIndex())
             .toStdString();
-    Settings::values->volume =
+    Settings::config_values->volume =
         static_cast<float>(ui->volume_slider->sliderPosition()) / ui->volume_slider->maximum();
 }
 
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index ea43eb183c..444e5f719c 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -27,36 +27,36 @@ ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::Co
 ConfigureDebug::~ConfigureDebug() = default;
 
 void ConfigureDebug::SetConfiguration() {
-    ui->toggle_gdbstub->setChecked(Settings::values->use_gdbstub);
-    ui->gdbport_spinbox->setEnabled(Settings::values->use_gdbstub);
-    ui->gdbport_spinbox->setValue(Settings::values->gdbstub_port);
+    ui->toggle_gdbstub->setChecked(Settings::config_values->use_gdbstub);
+    ui->gdbport_spinbox->setEnabled(Settings::config_values->use_gdbstub);
+    ui->gdbport_spinbox->setValue(Settings::config_values->gdbstub_port);
     ui->toggle_console->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->toggle_console->setChecked(UISettings::values.show_console);
-    ui->log_filter_edit->setText(QString::fromStdString(Settings::values->log_filter));
-    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values->program_args));
-    ui->reporting_services->setChecked(Settings::values->reporting_services);
-    ui->quest_flag->setChecked(Settings::values->quest_flag);
-    ui->disable_cpu_opt->setChecked(Settings::values->disable_cpu_opt);
+    ui->log_filter_edit->setText(QString::fromStdString(Settings::config_values->log_filter));
+    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::config_values->program_args));
+    ui->reporting_services->setChecked(Settings::config_values->reporting_services);
+    ui->quest_flag->setChecked(Settings::config_values->quest_flag);
+    ui->disable_cpu_opt->setChecked(Settings::config_values->disable_cpu_opt);
     ui->enable_graphics_debugging->setEnabled(!Core::System::GetInstance().IsPoweredOn());
-    ui->enable_graphics_debugging->setChecked(Settings::values->renderer_debug);
+    ui->enable_graphics_debugging->setChecked(Settings::config_values->renderer_debug);
     ui->disable_macro_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
-    ui->disable_macro_jit->setChecked(Settings::values->disable_macro_jit);
+    ui->disable_macro_jit->setChecked(Settings::config_values->disable_macro_jit);
 }
 
 void ConfigureDebug::ApplyConfiguration() {
-    Settings::values->use_gdbstub = ui->toggle_gdbstub->isChecked();
-    Settings::values->gdbstub_port = ui->gdbport_spinbox->value();
+    Settings::config_values->use_gdbstub = ui->toggle_gdbstub->isChecked();
+    Settings::config_values->gdbstub_port = ui->gdbport_spinbox->value();
     UISettings::values.show_console = ui->toggle_console->isChecked();
-    Settings::values->log_filter = ui->log_filter_edit->text().toStdString();
-    Settings::values->program_args = ui->homebrew_args_edit->text().toStdString();
-    Settings::values->reporting_services = ui->reporting_services->isChecked();
-    Settings::values->quest_flag = ui->quest_flag->isChecked();
-    Settings::values->disable_cpu_opt = ui->disable_cpu_opt->isChecked();
-    Settings::values->renderer_debug = ui->enable_graphics_debugging->isChecked();
-    Settings::values->disable_macro_jit = ui->disable_macro_jit->isChecked();
+    Settings::config_values->log_filter = ui->log_filter_edit->text().toStdString();
+    Settings::config_values->program_args = ui->homebrew_args_edit->text().toStdString();
+    Settings::config_values->reporting_services = ui->reporting_services->isChecked();
+    Settings::config_values->quest_flag = ui->quest_flag->isChecked();
+    Settings::config_values->disable_cpu_opt = ui->disable_cpu_opt->isChecked();
+    Settings::config_values->renderer_debug = ui->enable_graphics_debugging->isChecked();
+    Settings::config_values->disable_macro_jit = ui->disable_macro_jit->isChecked();
     Debugger::ToggleConsole();
     Log::Filter filter;
-    filter.ParseFilterString(Settings::values->log_filter);
+    filter.ParseFilterString(Settings::config_values->log_filter);
     Log::SetGlobalFilter(filter);
 }
 
diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp
index df4473b461..766c1aef69 100644
--- a/src/yuzu/configuration/configure_dialog.cpp
+++ b/src/yuzu/configuration/configure_dialog.cpp
@@ -14,6 +14,8 @@
 
 ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
     : QDialog(parent), ui(new Ui::ConfigureDialog), registry(registry) {
+    SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
+
     ui->setupUi(this);
     ui->hotkeysTab->Populate(registry);
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
@@ -28,7 +30,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
     ui->selectorList->setCurrentRow(0);
 }
 
-ConfigureDialog::~ConfigureDialog() = default;
+ConfigureDialog::~ConfigureDialog() {
+    Settings::CopyValues(Settings::game_values, Settings::global_values);
+}
 
 void ConfigureDialog::SetConfiguration() {}
 
diff --git a/src/yuzu/configuration/configure_filesystem.cpp b/src/yuzu/configuration/configure_filesystem.cpp
index e68a444bc9..e6e78bc515 100644
--- a/src/yuzu/configuration/configure_filesystem.cpp
+++ b/src/yuzu/configuration/configure_filesystem.cpp
@@ -58,7 +58,7 @@ void ConfigureFilesystem::setConfiguration() {
         QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
     ui->sdmc_directory_edit->setText(
         QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
-    ui->gamecard_path_edit->setText(QString::fromStdString(Settings::values->gamecard_path));
+    ui->gamecard_path_edit->setText(QString::fromStdString(Settings::config_values->gamecard_path));
     ui->dump_path_edit->setText(
         QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::DumpDir)));
     ui->load_path_edit->setText(
@@ -66,17 +66,17 @@ void ConfigureFilesystem::setConfiguration() {
     ui->cache_directory_edit->setText(
         QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)));
 
-    ui->gamecard_inserted->setChecked(Settings::values->gamecard_inserted);
-    ui->gamecard_current_game->setChecked(Settings::values->gamecard_current_game);
-    ui->dump_exefs->setChecked(Settings::values->dump_exefs);
-    ui->dump_nso->setChecked(Settings::values->dump_nso);
+    ui->gamecard_inserted->setChecked(Settings::config_values->gamecard_inserted);
+    ui->gamecard_current_game->setChecked(Settings::config_values->gamecard_current_game);
+    ui->dump_exefs->setChecked(Settings::config_values->dump_exefs);
+    ui->dump_nso->setChecked(Settings::config_values->dump_nso);
 
     ui->cache_game_list->setChecked(UISettings::values.cache_game_list);
 
-    SetComboBoxFromData(ui->nand_size, Settings::values->nand_total_size);
-    SetComboBoxFromData(ui->usrnand_size, Settings::values->nand_user_size);
-    SetComboBoxFromData(ui->sysnand_size, Settings::values->nand_system_size);
-    SetComboBoxFromData(ui->sdmc_size, Settings::values->sdmc_size);
+    SetComboBoxFromData(ui->nand_size, Settings::config_values->nand_total_size);
+    SetComboBoxFromData(ui->usrnand_size, Settings::config_values->nand_user_size);
+    SetComboBoxFromData(ui->sysnand_size, Settings::config_values->nand_system_size);
+    SetComboBoxFromData(ui->sdmc_size, Settings::config_values->sdmc_size);
 
     UpdateEnabledControls();
 }
@@ -90,22 +90,22 @@ void ConfigureFilesystem::applyConfiguration() {
     FileUtil::GetUserPath(FileUtil::UserPath::LoadDir, ui->load_path_edit->text().toStdString());
     FileUtil::GetUserPath(FileUtil::UserPath::CacheDir,
                           ui->cache_directory_edit->text().toStdString());
-    Settings::values->gamecard_path = ui->gamecard_path_edit->text().toStdString();
+    Settings::config_values->gamecard_path = ui->gamecard_path_edit->text().toStdString();
 
-    Settings::values->gamecard_inserted = ui->gamecard_inserted->isChecked();
-    Settings::values->gamecard_current_game = ui->gamecard_current_game->isChecked();
-    Settings::values->dump_exefs = ui->dump_exefs->isChecked();
-    Settings::values->dump_nso = ui->dump_nso->isChecked();
+    Settings::config_values->gamecard_inserted = ui->gamecard_inserted->isChecked();
+    Settings::config_values->gamecard_current_game = ui->gamecard_current_game->isChecked();
+    Settings::config_values->dump_exefs = ui->dump_exefs->isChecked();
+    Settings::config_values->dump_nso = ui->dump_nso->isChecked();
 
     UISettings::values.cache_game_list = ui->cache_game_list->isChecked();
 
-    Settings::values->nand_total_size = static_cast<Settings::NANDTotalSize>(
+    Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
         ui->nand_size->itemData(ui->nand_size->currentIndex()).toULongLong());
-    Settings::values->nand_system_size = static_cast<Settings::NANDSystemSize>(
+    Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
         ui->nand_size->itemData(ui->sysnand_size->currentIndex()).toULongLong());
-    Settings::values->nand_user_size = static_cast<Settings::NANDUserSize>(
+    Settings::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
         ui->nand_size->itemData(ui->usrnand_size->currentIndex()).toULongLong());
-    Settings::values->sdmc_size = static_cast<Settings::SDMCSize>(
+    Settings::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
         ui->nand_size->itemData(ui->sdmc_size->currentIndex()).toULongLong());
 }
 
diff --git a/src/yuzu/configuration/configure_general.cpp b/src/yuzu/configuration/configure_general.cpp
index 3bc52bb48a..fc268298f4 100644
--- a/src/yuzu/configuration/configure_general.cpp
+++ b/src/yuzu/configuration/configure_general.cpp
@@ -12,7 +12,6 @@
 
 ConfigureGeneral::ConfigureGeneral(QWidget* parent)
     : QWidget(parent), ui(new Ui::ConfigureGeneral) {
-
     ui->setupUi(this);
 
     SetConfiguration();
@@ -28,33 +27,33 @@ void ConfigureGeneral::SetConfiguration() {
     ui->use_multi_core->setEnabled(runtime_lock);
     ui->use_multi_core->setChecked(Settings::values.use_multi_core);
 
-    if (Settings::values == &Settings::global_values) {
+    if (Settings::config_values == &Settings::global_values) {
         ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
         ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
         ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);
         ui->toggle_hide_mouse->setChecked(UISettings::values.hide_mouse);
     }
-    ui->toggle_check_exit->setVisible(Settings::values == &Settings::global_values);
-    ui->toggle_user_on_boot->setVisible(Settings::values == &Settings::global_values);
-    ui->toggle_background_pause->setVisible(Settings::values == &Settings::global_values);
-    ui->toggle_hide_mouse->setVisible(Settings::values == &Settings::global_values);
+    ui->toggle_check_exit->setVisible(Settings::config_values == &Settings::global_values);
+    ui->toggle_user_on_boot->setVisible(Settings::config_values == &Settings::global_values);
+    ui->toggle_background_pause->setVisible(Settings::config_values == &Settings::global_values);
+    ui->toggle_hide_mouse->setVisible(Settings::config_values == &Settings::global_values);
 
-    ui->toggle_frame_limit->setChecked(Settings::values->use_frame_limit);
+    ui->toggle_frame_limit->setChecked(Settings::config_values->use_frame_limit);
     ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked());
-    ui->frame_limit->setValue(Settings::values->frame_limit);
+    ui->frame_limit->setValue(Settings::config_values->frame_limit);
 }
 
 void ConfigureGeneral::ApplyConfiguration() {
-    if (Settings::values == &Settings::global_values) {
+    if (Settings::config_values == &Settings::global_values) {
         UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
         UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
         UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();
         UISettings::values.hide_mouse = ui->toggle_hide_mouse->isChecked();
     }
 
-    Settings::values->use_frame_limit = ui->toggle_frame_limit->isChecked();
-    Settings::values->frame_limit = ui->frame_limit->value();
     Settings::values->use_multi_core = ui->use_multi_core->isChecked();
+    Settings::config_values->use_frame_limit = ui->toggle_frame_limit->isChecked();
+    Settings::config_values->frame_limit = ui->frame_limit->value();
 }
 
 void ConfigureGeneral::changeEvent(QEvent* event) {
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index ef6acf301f..517bb96270 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -21,7 +21,7 @@
 
 ConfigureGraphics::ConfigureGraphics(QWidget* parent)
     : QWidget(parent), ui(new Ui::ConfigureGraphics) {
-    vulkan_device = Settings::values->vulkan_device;
+    vulkan_device = Settings::config_values->vulkan_device;
     RetrieveVulkanDevices();
 
     ui->setupUi(this);
@@ -57,27 +57,29 @@ void ConfigureGraphics::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
     ui->api->setEnabled(runtime_lock);
-    ui->api->setCurrentIndex(static_cast<int>(Settings::values->renderer_backend));
-    ui->aspect_ratio_combobox->setCurrentIndex(Settings::values->aspect_ratio);
+    ui->api->setCurrentIndex(static_cast<int>(Settings::config_values->renderer_backend));
+    ui->aspect_ratio_combobox->setCurrentIndex(Settings::config_values->aspect_ratio);
     ui->use_disk_shader_cache->setEnabled(runtime_lock);
-    ui->use_disk_shader_cache->setChecked(Settings::values->use_disk_shader_cache);
+    ui->use_disk_shader_cache->setChecked(Settings::config_values->use_disk_shader_cache);
     ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
-    ui->use_asynchronous_gpu_emulation->setChecked(Settings::values->use_asynchronous_gpu_emulation);
-    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values->bg_red, Settings::values->bg_green,
-                                                 Settings::values->bg_blue));
+    ui->use_asynchronous_gpu_emulation->setChecked(
+        Settings::config_values->use_asynchronous_gpu_emulation);
+    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::config_values->bg_red,
+                                                 Settings::config_values->bg_green,
+                                                 Settings::config_values->bg_blue));
     UpdateDeviceComboBox();
 }
 
 void ConfigureGraphics::ApplyConfiguration() {
-    Settings::values->renderer_backend = GetCurrentGraphicsBackend();
-    Settings::values->vulkan_device = vulkan_device;
-    Settings::values->aspect_ratio = ui->aspect_ratio_combobox->currentIndex();
-    Settings::values->use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
-    Settings::values->use_asynchronous_gpu_emulation =
+    Settings::config_values->renderer_backend = GetCurrentGraphicsBackend();
+    Settings::config_values->vulkan_device = vulkan_device;
+    Settings::config_values->aspect_ratio = ui->aspect_ratio_combobox->currentIndex();
+    Settings::config_values->use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
+    Settings::config_values->use_asynchronous_gpu_emulation =
         ui->use_asynchronous_gpu_emulation->isChecked();
-    Settings::values->bg_red = static_cast<float>(bg_color.redF());
-    Settings::values->bg_green = static_cast<float>(bg_color.greenF());
-    Settings::values->bg_blue = static_cast<float>(bg_color.blueF());
+    Settings::config_values->bg_red = static_cast<float>(bg_color.redF());
+    Settings::config_values->bg_green = static_cast<float>(bg_color.greenF());
+    Settings::config_values->bg_blue = static_cast<float>(bg_color.blueF());
 }
 
 void ConfigureGraphics::changeEvent(QEvent* event) {
diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index e59b816210..776212e23e 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -19,26 +19,26 @@ ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
 
 void ConfigureGraphicsAdvanced::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
-    ui->gpu_accuracy->setCurrentIndex(static_cast<int>(Settings::values->gpu_accuracy));
+    ui->gpu_accuracy->setCurrentIndex(static_cast<int>(Settings::config_values->gpu_accuracy));
     ui->use_vsync->setEnabled(runtime_lock);
-    ui->use_vsync->setChecked(Settings::values->use_vsync);
+    ui->use_vsync->setChecked(Settings::config_values->use_vsync);
     ui->use_assembly_shaders->setEnabled(runtime_lock);
-    ui->use_assembly_shaders->setChecked(Settings::values->use_assembly_shaders);
-    ui->use_fast_gpu_time->setChecked(Settings::values->use_fast_gpu_time);
+    ui->use_assembly_shaders->setChecked(Settings::config_values->use_assembly_shaders);
+    ui->use_fast_gpu_time->setChecked(Settings::config_values->use_fast_gpu_time);
     ui->force_30fps_mode->setEnabled(runtime_lock);
-    ui->force_30fps_mode->setChecked(Settings::values->force_30fps_mode);
+    ui->force_30fps_mode->setChecked(Settings::config_values->force_30fps_mode);
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
-    ui->anisotropic_filtering_combobox->setCurrentIndex(Settings::values->max_anisotropy);
+    ui->anisotropic_filtering_combobox->setCurrentIndex(Settings::config_values->max_anisotropy);
 }
 
 void ConfigureGraphicsAdvanced::ApplyConfiguration() {
     auto gpu_accuracy = static_cast<Settings::GPUAccuracy>(ui->gpu_accuracy->currentIndex());
-    Settings::values->gpu_accuracy = gpu_accuracy;
-    Settings::values->use_vsync = ui->use_vsync->isChecked();
-    Settings::values->use_assembly_shaders = ui->use_assembly_shaders->isChecked();
-    Settings::values->use_fast_gpu_time = ui->use_fast_gpu_time->isChecked();
-    Settings::values->force_30fps_mode = ui->force_30fps_mode->isChecked();
-    Settings::values->max_anisotropy = ui->anisotropic_filtering_combobox->currentIndex();
+    Settings::config_values->gpu_accuracy = gpu_accuracy;
+    Settings::config_values->use_vsync = ui->use_vsync->isChecked();
+    Settings::config_values->use_assembly_shaders = ui->use_assembly_shaders->isChecked();
+    Settings::config_values->use_fast_gpu_time = ui->use_fast_gpu_time->isChecked();
+    Settings::config_values->force_30fps_mode = ui->force_30fps_mode->isChecked();
+    Settings::config_values->max_anisotropy = ui->anisotropic_filtering_combobox->currentIndex();
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 066eab7622..e5c8437770 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -119,26 +119,26 @@ void ConfigureInput::ApplyConfiguration() {
     for (std::size_t i = 0; i < players_controller.size(); ++i) {
         const auto controller_type_index = players_controller[i]->currentIndex();
 
-        Settings::values->players[i].connected = controller_type_index != 0;
+        Settings::config_values->players[i].connected = controller_type_index != 0;
 
         if (controller_type_index > 0) {
-            Settings::values->players[i].type =
+            Settings::config_values->players[i].type =
                 static_cast<Settings::ControllerType>(controller_type_index - 1);
         } else {
-            Settings::values->players[i].type = Settings::ControllerType::DualJoycon;
+            Settings::config_values->players[i].type = Settings::ControllerType::DualJoycon;
         }
     }
 
-    const bool pre_docked_mode = Settings::values->use_docked_mode;
-    Settings::values->use_docked_mode = ui->use_docked_mode->isChecked();
-    OnDockedModeChanged(pre_docked_mode, Settings::values->use_docked_mode);
+    const bool pre_docked_mode = Settings::config_values->use_docked_mode;
+    Settings::config_values->use_docked_mode = ui->use_docked_mode->isChecked();
+    OnDockedModeChanged(pre_docked_mode, Settings::config_values->use_docked_mode);
     Settings::values
         ->players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
         .connected = ui->handheld_connected->isChecked();
-    Settings::values->debug_pad_enabled = ui->debug_enabled->isChecked();
-    Settings::values->mouse_enabled = ui->mouse_enabled->isChecked();
-    Settings::values->keyboard_enabled = ui->keyboard_enabled->isChecked();
-    Settings::values->touchscreen.enabled = ui->touchscreen_enabled->isChecked();
+    Settings::config_values->debug_pad_enabled = ui->debug_enabled->isChecked();
+    Settings::config_values->mouse_enabled = ui->mouse_enabled->isChecked();
+    Settings::config_values->keyboard_enabled = ui->keyboard_enabled->isChecked();
+    Settings::config_values->touchscreen.enabled = ui->touchscreen_enabled->isChecked();
 }
 
 void ConfigureInput::changeEvent(QEvent* event) {
@@ -194,31 +194,31 @@ void ConfigureInput::UpdateUIEnabled() {
 
 void ConfigureInput::LoadConfiguration() {
     std::stable_partition(
-        Settings::values->players.begin(),
-        Settings::values->players.begin() +
+        Settings::config_values->players.begin(),
+        Settings::config_values->players.begin() +
             Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
         [](const auto& player) { return player.connected; });
 
     LoadPlayerControllerIndices();
 
-    ui->use_docked_mode->setChecked(Settings::values->use_docked_mode);
+    ui->use_docked_mode->setChecked(Settings::config_values->use_docked_mode);
     ui->handheld_connected->setChecked(
         Settings::values
             ->players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
             .connected);
-    ui->debug_enabled->setChecked(Settings::values->debug_pad_enabled);
-    ui->mouse_enabled->setChecked(Settings::values->mouse_enabled);
-    ui->keyboard_enabled->setChecked(Settings::values->keyboard_enabled);
-    ui->touchscreen_enabled->setChecked(Settings::values->touchscreen.enabled);
+    ui->debug_enabled->setChecked(Settings::config_values->debug_pad_enabled);
+    ui->mouse_enabled->setChecked(Settings::config_values->mouse_enabled);
+    ui->keyboard_enabled->setChecked(Settings::config_values->keyboard_enabled);
+    ui->touchscreen_enabled->setChecked(Settings::config_values->touchscreen.enabled);
 
     UpdateUIEnabled();
 }
 
 void ConfigureInput::LoadPlayerControllerIndices() {
     for (std::size_t i = 0; i < players_controller.size(); ++i) {
-        const auto connected = Settings::values->players[i].connected;
+        const auto connected = Settings::config_values->players[i].connected;
         players_controller[i]->setCurrentIndex(
-            connected ? static_cast<u8>(Settings::values->players[i].type) + 1 : 0);
+            connected ? static_cast<u8>(Settings::config_values->players[i].type) + 1 : 0);
     }
 }
 
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 29ab544a64..174aabfbe8 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -205,7 +205,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
         ui->buttonScreenshot, ui->labelScreenshot,
     };
 
-    auto layout = Settings::values->players[player_index].type;
+    auto layout = Settings::config_values->players[player_index].type;
     if (debug)
         layout = Settings::ControllerType::DualJoycon;
 
@@ -432,9 +432,9 @@ ConfigureInputPlayer::~ConfigureInputPlayer() = default;
 
 void ConfigureInputPlayer::ApplyConfiguration() {
     auto& buttons =
-        debug ? Settings::values->debug_pad_buttons : Settings::values->players[player_index].buttons;
+        debug ? Settings::config_values->debug_pad_buttons : Settings::config_values->players[player_index].buttons;
     auto& analogs =
-        debug ? Settings::values->debug_pad_analogs : Settings::values->players[player_index].analogs;
+        debug ? Settings::config_values->debug_pad_analogs : Settings::config_values->players[player_index].analogs;
 
     std::transform(buttons_param.begin(), buttons_param.end(), buttons.begin(),
                    [](const Common::ParamPackage& param) { return param.Serialize(); });
@@ -448,10 +448,10 @@ void ConfigureInputPlayer::ApplyConfiguration() {
     std::transform(controller_colors.begin(), controller_colors.end(), colors.begin(),
                    [](QColor color) { return color.rgb(); });
 
-    Settings::values->players[player_index].body_color_left = colors[0];
-    Settings::values->players[player_index].button_color_left = colors[1];
-    Settings::values->players[player_index].body_color_right = colors[2];
-    Settings::values->players[player_index].button_color_right = colors[3];
+    Settings::config_values->players[player_index].body_color_left = colors[0];
+    Settings::config_values->players[player_index].button_color_left = colors[1];
+    Settings::config_values->players[player_index].body_color_right = colors[2];
+    Settings::config_values->players[player_index].button_color_right = colors[3];
 }
 
 void ConfigureInputPlayer::changeEvent(QEvent* event) {
@@ -478,18 +478,18 @@ void ConfigureInputPlayer::OnControllerButtonClick(int i) {
 
 void ConfigureInputPlayer::LoadConfiguration() {
     if (debug) {
-        std::transform(Settings::values->debug_pad_buttons.begin(),
-                       Settings::values->debug_pad_buttons.end(), buttons_param.begin(),
+        std::transform(Settings::config_values->debug_pad_buttons.begin(),
+                       Settings::config_values->debug_pad_buttons.end(), buttons_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
-        std::transform(Settings::values->debug_pad_analogs.begin(),
-                       Settings::values->debug_pad_analogs.end(), analogs_param.begin(),
+        std::transform(Settings::config_values->debug_pad_analogs.begin(),
+                       Settings::config_values->debug_pad_analogs.end(), analogs_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
     } else {
-        std::transform(Settings::values->players[player_index].buttons.begin(),
-                       Settings::values->players[player_index].buttons.end(), buttons_param.begin(),
+        std::transform(Settings::config_values->players[player_index].buttons.begin(),
+                       Settings::config_values->players[player_index].buttons.end(), buttons_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
-        std::transform(Settings::values->players[player_index].analogs.begin(),
-                       Settings::values->players[player_index].analogs.end(), analogs_param.begin(),
+        std::transform(Settings::config_values->players[player_index].analogs.begin(),
+                       Settings::config_values->players[player_index].analogs.end(), analogs_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
     }
 
@@ -499,10 +499,10 @@ void ConfigureInputPlayer::LoadConfiguration() {
         return;
 
     std::array<u32, 4> colors = {
-        Settings::values->players[player_index].body_color_left,
-        Settings::values->players[player_index].button_color_left,
-        Settings::values->players[player_index].body_color_right,
-        Settings::values->players[player_index].button_color_right,
+        Settings::config_values->players[player_index].body_color_left,
+        Settings::config_values->players[player_index].button_color_left,
+        Settings::config_values->players[player_index].body_color_right,
+        Settings::config_values->players[player_index].button_color_right,
     };
 
     std::transform(colors.begin(), colors.end(), controller_colors.begin(),
diff --git a/src/yuzu/configuration/configure_input_simple.cpp b/src/yuzu/configuration/configure_input_simple.cpp
index a01d3291f8..a1f11ae3bd 100644
--- a/src/yuzu/configuration/configure_input_simple.cpp
+++ b/src/yuzu/configuration/configure_input_simple.cpp
@@ -39,33 +39,33 @@ constexpr std::size_t PLAYER_0_INDEX = 0;
 constexpr std::size_t HANDHELD_INDEX = 8;
 
 void HandheldOnProfileSelect() {
-    Settings::values->players[HANDHELD_INDEX].connected = true;
-    Settings::values->players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
+    Settings::config_values->players[HANDHELD_INDEX].connected = true;
+    Settings::config_values->players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
 
     for (std::size_t player = 0; player < HANDHELD_INDEX; ++player) {
-        Settings::values->players[player].connected = false;
+        Settings::config_values->players[player].connected = false;
     }
 
-    Settings::values->use_docked_mode = false;
-    Settings::values->keyboard_enabled = false;
-    Settings::values->mouse_enabled = false;
-    Settings::values->debug_pad_enabled = false;
-    Settings::values->touchscreen.enabled = true;
+    Settings::config_values->use_docked_mode = false;
+    Settings::config_values->keyboard_enabled = false;
+    Settings::config_values->mouse_enabled = false;
+    Settings::config_values->debug_pad_enabled = false;
+    Settings::config_values->touchscreen.enabled = true;
 }
 
 void DualJoyconsDockedOnProfileSelect() {
-    Settings::values->players[PLAYER_0_INDEX].connected = true;
-    Settings::values->players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
+    Settings::config_values->players[PLAYER_0_INDEX].connected = true;
+    Settings::config_values->players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
 
     for (std::size_t player = 1; player <= HANDHELD_INDEX; ++player) {
-        Settings::values->players[player].connected = false;
+        Settings::config_values->players[player].connected = false;
     }
 
-    Settings::values->use_docked_mode = true;
-    Settings::values->keyboard_enabled = false;
-    Settings::values->mouse_enabled = false;
-    Settings::values->debug_pad_enabled = false;
-    Settings::values->touchscreen.enabled = true;
+    Settings::config_values->use_docked_mode = true;
+    Settings::config_values->keyboard_enabled = false;
+    Settings::config_values->mouse_enabled = false;
+    Settings::config_values->debug_pad_enabled = false;
+    Settings::config_values->touchscreen.enabled = true;
 }
 
 // Name, OnProfileSelect (called when selected in drop down), OnConfigure (called when configure
@@ -142,9 +142,9 @@ void ConfigureInputSimple::LoadConfiguration() {
 }
 
 void ConfigureInputSimple::OnSelectProfile(int index) {
-    const auto old_docked = Settings::values->use_docked_mode;
+    const auto old_docked = Settings::config_values->use_docked_mode;
     ApplyInputProfileConfiguration(index);
-    OnDockedModeChanged(old_docked, Settings::values->use_docked_mode);
+    OnDockedModeChanged(old_docked, Settings::config_values->use_docked_mode);
 }
 
 void ConfigureInputSimple::OnConfigure() {
diff --git a/src/yuzu/configuration/configure_mouse_advanced.cpp b/src/yuzu/configuration/configure_mouse_advanced.cpp
index 035f650e3d..66746c038b 100644
--- a/src/yuzu/configuration/configure_mouse_advanced.cpp
+++ b/src/yuzu/configuration/configure_mouse_advanced.cpp
@@ -129,12 +129,13 @@ ConfigureMouseAdvanced::~ConfigureMouseAdvanced() = default;
 
 void ConfigureMouseAdvanced::ApplyConfiguration() {
     std::transform(buttons_param.begin(), buttons_param.end(),
-                   Settings::values->mouse_buttons.begin(),
+                   Settings::config_values->mouse_buttons.begin(),
                    [](const Common::ParamPackage& param) { return param.Serialize(); });
 }
 
 void ConfigureMouseAdvanced::LoadConfiguration() {
-    std::transform(Settings::values->mouse_buttons.begin(), Settings::values->mouse_buttons.end(),
+    std::transform(Settings::config_values->mouse_buttons.begin(),
+                   Settings::config_values->mouse_buttons.end(),
                    buttons_param.begin(),
                    [](const std::string& str) { return Common::ParamPackage(str); });
     UpdateButtonLabels();
diff --git a/src/yuzu/configuration/configure_per_game.cpp b/src/yuzu/configuration/configure_per_game.cpp
index 502947679c..bcb07822e5 100644
--- a/src/yuzu/configuration/configure_per_game.cpp
+++ b/src/yuzu/configuration/configure_per_game.cpp
@@ -29,8 +29,7 @@
 
 ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id)
     : QDialog(parent), ui(std::make_unique<Ui::ConfigurePerGame>()), title_id(title_id) {
-
-    Settings::SwapValues(Settings::ValuesSwapTarget::ToGame);
+    Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGame);
     game_config = std::make_unique<Config>(fmt::format("{:016X}", title_id) + ".ini", false);
 
     ui->setupUi(this);
@@ -48,11 +47,11 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id)
 }
 
 ConfigurePerGame::~ConfigurePerGame() {
-    Settings::SwapValues(Settings::ValuesSwapTarget::ToGlobal);
+    Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
 };
 
 void ConfigurePerGame::ApplyConfiguration() {
-    Settings::values->use_global_values = ui->check_global->isChecked();
+    Settings::config_values->use_global_values = ui->check_global->isChecked();
 
     ui->addonsTab->ApplyConfiguration();
     ui->generalTab->ApplyConfiguration();
@@ -60,10 +59,10 @@ void ConfigurePerGame::ApplyConfiguration() {
     ui->graphicsTab->ApplyConfiguration();
     ui->graphicsAdvancedTab->ApplyConfiguration();
     ui->audioTab->ApplyConfiguration();
-    ui->inputTab->ApplyConfiguration();
+    //ui->inputTab->ApplyConfiguration();
 
     game_config->Save();
-    Settings::SwapValues(Settings::ValuesSwapTarget::ToGlobal);
+    Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
 
     Settings::Apply();
     Settings::LogSettings();
@@ -91,7 +90,7 @@ void ConfigurePerGame::LoadConfiguration() {
         return;
     }
 
-    ui->check_global->setChecked(Settings::values->use_global_values);
+    ui->check_global->setChecked(Settings::config_values->use_global_values);
 
     ui->addonsTab->LoadFromFile(file);
 
@@ -157,5 +156,5 @@ void ConfigurePerGame::UpdateVisibleTabs() {
     ui->graphicsTab->setEnabled(visible);
     ui->graphicsAdvancedTab->setEnabled(visible);
     ui->audioTab->setEnabled(visible);
-    ui->inputTab->setEnabled(visible);
+    //ui->inputTab->setEnabled(visible);
 }
diff --git a/src/yuzu/configuration/configure_per_game.ui b/src/yuzu/configuration/configure_per_game.ui
index a27a974a11..7b8786bb11 100644
--- a/src/yuzu/configuration/configure_per_game.ui
+++ b/src/yuzu/configuration/configure_per_game.ui
@@ -260,11 +260,6 @@
            <string>Audio</string>
           </attribute>
          </widget>
-         <widget class="ConfigureInputSimple" name="inputTab">
-          <attribute name="title">
-           <string>Input</string>
-          </attribute>
-         </widget>
         </widget>
        </item>
       </layout>
@@ -326,12 +321,6 @@
    <header>configuration/configure_per_game_addons.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureInputSimple</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_input_simple.h</header>
-   <container>1</container>
-  </customwidget>
  </customwidgets>
  <resources/>
  <connections>
diff --git a/src/yuzu/configuration/configure_profile_manager.cpp b/src/yuzu/configuration/configure_profile_manager.cpp
index 2d699691ea..c206aa10ef 100644
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@@ -165,7 +165,7 @@ void ConfigureProfileManager::PopulateUserList() {
 void ConfigureProfileManager::UpdateCurrentUser() {
     ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
 
-    const auto& current_user = profile_manager->GetUser(Settings::values->current_user);
+    const auto& current_user = profile_manager->GetUser(Settings::config_values->current_user);
     ASSERT(current_user);
     const auto username = GetAccountUsername(*profile_manager, *current_user);
 
@@ -184,7 +184,7 @@ void ConfigureProfileManager::ApplyConfiguration() {
 }
 
 void ConfigureProfileManager::SelectUser(const QModelIndex& index) {
-    Settings::values->current_user =
+    Settings::config_values->current_user =
         std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager->GetUserCount() - 1));
 
     UpdateCurrentUser();
@@ -247,8 +247,8 @@ void ConfigureProfileManager::DeleteUser() {
     if (confirm == QMessageBox::No)
         return;
 
-    if (Settings::values->current_user == tree_view->currentIndex().row())
-        Settings::values->current_user = 0;
+    if (Settings::config_values->current_user == tree_view->currentIndex().row())
+        Settings::config_values->current_user = 0;
     UpdateCurrentUser();
 
     if (!profile_manager->RemoveUser(*uuid))
diff --git a/src/yuzu/configuration/configure_service.cpp b/src/yuzu/configuration/configure_service.cpp
index a6cc287d54..01c0eea5d7 100644
--- a/src/yuzu/configuration/configure_service.cpp
+++ b/src/yuzu/configuration/configure_service.cpp
@@ -54,7 +54,7 @@ ConfigureService::ConfigureService(QWidget* parent)
 ConfigureService::~ConfigureService() = default;
 
 void ConfigureService::ApplyConfiguration() {
-    Settings::values->bcat_backend = ui->bcat_source->currentText().toLower().toStdString();
+    Settings::config_values->bcat_backend = ui->bcat_source->currentText().toLower().toStdString();
 }
 
 void ConfigureService::RetranslateUi() {
@@ -63,7 +63,7 @@ void ConfigureService::RetranslateUi() {
 
 void ConfigureService::SetConfiguration() {
     const int index =
-        ui->bcat_source->findData(QString::fromStdString(Settings::values->bcat_backend));
+        ui->bcat_source->findData(QString::fromStdString(Settings::config_values->bcat_backend));
     ui->bcat_source->setCurrentIndex(index == -1 ? 0 : index);
 }
 
diff --git a/src/yuzu/configuration/configure_system.cpp b/src/yuzu/configuration/configure_system.cpp
index 864b51906a..a311c4ef58 100644
--- a/src/yuzu/configuration/configure_system.cpp
+++ b/src/yuzu/configuration/configure_system.cpp
@@ -58,23 +58,24 @@ void ConfigureSystem::SetConfiguration() {
     ui->label_console_id->setVisible(Settings::values == &Settings::global_values);
     ui->button_regenerate_console_id->setVisible(Settings::values == &Settings::global_values);
 
-    ui->combo_language->setCurrentIndex(Settings::values->language_index);
-    ui->combo_region->setCurrentIndex(Settings::values->region_index);
-    ui->combo_time_zone->setCurrentIndex(Settings::values->time_zone_index);
-    ui->combo_sound->setCurrentIndex(Settings::values->sound_index);
+    ui->combo_language->setCurrentIndex(Settings::config_values->language_index);
+    ui->combo_region->setCurrentIndex(Settings::config_values->region_index);
+    ui->combo_time_zone->setCurrentIndex(Settings::config_values->time_zone_index);
+    ui->combo_sound->setCurrentIndex(Settings::config_values->sound_index);
 
-    ui->rng_seed_checkbox->setChecked(Settings::values->rng_seed.has_value());
-    ui->rng_seed_edit->setEnabled(Settings::values->rng_seed.has_value());
+    ui->rng_seed_checkbox->setChecked(Settings::config_values->rng_seed.has_value());
+    ui->rng_seed_edit->setEnabled(Settings::config_values->rng_seed.has_value());
 
     const auto rng_seed = QStringLiteral("%1")
-                              .arg(Settings::values->rng_seed.value_or(0), 8, 16, QLatin1Char{'0'})
+                              .arg(Settings::config_values->rng_seed.value_or(0), 8, 16,
+                                   QLatin1Char{'0'})
                               .toUpper();
     ui->rng_seed_edit->setText(rng_seed);
 
-    ui->custom_rtc_checkbox->setChecked(Settings::values->custom_rtc.has_value());
-    ui->custom_rtc_edit->setEnabled(Settings::values->custom_rtc.has_value());
+    ui->custom_rtc_checkbox->setChecked(Settings::config_values->custom_rtc.has_value());
+    ui->custom_rtc_edit->setEnabled(Settings::config_values->custom_rtc.has_value());
 
-    const auto rtc_time = Settings::values->custom_rtc.value_or(
+    const auto rtc_time = Settings::config_values->custom_rtc.value_or(
         std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
     ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
 }
@@ -86,22 +87,22 @@ void ConfigureSystem::ApplyConfiguration() {
         return;
     }
 
-    Settings::values->language_index = ui->combo_language->currentIndex();
-    Settings::values->region_index = ui->combo_region->currentIndex();
-    Settings::values->time_zone_index = ui->combo_time_zone->currentIndex();
-    Settings::values->sound_index = ui->combo_sound->currentIndex();
+    Settings::config_values->language_index = ui->combo_language->currentIndex();
+    Settings::config_values->region_index = ui->combo_region->currentIndex();
+    Settings::config_values->time_zone_index = ui->combo_time_zone->currentIndex();
+    Settings::config_values->sound_index = ui->combo_sound->currentIndex();
 
     if (ui->rng_seed_checkbox->isChecked()) {
-        Settings::values->rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);
+        Settings::config_values->rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);
     } else {
-        Settings::values->rng_seed = std::nullopt;
+        Settings::config_values->rng_seed = std::nullopt;
     }
 
     if (ui->custom_rtc_checkbox->isChecked()) {
-        Settings::values->custom_rtc =
+        Settings::config_values->custom_rtc =
             std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
     } else {
-        Settings::values->custom_rtc = std::nullopt;
+        Settings::config_values->custom_rtc = std::nullopt;
     }
 
     Settings::Apply();
diff --git a/src/yuzu/configuration/configure_touchscreen_advanced.cpp b/src/yuzu/configuration/configure_touchscreen_advanced.cpp
index 2b5897012f..778a154d24 100644
--- a/src/yuzu/configuration/configure_touchscreen_advanced.cpp
+++ b/src/yuzu/configuration/configure_touchscreen_advanced.cpp
@@ -33,17 +33,17 @@ void ConfigureTouchscreenAdvanced::RetranslateUI() {
 }
 
 void ConfigureTouchscreenAdvanced::ApplyConfiguration() {
-    Settings::values->touchscreen.finger = ui->finger_box->value();
-    Settings::values->touchscreen.diameter_x = ui->diameter_x_box->value();
-    Settings::values->touchscreen.diameter_y = ui->diameter_y_box->value();
-    Settings::values->touchscreen.rotation_angle = ui->angle_box->value();
+    Settings::config_values->touchscreen.finger = ui->finger_box->value();
+    Settings::config_values->touchscreen.diameter_x = ui->diameter_x_box->value();
+    Settings::config_values->touchscreen.diameter_y = ui->diameter_y_box->value();
+    Settings::config_values->touchscreen.rotation_angle = ui->angle_box->value();
 }
 
 void ConfigureTouchscreenAdvanced::LoadConfiguration() {
-    ui->finger_box->setValue(Settings::values->touchscreen.finger);
-    ui->diameter_x_box->setValue(Settings::values->touchscreen.diameter_x);
-    ui->diameter_y_box->setValue(Settings::values->touchscreen.diameter_y);
-    ui->angle_box->setValue(Settings::values->touchscreen.rotation_angle);
+    ui->finger_box->setValue(Settings::config_values->touchscreen.finger);
+    ui->diameter_x_box->setValue(Settings::config_values->touchscreen.diameter_x);
+    ui->diameter_y_box->setValue(Settings::config_values->touchscreen.diameter_y);
+    ui->angle_box->setValue(Settings::config_values->touchscreen.rotation_angle);
 }
 
 void ConfigureTouchscreenAdvanced::RestoreDefaults() {
diff --git a/src/yuzu/configuration/configure_web.cpp b/src/yuzu/configuration/configure_web.cpp
index 344fd233eb..ede462c3dd 100644
--- a/src/yuzu/configuration/configure_web.cpp
+++ b/src/yuzu/configuration/configure_web.cpp
@@ -88,15 +88,16 @@ void ConfigureWeb::SetConfiguration() {
     ui->web_signup_link->setOpenExternalLinks(true);
     ui->web_token_info_link->setOpenExternalLinks(true);
 
-    if (Settings::values->yuzu_username.empty()) {
+    if (Settings::config_values->yuzu_username.empty()) {
         ui->username->setText(tr("Unspecified"));
     } else {
-        ui->username->setText(QString::fromStdString(Settings::values->yuzu_username));
+        ui->username->setText(QString::fromStdString(Settings::config_values->yuzu_username));
     }
 
-    ui->toggle_telemetry->setChecked(Settings::values->enable_telemetry);
+    ui->toggle_telemetry->setChecked(Settings::config_values->enable_telemetry);
     ui->edit_token->setText(QString::fromStdString(
-        GenerateDisplayToken(Settings::values->yuzu_username, Settings::values->yuzu_token)));
+        GenerateDisplayToken(Settings::config_values->yuzu_username,
+                             Settings::config_values->yuzu_token)));
 
     // Connect after setting the values, to avoid calling OnLoginChanged now
     connect(ui->edit_token, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
@@ -107,12 +108,13 @@ void ConfigureWeb::SetConfiguration() {
 }
 
 void ConfigureWeb::ApplyConfiguration() {
-    Settings::values->enable_telemetry = ui->toggle_telemetry->isChecked();
+    Settings::config_values->enable_telemetry = ui->toggle_telemetry->isChecked();
     UISettings::values.enable_discord_presence = ui->toggle_discordrpc->isChecked();
     if (user_verified) {
-        Settings::values->yuzu_username =
+        Settings::config_values->yuzu_username =
             UsernameFromDisplayToken(ui->edit_token->text().toStdString());
-        Settings::values->yuzu_token = TokenFromDisplayToken(ui->edit_token->text().toStdString());
+        Settings::config_values->yuzu_token =
+            TokenFromDisplayToken(ui->edit_token->text().toStdString());
     } else {
         QMessageBox::warning(
             this, tr("Token not verified"),