32 files changed, 807 insertions, 660 deletions

diff --git a/src/audio_core/audio_out.cpp b/src/audio_core/audio_out.cpp
index 20a756dce..44a899d08 100644
--- a/src/audio_core/audio_out.cpp
+++ b/src/audio_core/audio_out.cpp
@@ -30,7 +30,8 @@ StreamPtr AudioOut::OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample
                                u32 num_channels, std::string&& name,
                                Stream::ReleaseCallback&& release_callback) {
     if (!sink) {
-        sink = CreateSinkFromID(Settings::values.sink_id, Settings::values.audio_device_id);
+        sink = CreateSinkFromID(Settings::values.sink_id.GetValue(),
+                                Settings::values.audio_device_id.GetValue());
     }
 
     return std::make_shared<Stream>(
diff --git a/src/common/settings.cpp b/src/common/settings.cpp
index e1bb4b7ff..0061e29cc 100644
--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -41,7 +41,7 @@ void LogSettings() {
     LOG_INFO(Config, "yuzu Configuration:");
     log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
     log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
-    log_setting("System_CurrentUser", values.current_user);
+    log_setting("System_CurrentUser", values.current_user.GetValue());
     log_setting("System_LanguageIndex", values.language_index.GetValue());
     log_setting("System_RegionIndex", values.region_index.GetValue());
     log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
@@ -61,18 +61,18 @@ void LogSettings() {
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
     log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
-    log_setting("Audio_OutputEngine", values.sink_id);
+    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
     log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
-    log_setting("Audio_OutputDevice", values.audio_device_id);
-    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd);
+    log_setting("Audio_OutputDevice", values.audio_device_id.GetValue());
+    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
     log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
     log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
     log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
     log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
     log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
-    log_setting("Debugging_ProgramArgs", values.program_args);
-    log_setting("Services_BCATBackend", values.bcat_backend);
-    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local);
+    log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
+    log_setting("Services_BCATBackend", values.bcat_backend.GetValue());
+    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local.GetValue());
 }
 
 bool IsConfiguringGlobal() {
@@ -94,7 +94,7 @@ bool IsGPULevelHigh() {
 
 bool IsFastmemEnabled() {
     if (values.cpu_accuracy.GetValue() == CPUAccuracy::DebugMode) {
-        return values.cpuopt_fastmem;
+        return static_cast<bool>(values.cpuopt_fastmem);
     }
     return true;
 }
diff --git a/src/common/settings.h b/src/common/settings.h
index dd2d8d4d8..13896debf 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -10,10 +10,12 @@
 #include <map>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "common/common_types.h"
 #include "common/settings_input.h"
+#include "input_common/udp/client.h"
 
 namespace Settings {
 
@@ -34,73 +36,236 @@ enum class CPUAccuracy : u32 {
     DebugMode = 2,
 };
 
+/** The BasicSetting class is a simple resource manager. It defines a label and default value
+ * alongside the actual value of the setting for simpler and less-error prone use with frontend
+ * configurations. Setting a default value and label is required, though subclasses may deviate from
+ * this requirement.
+ */
 template <typename Type>
-class Setting final {
+class BasicSetting {
+protected:
+    BasicSetting() = default;
+
+    /**
+     * Only sets the setting to the given initializer, leaving the other members to their default
+     * initializers.
+     *
+     * @param global_val Initial value of the setting
+     */
+    explicit BasicSetting(const Type& global_val) : global{global_val} {}
+
 public:
-    explicit Setting(Type val) : global{val} {
-        default_value = val;
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit BasicSetting(const Type& default_val, const std::string& name)
+        : default_value{default_val}, global{default_val}, label{name} {}
+    ~BasicSetting() = default;
+
+    /**
+     *  Returns a reference to the setting's value.
+     *
+     * @returns A reference to the setting
+     */
+    [[nodiscard]] const Type& GetValue() const {
+        return global;
+    }
+
+    /**
+     * Sets the setting to the given value.
+     *
+     * @param value The desired value
+     */
+    void SetValue(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
     }
+
+    /**
+     * Returns the value that this setting was created with.
+     *
+     * @returns A reference to the default value
+     */
+    [[nodiscard]] const Type& GetDefault() const {
+        return default_value;
+    }
+
+    /**
+     * Returns the label this setting was created with.
+     *
+     * @returns A reference to the label
+     */
+    [[nodiscard]] const std::string& GetLabel() const {
+        return label;
+    }
+
+    /**
+     * Assigns a value to the setting.
+     *
+     * @param value The desired setting value
+     *
+     * @returns A reference to the setting
+     */
+    const Type& operator=(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
+        return global;
+    }
+
+    /**
+     * Returns a reference to the setting.
+     *
+     * @returns A reference to the setting
+     */
+    explicit operator const Type&() const {
+        return global;
+    }
+
+protected:
+    const Type default_value{}; ///< The default value
+    Type global{};              ///< The setting
+    const std::string label{};  ///< The setting's label
+};
+
+/**
+ * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
+ * custom setting to switch to when a guest application specifically requires it. The effect is that
+ * other components of the emulator can access the setting's intended value without any need for the
+ * component to ask whether the custom or global setting is needed at the moment.
+ *
+ * By default, the global setting is used.
+ *
+ * Like the BasicSetting, this requires setting a default value and label to use.
+ */
+template <typename Type>
+class Setting final : public BasicSetting<Type> {
+public:
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit Setting(const Type& default_val, const std::string& name)
+        : BasicSetting<Type>(default_val, name) {}
     ~Setting() = default;
+
+    /**
+     * Tells this setting to represent either the global or custom setting when other member
+     * functions are used. Setting to_global to true means using the global setting, to false
+     * false for the custom setting.
+     *
+     * @param to_global Whether to use the global or custom setting.
+     */
     void SetGlobal(bool to_global) {
         use_global = to_global;
     }
-    bool UsingGlobal() const {
+
+    /**
+     * Returns whether this setting is using the global setting or not.
+     *
+     * @returns The global state
+     */
+    [[nodiscard]] bool UsingGlobal() const {
         return use_global;
     }
-    Type GetValue(bool need_global = false) const {
+
+    /**
+     * Returns either the global or custom setting depending on the values of this setting's global
+     * state or if the global value was specifically requested.
+     *
+     * @param need_global Request global value regardless of setting's state; defaults to false
+     *
+     * @returns The required value of the setting
+     */
+    [[nodiscard]] const Type& GetValue(bool need_global = false) const {
         if (use_global || need_global) {
-            return global;
+            return this->global;
         }
-        return local;
+        return custom;
     }
+
+    /**
+     * Sets the current setting value depending on the global state.
+     *
+     * @param value The new value
+     */
     void SetValue(const Type& value) {
+        Type temp{value};
         if (use_global) {
-            global = value;
+            std::swap(this->global, temp);
         } else {
-            local = value;
+            std::swap(custom, temp);
         }
     }
-    Type GetDefault() const {
-        return default_value;
+
+    /**
+     * Assigns the current setting value depending on the global state.
+     *
+     * @param value The new value
+     *
+     * @returns A reference to the current setting value
+     */
+    const Type& operator=(const Type& value) {
+        Type temp{value};
+        if (use_global) {
+            std::swap(this->global, temp);
+            return this->global;
+        }
+        std::swap(custom, temp);
+        return custom;
+    }
+
+    /**
+     * Returns the current setting value depending on the global state.
+     *
+     * @returns A reference to the current setting value
+     */
+    explicit operator const Type&() const {
+        if (use_global) {
+            return this->global;
+        }
+        return custom;
     }
 
 private:
-    bool use_global = true;
-    Type global{};
-    Type local{};
-    Type default_value{};
+    bool use_global{true}; ///< The setting's global state
+    Type custom{};         ///< The custom value of the setting
 };
 
 /**
- * The InputSetting class allows for getting a reference to either the global or local members.
+ * The InputSetting class allows for getting a reference to either the global or custom members.
  * This is required as we cannot easily modify the values of user-defined types within containers
  * using the SetValue() member function found in the Setting class. The primary purpose of this
- * class is to store an array of 10 PlayerInput structs for both the global and local (per-game)
- * setting and allows for easily accessing and modifying both settings.
+ * class is to store an array of 10 PlayerInput structs for both the global and custom setting and
+ * allows for easily accessing and modifying both settings.
  */
 template <typename Type>
 class InputSetting final {
 public:
     InputSetting() = default;
-    explicit InputSetting(Type val) : global{val} {}
+    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
     ~InputSetting() = default;
     void SetGlobal(bool to_global) {
         use_global = to_global;
     }
-    bool UsingGlobal() const {
+    [[nodiscard]] bool UsingGlobal() const {
         return use_global;
     }
-    Type& GetValue(bool need_global = false) {
+    [[nodiscard]] Type& GetValue(bool need_global = false) {
         if (use_global || need_global) {
             return global;
         }
-        return local;
+        return custom;
     }
 
 private:
-    bool use_global = true;
-    Type global{};
-    Type local{};
+    bool use_global{true}; ///< The setting's global state
+    Type global{};         ///< The setting
+    Type custom{};         ///< The custom setting value
 };
 
 struct TouchFromButtonMap {
@@ -110,152 +275,155 @@ struct TouchFromButtonMap {
 
 struct Values {
     // Audio
-    std::string audio_device_id;
-    std::string sink_id;
-    bool audio_muted;
-    Setting<bool> enable_audio_stretching{true};
-    Setting<float> volume{1.0f};
+    BasicSetting<std::string> audio_device_id{"auto", "output_device"};
+    BasicSetting<std::string> sink_id{"auto", "output_engine"};
+    BasicSetting<bool> audio_muted{false, "audio_muted"};
+    Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
+    Setting<float> volume{1.0f, "volume"};
 
     // Core
-    Setting<bool> use_multi_core{true};
+    Setting<bool> use_multi_core{true, "use_multi_core"};
 
     // Cpu
-    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Accurate};
-
-    bool cpuopt_page_tables;
-    bool cpuopt_block_linking;
-    bool cpuopt_return_stack_buffer;
-    bool cpuopt_fast_dispatcher;
-    bool cpuopt_context_elimination;
-    bool cpuopt_const_prop;
-    bool cpuopt_misc_ir;
-    bool cpuopt_reduce_misalign_checks;
-    bool cpuopt_fastmem;
-
-    Setting<bool> cpuopt_unsafe_unfuse_fma{true};
-    Setting<bool> cpuopt_unsafe_reduce_fp_error{true};
-    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true};
-    Setting<bool> cpuopt_unsafe_inaccurate_nan{true};
-    Setting<bool> cpuopt_unsafe_fastmem_check{true};
+    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Accurate, "cpu_accuracy"};
+
+    BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
+    BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
+    BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
+    BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
+    BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
+    BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
+    BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
+    BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
+    BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
+
+    Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
+    Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
+    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
+    Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
+    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
 
     // Renderer
-    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL};
-    bool renderer_debug;
-    Setting<int> vulkan_device{0};
+    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
+    BasicSetting<bool> renderer_debug{false, "debug"};
+    Setting<int> vulkan_device{0, "vulkan_device"};
 
-    Setting<u16> resolution_factor{0};
+    Setting<u16> resolution_factor{0, "resolution_factor"};
     // *nix platforms may have issues with the borderless windowed fullscreen mode.
     // Default to exclusive fullscreen on these platforms for now.
     Setting<int> fullscreen_mode{
 #ifdef _WIN32
-        0
+        0,
 #else
-        1
+        1,
 #endif
-    };
-    Setting<int> aspect_ratio{0};
-    Setting<int> max_anisotropy{0};
-    Setting<bool> use_frame_limit{true};
-    Setting<u16> frame_limit{100};
-    Setting<bool> use_disk_shader_cache{true};
-    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High};
-    Setting<bool> use_asynchronous_gpu_emulation{true};
-    Setting<bool> use_nvdec_emulation{true};
-    Setting<bool> accelerate_astc{true};
-    Setting<bool> use_vsync{true};
-    Setting<bool> disable_fps_limit{false};
-    Setting<bool> use_assembly_shaders{false};
-    Setting<bool> use_asynchronous_shaders{false};
-    Setting<bool> use_fast_gpu_time{true};
-    Setting<bool> use_caches_gc{false};
-
-    Setting<float> bg_red{0.0f};
-    Setting<float> bg_green{0.0f};
-    Setting<float> bg_blue{0.0f};
+        "fullscreen_mode"};
+    Setting<int> aspect_ratio{0, "aspect_ratio"};
+    Setting<int> max_anisotropy{0, "max_anisotropy"};
+    Setting<bool> use_frame_limit{true, "use_frame_limit"};
+    Setting<u16> frame_limit{100, "frame_limit"};
+    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
+    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
+    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
+    Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
+    Setting<bool> accelerate_astc{true, "accelerate_astc"};
+    Setting<bool> use_vsync{true, "use_vsync"};
+    Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
+    Setting<bool> use_assembly_shaders{false, "use_assembly_shaders"};
+    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
+    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    Setting<bool> use_caches_gc{false, "use_caches_gc"};
+
+    Setting<float> bg_red{0.0f, "bg_red"};
+    Setting<float> bg_green{0.0f, "bg_green"};
+    Setting<float> bg_blue{0.0f, "bg_blue"};
 
     // System
-    Setting<std::optional<u32>> rng_seed{std::optional<u32>()};
+    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
     std::optional<std::chrono::seconds> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
     std::chrono::seconds custom_rtc_differential;
 
-    s32 current_user;
-    Setting<s32> language_index{1};
-    Setting<s32> region_index{1};
-    Setting<s32> time_zone_index{0};
-    Setting<s32> sound_index{1};
+    BasicSetting<s32> current_user{0, "current_user"};
+    Setting<s32> language_index{1, "language_index"};
+    Setting<s32> region_index{1, "region_index"};
+    Setting<s32> time_zone_index{0, "time_zone_index"};
+    Setting<s32> sound_index{1, "sound_index"};
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 
-    Setting<bool> use_docked_mode{true};
+    Setting<bool> use_docked_mode{true, "use_docked_mode"};
 
-    Setting<bool> vibration_enabled{true};
-    Setting<bool> enable_accurate_vibrations{false};
+    Setting<bool> vibration_enabled{true, "vibration_enabled"};
+    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
-    Setting<bool> motion_enabled{true};
-    std::string motion_device;
-    std::string udp_input_servers;
+    Setting<bool> motion_enabled{true, "motion_enabled"};
+    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
+                                            "motion_device"};
+    BasicSetting<std::string> udp_input_servers{InputCommon::CemuhookUDP::DEFAULT_SRV,
+                                                "udp_input_servers"};
 
-    bool mouse_panning;
-    float mouse_panning_sensitivity;
-    bool mouse_enabled;
+    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
+    BasicSetting<float> mouse_panning_sensitivity{1.0f, "mouse_panning_sensitivity"};
+    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
     std::string mouse_device;
     MouseButtonsRaw mouse_buttons;
 
-    bool emulate_analog_keyboard;
-    bool keyboard_enabled;
+    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
+    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
     KeyboardKeysRaw keyboard_keys;
     KeyboardModsRaw keyboard_mods;
 
-    bool debug_pad_enabled;
+    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
     TouchscreenInput touchscreen;
 
-    bool use_touch_from_button;
-    std::string touch_device;
-    int touch_from_button_map_index;
+    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
+    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
+                                           "touch_device"};
+    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
     std::atomic_bool is_device_reload_pending{true};
 
     // Data Storage
-    bool use_virtual_sd;
-    bool gamecard_inserted;
-    bool gamecard_current_game;
-    std::string gamecard_path;
+    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
+    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
+    BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
+    BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};
 
     // Debugging
     bool record_frame_times;
-    bool use_gdbstub;
-    u16 gdbstub_port;
-    std::string program_args;
-    bool dump_exefs;
-    bool dump_nso;
-    bool enable_fs_access_log;
-    bool reporting_services;
-    bool quest_flag;
-    bool disable_macro_jit;
-    bool extended_logging;
-    bool use_debug_asserts;
-    bool use_auto_stub;
+    BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
+    BasicSetting<u16> gdbstub_port{0, "gdbstub_port"};
+    BasicSetting<std::string> program_args{std::string(), "program_args"};
+    BasicSetting<bool> dump_exefs{false, "dump_exefs"};
+    BasicSetting<bool> dump_nso{false, "dump_nso"};
+    BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
+    BasicSetting<bool> reporting_services{false, "reporting_services"};
+    BasicSetting<bool> quest_flag{false, "quest_flag"};
+    BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    BasicSetting<bool> extended_logging{false, "extended_logging"};
+    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
+    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
 
     // Miscellaneous
-    std::string log_filter;
-    bool use_dev_keys;
+    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
+    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
 
     // Services
-    std::string bcat_backend;
-    bool bcat_boxcat_local;
+    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
+    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
 
     // WebService
-    bool enable_telemetry;
-    std::string web_api_url;
-    std::string yuzu_username;
-    std::string yuzu_token;
+    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
+    BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
+    BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
+    BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;
diff --git a/src/core/core.cpp b/src/core/core.cpp
index e6f1aa0e7..fc6ec9512 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -263,9 +263,9 @@ struct System::Impl {
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {
                 fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
-            } else if (!Settings::values.gamecard_path.empty()) {
-                fs_controller.SetGameCard(
-                    GetGameFileFromPath(virtual_filesystem, Settings::values.gamecard_path));
+            } else if (!Settings::values.gamecard_path.GetValue().empty()) {
+                fs_controller.SetGameCard(GetGameFileFromPath(
+                    virtual_filesystem, static_cast<std::string>(Settings::values.gamecard_path)));
             }
         }
 
diff --git a/src/core/frontend/applets/profile_select.cpp b/src/core/frontend/applets/profile_select.cpp
index 8d960d1ca..4c58c310f 100644
--- a/src/core/frontend/applets/profile_select.cpp
+++ b/src/core/frontend/applets/profile_select.cpp
@@ -13,7 +13,7 @@ ProfileSelectApplet::~ProfileSelectApplet() = default;
 void DefaultProfileSelectApplet::SelectProfile(
     std::function<void(std::optional<Common::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index f72d5d561..24a1c9157 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -48,7 +48,8 @@ ProfileManager::ProfileManager() {
         CreateNewUser(UUID::Generate(), "yuzu");
     }
 
-    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
+    auto current =
+        std::clamp<int>(static_cast<s32>(Settings::values.current_user), 0, MAX_USERS - 1);
 
     // If user index don't exist. Load the first user and change the active user
     if (!UserExistsIndex(current)) {
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index b578153d3..23ebc1138 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -1443,7 +1443,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
         params.is_account_selected = 1;
 
         Account::ProfileManager profile_manager{};
-        const auto uuid = profile_manager.GetUser(Settings::values.current_user);
+        const auto uuid = profile_manager.GetUser(static_cast<s32>(Settings::values.current_user));
         ASSERT(uuid);
         params.current_user = uuid->uuid;
 
diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp
index f03b2666a..e742db48f 100644
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -179,7 +179,7 @@ private:
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
 
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.PushEnum(RequestState::NotSubmitted);
         } else {
             rb.PushEnum(RequestState::Connected);
@@ -384,7 +384,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.Push<u8>(0);
         } else {
             rb.Push<u8>(1);
@@ -395,7 +395,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.Push<u8>(0);
         } else {
             rb.Push<u8>(1);
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index ece2a74c6..522a604a5 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -160,7 +160,7 @@ void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(Settings::values.quest_flag));
+    rb.Push(static_cast<u32>(Settings::values.quest_flag.GetValue()));
 }
 
 void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp
index 618555202..951ea966e 100644
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@@ -155,8 +155,8 @@ static bool LoadNroImpl(Kernel::KProcess& process, const std::vector<u8>& data)
         codeset.segments[i].size = PageAlignSize(nro_header.segments[i].size);
     }
 
-    if (!Settings::values.program_args.empty()) {
-        const auto arg_data = Settings::values.program_args;
+    if (!Settings::values.program_args.GetValue().empty()) {
+        const auto arg_data = Settings::values.program_args.GetValue();
         codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
         NSOArgumentHeader args_header{
             NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 0f5cfda68..4a2224c02 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -104,8 +104,8 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
         codeset.segments[i].size = nso_header.segments[i].size;
     }
 
-    if (should_pass_arguments && !Settings::values.program_args.empty()) {
-        const auto arg_data{Settings::values.program_args};
+    if (should_pass_arguments && !Settings::values.program_args.GetValue().empty()) {
+        const auto arg_data{Settings::values.program_args.GetValue()};
 
         codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
         NSOArgumentHeader args_header{
diff --git a/src/core/reporter.cpp b/src/core/reporter.cpp
index 82b0f535a..cfaf50105 100644
--- a/src/core/reporter.cpp
+++ b/src/core/reporter.cpp
@@ -397,7 +397,7 @@ void Reporter::ClearFSAccessLog() const {
 }
 
 bool Reporter::IsReportingEnabled() const {
-    return Settings::values.reporting_services;
+    return Settings::values.reporting_services.GetValue();
 }
 
 } // namespace Core
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index d4c23ced2..44b8bab5b 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -212,7 +212,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
 
     // Log user configuration information
     constexpr auto field_type = Telemetry::FieldType::UserConfig;
-    AddField(field_type, "Audio_SinkId", Settings::values.sink_id);
+    AddField(field_type, "Audio_SinkId", Settings::values.sink_id.GetValue());
     AddField(field_type, "Audio_EnableAudioStretching",
              Settings::values.enable_audio_stretching.GetValue());
     AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
diff --git a/src/input_common/mouse/mouse_poller.cpp b/src/input_common/mouse/mouse_poller.cpp
index 758f7af1f..4861a131e 100644
--- a/src/input_common/mouse/mouse_poller.cpp
+++ b/src/input_common/mouse/mouse_poller.cpp
@@ -84,7 +84,8 @@ public:
         std::lock_guard lock{mutex};
         const auto axis_value =
             static_cast<float>(mouse_input->GetMouseState(button).axis.at(axis));
-        return axis_value * Settings::values.mouse_panning_sensitivity / (100.0f * range);
+        return axis_value * Settings::values.mouse_panning_sensitivity.GetValue() /
+               (100.0f * range);
     }
 
     std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
diff --git a/src/input_common/touch_from_button.cpp b/src/input_common/touch_from_button.cpp
index 5b24fd8bf..87207f48f 100644
--- a/src/input_common/touch_from_button.cpp
+++ b/src/input_common/touch_from_button.cpp
@@ -12,8 +12,7 @@ namespace InputCommon {
 class TouchFromButtonDevice final : public Input::TouchDevice {
 public:
     TouchFromButtonDevice() {
-        const auto button_index =
-            static_cast<std::size_t>(Settings::values.touch_from_button_map_index);
+        const auto button_index = Settings::values.touch_from_button_map_index.GetValue();
         const auto& buttons = Settings::values.touch_from_button_maps[button_index].buttons;
 
         for (const auto& config_entry : buttons) {
diff --git a/src/input_common/udp/client.cpp b/src/input_common/udp/client.cpp
index bc1dfab3d..9b0aec797 100644
--- a/src/input_common/udp/client.cpp
+++ b/src/input_common/udp/client.cpp
@@ -201,7 +201,7 @@ bool Client::DeviceConnected(std::size_t pad) const {
 void Client::ReloadSockets() {
     Reset();
 
-    std::stringstream servers_ss(Settings::values.udp_input_servers);
+    std::stringstream servers_ss(static_cast<std::string>(Settings::values.udp_input_servers));
     std::string server_token;
     std::size_t client = 0;
     while (std::getline(servers_ss, server_token, ',')) {
@@ -370,7 +370,7 @@ std::optional<std::size_t> Client::GetUnusedFingerID() const {
 
 void Client::UpdateTouchInput(Response::TouchPad& touch_pad, std::size_t client, std::size_t id) {
     // TODO: Use custom calibration per device
-    const Common::ParamPackage touch_param(Settings::values.touch_device);
+    const Common::ParamPackage touch_param(Settings::values.touch_device.GetValue());
     const u16 min_x = static_cast<u16>(touch_param.Get("min_x", 100));
     const u16 min_y = static_cast<u16>(touch_param.Get("min_y", 50));
     const u16 max_x = static_cast<u16>(touch_param.Get("max_x", 1800));
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 3986eb172..2bab2b4f5 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -97,19 +97,14 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                                Core::Frontend::EmuWindow& emu_window,
                                Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
                                std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
-    : RendererBase(emu_window, std::move(context_)),
-      telemetry_session(telemetry_session_),
-      cpu_memory(cpu_memory_),
-      gpu(gpu_),
-      library(OpenLibrary()),
+    : RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
+      cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
       instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
-                              true, Settings::values.renderer_debug)),
+                              true, Settings::values.renderer_debug.GetValue())),
       debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
       surface(CreateSurface(instance, render_window)),
-      device(CreateDevice(instance, dld, *surface)),
-      memory_allocator(device, false),
-      state_tracker(gpu),
-      scheduler(device, state_tracker),
+      device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
+      state_tracker(gpu), scheduler(device, state_tracker),
       swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
                 render_window.GetFramebufferLayout().height, false),
       blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, scheduler,
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 2ad0ac32e..d36aaade2 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -272,6 +272,82 @@ void Config::Initialize(const std::string& config_name) {
     }
 }
 
+// Explicity std::string definition: Qt can't implicitly convert a std::string to a QVariant, nor
+// can it implicitly convert a QVariant back to a {std::,Q}string
+template <>
+void Config::ReadBasicSetting(Settings::BasicSetting<std::string>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
+        setting.SetValue(setting.GetDefault());
+    } else {
+        setting.SetValue(qt_config->value(name, QString::fromStdString(setting.GetDefault()))
+                             .toString()
+                             .toStdString());
+    }
+}
+template <typename Type>
+void Config::ReadBasicSetting(Settings::BasicSetting<Type>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
+        setting.SetValue(setting.GetDefault());
+    } else {
+        setting.SetValue(
+            static_cast<QVariant>(qt_config->value(name, setting.GetDefault())).value<Type>());
+    }
+}
+
+// Explicit std::string definition: Qt can't implicitly convert a std::string to a QVariant
+template <>
+void Config::WriteBasicSetting(const Settings::BasicSetting<std::string>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    qt_config->setValue(name + QStringLiteral("/default"),
+                        setting.GetValue() == setting.GetDefault());
+    qt_config->setValue(name, QString::fromStdString(setting.GetValue()));
+}
+// Explicit float definition: use a double as Qt doesn't write legible floats to config files
+template <>
+void Config::WriteBasicSetting(const Settings::BasicSetting<float>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    const double value = setting.GetValue();
+    qt_config->setValue(name + QStringLiteral("/default"),
+                        setting.GetValue() == setting.GetDefault());
+    qt_config->setValue(name, value);
+}
+template <typename Type>
+void Config::WriteBasicSetting(const Settings::BasicSetting<Type>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    qt_config->setValue(name + QStringLiteral("/default"),
+                        setting.GetValue() == setting.GetDefault());
+    qt_config->setValue(name, setting.GetValue());
+}
+
+// Explicit float definition: use a double as Qt doesn't write legible floats to config files
+template <>
+void Config::WriteGlobalSetting(const Settings::Setting<float>& setting) {
+    const QString name = QString::fromStdString(setting.GetLabel());
+    const double value = setting.GetValue(global);
+    if (!global) {
+        qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal());
+    }
+    if (global || !setting.UsingGlobal()) {
+        qt_config->setValue(name + QStringLiteral("/default"),
+                            setting.GetValue(global) == setting.GetDefault());
+        qt_config->setValue(name, value);
+    }
+}
+template <typename Type>
+void Config::WriteGlobalSetting(const Settings::Setting<Type>& setting) {
+    QString name = QString::fromStdString(setting.GetLabel());
+    if (!global) {
+        qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal());
+    }
+    if (global || !setting.UsingGlobal()) {
+        qt_config->setValue(name + QStringLiteral("/default"),
+                            setting.GetValue(global) == setting.GetDefault());
+        qt_config->setValue(name, setting.GetValue(global));
+    }
+}
+
 void Config::ReadPlayerValue(std::size_t player_index) {
     const QString player_prefix = [this, player_index] {
         if (type == ConfigType::InputProfile) {
@@ -395,8 +471,7 @@ void Config::ReadPlayerValue(std::size_t player_index) {
 }
 
 void Config::ReadDebugValues() {
-    Settings::values.debug_pad_enabled =
-        ReadSetting(QStringLiteral("debug_pad_enabled"), false).toBool();
+    ReadBasicSetting(Settings::values.debug_pad_enabled);
 
     for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
@@ -432,8 +507,7 @@ void Config::ReadDebugValues() {
 }
 
 void Config::ReadKeyboardValues() {
-    Settings::values.keyboard_enabled =
-        ReadSetting(QStringLiteral("keyboard_enabled"), false).toBool();
+    ReadBasicSetting(Settings::values.keyboard_enabled);
 
     std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
                    Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
@@ -446,7 +520,7 @@ void Config::ReadKeyboardValues() {
 }
 
 void Config::ReadMouseValues() {
-    Settings::values.mouse_enabled = ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
+    ReadBasicSetting(Settings::values.mouse_enabled);
 
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         const std::string default_param =
@@ -481,18 +555,11 @@ void Config::ReadAudioValues() {
     qt_config->beginGroup(QStringLiteral("Audio"));
 
     if (global) {
-        Settings::values.sink_id =
-            ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
-                .toString()
-                .toStdString();
-        Settings::values.audio_device_id =
-            ReadSetting(QStringLiteral("output_device"), QStringLiteral("auto"))
-                .toString()
-                .toStdString();
+        ReadBasicSetting(Settings::values.audio_device_id);
+        ReadBasicSetting(Settings::values.sink_id);
     }
-    ReadSettingGlobal(Settings::values.enable_audio_stretching,
-                      QStringLiteral("enable_audio_stretching"));
-    ReadSettingGlobal(Settings::values.volume, QStringLiteral("volume"));
+    ReadGlobalSetting(Settings::values.enable_audio_stretching);
+    ReadGlobalSetting(Settings::values.volume);
 
     qt_config->endGroup();
 }
@@ -509,13 +576,11 @@ void Config::ReadControlValues() {
     ReadTouchscreenValues();
     ReadMotionTouchValues();
 
-    Settings::values.emulate_analog_keyboard =
-        ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool();
+    ReadBasicSetting(Settings::values.emulate_analog_keyboard);
     Settings::values.mouse_panning = false;
-    Settings::values.mouse_panning_sensitivity =
-        ReadSetting(QStringLiteral("mouse_panning_sensitivity"), 1).toFloat();
+    ReadBasicSetting(Settings::values.mouse_panning_sensitivity);
 
-    ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"));
+    ReadGlobalSetting(Settings::values.use_docked_mode);
 
     // Disable docked mode if handheld is selected
     const auto controller_type = Settings::values.players.GetValue()[0].controller_type;
@@ -523,10 +588,9 @@ void Config::ReadControlValues() {
         Settings::values.use_docked_mode.SetValue(false);
     }
 
-    ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"));
-    ReadSettingGlobal(Settings::values.enable_accurate_vibrations,
-                      QStringLiteral("enable_accurate_vibrations"));
-    ReadSettingGlobal(Settings::values.motion_enabled, QStringLiteral("motion_enabled"));
+    ReadGlobalSetting(Settings::values.vibration_enabled);
+    ReadGlobalSetting(Settings::values.enable_accurate_vibrations);
+    ReadGlobalSetting(Settings::values.motion_enabled);
 
     qt_config->endGroup();
 }
@@ -564,33 +628,19 @@ void Config::ReadMotionTouchValues() {
     }
     qt_config->endArray();
 
-    Settings::values.motion_device =
-        ReadSetting(QStringLiteral("motion_device"),
-                    QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
-            .toString()
-            .toStdString();
-    Settings::values.touch_device =
-        ReadSetting(QStringLiteral("touch_device"),
-                    QStringLiteral("min_x:100,min_y:50,max_x:1800,max_y:850"))
-            .toString()
-            .toStdString();
-    Settings::values.use_touch_from_button =
-        ReadSetting(QStringLiteral("use_touch_from_button"), false).toBool();
-    Settings::values.touch_from_button_map_index =
-        ReadSetting(QStringLiteral("touch_from_button_map"), 0).toInt();
-    Settings::values.touch_from_button_map_index =
-        std::clamp(Settings::values.touch_from_button_map_index, 0, num_touch_from_button_maps - 1);
-    Settings::values.udp_input_servers =
-        ReadSetting(QStringLiteral("udp_input_servers"),
-                    QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_SRV))
-            .toString()
-            .toStdString();
+    ReadBasicSetting(Settings::values.motion_device);
+    ReadBasicSetting(Settings::values.touch_device);
+    ReadBasicSetting(Settings::values.use_touch_from_button);
+    ReadBasicSetting(Settings::values.touch_from_button_map_index);
+    Settings::values.touch_from_button_map_index = std::clamp(
+        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
+    ReadBasicSetting(Settings::values.udp_input_servers);
 }
 
 void Config::ReadCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    ReadSettingGlobal(Settings::values.use_multi_core, QStringLiteral("use_multi_core"));
+    ReadGlobalSetting(Settings::values.use_multi_core);
 
     qt_config->endGroup();
 }
@@ -598,7 +648,7 @@ void Config::ReadCoreValues() {
 void Config::ReadDataStorageValues() {
     qt_config->beginGroup(QStringLiteral("Data Storage"));
 
-    Settings::values.use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
+    ReadBasicSetting(Settings::values.use_virtual_sd);
     FS::SetYuzuPath(
         FS::YuzuPath::NANDDir,
         qt_config
@@ -627,12 +677,9 @@ void Config::ReadDataStorageValues() {
                     QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)))
             .toString()
             .toStdString());
-    Settings::values.gamecard_inserted =
-        ReadSetting(QStringLiteral("gamecard_inserted"), false).toBool();
-    Settings::values.gamecard_current_game =
-        ReadSetting(QStringLiteral("gamecard_current_game"), false).toBool();
-    Settings::values.gamecard_path =
-        ReadSetting(QStringLiteral("gamecard_path"), QString{}).toString().toStdString();
+    ReadBasicSetting(Settings::values.gamecard_inserted);
+    ReadBasicSetting(Settings::values.gamecard_current_game);
+    ReadBasicSetting(Settings::values.gamecard_path);
 
     qt_config->endGroup();
 }
@@ -643,34 +690,24 @@ void Config::ReadDebuggingValues() {
     // Intentionally not using the QT default setting as this is intended to be changed in the ini
     Settings::values.record_frame_times =
         qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
-    Settings::values.program_args =
-        ReadSetting(QStringLiteral("program_args"), QString{}).toString().toStdString();
-    Settings::values.dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
-    Settings::values.dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
-    Settings::values.enable_fs_access_log =
-        ReadSetting(QStringLiteral("enable_fs_access_log"), false).toBool();
-    Settings::values.reporting_services =
-        ReadSetting(QStringLiteral("reporting_services"), false).toBool();
-    Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
-    Settings::values.disable_macro_jit =
-        ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
-    Settings::values.extended_logging =
-        ReadSetting(QStringLiteral("extended_logging"), false).toBool();
-    Settings::values.use_debug_asserts =
-        ReadSetting(QStringLiteral("use_debug_asserts"), false).toBool();
-    Settings::values.use_auto_stub = ReadSetting(QStringLiteral("use_auto_stub"), false).toBool();
+    ReadBasicSetting(Settings::values.program_args);
+    ReadBasicSetting(Settings::values.dump_exefs);
+    ReadBasicSetting(Settings::values.dump_nso);
+    ReadBasicSetting(Settings::values.enable_fs_access_log);
+    ReadBasicSetting(Settings::values.reporting_services);
+    ReadBasicSetting(Settings::values.quest_flag);
+    ReadBasicSetting(Settings::values.disable_macro_jit);
+    ReadBasicSetting(Settings::values.extended_logging);
+    ReadBasicSetting(Settings::values.use_debug_asserts);
+    ReadBasicSetting(Settings::values.use_auto_stub);
 
     qt_config->endGroup();
 }
 
 void Config::ReadServiceValues() {
     qt_config->beginGroup(QStringLiteral("Services"));
-    Settings::values.bcat_backend =
-        ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("none"))
-            .toString()
-            .toStdString();
-    Settings::values.bcat_boxcat_local =
-        ReadSetting(QStringLiteral("bcat_boxcat_local"), false).toBool();
+    ReadBasicSetting(Settings::values.bcat_backend);
+    ReadBasicSetting(Settings::values.bcat_boxcat_local);
     qt_config->endGroup();
 }
 
@@ -696,11 +733,8 @@ void Config::ReadDisabledAddOnValues() {
 void Config::ReadMiscellaneousValues() {
     qt_config->beginGroup(QStringLiteral("Miscellaneous"));
 
-    Settings::values.log_filter =
-        ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
-            .toString()
-            .toStdString();
-    Settings::values.use_dev_keys = ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
+    ReadBasicSetting(Settings::values.log_filter);
+    ReadBasicSetting(Settings::values.use_dev_keys);
 
     qt_config->endGroup();
 }
@@ -750,38 +784,24 @@ void Config::ReadPathValues() {
 void Config::ReadCpuValues() {
     qt_config->beginGroup(QStringLiteral("Cpu"));
 
-    ReadSettingGlobal(Settings::values.cpu_accuracy, QStringLiteral("cpu_accuracy"));
+    ReadGlobalSetting(Settings::values.cpu_accuracy);
 
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_unfuse_fma,
-                      QStringLiteral("cpuopt_unsafe_unfuse_fma"));
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_reduce_fp_error,
-                      QStringLiteral("cpuopt_unsafe_reduce_fp_error"));
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
-                      QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"));
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_inaccurate_nan,
-                      QStringLiteral("cpuopt_unsafe_inaccurate_nan"));
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_fastmem_check,
-                      QStringLiteral("cpuopt_unsafe_fastmem_check"));
+    ReadGlobalSetting(Settings::values.cpuopt_unsafe_unfuse_fma);
+    ReadGlobalSetting(Settings::values.cpuopt_unsafe_reduce_fp_error);
+    ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
+    ReadGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
+    ReadGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
 
     if (global) {
-        Settings::values.cpuopt_page_tables =
-            ReadSetting(QStringLiteral("cpuopt_page_tables"), true).toBool();
-        Settings::values.cpuopt_block_linking =
-            ReadSetting(QStringLiteral("cpuopt_block_linking"), true).toBool();
-        Settings::values.cpuopt_return_stack_buffer =
-            ReadSetting(QStringLiteral("cpuopt_return_stack_buffer"), true).toBool();
-        Settings::values.cpuopt_fast_dispatcher =
-            ReadSetting(QStringLiteral("cpuopt_fast_dispatcher"), true).toBool();
-        Settings::values.cpuopt_context_elimination =
-            ReadSetting(QStringLiteral("cpuopt_context_elimination"), true).toBool();
-        Settings::values.cpuopt_const_prop =
-            ReadSetting(QStringLiteral("cpuopt_const_prop"), true).toBool();
-        Settings::values.cpuopt_misc_ir =
-            ReadSetting(QStringLiteral("cpuopt_misc_ir"), true).toBool();
-        Settings::values.cpuopt_reduce_misalign_checks =
-            ReadSetting(QStringLiteral("cpuopt_reduce_misalign_checks"), true).toBool();
-        Settings::values.cpuopt_fastmem =
-            ReadSetting(QStringLiteral("cpuopt_fastmem"), true).toBool();
+        ReadBasicSetting(Settings::values.cpuopt_page_tables);
+        ReadBasicSetting(Settings::values.cpuopt_block_linking);
+        ReadBasicSetting(Settings::values.cpuopt_return_stack_buffer);
+        ReadBasicSetting(Settings::values.cpuopt_fast_dispatcher);
+        ReadBasicSetting(Settings::values.cpuopt_context_elimination);
+        ReadBasicSetting(Settings::values.cpuopt_const_prop);
+        ReadBasicSetting(Settings::values.cpuopt_misc_ir);
+        ReadBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
+        ReadBasicSetting(Settings::values.cpuopt_fastmem);
     }
 
     qt_config->endGroup();
@@ -790,32 +810,28 @@ void Config::ReadCpuValues() {
 void Config::ReadRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
-    ReadSettingGlobal(Settings::values.renderer_backend, QStringLiteral("backend"));
-    ReadSettingGlobal(Settings::values.renderer_debug, QStringLiteral("debug"), false);
-    ReadSettingGlobal(Settings::values.vulkan_device, QStringLiteral("vulkan_device"));
-    ReadSettingGlobal(Settings::values.fullscreen_mode, QStringLiteral("fullscreen_mode"));
-    ReadSettingGlobal(Settings::values.aspect_ratio, QStringLiteral("aspect_ratio"));
-    ReadSettingGlobal(Settings::values.max_anisotropy, QStringLiteral("max_anisotropy"));
-    ReadSettingGlobal(Settings::values.use_frame_limit, QStringLiteral("use_frame_limit"));
-    ReadSettingGlobal(Settings::values.frame_limit, QStringLiteral("frame_limit"));
-    ReadSettingGlobal(Settings::values.use_disk_shader_cache,
-                      QStringLiteral("use_disk_shader_cache"));
-    ReadSettingGlobal(Settings::values.gpu_accuracy, QStringLiteral("gpu_accuracy"));
-    ReadSettingGlobal(Settings::values.use_asynchronous_gpu_emulation,
-                      QStringLiteral("use_asynchronous_gpu_emulation"));
-    ReadSettingGlobal(Settings::values.use_nvdec_emulation, QStringLiteral("use_nvdec_emulation"));
-    ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"));
-    ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"));
-    ReadSettingGlobal(Settings::values.disable_fps_limit, QStringLiteral("disable_fps_limit"));
-    ReadSettingGlobal(Settings::values.use_assembly_shaders,
-                      QStringLiteral("use_assembly_shaders"));
-    ReadSettingGlobal(Settings::values.use_asynchronous_shaders,
-                      QStringLiteral("use_asynchronous_shaders"));
-    ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"));
-    ReadSettingGlobal(Settings::values.use_caches_gc, QStringLiteral("use_caches_gc"));
-    ReadSettingGlobal(Settings::values.bg_red, QStringLiteral("bg_red"));
-    ReadSettingGlobal(Settings::values.bg_green, QStringLiteral("bg_green"));
-    ReadSettingGlobal(Settings::values.bg_blue, QStringLiteral("bg_blue"));
+    ReadGlobalSetting(Settings::values.renderer_backend);
+    ReadBasicSetting(Settings::values.renderer_debug);
+    ReadGlobalSetting(Settings::values.vulkan_device);
+    ReadGlobalSetting(Settings::values.fullscreen_mode);
+    ReadGlobalSetting(Settings::values.aspect_ratio);
+    ReadGlobalSetting(Settings::values.max_anisotropy);
+    ReadGlobalSetting(Settings::values.use_frame_limit);
+    ReadGlobalSetting(Settings::values.frame_limit);
+    ReadGlobalSetting(Settings::values.use_disk_shader_cache);
+    ReadGlobalSetting(Settings::values.gpu_accuracy);
+    ReadGlobalSetting(Settings::values.use_asynchronous_gpu_emulation);
+    ReadGlobalSetting(Settings::values.use_nvdec_emulation);
+    ReadGlobalSetting(Settings::values.accelerate_astc);
+    ReadGlobalSetting(Settings::values.use_vsync);
+    ReadGlobalSetting(Settings::values.disable_fps_limit);
+    ReadGlobalSetting(Settings::values.use_assembly_shaders);
+    ReadGlobalSetting(Settings::values.use_asynchronous_shaders);
+    ReadGlobalSetting(Settings::values.use_fast_gpu_time);
+    ReadGlobalSetting(Settings::values.use_caches_gc);
+    ReadGlobalSetting(Settings::values.bg_red);
+    ReadGlobalSetting(Settings::values.bg_green);
+    ReadGlobalSetting(Settings::values.bg_blue);
 
     qt_config->endGroup();
 }
@@ -860,15 +876,15 @@ void Config::ReadShortcutValues() {
 void Config::ReadSystemValues() {
     qt_config->beginGroup(QStringLiteral("System"));
 
-    ReadSettingGlobal(Settings::values.current_user, QStringLiteral("current_user"), 0);
-    Settings::values.current_user =
-        std::clamp<int>(Settings::values.current_user, 0, Service::Account::MAX_USERS - 1);
+    ReadBasicSetting(Settings::values.current_user);
+    Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
+                                                    Service::Account::MAX_USERS - 1);
 
-    ReadSettingGlobal(Settings::values.language_index, QStringLiteral("language_index"));
+    ReadGlobalSetting(Settings::values.language_index);
 
-    ReadSettingGlobal(Settings::values.region_index, QStringLiteral("region_index"));
+    ReadGlobalSetting(Settings::values.region_index);
 
-    ReadSettingGlobal(Settings::values.time_zone_index, QStringLiteral("time_zone_index"));
+    ReadGlobalSetting(Settings::values.time_zone_index);
 
     bool rng_seed_enabled;
     ReadSettingGlobal(rng_seed_enabled, QStringLiteral("rng_seed_enabled"), false);
@@ -894,7 +910,7 @@ void Config::ReadSystemValues() {
         }
     }
 
-    ReadSettingGlobal(Settings::values.sound_index, QStringLiteral("sound_index"));
+    ReadGlobalSetting(Settings::values.sound_index);
 
     qt_config->endGroup();
 }
@@ -978,16 +994,10 @@ void Config::ReadUILayoutValues() {
 void Config::ReadWebServiceValues() {
     qt_config->beginGroup(QStringLiteral("WebService"));
 
-    Settings::values.enable_telemetry =
-        ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
-    Settings::values.web_api_url =
-        ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.yuzu-emu.org"))
-            .toString()
-            .toStdString();
-    Settings::values.yuzu_username =
-        ReadSetting(QStringLiteral("yuzu_username")).toString().toStdString();
-    Settings::values.yuzu_token =
-        ReadSetting(QStringLiteral("yuzu_token")).toString().toStdString();
+    ReadBasicSetting(Settings::values.enable_telemetry);
+    ReadBasicSetting(Settings::values.web_api_url);
+    ReadBasicSetting(Settings::values.yuzu_username);
+    ReadBasicSetting(Settings::values.yuzu_token);
 
     qt_config->endGroup();
 }
@@ -1073,7 +1083,7 @@ void Config::SavePlayerValue(std::size_t player_index) {
 }
 
 void Config::SaveDebugValues() {
-    WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::values.debug_pad_enabled, false);
+    WriteBasicSetting(Settings::values.debug_pad_enabled);
     for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
         WriteSetting(QStringLiteral("debug_pad_") +
@@ -1093,7 +1103,7 @@ void Config::SaveDebugValues() {
 }
 
 void Config::SaveMouseValues() {
-    WriteSetting(QStringLiteral("mouse_enabled"), Settings::values.mouse_enabled, false);
+    WriteBasicSetting(Settings::values.mouse_enabled);
 
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         const std::string default_param =
@@ -1116,19 +1126,11 @@ void Config::SaveTouchscreenValues() {
 }
 
 void Config::SaveMotionTouchValues() {
-    WriteSetting(QStringLiteral("motion_device"),
-                 QString::fromStdString(Settings::values.motion_device),
-                 QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
-    WriteSetting(QStringLiteral("touch_device"),
-                 QString::fromStdString(Settings::values.touch_device),
-                 QStringLiteral("engine:emu_window"));
-    WriteSetting(QStringLiteral("use_touch_from_button"), Settings::values.use_touch_from_button,
-                 false);
-    WriteSetting(QStringLiteral("touch_from_button_map"),
-                 Settings::values.touch_from_button_map_index, 0);
-    WriteSetting(QStringLiteral("udp_input_servers"),
-                 QString::fromStdString(Settings::values.udp_input_servers),
-                 QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_SRV));
+    WriteBasicSetting(Settings::values.motion_device);
+    WriteBasicSetting(Settings::values.touch_device);
+    WriteBasicSetting(Settings::values.use_touch_from_button);
+    WriteBasicSetting(Settings::values.touch_from_button_map_index);
+    WriteBasicSetting(Settings::values.udp_input_servers);
 
     qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
     for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
@@ -1171,15 +1173,11 @@ void Config::SaveAudioValues() {
     qt_config->beginGroup(QStringLiteral("Audio"));
 
     if (global) {
-        WriteSetting(QStringLiteral("output_engine"),
-                     QString::fromStdString(Settings::values.sink_id), QStringLiteral("auto"));
-        WriteSetting(QStringLiteral("output_device"),
-                     QString::fromStdString(Settings::values.audio_device_id),
-                     QStringLiteral("auto"));
+        WriteBasicSetting(Settings::values.sink_id);
+        WriteBasicSetting(Settings::values.audio_device_id);
     }
-    WriteSettingGlobal(QStringLiteral("enable_audio_stretching"),
-                       Settings::values.enable_audio_stretching);
-    WriteSettingGlobal(QStringLiteral("volume"), Settings::values.volume);
+    WriteGlobalSetting(Settings::values.enable_audio_stretching);
+    WriteGlobalSetting(Settings::values.volume);
 
     qt_config->endGroup();
 }
@@ -1195,29 +1193,21 @@ void Config::SaveControlValues() {
     SaveTouchscreenValues();
     SaveMotionTouchValues();
 
-    WriteSettingGlobal(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode);
-    WriteSettingGlobal(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled);
-    WriteSettingGlobal(QStringLiteral("enable_accurate_vibrations"),
-                       Settings::values.enable_accurate_vibrations);
-    WriteSettingGlobal(QStringLiteral("motion_enabled"), Settings::values.motion_enabled);
-    WriteSetting(QStringLiteral("motion_device"),
-                 QString::fromStdString(Settings::values.motion_device),
-                 QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
-    WriteSetting(QStringLiteral("touch_device"),
-                 QString::fromStdString(Settings::values.touch_device),
-                 QStringLiteral("engine:emu_window"));
-    WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false);
-    WriteSetting(QStringLiteral("emulate_analog_keyboard"),
-                 Settings::values.emulate_analog_keyboard, false);
-    WriteSetting(QStringLiteral("mouse_panning_sensitivity"),
-                 Settings::values.mouse_panning_sensitivity, 1.0f);
+    WriteGlobalSetting(Settings::values.use_docked_mode);
+    WriteGlobalSetting(Settings::values.vibration_enabled);
+    WriteGlobalSetting(Settings::values.enable_accurate_vibrations);
+    WriteGlobalSetting(Settings::values.motion_enabled);
+    WriteBasicSetting(Settings::values.keyboard_enabled);
+    WriteBasicSetting(Settings::values.emulate_analog_keyboard);
+    WriteBasicSetting(Settings::values.mouse_panning_sensitivity);
+
     qt_config->endGroup();
 }
 
 void Config::SaveCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
-    WriteSettingGlobal(QStringLiteral("use_multi_core"), Settings::values.use_multi_core);
+    WriteGlobalSetting(Settings::values.use_multi_core);
 
     qt_config->endGroup();
 }
@@ -1225,7 +1215,7 @@ void Config::SaveCoreValues() {
 void Config::SaveDataStorageValues() {
     qt_config->beginGroup(QStringLiteral("Data Storage"));
 
-    WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values.use_virtual_sd, true);
+    WriteBasicSetting(Settings::values.use_virtual_sd);
     WriteSetting(QStringLiteral("nand_directory"),
                  QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)),
                  QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
@@ -1238,11 +1228,9 @@ void Config::SaveDataStorageValues() {
     WriteSetting(QStringLiteral("dump_directory"),
                  QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)),
                  QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    WriteSetting(QStringLiteral("gamecard_inserted"), Settings::values.gamecard_inserted, false);
-    WriteSetting(QStringLiteral("gamecard_current_game"), Settings::values.gamecard_current_game,
-                 false);
-    WriteSetting(QStringLiteral("gamecard_path"),
-                 QString::fromStdString(Settings::values.gamecard_path), QString{});
+    WriteBasicSetting(Settings::values.gamecard_inserted);
+    WriteBasicSetting(Settings::values.gamecard_current_game);
+    WriteBasicSetting(Settings::values.gamecard_path);
 
     qt_config->endGroup();
 }
@@ -1252,24 +1240,23 @@ void Config::SaveDebuggingValues() {
 
     // 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("program_args"),
-                 QString::fromStdString(Settings::values.program_args), QString{});
-    WriteSetting(QStringLiteral("dump_exefs"), Settings::values.dump_exefs, false);
-    WriteSetting(QStringLiteral("dump_nso"), Settings::values.dump_nso, false);
-    WriteSetting(QStringLiteral("enable_fs_access_log"), Settings::values.enable_fs_access_log,
-                 false);
-    WriteSetting(QStringLiteral("quest_flag"), Settings::values.quest_flag, false);
-    WriteSetting(QStringLiteral("use_debug_asserts"), Settings::values.use_debug_asserts, false);
-    WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values.disable_macro_jit, false);
+    WriteBasicSetting(Settings::values.program_args);
+    WriteBasicSetting(Settings::values.dump_exefs);
+    WriteBasicSetting(Settings::values.dump_nso);
+    WriteBasicSetting(Settings::values.enable_fs_access_log);
+    WriteBasicSetting(Settings::values.quest_flag);
+    WriteBasicSetting(Settings::values.use_debug_asserts);
+    WriteBasicSetting(Settings::values.disable_macro_jit);
 
     qt_config->endGroup();
 }
 
 void Config::SaveServiceValues() {
     qt_config->beginGroup(QStringLiteral("Services"));
-    WriteSetting(QStringLiteral("bcat_backend"),
-                 QString::fromStdString(Settings::values.bcat_backend), QStringLiteral("none"));
-    WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::values.bcat_boxcat_local, false);
+
+    WriteBasicSetting(Settings::values.bcat_backend);
+    WriteBasicSetting(Settings::values.bcat_boxcat_local);
+
     qt_config->endGroup();
 }
 
@@ -1295,9 +1282,8 @@ void Config::SaveDisabledAddOnValues() {
 void Config::SaveMiscellaneousValues() {
     qt_config->beginGroup(QStringLiteral("Miscellaneous"));
 
-    WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values.log_filter),
-                 QStringLiteral("*:Info"));
-    WriteSetting(QStringLiteral("use_dev_keys"), Settings::values.use_dev_keys, false);
+    WriteBasicSetting(Settings::values.log_filter);
+    WriteBasicSetting(Settings::values.use_dev_keys);
 
     qt_config->endGroup();
 }
@@ -1325,38 +1311,27 @@ void Config::SavePathValues() {
 void Config::SaveCpuValues() {
     qt_config->beginGroup(QStringLiteral("Cpu"));
 
-    WriteSettingGlobal(QStringLiteral("cpu_accuracy"),
-                       static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)),
-                       Settings::values.cpu_accuracy.UsingGlobal(),
-                       static_cast<u32>(Settings::values.cpu_accuracy.GetDefault()));
-
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_unfuse_fma"),
-                       Settings::values.cpuopt_unsafe_unfuse_fma);
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_reduce_fp_error"),
-                       Settings::values.cpuopt_unsafe_reduce_fp_error);
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"),
-                       Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_inaccurate_nan"),
-                       Settings::values.cpuopt_unsafe_inaccurate_nan);
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_fastmem_check"),
-                       Settings::values.cpuopt_unsafe_fastmem_check);
+    WriteSetting(QStringLiteral("cpu_accuracy"),
+                 static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)),
+                 static_cast<u32>(Settings::values.cpu_accuracy.GetDefault()),
+                 Settings::values.cpu_accuracy.UsingGlobal());
+
+    WriteGlobalSetting(Settings::values.cpuopt_unsafe_unfuse_fma);
+    WriteGlobalSetting(Settings::values.cpuopt_unsafe_reduce_fp_error);
+    WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
+    WriteGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
+    WriteGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
 
     if (global) {
-        WriteSetting(QStringLiteral("cpuopt_page_tables"), Settings::values.cpuopt_page_tables,
-                     true);
-        WriteSetting(QStringLiteral("cpuopt_block_linking"), Settings::values.cpuopt_block_linking,
-                     true);
-        WriteSetting(QStringLiteral("cpuopt_return_stack_buffer"),
-                     Settings::values.cpuopt_return_stack_buffer, true);
-        WriteSetting(QStringLiteral("cpuopt_fast_dispatcher"),
-                     Settings::values.cpuopt_fast_dispatcher, true);
-        WriteSetting(QStringLiteral("cpuopt_context_elimination"),
-                     Settings::values.cpuopt_context_elimination, true);
-        WriteSetting(QStringLiteral("cpuopt_const_prop"), Settings::values.cpuopt_const_prop, true);
-        WriteSetting(QStringLiteral("cpuopt_misc_ir"), Settings::values.cpuopt_misc_ir, true);
-        WriteSetting(QStringLiteral("cpuopt_reduce_misalign_checks"),
-                     Settings::values.cpuopt_reduce_misalign_checks, true);
-        WriteSetting(QStringLiteral("cpuopt_fastmem"), Settings::values.cpuopt_fastmem, true);
+        WriteBasicSetting(Settings::values.cpuopt_page_tables);
+        WriteBasicSetting(Settings::values.cpuopt_block_linking);
+        WriteBasicSetting(Settings::values.cpuopt_return_stack_buffer);
+        WriteBasicSetting(Settings::values.cpuopt_fast_dispatcher);
+        WriteBasicSetting(Settings::values.cpuopt_context_elimination);
+        WriteBasicSetting(Settings::values.cpuopt_const_prop);
+        WriteBasicSetting(Settings::values.cpuopt_misc_ir);
+        WriteBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
+        WriteBasicSetting(Settings::values.cpuopt_fastmem);
     }
 
     qt_config->endGroup();
@@ -1365,38 +1340,34 @@ void Config::SaveCpuValues() {
 void Config::SaveRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
-    WriteSettingGlobal(QStringLiteral("backend"),
-                       static_cast<u32>(Settings::values.renderer_backend.GetValue(global)),
-                       Settings::values.renderer_backend.UsingGlobal(),
-                       static_cast<u32>(Settings::values.renderer_backend.GetDefault()));
-    WriteSetting(QStringLiteral("debug"), Settings::values.renderer_debug);
-    WriteSettingGlobal(QStringLiteral("vulkan_device"), Settings::values.vulkan_device);
-    WriteSettingGlobal(QStringLiteral("fullscreen_mode"), Settings::values.fullscreen_mode);
-    WriteSettingGlobal(QStringLiteral("aspect_ratio"), Settings::values.aspect_ratio);
-    WriteSettingGlobal(QStringLiteral("max_anisotropy"), Settings::values.max_anisotropy);
-    WriteSettingGlobal(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit);
-    WriteSettingGlobal(QStringLiteral("frame_limit"), Settings::values.frame_limit);
-    WriteSettingGlobal(QStringLiteral("use_disk_shader_cache"),
-                       Settings::values.use_disk_shader_cache);
-    WriteSettingGlobal(QStringLiteral("gpu_accuracy"),
-                       static_cast<u32>(Settings::values.gpu_accuracy.GetValue(global)),
-                       Settings::values.gpu_accuracy.UsingGlobal(),
-                       static_cast<u32>(Settings::values.gpu_accuracy.GetDefault()));
-    WriteSettingGlobal(QStringLiteral("use_asynchronous_gpu_emulation"),
-                       Settings::values.use_asynchronous_gpu_emulation);
-    WriteSettingGlobal(QStringLiteral("use_nvdec_emulation"), Settings::values.use_nvdec_emulation);
-    WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc);
-    WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync);
-    WriteSettingGlobal(QStringLiteral("disable_fps_limit"), Settings::values.disable_fps_limit);
-    WriteSettingGlobal(QStringLiteral("use_assembly_shaders"),
-                       Settings::values.use_assembly_shaders);
-    WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"),
-                       Settings::values.use_asynchronous_shaders);
-    WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time);
-    WriteSettingGlobal(QStringLiteral("use_caches_gc"), Settings::values.use_caches_gc);
-    WriteSettingGlobal(QStringLiteral("bg_red"), Settings::values.bg_red);
-    WriteSettingGlobal(QStringLiteral("bg_green"), Settings::values.bg_green);
-    WriteSettingGlobal(QStringLiteral("bg_blue"), Settings::values.bg_blue);
+    WriteSetting(QString::fromStdString(Settings::values.renderer_backend.GetLabel()),
+                 static_cast<u32>(Settings::values.renderer_backend.GetValue(global)),
+                 static_cast<u32>(Settings::values.renderer_backend.GetDefault()),
+                 Settings::values.renderer_backend.UsingGlobal());
+    WriteBasicSetting(Settings::values.renderer_debug);
+    WriteGlobalSetting(Settings::values.vulkan_device);
+    WriteGlobalSetting(Settings::values.fullscreen_mode);
+    WriteGlobalSetting(Settings::values.aspect_ratio);
+    WriteGlobalSetting(Settings::values.max_anisotropy);
+    WriteGlobalSetting(Settings::values.use_frame_limit);
+    WriteGlobalSetting(Settings::values.frame_limit);
+    WriteGlobalSetting(Settings::values.use_disk_shader_cache);
+    WriteSetting(QString::fromStdString(Settings::values.gpu_accuracy.GetLabel()),
+                 static_cast<u32>(Settings::values.gpu_accuracy.GetValue(global)),
+                 static_cast<u32>(Settings::values.gpu_accuracy.GetDefault()),
+                 Settings::values.gpu_accuracy.UsingGlobal());
+    WriteGlobalSetting(Settings::values.use_asynchronous_gpu_emulation);
+    WriteGlobalSetting(Settings::values.use_nvdec_emulation);
+    WriteGlobalSetting(Settings::values.accelerate_astc);
+    WriteGlobalSetting(Settings::values.use_vsync);
+    WriteGlobalSetting(Settings::values.disable_fps_limit);
+    WriteGlobalSetting(Settings::values.use_assembly_shaders);
+    WriteGlobalSetting(Settings::values.use_asynchronous_shaders);
+    WriteGlobalSetting(Settings::values.use_fast_gpu_time);
+    WriteGlobalSetting(Settings::values.use_caches_gc);
+    WriteGlobalSetting(Settings::values.bg_red);
+    WriteGlobalSetting(Settings::values.bg_green);
+    WriteGlobalSetting(Settings::values.bg_blue);
 
     qt_config->endGroup();
 }
@@ -1435,17 +1406,16 @@ void Config::SaveShortcutValues() {
 void Config::SaveSystemValues() {
     qt_config->beginGroup(QStringLiteral("System"));
 
-    WriteSetting(QStringLiteral("current_user"), Settings::values.current_user);
-    WriteSettingGlobal(QStringLiteral("language_index"), Settings::values.language_index);
-    WriteSettingGlobal(QStringLiteral("region_index"), Settings::values.region_index);
-    WriteSettingGlobal(QStringLiteral("time_zone_index"), Settings::values.time_zone_index);
+    WriteBasicSetting(Settings::values.current_user);
+    WriteGlobalSetting(Settings::values.language_index);
+    WriteGlobalSetting(Settings::values.region_index);
+    WriteGlobalSetting(Settings::values.time_zone_index);
 
-    WriteSettingGlobal(QStringLiteral("rng_seed_enabled"),
-                       Settings::values.rng_seed.GetValue(global).has_value(),
-                       Settings::values.rng_seed.UsingGlobal(), false);
-    WriteSettingGlobal(QStringLiteral("rng_seed"),
-                       Settings::values.rng_seed.GetValue(global).value_or(0),
-                       Settings::values.rng_seed.UsingGlobal(), 0);
+    WriteSetting(QStringLiteral("rng_seed_enabled"),
+                 Settings::values.rng_seed.GetValue(global).has_value(),
+                 Settings::values.rng_seed.UsingGlobal(), false);
+    WriteSetting(QStringLiteral("rng_seed"), Settings::values.rng_seed.GetValue(global).value_or(0),
+                 Settings::values.rng_seed.UsingGlobal(), 0);
 
     if (global) {
         WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
@@ -1456,7 +1426,7 @@ void Config::SaveSystemValues() {
                      0);
     }
 
-    WriteSettingGlobal(QStringLiteral("sound_index"), Settings::values.sound_index);
+    WriteGlobalSetting(Settings::values.sound_index);
 
     qt_config->endGroup();
 }
@@ -1530,13 +1500,10 @@ void Config::SaveUILayoutValues() {
 void Config::SaveWebServiceValues() {
     qt_config->beginGroup(QStringLiteral("WebService"));
 
-    WriteSetting(QStringLiteral("enable_telemetry"), Settings::values.enable_telemetry, true);
-    WriteSetting(QStringLiteral("web_api_url"),
-                 QString::fromStdString(Settings::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));
+    WriteBasicSetting(Settings::values.enable_telemetry);
+    WriteBasicSetting(Settings::values.web_api_url);
+    WriteBasicSetting(Settings::values.yuzu_username);
+    WriteBasicSetting(Settings::values.yuzu_token);
 
     qt_config->endGroup();
 }
@@ -1555,25 +1522,15 @@ QVariant Config::ReadSetting(const QString& name, const QVariant& default_value)
     return result;
 }
 
-QVariant Config::ReadSetting(const QString& name, Settings::CPUAccuracy default_value) const {
-    return ReadSetting(name, static_cast<u32>(default_value));
-}
-
-QVariant Config::ReadSetting(const QString& name, Settings::GPUAccuracy default_value) const {
-    return ReadSetting(name, static_cast<u32>(default_value));
-}
-
-QVariant Config::ReadSetting(const QString& name, Settings::RendererBackend default_value) const {
-    return ReadSetting(name, static_cast<u32>(default_value));
-}
-
 template <typename Type>
-void Config::ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name) {
+void Config::ReadGlobalSetting(Settings::Setting<Type>& setting) {
+    QString name = QString::fromStdString(setting.GetLabel());
     const bool use_global = qt_config->value(name + QStringLiteral("/use_global"), true).toBool();
     setting.SetGlobal(use_global);
-    const Type& default_value = setting.GetDefault();
     if (global || !use_global) {
-        setting.SetValue(static_cast<QVariant>(ReadSetting(name, default_value)).value<Type>());
+        setting.SetValue(static_cast<QVariant>(
+                             ReadSetting(name, QVariant::fromValue<Type>(setting.GetDefault())))
+                             .value<Type>());
     }
 }
 
@@ -1596,20 +1553,8 @@ void Config::WriteSetting(const QString& name, const QVariant& value,
     qt_config->setValue(name, value);
 }
 
-template <typename Type>
-void Config::WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting) {
-    if (!global) {
-        qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal());
-    }
-    if (global || !setting.UsingGlobal()) {
-        qt_config->setValue(name + QStringLiteral("/default"),
-                            setting.GetValue(global) == setting.GetDefault());
-        qt_config->setValue(name, setting.GetValue(global));
-    }
-}
-
-void Config::WriteSettingGlobal(const QString& name, const QVariant& value, bool use_global,
-                                const QVariant& default_value) {
+void Config::WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
+                          bool use_global) {
     if (!global) {
         qt_config->setValue(name + QStringLiteral("/use_global"), use_global);
     }
diff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.h
index 62501997c..96f9b6de1 100644
--- a/src/yuzu/configuration/config.h
+++ b/src/yuzu/configuration/config.h
@@ -102,28 +102,75 @@ private:
     void SaveUILayoutValues();
     void SaveWebServiceValues();
 
+    /**
+     * Reads a setting from the qt_config.
+     *
+     * @param name The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
     QVariant ReadSetting(const QString& name) const;
     QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
-    QVariant ReadSetting(const QString& name, Settings::CPUAccuracy default_value) const;
-    QVariant ReadSetting(const QString& name, Settings::GPUAccuracy default_value) const;
-    QVariant ReadSetting(const QString& name, Settings::RendererBackend default_value) const;
-    // Templated ReadSettingGlobal functions will also look for the use_global setting and set
-    // both the value and the global state properly
-    template <typename Type>
-    void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name);
+
+    /**
+     * Only reads a setting from the qt_config if the current config is a global config, or if the
+     * current config is a custom config and the setting is overriding the global setting. Otherwise
+     * it does nothing.
+     *
+     * @param setting The variable to be modified
+     * @param name The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
     template <typename Type>
     void ReadSettingGlobal(Type& setting, const QString& name, const QVariant& default_value) const;
-    // Templated WriteSettingGlobal functions will also write the global state if needed and will
-    // skip writing the actual setting if it defers to the global value
+
+    /**
+     * Writes a setting to the qt_config.
+     *
+     * @param name The setting's idetentifier
+     * @param value Value of the setting
+     * @param default_value Default of the setting if not present in qt_config
+     * @param use_global Specifies if the custom or global config should be in use, for custom
+     * configs
+     */
     void WriteSetting(const QString& name, const QVariant& value);
     void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value);
+    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
+                      bool use_global);
+
+    /**
+     * Reads a value from the qt_config and applies it to the setting, using its label and default
+     * value. If the config is a custom config, this will also read the global state of the setting
+     * and apply that information to it.
+     *
+     * @param The setting
+     */
     template <typename Type>
-    void WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting);
+    void ReadGlobalSetting(Settings::Setting<Type>& setting);
+
+    /**
+     * Sets a value to the qt_config using the setting's label and default value. If the config is a
+     * custom config, it will apply the global state, and the custom value if needed.
+     *
+     * @param The setting
+     */
+    template <typename Type>
+    void WriteGlobalSetting(const Settings::Setting<Type>& setting);
+
+    /**
+     * Reads a value from the qt_config using the setting's label and default value and applies the
+     * value to the setting.
+     *
+     * @param The setting
+     */
+    template <typename Type>
+    void ReadBasicSetting(Settings::BasicSetting<Type>& setting);
+
+    /** Sets a value from the setting in the qt_config using the setting's label and default value.
+     *
+     * @param The setting
+     */
     template <typename Type>
-    void WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting,
-                            const QVariant& default_value);
-    void WriteSettingGlobal(const QString& name, const QVariant& value, bool use_global,
-                            const QVariant& default_value);
+    void WriteBasicSetting(const Settings::BasicSetting<Type>& setting);
 
     ConfigType type;
     std::unique_ptr<QSettings> qt_config;
diff --git a/src/yuzu/configuration/configure_audio.cpp b/src/yuzu/configuration/configure_audio.cpp
index fc0191432..5aba1a3b2 100644
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@@ -69,7 +69,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::values.sink_id.GetValue());
     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;
@@ -83,7 +83,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::values.audio_device_id.GetValue());
     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;
@@ -106,9 +106,9 @@ void ConfigureAudio::ApplyConfiguration() {
         Settings::values.sink_id =
             ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
                 .toStdString();
-        Settings::values.audio_device_id =
+        Settings::values.audio_device_id.SetValue(
             ui->audio_device_combo_box->itemText(ui->audio_device_combo_box->currentIndex())
-                .toStdString();
+                .toStdString());
 
         // Guard if during game and set to game-specific value
         if (Settings::values.volume.UsingGlobal()) {
diff --git a/src/yuzu/configuration/configure_cpu_debug.cpp b/src/yuzu/configuration/configure_cpu_debug.cpp
index e25c52baf..98e2d2be5 100644
--- a/src/yuzu/configuration/configure_cpu_debug.cpp
+++ b/src/yuzu/configuration/configure_cpu_debug.cpp
@@ -24,23 +24,26 @@ void ConfigureCpuDebug::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
     ui->cpuopt_page_tables->setEnabled(runtime_lock);
-    ui->cpuopt_page_tables->setChecked(Settings::values.cpuopt_page_tables);
+    ui->cpuopt_page_tables->setChecked(Settings::values.cpuopt_page_tables.GetValue());
     ui->cpuopt_block_linking->setEnabled(runtime_lock);
-    ui->cpuopt_block_linking->setChecked(Settings::values.cpuopt_block_linking);
+    ui->cpuopt_block_linking->setChecked(Settings::values.cpuopt_block_linking.GetValue());
     ui->cpuopt_return_stack_buffer->setEnabled(runtime_lock);
-    ui->cpuopt_return_stack_buffer->setChecked(Settings::values.cpuopt_return_stack_buffer);
+    ui->cpuopt_return_stack_buffer->setChecked(
+        Settings::values.cpuopt_return_stack_buffer.GetValue());
     ui->cpuopt_fast_dispatcher->setEnabled(runtime_lock);
-    ui->cpuopt_fast_dispatcher->setChecked(Settings::values.cpuopt_fast_dispatcher);
+    ui->cpuopt_fast_dispatcher->setChecked(Settings::values.cpuopt_fast_dispatcher.GetValue());
     ui->cpuopt_context_elimination->setEnabled(runtime_lock);
-    ui->cpuopt_context_elimination->setChecked(Settings::values.cpuopt_context_elimination);
+    ui->cpuopt_context_elimination->setChecked(
+        Settings::values.cpuopt_context_elimination.GetValue());
     ui->cpuopt_const_prop->setEnabled(runtime_lock);
-    ui->cpuopt_const_prop->setChecked(Settings::values.cpuopt_const_prop);
+    ui->cpuopt_const_prop->setChecked(Settings::values.cpuopt_const_prop.GetValue());
     ui->cpuopt_misc_ir->setEnabled(runtime_lock);
-    ui->cpuopt_misc_ir->setChecked(Settings::values.cpuopt_misc_ir);
+    ui->cpuopt_misc_ir->setChecked(Settings::values.cpuopt_misc_ir.GetValue());
     ui->cpuopt_reduce_misalign_checks->setEnabled(runtime_lock);
-    ui->cpuopt_reduce_misalign_checks->setChecked(Settings::values.cpuopt_reduce_misalign_checks);
+    ui->cpuopt_reduce_misalign_checks->setChecked(
+        Settings::values.cpuopt_reduce_misalign_checks.GetValue());
     ui->cpuopt_fastmem->setEnabled(runtime_lock);
-    ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem);
+    ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem.GetValue());
 }
 
 void ConfigureCpuDebug::ApplyConfiguration() {
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index 15d6a5ad7..7d15d54b8 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -32,19 +32,20 @@ void ConfigureDebug::SetConfiguration() {
 
     ui->toggle_console->setEnabled(runtime_lock);
     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->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter.GetValue()));
+    ui->homebrew_args_edit->setText(
+        QString::fromStdString(Settings::values.program_args.GetValue()));
     ui->fs_access_log->setEnabled(runtime_lock);
-    ui->fs_access_log->setChecked(Settings::values.enable_fs_access_log);
-    ui->reporting_services->setChecked(Settings::values.reporting_services);
-    ui->quest_flag->setChecked(Settings::values.quest_flag);
-    ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts);
-    ui->use_auto_stub->setChecked(Settings::values.use_auto_stub);
+    ui->fs_access_log->setChecked(Settings::values.enable_fs_access_log.GetValue());
+    ui->reporting_services->setChecked(Settings::values.reporting_services.GetValue());
+    ui->quest_flag->setChecked(Settings::values.quest_flag.GetValue());
+    ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts.GetValue());
+    ui->use_auto_stub->setChecked(Settings::values.use_auto_stub.GetValue());
     ui->enable_graphics_debugging->setEnabled(runtime_lock);
-    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
+    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug.GetValue());
     ui->disable_macro_jit->setEnabled(runtime_lock);
-    ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
-    ui->extended_logging->setChecked(Settings::values.extended_logging);
+    ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit.GetValue());
+    ui->extended_logging->setChecked(Settings::values.extended_logging.GetValue());
 }
 
 void ConfigureDebug::ApplyConfiguration() {
@@ -61,7 +62,7 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.extended_logging = ui->extended_logging->isChecked();
     Debugger::ToggleConsole();
     Common::Log::Filter filter;
-    filter.ParseFilterString(Settings::values.log_filter);
+    filter.ParseFilterString(Settings::values.log_filter.GetValue());
     Common::Log::SetGlobalFilter(filter);
 }
 
diff --git a/src/yuzu/configuration/configure_filesystem.cpp b/src/yuzu/configuration/configure_filesystem.cpp
index d223c40ea..d0b5c6efe 100644
--- a/src/yuzu/configuration/configure_filesystem.cpp
+++ b/src/yuzu/configuration/configure_filesystem.cpp
@@ -43,16 +43,17 @@ void ConfigureFilesystem::setConfiguration() {
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::NANDDir)));
     ui->sdmc_directory_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::SDMCDir)));
-    ui->gamecard_path_edit->setText(QString::fromStdString(Settings::values.gamecard_path));
+    ui->gamecard_path_edit->setText(
+        QString::fromStdString(Settings::values.gamecard_path.GetValue()));
     ui->dump_path_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::DumpDir)));
     ui->load_path_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::LoadDir)));
 
-    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::values.gamecard_inserted.GetValue());
+    ui->gamecard_current_game->setChecked(Settings::values.gamecard_current_game.GetValue());
+    ui->dump_exefs->setChecked(Settings::values.dump_exefs.GetValue());
+    ui->dump_nso->setChecked(Settings::values.dump_nso.GetValue());
 
     ui->cache_game_list->setChecked(UISettings::values.cache_game_list);
 
diff --git a/src/yuzu/configuration/configure_input_advanced.cpp b/src/yuzu/configuration/configure_input_advanced.cpp
index d8d3b83dc..2f1419b5b 100644
--- a/src/yuzu/configuration/configure_input_advanced.cpp
+++ b/src/yuzu/configuration/configure_input_advanced.cpp
@@ -148,12 +148,12 @@ void ConfigureInputAdvanced::LoadConfiguration() {
         }
     }
 
-    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->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard);
-    ui->mouse_panning->setChecked(Settings::values.mouse_panning);
-    ui->mouse_panning_sensitivity->setValue(Settings::values.mouse_panning_sensitivity);
+    ui->debug_enabled->setChecked(Settings::values.debug_pad_enabled.GetValue());
+    ui->mouse_enabled->setChecked(Settings::values.mouse_enabled.GetValue());
+    ui->keyboard_enabled->setChecked(Settings::values.keyboard_enabled.GetValue());
+    ui->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard.GetValue());
+    ui->mouse_panning->setChecked(Settings::values.mouse_panning.GetValue());
+    ui->mouse_panning_sensitivity->setValue(Settings::values.mouse_panning_sensitivity.GetValue());
     ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
 
     UpdateUIEnabled();
diff --git a/src/yuzu/configuration/configure_motion_touch.cpp b/src/yuzu/configuration/configure_motion_touch.cpp
index 6a5d625df..f8e08c422 100644
--- a/src/yuzu/configuration/configure_motion_touch.cpp
+++ b/src/yuzu/configuration/configure_motion_touch.cpp
@@ -101,15 +101,16 @@ ConfigureMotionTouch::ConfigureMotionTouch(QWidget* parent,
 ConfigureMotionTouch::~ConfigureMotionTouch() = default;
 
 void ConfigureMotionTouch::SetConfiguration() {
-    const Common::ParamPackage motion_param(Settings::values.motion_device);
-    const Common::ParamPackage touch_param(Settings::values.touch_device);
+    const Common::ParamPackage motion_param(Settings::values.motion_device.GetValue());
+    const Common::ParamPackage touch_param(Settings::values.touch_device.GetValue());
 
-    ui->touch_from_button_checkbox->setChecked(Settings::values.use_touch_from_button);
+    ui->touch_from_button_checkbox->setChecked(Settings::values.use_touch_from_button.GetValue());
     touch_from_button_maps = Settings::values.touch_from_button_maps;
     for (const auto& touch_map : touch_from_button_maps) {
         ui->touch_from_button_map->addItem(QString::fromStdString(touch_map.name));
     }
-    ui->touch_from_button_map->setCurrentIndex(Settings::values.touch_from_button_map_index);
+    ui->touch_from_button_map->setCurrentIndex(
+        Settings::values.touch_from_button_map_index.GetValue());
     ui->motion_sensitivity->setValue(motion_param.Get("sensitivity", 0.01f));
 
     min_x = touch_param.Get("min_x", 100);
@@ -124,7 +125,7 @@ void ConfigureMotionTouch::SetConfiguration() {
     udp_server_list_model->setStringList({});
     ui->udp_server_list->setModel(udp_server_list_model);
 
-    std::stringstream ss(Settings::values.udp_input_servers);
+    std::stringstream ss(Settings::values.udp_input_servers.GetValue());
     std::string token;
 
     while (std::getline(ss, token, ',')) {
diff --git a/src/yuzu/configuration/configure_profile_manager.cpp b/src/yuzu/configuration/configure_profile_manager.cpp
index f5881e58d..ac849b01d 100644
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@@ -166,7 +166,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::values.current_user.GetValue());
     ASSERT(current_user);
     const auto username = GetAccountUsername(*profile_manager, *current_user);
 
@@ -245,15 +245,18 @@ void ConfigureProfileManager::DeleteUser() {
         this, tr("Confirm Delete"),
         tr("You are about to delete user with name \"%1\". Are you sure?").arg(username));
 
-    if (confirm == QMessageBox::No)
+    if (confirm == QMessageBox::No) {
         return;
+    }
 
-    if (Settings::values.current_user == tree_view->currentIndex().row())
+    if (Settings::values.current_user.GetValue() == tree_view->currentIndex().row()) {
         Settings::values.current_user = 0;
+    }
     UpdateCurrentUser();
 
-    if (!profile_manager->RemoveUser(*uuid))
+    if (!profile_manager->RemoveUser(*uuid)) {
         return;
+    }
 
     item_model->removeRows(tree_view->currentIndex().row(), 1);
     tree_view->clearSelection();
diff --git a/src/yuzu/configuration/configure_service.cpp b/src/yuzu/configuration/configure_service.cpp
index 6d954a67f..4aa424803 100644
--- a/src/yuzu/configuration/configure_service.cpp
+++ b/src/yuzu/configuration/configure_service.cpp
@@ -65,7 +65,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::values.bcat_backend.GetValue()));
     ui->bcat_source->setCurrentIndex(index == -1 ? 0 : index);
 }
 
diff --git a/src/yuzu/configuration/configure_web.cpp b/src/yuzu/configuration/configure_web.cpp
index f3f3b54d6..0fd76dc2c 100644
--- a/src/yuzu/configuration/configure_web.cpp
+++ b/src/yuzu/configuration/configure_web.cpp
@@ -88,15 +88,15 @@ void ConfigureWeb::SetConfiguration() {
     ui->web_signup_link->setOpenExternalLinks(true);
     ui->web_token_info_link->setOpenExternalLinks(true);
 
-    if (Settings::values.yuzu_username.empty()) {
+    if (Settings::values.yuzu_username.GetValue().empty()) {
         ui->username->setText(tr("Unspecified"));
     } else {
-        ui->username->setText(QString::fromStdString(Settings::values.yuzu_username));
+        ui->username->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue()));
     }
 
-    ui->toggle_telemetry->setChecked(Settings::values.enable_telemetry);
-    ui->edit_token->setText(QString::fromStdString(
-        GenerateDisplayToken(Settings::values.yuzu_username, Settings::values.yuzu_token)));
+    ui->toggle_telemetry->setChecked(Settings::values.enable_telemetry.GetValue());
+    ui->edit_token->setText(QString::fromStdString(GenerateDisplayToken(
+        Settings::values.yuzu_username.GetValue(), Settings::values.yuzu_token.GetValue())));
 
     // Connect after setting the values, to avoid calling OnLoginChanged now
     connect(ui->edit_token, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 6f5b2f6d6..d9375fc77 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -176,7 +176,7 @@ static void InitializeLogging() {
     using namespace Common;
 
     Log::Filter log_filter;
-    log_filter.ParseFilterString(Settings::values.log_filter);
+    log_filter.ParseFilterString(Settings::values.log_filter.GetValue());
     Log::SetGlobalFilter(log_filter);
 
     const auto log_dir = FS::GetYuzuPath(FS::YuzuPath::LogDir);
@@ -2443,7 +2443,8 @@ void GMainWindow::ErrorDisplayDisplayError(QString error_code, QString error_tex
 }
 
 void GMainWindow::OnMenuReportCompatibility() {
-    if (!Settings::values.yuzu_token.empty() && !Settings::values.yuzu_username.empty()) {
+    if (!Settings::values.yuzu_token.GetValue().empty() &&
+        !Settings::values.yuzu_username.GetValue().empty()) {
         CompatDB compatdb{this};
         compatdb.exec();
     } else {
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index 60bf66ec0..2c8d3f683 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -241,6 +241,24 @@ static const std::array<int, 8> keyboard_mods{
     SDL_SCANCODE_RCTRL, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_RALT, SDL_SCANCODE_RGUI,
 };
 
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<float> setting) {
+    setting = sdl2_config->GetReal(group, setting.GetLabel(), setting.GetDefault());
+}
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<std::string> setting) {
+    setting = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault());
+}
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<bool> setting) {
+    setting = sdl2_config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
+}
+template <typename Type>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<Type> setting) {
+    setting = static_cast<Type>(sdl2_config->GetInteger(group, setting.GetLabel(),
+                                                        static_cast<long>(setting.GetDefault())));
+}
+
 void Config::ReadValues() {
     // Controls
     for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
@@ -264,8 +282,7 @@ void Config::ReadValues() {
         }
     }
 
-    Settings::values.mouse_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "mouse_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.mouse_enabled);
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         std::string default_param = InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
         Settings::values.mouse_buttons[i] = sdl2_config->Get(
@@ -275,14 +292,11 @@ void Config::ReadValues() {
             Settings::values.mouse_buttons[i] = default_param;
     }
 
-    Settings::values.motion_device = sdl2_config->Get(
-        "ControlsGeneral", "motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01");
+    ReadSetting("ControlsGeneral", Settings::values.motion_device);
 
-    Settings::values.keyboard_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "keyboard_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.keyboard_enabled);
 
-    Settings::values.debug_pad_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "debug_pad_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.debug_pad_enabled);
     for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
         Settings::values.debug_pad_buttons[i] = sdl2_config->Get(
@@ -303,12 +317,9 @@ void Config::ReadValues() {
             Settings::values.debug_pad_analogs[i] = default_param;
     }
 
-    Settings::values.vibration_enabled.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "vibration_enabled", true));
-    Settings::values.enable_accurate_vibrations.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "enable_accurate_vibrations", false));
-    Settings::values.motion_enabled.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "motion_enabled", true));
+    ReadSetting("ControlsGeneral", Settings::values.vibration_enabled);
+    ReadSetting("ControlsGeneral", Settings::values.enable_accurate_vibrations);
+    ReadSetting("ControlsGeneral", Settings::values.motion_enabled);
     Settings::values.touchscreen.enabled =
         sdl2_config->GetBoolean("ControlsGeneral", "touch_enabled", true);
     Settings::values.touchscreen.rotation_angle =
@@ -349,13 +360,11 @@ void Config::ReadValues() {
             Settings::TouchFromButtonMap{"default", {}});
         num_touch_from_button_maps = 1;
     }
-    Settings::values.use_touch_from_button =
-        sdl2_config->GetBoolean("ControlsGeneral", "use_touch_from_button", false);
-    Settings::values.touch_from_button_map_index =
-        std::clamp(Settings::values.touch_from_button_map_index, 0, num_touch_from_button_maps - 1);
+    ReadSetting("ControlsGeneral", Settings::values.use_touch_from_button);
+    Settings::values.touch_from_button_map_index = std::clamp(
+        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
 
-    Settings::values.udp_input_servers =
-        sdl2_config->Get("Controls", "udp_input_address", InputCommon::CemuhookUDP::DEFAULT_SRV);
+    ReadSetting("ControlsGeneral", Settings::values.udp_input_servers);
 
     std::transform(keyboard_keys.begin(), keyboard_keys.end(),
                    Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
@@ -367,8 +376,7 @@ void Config::ReadValues() {
                    Settings::values.keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
 
     // Data Storage
-    Settings::values.use_virtual_sd =
-        sdl2_config->GetBoolean("Data Storage", "use_virtual_sd", true);
+    ReadSetting("Data Storage", Settings::values.use_virtual_sd);
     FS::SetYuzuPath(FS::YuzuPath::NANDDir,
                     sdl2_config->Get("Data Storage", "nand_directory",
                                      FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
@@ -381,18 +389,16 @@ void Config::ReadValues() {
     FS::SetYuzuPath(FS::YuzuPath::DumpDir,
                     sdl2_config->Get("Data Storage", "dump_directory",
                                      FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    Settings::values.gamecard_inserted =
-        sdl2_config->GetBoolean("Data Storage", "gamecard_inserted", false);
-    Settings::values.gamecard_current_game =
-        sdl2_config->GetBoolean("Data Storage", "gamecard_current_game", false);
-    Settings::values.gamecard_path = sdl2_config->Get("Data Storage", "gamecard_path", "");
+    ReadSetting("Data Storage", Settings::values.gamecard_inserted);
+    ReadSetting("Data Storage", Settings::values.gamecard_current_game);
+    ReadSetting("Data Storage", Settings::values.gamecard_path);
 
     // System
-    Settings::values.use_docked_mode.SetValue(
-        sdl2_config->GetBoolean("System", "use_docked_mode", true));
+    ReadSetting("System", Settings::values.use_docked_mode);
 
-    Settings::values.current_user = std::clamp<int>(
-        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);
+    ReadSetting("System", Settings::values.current_user);
+    Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
+                                                    Service::Account::MAX_USERS - 1);
 
     const auto rng_seed_enabled = sdl2_config->GetBoolean("System", "rng_seed_enabled", false);
     if (rng_seed_enabled) {
@@ -409,89 +415,60 @@ void Config::ReadValues() {
         Settings::values.custom_rtc = std::nullopt;
     }
 
-    Settings::values.language_index.SetValue(
-        sdl2_config->GetInteger("System", "language_index", 1));
-    Settings::values.time_zone_index.SetValue(
-        sdl2_config->GetInteger("System", "time_zone_index", 0));
+    ReadSetting("System", Settings::values.language_index);
+    ReadSetting("System", Settings::values.time_zone_index);
 
     // Core
-    Settings::values.use_multi_core.SetValue(
-        sdl2_config->GetBoolean("Core", "use_multi_core", true));
+    ReadSetting("Core", Settings::values.use_multi_core);
 
     // Renderer
-    const int renderer_backend = sdl2_config->GetInteger(
-        "Renderer", "backend", static_cast<int>(Settings::RendererBackend::OpenGL));
-    Settings::values.renderer_backend.SetValue(
-        static_cast<Settings::RendererBackend>(renderer_backend));
-    Settings::values.renderer_debug = sdl2_config->GetBoolean("Renderer", "debug", false);
-    Settings::values.vulkan_device.SetValue(
-        sdl2_config->GetInteger("Renderer", "vulkan_device", 0));
-
-    Settings::values.aspect_ratio.SetValue(
-        static_cast<int>(sdl2_config->GetInteger("Renderer", "aspect_ratio", 0)));
-    Settings::values.max_anisotropy.SetValue(
-        static_cast<int>(sdl2_config->GetInteger("Renderer", "max_anisotropy", 0)));
-    Settings::values.use_frame_limit.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_frame_limit", true));
-    Settings::values.frame_limit.SetValue(
-        static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100)));
-    Settings::values.use_disk_shader_cache.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_disk_shader_cache", false));
-    const int gpu_accuracy_level = sdl2_config->GetInteger("Renderer", "gpu_accuracy", 1);
-    Settings::values.gpu_accuracy.SetValue(static_cast<Settings::GPUAccuracy>(gpu_accuracy_level));
-    Settings::values.use_asynchronous_gpu_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
-    Settings::values.use_vsync.SetValue(
-        static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1)));
-    Settings::values.disable_fps_limit.SetValue(
-        sdl2_config->GetBoolean("Renderer", "disable_fps_limit", false));
-    Settings::values.use_assembly_shaders.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
-    Settings::values.use_asynchronous_shaders.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_shaders", false));
-    Settings::values.use_nvdec_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_nvdec_emulation", true));
-    Settings::values.accelerate_astc.SetValue(
-        sdl2_config->GetBoolean("Renderer", "accelerate_astc", true));
-    Settings::values.use_fast_gpu_time.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_fast_gpu_time", true));
-
-    Settings::values.bg_red.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_red", 0.0)));
-    Settings::values.bg_green.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_green", 0.0)));
-    Settings::values.bg_blue.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_blue", 0.0)));
+    ReadSetting("Renderer", Settings::values.renderer_backend);
+    ReadSetting("Renderer", Settings::values.renderer_debug);
+    ReadSetting("Renderer", Settings::values.vulkan_device);
+
+    ReadSetting("Renderer", Settings::values.aspect_ratio);
+    ReadSetting("Renderer", Settings::values.max_anisotropy);
+    ReadSetting("Renderer", Settings::values.use_frame_limit);
+    ReadSetting("Renderer", Settings::values.frame_limit);
+    ReadSetting("Renderer", Settings::values.use_disk_shader_cache);
+    ReadSetting("Renderer", Settings::values.gpu_accuracy);
+    ReadSetting("Renderer", Settings::values.use_asynchronous_gpu_emulation);
+    ReadSetting("Renderer", Settings::values.use_vsync);
+    ReadSetting("Renderer", Settings::values.disable_fps_limit);
+    ReadSetting("Renderer", Settings::values.use_assembly_shaders);
+    ReadSetting("Renderer", Settings::values.use_asynchronous_shaders);
+    ReadSetting("Renderer", Settings::values.use_nvdec_emulation);
+    ReadSetting("Renderer", Settings::values.accelerate_astc);
+    ReadSetting("Renderer", Settings::values.use_fast_gpu_time);
+
+    ReadSetting("Renderer", Settings::values.bg_red);
+    ReadSetting("Renderer", Settings::values.bg_green);
+    ReadSetting("Renderer", Settings::values.bg_blue);
 
     // Audio
-    Settings::values.sink_id = sdl2_config->Get("Audio", "output_engine", "auto");
-    Settings::values.enable_audio_stretching.SetValue(
-        sdl2_config->GetBoolean("Audio", "enable_audio_stretching", true));
-    Settings::values.audio_device_id = sdl2_config->Get("Audio", "output_device", "auto");
-    Settings::values.volume.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Audio", "volume", 1)));
+    ReadSetting("Audio", Settings::values.sink_id);
+    ReadSetting("Audio", Settings::values.enable_audio_stretching);
+    ReadSetting("Audio", Settings::values.audio_device_id);
+    ReadSetting("Audio", Settings::values.volume);
 
     // Miscellaneous
-    Settings::values.log_filter = sdl2_config->Get("Miscellaneous", "log_filter", "*:Trace");
-    Settings::values.use_dev_keys = sdl2_config->GetBoolean("Miscellaneous", "use_dev_keys", false);
+    // log_filter has a different default here than from common
+    Settings::values.log_filter =
+        sdl2_config->Get("Miscellaneous", Settings::values.log_filter.GetLabel(), "*:Trace");
+    ReadSetting("Miscellaneous", Settings::values.use_dev_keys);
 
     // Debugging
     Settings::values.record_frame_times =
         sdl2_config->GetBoolean("Debugging", "record_frame_times", false);
-    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
-    Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
-    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
-    Settings::values.enable_fs_access_log =
-        sdl2_config->GetBoolean("Debugging", "enable_fs_access_log", false);
-    Settings::values.reporting_services =
-        sdl2_config->GetBoolean("Debugging", "reporting_services", false);
-    Settings::values.quest_flag = sdl2_config->GetBoolean("Debugging", "quest_flag", false);
-    Settings::values.use_debug_asserts =
-        sdl2_config->GetBoolean("Debugging", "use_debug_asserts", false);
-    Settings::values.use_auto_stub = sdl2_config->GetBoolean("Debugging", "use_auto_stub", false);
-
-    Settings::values.disable_macro_jit =
-        sdl2_config->GetBoolean("Debugging", "disable_macro_jit", false);
+    ReadSetting("Debugging", Settings::values.program_args);
+    ReadSetting("Debugging", Settings::values.dump_exefs);
+    ReadSetting("Debugging", Settings::values.dump_nso);
+    ReadSetting("Debugging", Settings::values.enable_fs_access_log);
+    ReadSetting("Debugging", Settings::values.reporting_services);
+    ReadSetting("Debugging", Settings::values.quest_flag);
+    ReadSetting("Debugging", Settings::values.use_debug_asserts);
+    ReadSetting("Debugging", Settings::values.use_auto_stub);
+    ReadSetting("Debugging", Settings::values.disable_macro_jit);
 
     const auto title_list = sdl2_config->Get("AddOns", "title_ids", "");
     std::stringstream ss(title_list);
@@ -511,17 +488,14 @@ void Config::ReadValues() {
     }
 
     // Web Service
-    Settings::values.enable_telemetry =
-        sdl2_config->GetBoolean("WebService", "enable_telemetry", true);
-    Settings::values.web_api_url =
-        sdl2_config->Get("WebService", "web_api_url", "https://api.yuzu-emu.org");
-    Settings::values.yuzu_username = sdl2_config->Get("WebService", "yuzu_username", "");
-    Settings::values.yuzu_token = sdl2_config->Get("WebService", "yuzu_token", "");
+    ReadSetting("WebService", Settings::values.enable_telemetry);
+    ReadSetting("WebService", Settings::values.web_api_url);
+    ReadSetting("WebService", Settings::values.yuzu_username);
+    ReadSetting("WebService", Settings::values.yuzu_token);
 
     // Services
-    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "none");
-    Settings::values.bcat_boxcat_local =
-        sdl2_config->GetBoolean("Services", "bcat_boxcat_local", false);
+    ReadSetting("Services", Settings::values.bcat_backend);
+    ReadSetting("Services", Settings::values.bcat_boxcat_local);
 }
 
 void Config::Reload() {
diff --git a/src/yuzu_cmd/config.h b/src/yuzu_cmd/config.h
index 807199278..bf0103dee 100644
--- a/src/yuzu_cmd/config.h
+++ b/src/yuzu_cmd/config.h
@@ -8,6 +8,8 @@
 #include <memory>
 #include <string>
 
+#include "common/settings.h"
+
 class INIReader;
 
 class Config {
@@ -22,4 +24,8 @@ public:
     ~Config();
 
     void Reload();
+
+private:
+    template <typename Type>
+    void ReadSetting(const std::string& group, Settings::BasicSetting<Type> setting);
 };
diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp
index 50e388312..9607cdcb1 100644
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -78,7 +78,7 @@ static void InitializeLogging() {
     using namespace Common;
 
     Log::Filter log_filter(Log::Level::Debug);
-    log_filter.ParseFilterString(Settings::values.log_filter);
+    log_filter.ParseFilterString(static_cast<std::string>(Settings::values.log_filter));
     Log::SetGlobalFilter(log_filter);
 
     Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());