diff --git a/CMakeLists.txt b/CMakeLists.txt
index dbf9a92e88..3a074ea869 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,6 +71,12 @@ FetchContent_Declare(
 )
 
 FetchContent_MakeAvailable(cxxopts)
+FetchContent_Declare(json
+    URL https://github.com/nlohmann/json/releases/download/v3.12.0/json.tar.xz
+    URL_HASH SHA256=42f6e95cad6ec532fd372391373363b62a14af6d771056dbfc86160e6dfff7aa
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+)
+FetchContent_MakeAvailable(json)
 
 include(files.cmake)
 
@@ -103,7 +109,7 @@ set(GAME_INCLUDE_DIRS
     build/${DUSK_TP_VERSION}/include)
 
 set(GAME_LIBS aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd
-    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map)
+    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json)
 
 if (DUSK_MOVIE_SUPPORT_REAL)
   if (TARGET libjpeg-turbo::turbojpeg-static)
diff --git a/files.cmake b/files.cmake
index 278ecdb815..7d07408613 100644
--- a/files.cmake
+++ b/files.cmake
@@ -1332,17 +1332,22 @@ set(DOLPHIN_FILES
 
 set(DUSK_FILES
         include/dusk/endian_gx.hpp
+        include/dusk/config.hpp
         src/d/actor/d_a_alink_dusk.cpp
         src/dusk/asserts.cpp
+        src/dusk/config.cpp
+        src/dusk/settings.cpp
         src/dusk/logging.cpp
         src/dusk/layout.cpp
         src/dusk/stubs.cpp
         src/dusk/endian.cpp
         src/dusk/extras.c
         src/dusk/extras.cpp
+        src/dusk/io.cpp
         src/dusk/globals.cpp
         src/dusk/settings.cpp
         #src/dusk/m_Do_ext_dusk.cpp
+        src/dusk/imgui/ImGuiConfig.hpp
         src/dusk/imgui/ImGuiConsole.hpp
         src/dusk/imgui/ImGuiConsole.cpp
         src/dusk/imgui/ImGuiEngine.cpp
diff --git a/include/dusk/app_info.hpp b/include/dusk/app_info.hpp
new file mode 100644
index 0000000000..d5d5f40083
--- /dev/null
+++ b/include/dusk/app_info.hpp
@@ -0,0 +1,20 @@
+#ifndef DUSK_APPNAME_HPP
+#define DUSK_APPNAME_HPP
+
+namespace dusk {
+    /**
+     * \brief The internal application name for the game.
+     *
+     * This gets used for file paths and such, and cannot be changed!
+     */
+    constexpr auto AppName = "Dusk";
+
+    /**
+     * \brief The internal organization name for the game.
+     *
+     * This gets used for file paths and such, and cannot be changed!
+     */
+    constexpr auto OrgName = "TwilitRealm";
+}
+
+#endif  // DUSK_APPNAME_HPP
diff --git a/include/dusk/config.hpp b/include/dusk/config.hpp
new file mode 100644
index 0000000000..258e012f2b
--- /dev/null
+++ b/include/dusk/config.hpp
@@ -0,0 +1,122 @@
+#ifndef DUSK_CONFIG_HPP
+#define DUSK_CONFIG_HPP
+
+#include <stdexcept>
+#include "nlohmann/json.hpp"
+#include "config_var.hpp"
+
+namespace dusk::config {
+
+/*
+ * config.hpp is a heavier "full" header for the configuration system.
+ * For a basic overview and the basic types (sufficient for accessing settings),
+ * look at config_var.hpp.
+ *
+ * Avoid including this header in the entire game, it's heavier than I'd like!
+ */
+
+/**
+ * \brief Base class containing virtual functions used for save/load of CVars.
+ */
+class ConfigImplBase {
+protected:
+    virtual ~ConfigImplBase() = default;
+
+public:
+    /**
+     * \brief Load a JSON value into a CVar at the Value layer.
+     */
+    virtual void loadFromJson(ConfigVarBase& cVar, const nlohmann::json& jsonValue) const = 0;
+
+    /**
+     * \brief Load a simple launch argument into the CVar at the Override layer.
+     */
+    virtual void loadFromArg(ConfigVarBase& cVar, std::string_view stringValue) const = 0;
+
+    /**
+     * \brief Dump the value contained in the CVar to JSON.
+     */
+    [[nodiscard]] virtual nlohmann::json dumpToJson(const ConfigVarBase& cVar) const = 0;
+};
+
+template<ConfigValue T>
+class ConfigImpl : public ConfigImplBase {
+    // Just downcasting the references...
+    void loadFromJson(ConfigVarBase& cVar, const nlohmann::json& jsonValue) const final {
+        assert(typeid(cVar) == typeid(ConfigVar<T>));
+        loadFromJson(dynamic_cast<ConfigVar<T>&>(cVar), jsonValue);
+    }
+
+    void loadFromArg(ConfigVarBase& cVar, std::string_view stringValue) const final {
+        assert(typeid(cVar) == typeid(ConfigVar<T>));
+        loadFromArg(dynamic_cast<ConfigVar<T>&>(cVar), stringValue);
+    }
+
+    [[nodiscard]] nlohmann::json dumpToJson(const ConfigVarBase& cVar) const final {
+        assert(typeid(cVar) == typeid(ConfigVar<T>));
+        return dumpToJson(dynamic_cast<const ConfigVar<T>&>(cVar));
+    }
+
+    /**
+     * \brief Load a JSON value into a CVar at the Value layer.
+     */
+    static void loadFromJson(ConfigVar<T>& cVar, const nlohmann::json& jsonValue);
+
+    /**
+     * \brief Load a simple launch argument into the CVar at the Override layer.
+     */
+    static void loadFromArg(ConfigVar<T>& cVar, std::string_view stringValue);
+
+    /**
+     * \brief Dump the value contained in the CVar to JSON.
+     */
+    [[nodiscard]] static nlohmann::json dumpToJson(const ConfigVar<T>& cVar);
+};
+
+/**
+ * \brief Thrown by config loading functions if the value provided is invalid for the CVar.
+ */
+class InvalidConfigError : public std::runtime_error {
+public:
+    explicit InvalidConfigError(const char* what) : runtime_error(what) {}
+};
+
+/**
+ * \brief Register a CVar to make the config system aware of it.
+ *
+ * This must be done on startup *before* config has been loaded.
+ */
+void Register(ConfigVarBase& configVar);
+
+/**
+ * \brief Indicate that all registrations have happened and everything should lock in.
+ */
+void FinishRegistration();
+
+/**
+ * \brief Load config from the standard user preferences location.
+ */
+void LoadFromUserPreferences();
+void LoadFromFileName(const char* path);
+
+/**
+ * \brief Save the config to file.
+ */
+void Save();
+
+/**
+ * \brief Get a registered CVar by name.
+ *
+ * @return null if the CVar does not exist.
+ */
+ConfigVarBase* GetConfigVar(std::string_view name);
+
+template <ConfigValue T>
+const ConfigImplBase* GetConfigImpl() {
+    static ConfigImpl<T> config;
+    return &config;
+}
+
+}  // namespace dusk::config
+
+#endif
diff --git a/include/dusk/config_var.hpp b/include/dusk/config_var.hpp
new file mode 100644
index 0000000000..064d37028d
--- /dev/null
+++ b/include/dusk/config_var.hpp
@@ -0,0 +1,235 @@
+#ifndef DUSK_CONFIG_VAR_HPP
+#define DUSK_CONFIG_VAR_HPP
+
+#include "dolphin/types.h"
+#include <type_traits>
+#include <cstdlib>
+#include <string>
+
+/**
+ * The configuration system.
+ *
+ * Configuration works via "configuration variables" aka "CVars". Each stores a single value that
+ * may be individually written to/from a configuration file.
+ *
+ * CVars, like ogres, have layers. Higher layers (e.g. a set value) override lower layers
+ * (e.g. the default value).
+ *
+ * To define a CVar, simply make a global variable of type ConfigVar<T>,
+ * and make sure Register() is called on it during program startup.
+ *
+ * config_var.hpp contains the simplest "just the configuration vars themselves".
+ * This should be safe to include for files that need to *access* configuration,
+ * without blowing up compile times on implementation details.
+ *
+ * config.hpp on the other hand contains far more calls for mutating, loading, and defining CVars.
+ */
+namespace dusk::config {
+
+/**
+ * \brief Layers that a configuration variable can currently be at.
+ *
+ * A configuration variable can be on one of multiple *layers*, which determines where
+ * the current value is coming from.
+ */
+enum class ConfigVarLayer : u8 {
+    /**
+     * The CVar is at the default value defined by the application code.
+     */
+    Default,
+
+    /**
+     * The CVar has been modified by the user and may be saved to config.
+     */
+    Value,
+
+    /**
+     * The CVar is modified by launch argument, overruling the normal config value.
+     * Will not get saved to config.
+     */
+    Override,
+};
+
+class ConfigImplBase;
+
+/**
+ * Base class that all CVars inherit from.
+ * You want the templated ConfigVar instead for actual usage.
+ */
+class ConfigVarBase {
+protected:
+    /**
+     * The name of this CVar, used in the configuration file.
+     */
+    const char* name;
+
+    /**
+     * Whether this CVar has been registered with the global managing logic.
+     * If this is not done, it is not functional.
+     */
+    bool registered;
+
+    /**
+     * The layer this CVar is at.
+     */
+    ConfigVarLayer layer;
+
+    /**
+     * Pointer to an implementation struct for various load/save calls.
+     */
+    const ConfigImplBase* impl;
+
+    ConfigVarBase(const char* name, const ConfigImplBase* impl);
+    virtual ~ConfigVarBase() = default;
+
+    /**
+     * Check that the CVar is registered, aborting if this is not the case.
+     */
+    void checkRegistered() const {
+        if (!registered)
+            abort();
+    }
+
+public:
+    /**
+     * Get the name of this CVar, used in the configuration file.
+     */
+    [[nodiscard]] const char* getName() const noexcept;
+
+    /**
+     * Get the pointer to the implementation struct.
+     */
+    [[nodiscard]] const ConfigImplBase* getImpl() const noexcept;
+
+    /**
+     * Get the layer this CVar is currently at.
+     */
+    [[nodiscard]] constexpr ConfigVarLayer getLayer() const noexcept {
+        return layer;
+    }
+
+    /**
+     * Mark this CVar as being registered with the central save/load logic.
+     * This is necessary to make it legal to access.
+     */
+    void markRegistered();
+};
+
+template <typename T>
+concept ConfigValueInteger =
+    std::is_same_v<T, s8>
+    || std::is_same_v<T, u8>
+    || std::is_same_v<T, s16>
+    || std::is_same_v<T, u16>
+    || std::is_same_v<T, s32>
+    || std::is_same_v<T, u32>
+    || std::is_same_v<T, s64>
+    || std::is_same_v<T, u64>;
+
+/**
+ * \brief Concept that defines the legal set of types that can be used for CVar values.
+ *
+ * Valid types cannot be cv-qualified and must be basic primitive types (int, float, bool),
+ * strings, or enums of the basic primitives.
+ */
+template <typename T>
+concept ConfigValue =
+    !std::is_const_v<T>
+    && !std::is_volatile_v<T>
+    && (std::is_same_v<T, bool>
+        || ConfigValueInteger<T>
+        || std::is_same_v<T, f32>
+        || std::is_same_v<T, f64>
+        || std::is_same_v<T, std::string>
+        || (std::is_enum_v<T> && ConfigValueInteger<std::underlying_type_t<T>>));
+
+template <ConfigValue T>
+const ConfigImplBase* GetConfigImpl();
+
+/**
+ * \brief A CVar storing values.
+ *
+ * @tparam T The type of value stored in the CVar.
+ */
+template <ConfigValue T>
+class ConfigVar : public ConfigVarBase {
+    T defaultValue;
+    T value;
+    T overrideValue;
+
+public:
+    /**
+     * \brief Construct a CVar.
+     *
+     * @param name The name of this CVar. Must be unique.
+     * @param arg Arguments to forward to construct the default value.
+     */
+    template <typename... Args>
+    explicit ConfigVar(const char* name, Args&&... arg)
+        : ConfigVarBase(name, GetConfigImpl<T>()), defaultValue(std::forward<Args>(arg)...),
+        value(), overrideValue() {}
+
+    /**
+     * \brief Get the current value of the CVar.
+     *
+     * This reference is not guaranteed to remain up-to-date after modification of the CVar.
+     * It will, however, remain sound to access.
+     */
+    [[nodiscard]] constexpr const T& getValue() const noexcept {
+        checkRegistered();
+        switch (layer) {
+        case ConfigVarLayer::Default:
+            return defaultValue;
+        case ConfigVarLayer::Value:
+            return value;
+        case ConfigVarLayer::Override:
+            return overrideValue;
+        default:
+            abort();
+        }
+    }
+
+    /**
+     * \brief Change the value of a CVar.
+     *
+     * The new value is always stored at the Value layer.
+     *
+     * @param newValue The new value the CVar will get.
+     * @param replaceOverride If true, clear an existing override layer if there is one.
+     *     If this is false and there is an override layer,
+     *     the result of getValue() will not change immediately.
+     */
+    void setValue(T newValue, bool replaceOverride = true) {
+        checkRegistered();
+        value = std::move(newValue);
+
+        if (replaceOverride) {
+            overrideValue = {};
+            layer = ConfigVarLayer::Value;
+        } else if (layer != ConfigVarLayer::Override) {
+            layer = ConfigVarLayer::Value;
+        }
+    }
+
+    operator const T&() {
+        return getValue();
+    }
+
+    /**
+     * \brief Give a CVar an override value.
+     *
+     * This overrides (but does not replace) the apparent set value of this CVar.
+     * The overriden value will not get saved to config.
+     *
+     * @param newValue The new value the CVar will get.
+     */
+    void setOverrideValue(T newValue) {
+        checkRegistered();
+        overrideValue = std::move(newValue);
+        layer = ConfigVarLayer::Override;
+    }
+};
+
+}
+
+#endif  // DUSK_CONFIG_VAR_HPP
diff --git a/include/dusk/dusk.h b/include/dusk/dusk.h
index d84e496827..7fc2a23070 100644
--- a/include/dusk/dusk.h
+++ b/include/dusk/dusk.h
@@ -4,5 +4,6 @@
 #include <aurora/aurora.h>
 
 extern AuroraInfo auroraInfo;
+extern const char* configPath;
 
 #endif  // DUSK_DUSK_H
diff --git a/include/dusk/io.hpp b/include/dusk/io.hpp
new file mode 100644
index 0000000000..fb71a77d68
--- /dev/null
+++ b/include/dusk/io.hpp
@@ -0,0 +1,75 @@
+#ifndef DUSK_IO_HPP
+#define DUSK_IO_HPP
+
+#include <vector>
+
+// I can't believe it's 2026 and neither SDL (no error codes) nor
+// C++ (no error codes) have a file system API functional enough for me to use.
+// Here you go, this one's inspired by C#. I only wrote the functions I need.
+
+namespace dusk::io {
+
+/**
+ * \brief A simple file stream wrapping cstdio FILE*.
+ *
+ * Methods on this class throw appropriate C++ exceptions when an error occurs.
+ */
+class FileStream {
+    void* file;
+
+public:
+    FileStream() noexcept;
+
+    /**
+     * \brief Take ownership of a FILE* handle.
+     */
+    explicit FileStream(void* file);
+    FileStream(const FileStream& other) = delete;
+    FileStream(FileStream&& other) noexcept;
+
+    ~FileStream();
+
+    /**
+     * \brief Open a file for reading at the given path.
+     */
+    static FileStream OpenRead(const char* utf8Path);
+
+    /**
+     * \brief Create a file for writing.
+     *
+     * If there is an existing file, its contents are demolished.
+     */
+    static FileStream Create(const char* utf8Path);
+
+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static std::vector<u8> ReadAllBytes(const char* utf8Path);
+
+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static void WriteAllText(const char* utf8Path, std::string_view text);
+
+    /**
+     * \brief Read the remaining contents of the file directly into a vector.
+     */
+    std::vector<u8> ReadFull();
+
+    /**
+     * Get direct access to the underlying FILE* handle.
+     */
+    [[nodiscard]] void* GetFileHandle() const noexcept {
+        return file;
+    }
+
+    /**
+     * Write data to the file.
+     */
+    void Write(const char* data, size_t dataLen);
+};
+
+}
+
+
+#endif  // DUSK_IO_HPP
diff --git a/include/dusk/settings.h b/include/dusk/settings.h
index 07047fad99..cf4d79f6ac 100644
--- a/include/dusk/settings.h
+++ b/include/dusk/settings.h
@@ -1,8 +1,12 @@
 #ifndef DUSK_CONFIG_H
 #define DUSK_CONFIG_H
 
+#include "dusk/config_var.hpp"
+
 namespace dusk {
 
+using namespace config;
+
 // Persistent user settings
 
 struct UserSettings {
@@ -10,61 +14,63 @@ struct UserSettings {
 
     struct {
         // Video
-        bool enableFullscreen;
+        ConfigVar<bool> enableFullscreen;
     } video;
 
     struct {
         // Audio
-        int masterVolume;
-        int mainMusicVolume;
-        int subMusicVolume;
-        int soundEffectsVolume;
-        int fanfareVolume;
-        bool enableReverb;
+        ConfigVar<int> masterVolume;
+        ConfigVar<int> mainMusicVolume;
+        ConfigVar<int> subMusicVolume;
+        ConfigVar<int> soundEffectsVolume;
+        ConfigVar<int> fanfareVolume;
+        ConfigVar<bool> enableReverb;
     } audio;
 
     // Game settings
 
     struct {
         // QoL
-        bool enableQuickTransform;
-        bool hideTvSettingsScreen;
-        bool biggerWallets;
-        bool noReturnRupees;
-        bool disableRupeeCutscenes;
-        bool noSwordRecoil;
-        int damageMultiplier;
-        bool instantDeath;
-        bool fastClimbing;
-        bool noMissClimbing;
-        bool fastTears;
+        ConfigVar<bool> enableQuickTransform;
+        ConfigVar<bool> hideTvSettingsScreen;
+        ConfigVar<bool> biggerWallets;
+        ConfigVar<bool> noReturnRupees;
+        ConfigVar<bool> disableRupeeCutscenes;
+        ConfigVar<bool> noSwordRecoil;
+        ConfigVar<int> damageMultiplier;
+        ConfigVar<bool> instantDeath;
+        ConfigVar<bool> fastClimbing;
+        ConfigVar<bool> noMissClimbing;
+        ConfigVar<bool> fastTears;
 
         // Preferences
-        bool enableMirrorMode;
-        bool invertCameraXAxis;
+        ConfigVar<bool> enableMirrorMode;
+        ConfigVar<bool> invertCameraXAxis;
 
         // Graphics
-        bool enableBloom;
-        bool useWaterProjectionOffset;
+        ConfigVar<bool> enableBloom;
+        ConfigVar<bool> useWaterProjectionOffset;
 
         // Audio
-        bool noLowHpSound;   
-        bool midnasLamentNonStop;
+        ConfigVar<bool> noLowHpSound;
+        ConfigVar<bool> midnasLamentNonStop;
 
         // Cheats
-        bool enableFastIronBoots;
-        bool canTransformAnywhere;
+        ConfigVar<bool> enableFastIronBoots;
+        ConfigVar<bool> canTransformAnywhere;
 
         // Technical
-        bool restoreWiiGlitches;
+        ConfigVar<bool> restoreWiiGlitches;
 
         // Controls
-        bool enableTurboKeybind;
+        ConfigVar<bool> enableTurboKeybind;
     } game;
 };
 
 UserSettings& getSettings();
 
+void registerSettings();
+
 // Transient settings
 
 struct CollisionViewSettings {
diff --git a/src/dusk/config.cpp b/src/dusk/config.cpp
new file mode 100644
index 0000000000..159706fac8
--- /dev/null
+++ b/src/dusk/config.cpp
@@ -0,0 +1,222 @@
+#include "dusk/config.hpp"
+#include "fmt/format.h"
+#include "nlohmann/json.hpp"
+#include "absl/container/flat_hash_map.h"
+
+#include "aurora/lib/logging.hpp"
+#include "dusk/io.hpp"
+
+#include <limits>
+#include <string>
+
+#include "dusk/dusk.h"
+
+using namespace dusk::config;
+
+constexpr auto ConfigFileName = "config.json";
+
+using json = nlohmann::json;
+
+aurora::Module DuskConfigLog("dusk::config");
+
+static absl::flat_hash_map<std::string_view, ConfigVarBase*> RegisteredConfigVars;
+static bool RegistrationDone;
+
+static std::string GetConfigJsonPath() {
+    return fmt::format("{}{}", configPath, ConfigFileName);
+}
+
+ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {
+}
+
+const char* ConfigVarBase::getName() const noexcept {
+    return name;
+}
+
+const ConfigImplBase* ConfigVarBase::getImpl() const noexcept {
+    return impl;
+}
+
+template<ConfigValue T>
+void ConfigImpl<T>::loadFromJson(ConfigVar<T>& cVar, const json& jsonValue) {
+    cVar.setValue(jsonValue.get<T>(), false);
+}
+
+template<ConfigValue T>
+nlohmann::json ConfigImpl<T>::dumpToJson(const ConfigVar<T>& cVar) {
+    return cVar.getValue();
+}
+
+template<ConfigValue T> requires std::is_integral_v<T> && std::is_signed_v<T>
+static void loadFromArgImpl(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stoll(str);
+    if (result >= std::numeric_limits<T>::min() && result <= std::numeric_limits<T>::max()) {
+        cVar.setOverrideValue(result);
+    } else {
+        throw std::out_of_range("Value is too large");
+    }
+}
+
+template<ConfigValue T> requires std::is_integral_v<T> && std::is_unsigned_v<T>
+static void loadFromArgImpl(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stoull(str);
+    if (result <= std::numeric_limits<T>::max()) {
+        cVar.setOverrideValue(result);
+    } else {
+        throw std::out_of_range("Value is too large");
+    }
+}
+
+static void loadFromArgImpl(ConfigVar<f32>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stof(str);
+    cVar.setOverrideValue(result);
+}
+
+static void loadFromArgImpl(ConfigVar<f64>& cVar, const std::string_view stringValue) {
+    const std::string str(stringValue);
+    const auto result = std::stod(str);
+    cVar.setOverrideValue(result);
+}
+
+static void loadFromArgImpl(ConfigVar<std::string>& cVar, const std::string_view stringValue) {
+    cVar.setOverrideValue(std::string(stringValue));
+}
+
+template<ConfigValue T>
+void ConfigImpl<T>::loadFromArg(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    loadFromArgImpl(cVar, stringValue);
+}
+
+template<>
+void ConfigImpl<bool>::loadFromArg(ConfigVar<bool>& cVar, const std::string_view stringValue) {
+    if (stringValue == "1" || stringValue == "TRUE" || stringValue == "true" || stringValue == "True") {
+        cVar.setOverrideValue(true);
+    } else if (stringValue == "0" || stringValue == "FALSE" || stringValue == "false" || stringValue == "False") {
+        cVar.setOverrideValue(false);
+    } else {
+        throw InvalidConfigError("Value cannot be parsed as boolean");
+    }
+}
+
+// My IDE is convinced this namespace is necessary. It shouldn't be AFAICT?
+namespace dusk::config {
+    template class ConfigImpl<bool>;
+    template class ConfigImpl<s8>;
+    template class ConfigImpl<u8>;
+    template class ConfigImpl<s16>;
+    template class ConfigImpl<u16>;
+    template class ConfigImpl<s32>;
+    template class ConfigImpl<u32>;
+    template class ConfigImpl<s64>;
+    template class ConfigImpl<u64>;
+    template class ConfigImpl<f32>;
+    template class ConfigImpl<f64>;
+    template class ConfigImpl<std::string>;
+}
+
+void dusk::config::Register(ConfigVarBase& configVar) {
+    const auto& name = configVar.getName();
+    if (RegistrationDone) {
+        DuskConfigLog.fatal("Tried to register CVar {} after registrations closed!", name);
+    }
+
+    if (RegisteredConfigVars.contains(name)) {
+        DuskConfigLog.fatal("Tried to register CVar {} twice!", name);
+    }
+
+    RegisteredConfigVars[name] = &configVar;
+    configVar.markRegistered();
+}
+
+void ConfigVarBase::markRegistered() {
+    if (registered)
+        abort();
+
+    registered = true;
+}
+
+void dusk::config::FinishRegistration() {
+    RegistrationDone = true;
+}
+
+void dusk::config::LoadFromUserPreferences() {
+    const auto configJsonPath = GetConfigJsonPath();
+    if (configJsonPath.empty()) {
+        return;
+    }
+    LoadFromFileName(configJsonPath.c_str());
+}
+
+static void LoadFromPath(const char* path) {
+    auto data = dusk::io::FileStream::ReadAllBytes(path);
+
+    json j = json::parse(data);
+    if (!j.is_object()) {
+        DuskConfigLog.error("Config JSON is not an object!");
+        return;
+    }
+
+    for (const auto& el : j.items()) {
+        const auto& key = el.key();
+        auto configVar = RegisteredConfigVars.find(key);
+        if (configVar == RegisteredConfigVars.end()) {
+            DuskConfigLog.error("Unknown key '{}' found in config!", key);
+            continue;
+        }
+
+        try {
+            configVar->second->getImpl()->loadFromJson(*configVar->second, el.value());
+        } catch (std::exception& e) {
+            DuskConfigLog.error("Failed to load key '{}' from config: {}", key, e.what());
+        }
+    }
+}
+
+void dusk::config::LoadFromFileName(const char* path) {
+    if (!RegistrationDone) {
+        DuskConfigLog.fatal("Registration not finished yet!");
+    }
+
+    DuskConfigLog.info("Loading config from '{}'", path);
+
+    try {
+        LoadFromPath(path);
+    } catch (const std::system_error& e) {
+        if (e.code() == std::errc::no_such_file_or_directory) {
+            DuskConfigLog.info("Config file did not exist, staying with defaults");
+        } else {
+            DuskConfigLog.error("Failed to load from config! {}", e.what());
+        }
+    }
+}
+
+void dusk::config::Save() {
+    const auto configJsonPath = GetConfigJsonPath();
+    if (configJsonPath.empty()) {
+        return;
+    }
+
+    DuskConfigLog.info("Saving config to '{}'", configJsonPath);
+
+    json j;
+
+    for (const auto& pair : RegisteredConfigVars) {
+        if (pair.second->getLayer() == ConfigVarLayer::Value) {
+            j[pair.first] = pair.second->getImpl()->dumpToJson(*pair.second);
+        }
+    }
+
+    io::FileStream::WriteAllText(configJsonPath.c_str(), j.dump(4));
+}
+
+ConfigVarBase* dusk::config::GetConfigVar(std::string_view name) {
+    const auto configVar = RegisteredConfigVars.find(name);
+    if (configVar != RegisteredConfigVars.end()) {
+        return configVar->second;
+    }
+
+    return nullptr;
+}
\ No newline at end of file
diff --git a/src/dusk/imgui/ImGuiConfig.hpp b/src/dusk/imgui/ImGuiConfig.hpp
new file mode 100644
index 0000000000..fc5aa34bbd
--- /dev/null
+++ b/src/dusk/imgui/ImGuiConfig.hpp
@@ -0,0 +1,41 @@
+#ifndef DUSK_IMGUICONFIG_HPP
+#define DUSK_IMGUICONFIG_HPP
+
+#include "dusk/config.hpp"
+#include "imgui.h"
+
+namespace dusk::config {
+    inline void ImGuiCheckbox(const char* title, ConfigVar<bool>& var) {
+        bool copy = var.getValue();
+        if (ImGui::Checkbox(title, &copy)) {
+            var.setValue(copy);
+            Save();
+        }
+    }
+
+    static void ImGuiSliderFloat(const char* label, ConfigVar<float>& var, float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0) {
+        float val = var;
+        if (ImGui::SliderFloat(label, &val, v_min, v_max, format, flags)) {
+            var.setValue(val);
+            Save();
+        }
+    }
+
+    static void ImGuiSliderInt(const char* label, ConfigVar<int>& var, int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0) {
+        int val = var;
+        if (ImGui::SliderInt(label, &val, v_min, v_max, format, flags)) {
+            var.setValue(val);
+            Save();
+        }
+    }
+
+    static void ImGuiMenuItem(const char* label, const char* shortcut, ConfigVar<bool>& p_selected, bool enabled = true) {
+        bool copy = p_selected.getValue();
+        if (ImGui::MenuItem(label, shortcut, &copy, enabled)) {
+            p_selected.setValue(copy);
+            Save();
+        }
+    }
+}
+
+#endif  // DUSK_IMGUICONFIG_HPP
diff --git a/src/dusk/imgui/ImGuiConsole.cpp b/src/dusk/imgui/ImGuiConsole.cpp
index 7efa6c3314..fe5d3e7c9a 100644
--- a/src/dusk/imgui/ImGuiConsole.cpp
+++ b/src/dusk/imgui/ImGuiConsole.cpp
@@ -13,6 +13,7 @@
 #include "ImGuiConsole.hpp"
 
 #include "JSystem/JUtility/JUTGamePad.h"
+#include "dusk/config.hpp"
 #include "dusk/settings.h"
 
 #if _WIN32
@@ -192,8 +193,7 @@ namespace dusk {
         }
 
         if (ImGui::IsKeyPressed(ImGuiKey_F11)) {
-            getSettings().video.enableFullscreen = !getSettings().video.enableFullscreen;
-            VISetWindowFullscreen(getSettings().video.enableFullscreen);
+            ImGuiMenuGame::ToggleFullscreen();
         }
 
         if (CheckMenuViewToggle(ImGuiKey_F1, m_isHidden)) {
diff --git a/src/dusk/imgui/ImGuiMenuEnhancements.cpp b/src/dusk/imgui/ImGuiMenuEnhancements.cpp
index 3069d9b3f6..3fbd55a8f2 100644
--- a/src/dusk/imgui/ImGuiMenuEnhancements.cpp
+++ b/src/dusk/imgui/ImGuiMenuEnhancements.cpp
@@ -1,7 +1,7 @@
 #include "imgui.h"
 
 #include "ImGuiMenuEnhancements.hpp"
-
+#include "ImGuiConfig.hpp"
 #include "dusk/settings.h"
 
 namespace dusk {
@@ -10,45 +10,45 @@ namespace dusk {
     void ImGuiMenuEnhancements::draw() {
         if (ImGui::BeginMenu("Enhancements")) {
             if (ImGui::BeginMenu("Quality of Life")) {
-                ImGui::Checkbox("Quick Transform (R+Y)", &getSettings().game.enableQuickTransform);
+                config::ImGuiCheckbox("Quick Transform (R+Y)", getSettings().game.enableQuickTransform);
 
-                ImGui::Checkbox("Bigger Wallets", &getSettings().game.biggerWallets);
+                config::ImGuiCheckbox("Bigger Wallets", getSettings().game.biggerWallets);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Wallet sizes are like in the HD version (500, 1000, 2000)");
                 }
 
-                ImGui::Checkbox("No Rupee Returns", &getSettings().game.noReturnRupees);
+                config::ImGuiCheckbox("No Rupee Returns", getSettings().game.noReturnRupees);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Always collect Rupees even if your Wallet is too full");
                 }
 
-                ImGui::Checkbox("Disable Rupee Cutscenes", &getSettings().game.disableRupeeCutscenes);
+                config::ImGuiCheckbox("Disable Rupee Cutscenes", getSettings().game.disableRupeeCutscenes);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Rupees won't play cutscenes after you've collected them the first time");
                 }
 
-                ImGui::Checkbox("No Sword Recoil", &getSettings().game.noSwordRecoil);
+                config::ImGuiCheckbox("No Sword Recoil", getSettings().game.noSwordRecoil);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Link won't recoil when his sword hits walls");
                 }
 
-                ImGui::Checkbox("Faster Climbing", &getSettings().game.fastClimbing);
+                config::ImGuiCheckbox("Faster Climbing", getSettings().game.fastClimbing);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Quicker climbing on ladders and vines like the HD version");
                 }
 
-                ImGui::Checkbox("No Climbing Miss Animation", &getSettings().game.noMissClimbing);
+                config::ImGuiCheckbox("No Climbing Miss Animation", getSettings().game.noMissClimbing);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Prevents Link from playing a struggle animation\n"
                                       "when using the Clawshot on vines at a weird angle");
                 }
 
-                ImGui::Checkbox("Faster Tears of Light", &getSettings().game.fastTears);
+                config::ImGuiCheckbox("Faster Tears of Light", getSettings().game.fastTears);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Tears of Light dropped by Shadow Insects pop out faster like the HD version");
                 }
 
-                ImGui::Checkbox("Hide TV Settings Screen", &getSettings().game.hideTvSettingsScreen);
+                config::ImGuiCheckbox("Hide TV Settings Screen", getSettings().game.hideTvSettingsScreen);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Hides the TV calibration screen shown when loading a save");
                 }
@@ -57,20 +57,20 @@ namespace dusk {
             }
 
             if (ImGui::BeginMenu("Preferences")) {
-                ImGui::Checkbox("Mirror Mode", &getSettings().game.enableMirrorMode);
+                config::ImGuiCheckbox("Mirror Mode", getSettings().game.enableMirrorMode);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Mirrors the world, matching the Wii version of the game");
                 }
 
-                ImGui::Checkbox("Invert Camera X Axis", &getSettings().game.invertCameraXAxis);
+                config::ImGuiCheckbox("Invert Camera X Axis", getSettings().game.invertCameraXAxis);
 
                 ImGui::EndMenu();
             }
 
             if (ImGui::BeginMenu("Graphics")) {
-                ImGui::Checkbox("Native Bloom", &getSettings().game.enableBloom);
+                config::ImGuiCheckbox("Native Bloom", getSettings().game.enableBloom);
 
-                ImGui::Checkbox("Water Projection Offset", &getSettings().game.useWaterProjectionOffset);
+                config::ImGuiCheckbox("Water Projection Offset", getSettings().game.useWaterProjectionOffset);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Adds GC-specific -0.01 transS offset\n"
                                       "that causes ~6px ghost artifacts in water reflections");
@@ -80,12 +80,12 @@ namespace dusk {
             }
 
             if (ImGui::BeginMenu("Audio")) {
-                ImGui::Checkbox("No Low HP Sound", &getSettings().game.noLowHpSound);
+                config::ImGuiCheckbox("No Low HP Sound", getSettings().game.noLowHpSound);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Disable the beeping sound when having low health");
                 }
 
-                ImGui::Checkbox("Non-Stop Midna's Lament", &getSettings().game.midnasLamentNonStop);
+                config::ImGuiCheckbox("Non-Stop Midna's Lament", getSettings().game.midnasLamentNonStop);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Prevents enemy music while Midna's Lament is playing");
                 }
@@ -94,9 +94,9 @@ namespace dusk {
             }
 
             if (ImGui::BeginMenu("Cheats")) {
-                ImGui::Checkbox("Fast Iron Boots", &getSettings().game.enableFastIronBoots);
+                config::ImGuiCheckbox("Fast Iron Boots", getSettings().game.enableFastIronBoots);
 
-                ImGui::Checkbox("Can Transform Anywhere", &getSettings().game.canTransformAnywhere);
+                config::ImGuiCheckbox("Can Transform Anywhere", getSettings().game.canTransformAnywhere);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Allows you to transform even if NPCs are looking");
                 }
@@ -105,9 +105,9 @@ namespace dusk {
             }
 
             if (ImGui::BeginMenu("Difficulty")) {
-                ImGui::SliderInt("Damage Multiplier", &getSettings().game.damageMultiplier, 1, 8, "x%d");
+                config::ImGuiSliderInt("Damage Multiplier", getSettings().game.damageMultiplier, 1, 8, "x%d");
 
-                ImGui::Checkbox("Instant Death", &getSettings().game.instantDeath);
+                config::ImGuiCheckbox("Instant Death", getSettings().game.instantDeath);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Any hit will instantly kill you");
                 }
@@ -116,7 +116,7 @@ namespace dusk {
             }
 
             if (ImGui::BeginMenu("Technical")) {
-                ImGui::Checkbox("Restore Wii 1.0 Glitches", &getSettings().game.restoreWiiGlitches);
+                config::ImGuiCheckbox("Restore Wii 1.0 Glitches", getSettings().game.restoreWiiGlitches);
                 if (ImGui::IsItemHovered()) {
                     ImGui::SetTooltip("Restores patched glitches from Wii USA 1.0,\n"
                                       "the first released version");
diff --git a/src/dusk/imgui/ImGuiMenuGame.cpp b/src/dusk/imgui/ImGuiMenuGame.cpp
index cd1d5a06f3..b2ed26b20a 100644
--- a/src/dusk/imgui/ImGuiMenuGame.cpp
+++ b/src/dusk/imgui/ImGuiMenuGame.cpp
@@ -3,6 +3,7 @@
 
 #include "ImGuiConsole.hpp"
 #include "ImGuiMenuGame.hpp"
+#include "ImGuiConfig.hpp"
 #include <imgui_internal.h>
 
 #include "JSystem/JUtility/JUTGamePad.h"
@@ -13,6 +14,12 @@
 #include "m_Do/m_Do_controller_pad.h"
 
 namespace dusk {
+    void ImGuiMenuGame::ToggleFullscreen() {
+        getSettings().video.enableFullscreen.setValue(!getSettings().video.enableFullscreen);
+        VISetWindowFullscreen(getSettings().video.enableFullscreen);
+        config::Save();
+    }
+
     ImGuiMenuGame::ImGuiMenuGame() {}
 
     void ImGuiMenuGame::draw() {
@@ -25,8 +32,7 @@ namespace dusk {
 
             if (ImGui::BeginMenu("Graphics")) {
                 if (ImGui::MenuItem("Toggle Fullscreen", hotkeys::TOGGLE_FULLSCREEN)) {
-                    getSettings().video.enableFullscreen = !getSettings().video.enableFullscreen;
-                    VISetWindowFullscreen(getSettings().video.enableFullscreen);
+                    ToggleFullscreen();
                 }
 
                 ImGui::EndMenu();
@@ -34,9 +40,8 @@ namespace dusk {
 
             if (ImGui::BeginMenu("Audio")) {
                 ImGui::Text("Master Volume");
-                ImGui::SliderInt("##masterVolume", &getSettings().audio.masterVolume, 0, 100);
-                ImGui::Checkbox("Enable Reverb", &getSettings().audio.enableReverb);
-
+                config::ImGuiSliderInt("##masterVolume", getSettings().audio.masterVolume, 0, 100);
+                config::ImGuiCheckbox("Enable Reverb", getSettings().audio.enableReverb);
                 /*
                 // TODO: Implement additional settings
                 ImGui::Text("Main Music Volume");
diff --git a/src/dusk/imgui/ImGuiMenuGame.hpp b/src/dusk/imgui/ImGuiMenuGame.hpp
index 6d7ed614aa..77e5952d1a 100644
--- a/src/dusk/imgui/ImGuiMenuGame.hpp
+++ b/src/dusk/imgui/ImGuiMenuGame.hpp
@@ -16,6 +16,8 @@ namespace dusk {
         void windowInputViewer();
         void windowControllerConfig();
 
+        static void ToggleFullscreen();
+
     private:
         struct {
             int m_selectedPort = 0;
diff --git a/src/dusk/imgui/ImGuiMenuTools.cpp b/src/dusk/imgui/ImGuiMenuTools.cpp
index b48127167c..6a2fc2ede0 100644
--- a/src/dusk/imgui/ImGuiMenuTools.cpp
+++ b/src/dusk/imgui/ImGuiMenuTools.cpp
@@ -7,10 +7,11 @@
 #include "ImGuiConsole.hpp"
 #include "ImGuiMenuTools.hpp"
 
-#include "m_Do/m_Do_main.h"
-#include "d/d_com_inf_game.h"
+#include "ImGuiConfig.hpp"
 #include "d/actor/d_a_alink.h"
 #include "d/actor/d_a_horse.h"
+#include "d/d_com_inf_game.h"
+#include "m_Do/m_Do_main.h"
 
 namespace dusk {
     ImGuiMenuTools::ImGuiMenuTools() {}
@@ -50,7 +51,7 @@ namespace dusk {
             ImGui::MenuItem("Audio Debug", hotkeys::SHOW_AUDIO_DEBUG, &m_showAudioDebug);
             ImGui::MenuItem("OSReport Force", nullptr, &OSReportReallyForceEnable);
             ImGui::Separator();
-            ImGui::MenuItem("Enable Turbo Key", hotkeys::TURBO, &getSettings().game.enableTurboKeybind);
+            config::ImGuiMenuItem("Enable Turbo Key", hotkeys::TURBO, getSettings().game.enableTurboKeybind);
             ImGui::EndMenu();
         }
 
diff --git a/src/dusk/io.cpp b/src/dusk/io.cpp
new file mode 100644
index 0000000000..50b5cab5bd
--- /dev/null
+++ b/src/dusk/io.cpp
@@ -0,0 +1,147 @@
+#include "dusk/io.hpp"
+#include <cstdio>
+#include <filesystem>
+
+using namespace dusk::io;
+
+#if _WIN32
+#define MODE_TYPE wchar_t
+#define MODE(val) L##val
+#define ftell(file) _ftelli64(file)
+#define fseek(a, b, c) _fseeki64(a, b, c)
+#else
+#define MODE_TYPE char
+#if _MSVC_VER
+#define MODE(val) ##val
+#else
+#define MODE(val) val
+#endif
+#endif
+
+static FILE* ThrowIfNotOpen(const FileStream& file) {
+    if (!file.GetFileHandle()) {
+        throw std::runtime_error("Invalid file handle!");
+    }
+
+    return static_cast<FILE*>(file.GetFileHandle());
+}
+
+[[noreturn]] static void ThrowForError(int code) {
+    throw std::system_error(std::make_error_code(static_cast<std::errc>(code)));
+}
+
+static FILE* OpenCore(const std::filesystem::path& path, const MODE_TYPE* mode) {
+    FILE* file;
+
+    int err;
+#if _WIN32
+    static_assert(std::is_same_v<std::filesystem::path::value_type, wchar_t>);
+    err = _wfopen_s(&file, path.c_str(), mode);
+#else
+    errno = 0;
+    static_assert(std::is_same_v<std::filesystem::path::value_type, char>);
+    file = fopen(path.c_str(), mode);
+    err = errno;
+#endif
+
+    if (!file) {
+        ThrowForError(err);
+    }
+
+    return file;
+}
+
+static FILE* OpenCore(const char* path, const MODE_TYPE* mode) {
+    return OpenCore(reinterpret_cast<const char8_t*>(path), mode);
+}
+
+FileStream::FileStream() noexcept : file(nullptr) {
+}
+
+FileStream::FileStream(void* file) : file(file) {
+    if (!file) {
+        CRASH("Invalid file handle");
+    }
+}
+
+FileStream::FileStream(FileStream&& other) noexcept {
+    file = other.file;
+    other.file = nullptr;
+}
+
+FileStream::~FileStream() {
+    if (file)
+        fclose(static_cast<FILE*>(file));
+}
+
+FileStream FileStream::OpenRead(const char* utf8Path) {
+    return FileStream(OpenCore(utf8Path, MODE("rb")));
+}
+
+FileStream FileStream::Create(const char* utf8Path) {
+    return FileStream(OpenCore(utf8Path, MODE("wb")));
+}
+
+std::vector<u8> FileStream::ReadFull() {
+    const auto fileHandle = ThrowIfNotOpen(*this);
+
+    std::vector<u8> result;
+
+    const auto startPos = ftell(fileHandle);
+    if (startPos == -1) {
+        ThrowForError(errno);
+    }
+
+    auto seekRes = fseek(fileHandle, 0, SEEK_END);
+    if (seekRes != 0) {
+        ThrowForError(errno);
+    }
+
+    const auto endPos = ftell(fileHandle);
+    if (endPos == -1) {
+        ThrowForError(errno);
+    }
+
+    seekRes = fseek(fileHandle, startPos, SEEK_SET);
+    if (seekRes != 0) {
+        ThrowForError(errno);
+    }
+
+    result.resize(endPos - startPos);
+
+    if (result.empty()) {
+        return result;
+    }
+
+    auto ret = fread(result.data(), 1, result.size(), fileHandle);
+    if (ret < result.size()) {
+        int err = errno;
+        // Error or EOF
+        if (feof(fileHandle)) {
+            result.resize(ret);
+        } else {
+            ThrowForError(err);
+        }
+    }
+
+    return result;
+}
+
+std::vector<u8> FileStream::ReadAllBytes(const char* utf8Path) {
+    auto handle = OpenRead(utf8Path);
+    return std::move(handle.ReadFull());
+}
+
+void FileStream::Write(const char* data, size_t dataLen) {
+    FILE* fileHandle = ThrowIfNotOpen(*this);
+
+    const auto ret = fwrite(data, 1, dataLen, fileHandle);
+    if (ret < dataLen) {
+        ThrowForError(errno);
+    }
+}
+
+void FileStream::WriteAllText(const char* utf8Path, const std::string_view text) {
+    auto handle = Create(utf8Path);
+    handle.Write(text.data(), text.size());
+}
diff --git a/src/dusk/settings.cpp b/src/dusk/settings.cpp
index 38fa455e47..278f783dbf 100644
--- a/src/dusk/settings.cpp
+++ b/src/dusk/settings.cpp
@@ -1,68 +1,100 @@
 #include "dusk/settings.h"
+#include "dusk/config.hpp"
 
 namespace dusk {
 
 UserSettings g_userSettings = {
-    // Program settings
-
-    // Video
     .video = {
-        .enableFullscreen = false,
+        .enableFullscreen {"video.enableFullscreen", false},
     },
 
-    // Audio
     .audio = {
-        .masterVolume = 80,
-        .mainMusicVolume = 100,
-        .subMusicVolume = 100,
-        .soundEffectsVolume = 100,
-        .fanfareVolume = 100,
-        .enableReverb = true
+        .masterVolume {"audio.masterVolume", 80},
+        .mainMusicVolume {"audio.mainMusicVolume", 100},
+        .subMusicVolume {"audio.subMusicVolume", 100},
+        .soundEffectsVolume {"audio.soundEffectsVolume", 100},
+        .fanfareVolume {"audio.fanfareVolume", 100},
+        .enableReverb {"audio.enableReverb", true},
     },
 
-    // Game settings
     .game = {
         // Quality of Life
-        .enableQuickTransform = false,
-        .hideTvSettingsScreen = false,
-        .biggerWallets = false,
-        .noReturnRupees = false,
-        .disableRupeeCutscenes = false,
-        .noSwordRecoil = false,
-        .damageMultiplier = 1,
-        .instantDeath = false,
-        .fastClimbing = false,
-        .noMissClimbing = false,
-        .fastTears = false,
+        .enableQuickTransform {"game.enableQuickTransform", false},
+        .hideTvSettingsScreen {"game.hideTvSettingsScreen", false},
+        .biggerWallets {"game.biggerWallets", false},
+        .noReturnRupees {"game.noReturnRupees", false},
+        .disableRupeeCutscenes {"game.disableRupeeCutscenes", false},
+        .noSwordRecoil {"game.noSwordRecoil", false},
+        .damageMultiplier {"game.damageMultiplier", 1},
+        .instantDeath {"game.instantDeath", false},
+        .fastClimbing {"game.fastClimbing", false},
+        .noMissClimbing {"game.noMissClimbing", false},
+        .fastTears {"game.fastTears", false},
 
         // Preferences
-        .enableMirrorMode = false,
-        .invertCameraXAxis = false,
+        .enableMirrorMode {"game.enableMirrorMode", false},
+        .invertCameraXAxis {"game.invertCameraXAxis", false},
 
         // Graphics
-        .enableBloom = true,
-        .useWaterProjectionOffset = false,
+        .enableBloom {"game.enableBloom", true},
+        .useWaterProjectionOffset {"game.useWaterProjectionOffset", false},
 
         // Audio
-        .noLowHpSound = false,
-        .midnasLamentNonStop = false,
+        .noLowHpSound {"game.noLowHpSound", false},
+        .midnasLamentNonStop {"game.midnasLamentNonStop", false},
 
         // Cheats
-        .enableFastIronBoots = false,
-        .canTransformAnywhere = false,
+        .enableFastIronBoots {"game.enableFastIronBoots", false},
+        .canTransformAnywhere {"game.canTransformAnywhere", false},
 
         // Technical
-        .restoreWiiGlitches = false,
+        .restoreWiiGlitches {"game.restoreWiiGlitches", false},
 
         // Controls
-        .enableTurboKeybind = true,
-    }
+        .enableTurboKeybind {"game.enableTurboKeybind", true},
+    },
 };
 
 UserSettings& getSettings() {
     return g_userSettings;
 }
 
+void registerSettings() {
+    // Video
+    Register(g_userSettings.video.enableFullscreen);
+
+    // Audio
+    Register(g_userSettings.audio.masterVolume);
+    Register(g_userSettings.audio.mainMusicVolume);
+    Register(g_userSettings.audio.subMusicVolume);
+    Register(g_userSettings.audio.soundEffectsVolume);
+    Register(g_userSettings.audio.fanfareVolume);
+    Register(g_userSettings.audio.enableReverb);
+
+    // Game
+    Register(g_userSettings.game.enableQuickTransform);
+    Register(g_userSettings.game.hideTvSettingsScreen);
+    Register(g_userSettings.game.biggerWallets);
+    Register(g_userSettings.game.noReturnRupees);
+    Register(g_userSettings.game.disableRupeeCutscenes);
+    Register(g_userSettings.game.noSwordRecoil);
+    Register(g_userSettings.game.damageMultiplier);
+    Register(g_userSettings.game.instantDeath);
+    Register(g_userSettings.game.fastClimbing);
+    Register(g_userSettings.game.fastTears);
+    Register(g_userSettings.game.enableMirrorMode);
+    Register(g_userSettings.game.invertCameraXAxis);
+    Register(g_userSettings.game.enableBloom);
+    Register(g_userSettings.game.useWaterProjectionOffset);
+    Register(g_userSettings.game.enableFastIronBoots);
+    Register(g_userSettings.game.canTransformAnywhere);
+    Register(g_userSettings.game.restoreWiiGlitches);
+    Register(g_userSettings.game.noMissClimbing);
+    Register(g_userSettings.game.noLowHpSound);
+    Register(g_userSettings.game.midnasLamentNonStop);
+    Register(g_userSettings.game.enableTurboKeybind);
+}
+
 // Transient settings
 
 static TransientSettings g_transientSettings = {
diff --git a/src/m_Do/m_Do_main.cpp b/src/m_Do/m_Do_main.cpp
index b8eeba892e..632d696ae9 100644
--- a/src/m_Do/m_Do_main.cpp
+++ b/src/m_Do/m_Do_main.cpp
@@ -44,11 +44,12 @@
 #include <chrono>
 #include <thread>
 #include "SSystem/SComponent/c_API.h"
+#include "dusk/app_info.hpp"
 #include "dusk/dusk.h"
-#include "dusk/logging.h"
-#include "dusk/time.h"
-#include "dusk/main.h"
 #include "dusk/imgui/ImGuiEngine.hpp"
+#include "dusk/logging.h"
+#include "dusk/main.h"
+#include "dusk/time.h"
 
 #include <aurora/aurora.h>
 #include <aurora/event.h>
@@ -56,7 +57,9 @@
 #include <aurora/dvd.h>
 #include <dolphin/dvd.h>
 
+#include "SDL3/SDL_filesystem.h"
 #include "cxxopts.hpp"
+#include "dusk/config.hpp"
 
 // --- GLOBALS ---
 s8 mDoMain::developmentMode = -1;
@@ -107,6 +110,7 @@ s32 LOAD_COPYDATE(void*) {
 }
 
 AuroraInfo auroraInfo;
+const char* configPath;
 
 void main01(void) {
     OS_REPORT("\x1b[m");
@@ -233,10 +237,51 @@ static void aurora_imgui_init_callback(const AuroraWindowSize* size) {
     dusk::ImGuiEngine_Initialize(size->scale);
 }
 
+static void ApplyCVarOverrides(const cxxopts::OptionValue& option) {
+    if (option.count() == 0) {
+        return;
+    }
+
+    const auto& cVars = option.as<std::vector<std::string>>();
+    for (const auto& cvarArg : cVars) {
+        const auto sep = cvarArg.find('=');
+        if (sep == std::string::npos) {
+            DuskLog.fatal("--cvar argument has no '=': '{}'", cvarArg);
+            continue;
+        }
+
+        const auto name = std::string_view(cvarArg).substr(0, sep);
+        const auto value = std::string_view(cvarArg).substr(sep + 1);
+
+        const auto cVar = dusk::config::GetConfigVar(name);
+        if (!cVar) {
+            DuskLog.fatal("Unknown --cvar name: '{}'", name);
+        }
+
+        try {
+            cVar->getImpl()->loadFromArg(*cVar, value);
+        } catch (const std::exception& e) {
+            DuskLog.fatal("Unable to parse: '{}': {}", value, e.what());
+        }
+    }
+}
+
+static const char* CalculateConfigPath() {
+    const auto result = SDL_GetPrefPath(dusk::OrgName, dusk::AppName);
+    if (!result) {
+        DuskLog.fatal("Unable to get PrefPath: {}", SDL_GetError());
+    }
+
+    return result;
+}
+
 // =========================================================================
 // PC ENTRY POINT
 // =========================================================================
 int game_main(int argc, char* argv[]) {
+    dusk::registerSettings();
+    dusk::config::FinishRegistration();
+
     cxxopts::ParseResult parsed_arg_options;
 
     try {
@@ -246,7 +291,8 @@ int game_main(int argc, char* argv[]) {
             ("l,log-level", "Log level from " + std::to_string(AuroraLogLevel::LOG_DEBUG) + " to " + std::to_string(AuroraLogLevel::LOG_FATAL), cxxopts::value<uint8_t>()->default_value("0"))
             ("h,help", "Print usage")
             ("dvd", "Path to DVD image file", cxxopts::value<std::string>()->default_value("game.iso"))
-            ("backend", "Graphics API backend to use (auto, d3d11, d3d12, metal, vulkan, opengl, opengles, webgpu, null)", cxxopts::value<std::string>()->default_value("auto"));
+            ("backend", "Graphics API backend to use (auto, d3d11, d3d12, metal, vulkan, opengl, opengles, webgpu, null)", cxxopts::value<std::string>()->default_value("auto"))
+            ("cvar", "Override configuration variables without modifying config", cxxopts::value<std::vector<std::string>>());
 
         arg_options.parse_positional({"dvd"});
         arg_options.positional_help("<dvd-image>");
@@ -265,8 +311,14 @@ int game_main(int argc, char* argv[]) {
         exit(1);
     }
 
+    configPath = CalculateConfigPath();
+
+    dusk::config::LoadFromUserPreferences();
+    ApplyCVarOverrides(parsed_arg_options["cvar"]);
+
     AuroraConfig config{};
-    config.appName = "Dusk";
+    config.appName = dusk::AppName;
+    config.configPath = configPath;
     config.windowPosX = -1;
     config.windowPosY = -1;
     config.windowWidth = 608 * 2;