diff --git a/UnleashedRecomp/cfg/config.h b/UnleashedRecomp/cfg/config.h
index c19afa41..2d7cfa1f 100644
--- a/UnleashedRecomp/cfg/config.h
+++ b/UnleashedRecomp/cfg/config.h
@@ -39,15 +39,13 @@ public:
 
     CONFIG_DEFINE_CALLBACK("Video", float, ResolutionScale, 1.0f,
     {
-        def->NameLocale = &g_ResolutionScale_locale;
-        def->DescLocale = &g_ResolutionScale_desc_locale;
+        def->Locale = &g_ResolutionScale_locale;
         def->Value = std::clamp(def->Value, 0.25f, 2.0f);
     });
 
     CONFIG_DEFINE_CALLBACK("Video", bool, Fullscreen, false,
     {
-        def->NameLocale = &g_Fullscreen_locale;
-        def->DescLocale = &g_Fullscreen_desc_locale;
+        def->Locale = &g_Fullscreen_locale;
 
         Window_SetFullscreen(def->Value);
     });
diff --git a/UnleashedRecomp/cfg/config_detail.cpp b/UnleashedRecomp/cfg/config_detail.cpp
index 5359b751..084ca684 100644
--- a/UnleashedRecomp/cfg/config_detail.cpp
+++ b/UnleashedRecomp/cfg/config_detail.cpp
@@ -10,8 +10,8 @@ ConfigDef<T>::ConfigDef(std::string section, std::string name, T defaultValue) :
 
 // CONFIG_DEFINE_LOCALISED
 template<typename T>
-ConfigDef<T>::ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, CONFIG_LOCALE* descLocale, T defaultValue)
-    : Section(section), Name(name), NameLocale(nameLocale), DescLocale(descLocale), DefaultValue(defaultValue)
+ConfigDef<T>::ConfigDef(std::string section, std::string name, CONFIG_LOCALE* locale, T defaultValue)
+    : Section(section), Name(name), Locale(locale), DefaultValue(defaultValue)
 {
     Config::Definitions.emplace_back(this);
 }
@@ -29,8 +29,8 @@ ConfigDef<T>::ConfigDef(std::string section, std::string name, T defaultValue, s
 
 // CONFIG_DEFINE_ENUM_LOCALISED
 template<typename T>
-ConfigDef<T>::ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, CONFIG_LOCALE* descLocale, T defaultValue, std::unordered_map<std::string, T>* enumTemplate, CONFIG_ENUM_LOCALE(T)* enumLocale)
-    : Section(section), Name(name), NameLocale(nameLocale), DescLocale(descLocale), DefaultValue(defaultValue), EnumTemplate(enumTemplate), EnumLocale(enumLocale)
+ConfigDef<T>::ConfigDef(std::string section, std::string name, CONFIG_LOCALE* locale, T defaultValue, std::unordered_map<std::string, T>* enumTemplate, CONFIG_ENUM_LOCALE(T)* enumLocale)
+    : Section(section), Name(name), Locale(locale), DefaultValue(defaultValue), EnumTemplate(enumTemplate), EnumLocale(enumLocale)
 {
     for (const auto& pair : *EnumTemplate)
         EnumTemplateReverse[pair.second] = pair.first;
@@ -46,38 +46,17 @@ ConfigDef<T>::ConfigDef(std::string section, std::string name, T defaultValue, s
     Config::Definitions.emplace_back(this);
 }
 
-template<typename T>
-std::string ConfigDef<T>::GetDescription() const
-{
-    if (!DescLocale)
-        return "";
-
-    if (!DescLocale->count(Config::Language))
-    {
-        if (DescLocale->count(ELanguage::English))
-        {
-            return DescLocale->at(ELanguage::English);
-        }
-        else
-        {
-            return "";
-        }
-    }
-
-    return DescLocale->at(Config::Language);
-}
-
 template<typename T>
 std::string ConfigDef<T>::GetNameLocalised() const
 {
-    if (!NameLocale)
+    if (!Locale)
         return Name;
 
-    if (!NameLocale->count(Config::Language))
+    if (!Locale->count(Config::Language))
     {
-        if (NameLocale->count(ELanguage::English))
+        if (Locale->count(ELanguage::English))
         {
-            return NameLocale->at(ELanguage::English);
+            return std::get<0>(Locale->at(ELanguage::English));
         }
         else
         {
@@ -85,7 +64,28 @@ std::string ConfigDef<T>::GetNameLocalised() const
         }
     }
 
-    return NameLocale->at(Config::Language);
+    return std::get<0>(Locale->at(Config::Language));
+}
+
+template<typename T>
+std::string ConfigDef<T>::GetDescription() const
+{
+    if (!Locale)
+        return "";
+
+    if (!Locale->count(Config::Language))
+    {
+        if (Locale->count(ELanguage::English))
+        {
+            return std::get<1>(Locale->at(ELanguage::English));
+        }
+        else
+        {
+            return "";
+        }
+    }
+
+    return std::get<1>(Locale->at(Config::Language));
 }
 
 template<typename T>
@@ -123,5 +123,43 @@ std::string ConfigDef<T>::GetValueLocalised() const
     if (!strings.count(Value))
         return ToString(false);
 
-    return strings.at(Value);
+    return std::get<0>(strings.at(Value));
+}
+
+template<typename T>
+std::string ConfigDef<T>::GetValueDescription() const
+{
+    auto language = Config::Language;
+    CONFIG_ENUM_LOCALE(T)* locale = nullptr;
+
+    if constexpr (std::is_enum_v<T>)
+    {
+        locale = EnumLocale;
+    }
+    else if constexpr (std::is_same_v<T, bool>)
+    {
+        locale = &g_bool_locale;
+    }
+
+    if (!locale)
+        return "";
+
+    if (!locale->count(language))
+    {
+        if (locale->count(ELanguage::English))
+        {
+            language = ELanguage::English;
+        }
+        else
+        {
+            return "";
+        }
+    }
+
+    auto strings = locale->at(language);
+
+    if (!strings.count(Value))
+        return "";
+
+    return std::get<1>(strings.at(Value));
 }
diff --git a/UnleashedRecomp/cfg/config_detail.h b/UnleashedRecomp/cfg/config_detail.h
index 8b2f8470..26455bf7 100644
--- a/UnleashedRecomp/cfg/config_detail.h
+++ b/UnleashedRecomp/cfg/config_detail.h
@@ -8,13 +8,13 @@
     inline static ConfigDef<type> name{section, #name, defaultValue};
 
 #define CONFIG_DEFINE_LOCALISED(section, type, name, defaultValue) \
-    inline static ConfigDef<type> name{section, #name, &g_##name##_locale, &g_##name##_desc_locale, defaultValue};
+    inline static ConfigDef<type> name{section, #name, &g_##name##_locale, defaultValue};
 
 #define CONFIG_DEFINE_ENUM(section, type, name, defaultValue) \
     inline static ConfigDef<type> name{section, #name, defaultValue, &g_##type##_template};
 
 #define CONFIG_DEFINE_ENUM_LOCALISED(section, type, name, defaultValue) \
-    inline static ConfigDef<type> name{section, #name, &g_##name##_locale, &g_##name##_desc_locale, defaultValue, &g_##type##_template, &g_##type##_locale};
+    inline static ConfigDef<type> name{section, #name, &g_##name##_locale, defaultValue, &g_##type##_template, &g_##type##_locale};
 
 #define CONFIG_DEFINE_CALLBACK(section, type, name, defaultValue, readCallback) \
     inline static ConfigDef<type> name{section, #name, defaultValue, [](ConfigDef<type>* def) readCallback};
@@ -22,8 +22,8 @@
 #define CONFIG_DEFINE_ENUM_TEMPLATE(type) \
     inline static std::unordered_map<std::string, type> g_##type##_template =
 
-#define CONFIG_LOCALE std::unordered_map<ELanguage, std::string>
-#define CONFIG_ENUM_LOCALE(type) std::unordered_map<ELanguage, std::unordered_map<type, std::string>>
+#define CONFIG_LOCALE std::unordered_map<ELanguage, std::tuple<std::string, std::string>>
+#define CONFIG_ENUM_LOCALE(type) std::unordered_map<ELanguage, std::unordered_map<type, std::tuple<std::string, std::string>>>
 
 #define WINDOWPOS_CENTRED 0x2FFF0000
 
@@ -181,10 +181,11 @@ public:
     virtual void MakeDefault() = 0;
     virtual std::string_view GetSection() const = 0;
     virtual std::string_view GetName() const = 0;
-    virtual std::string GetDescription() const = 0;
     virtual std::string GetNameLocalised() const = 0;
+    virtual std::string GetDescription() const = 0;
     virtual const void* GetValue() const = 0;
     virtual std::string GetValueLocalised() const = 0;
+    virtual std::string GetValueDescription() const = 0;
     virtual std::string GetDefinition(bool withSection = false) const = 0;
     virtual std::string ToString(bool strWithQuotes = true) const = 0;
 };
@@ -195,8 +196,7 @@ class ConfigDef : public IConfigDef
 public:
     std::string Section{};
     std::string Name{};
-    CONFIG_LOCALE* NameLocale;
-    CONFIG_LOCALE* DescLocale;
+    CONFIG_LOCALE* Locale;
     T DefaultValue{};
     T Value{ DefaultValue };
     std::unordered_map<std::string, T>* EnumTemplate;
@@ -208,13 +208,13 @@ public:
     ConfigDef(std::string section, std::string name, T defaultValue);
 
     // CONFIG_DEFINE_LOCALISED
-    ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, CONFIG_LOCALE* descLocale, T defaultValue);
+    ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, T defaultValue);
 
     // CONFIG_DEFINE_ENUM
     ConfigDef(std::string section, std::string name, T defaultValue, std::unordered_map<std::string, T>* enumTemplate);
 
     // CONFIG_DEFINE_ENUM_LOCALISED
-    ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, CONFIG_LOCALE* descLocale, T defaultValue, std::unordered_map<std::string, T>* enumTemplate, CONFIG_ENUM_LOCALE(T)* enumLocale);
+    ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, T defaultValue, std::unordered_map<std::string, T>* enumTemplate, CONFIG_ENUM_LOCALE(T)* enumLocale);
 
     // CONFIG_DEFINE_CALLBACK
     ConfigDef(std::string section, std::string name, T defaultValue, std::function<void(ConfigDef<T>*)> callback);
@@ -260,10 +260,10 @@ public:
         return Name;
     }
 
-    std::string GetDescription() const override;
-
     std::string GetNameLocalised() const override;
 
+    std::string GetDescription() const override;
+
     const void* GetValue() const override
     {
         return &Value;
@@ -271,6 +271,8 @@ public:
 
     std::string GetValueLocalised() const override;
 
+    std::string GetValueDescription() const override;
+
     std::string GetDefinition(bool withSection = false) const override
     {
         std::string result;
diff --git a/UnleashedRecomp/cfg/config_locale.h b/UnleashedRecomp/cfg/config_locale.h
index 05b7168a..0bd0d33f 100644
--- a/UnleashedRecomp/cfg/config_locale.h
+++ b/UnleashedRecomp/cfg/config_locale.h
@@ -3,52 +3,65 @@
 #include "config_detail.h"
 
 #define CONFIG_DEFINE_LOCALE(name) \
-    inline static std::unordered_map<ELanguage, std::string> g_##name##_locale =
-
-#define CONFIG_DEFINE_DESCRIPTION_LOCALE(name) \
-    inline static std::unordered_map<ELanguage, std::string> g_##name##_desc_locale =
+    inline static std::unordered_map<ELanguage, std::tuple<std::string, std::string>> g_##name##_locale =
 
 #define CONFIG_DEFINE_ENUM_LOCALE(type) \
-    inline static std::unordered_map<ELanguage, std::unordered_map<type, std::string>> g_##type##_locale =
-
-#define CONFIG_DEFINE_ENUM_DESCRIPTION_LOCALE(type) \
-    inline static std::unordered_map<ELanguage, std::unordered_map<type, std::string>> g_##type##_desc_locale =
+    inline static std::unordered_map<ELanguage, std::unordered_map<type, std::tuple<std::string, std::string>>> g_##type##_locale =
 
 CONFIG_DEFINE_ENUM_LOCALE(bool)
 {
     {
-        ELanguage::English, { { true, "ON" }, { false, "OFF" } }
+        ELanguage::English,
+        {
+            { true,  { "ON", "" } },
+            { false, { "OFF", "" } }
+        }
     },
     {
-        ELanguage::Japanese, { { true, "オン" }, { false, "オフ" } }
+        ELanguage::Japanese,
+        {
+            { true,  { "オン", "" } },
+            { false, { "オフ", "" } }
+        }
     },
     {
-        ELanguage::German, { { true, "EIN" }, { false, "AUS" } }
+        ELanguage::German,
+        {
+            { true,  { "EIN", "" } },
+            { false, { "AUS", "" } }
+        }
     },
     {
-        ELanguage::French, { { true, "OUI" }, { false, "NON" } }
+        ELanguage::French,
+        {
+            { true,  { "OUI", "" } },
+            { false, { "NON", "" } }
+        }
     },
     {
-        ELanguage::Spanish, { { true, "SÍ" }, { false, "NO" } }
+        ELanguage::Spanish,
+        {
+            { true,  { "SÍ", "" } },
+            { false, { "NO", "" } }
+        }
     },
     {
-        ELanguage::Italian, { { true, "SÌ" }, { false, "NO" } }
+        ELanguage::Italian,
+        {
+            { true,  { "SÌ", "" } },
+            { false, { "NO", "" } }
+        }
     }
 };
 
 CONFIG_DEFINE_LOCALE(Language)
 {
-    { ELanguage::English,  "Language" },
-    { ELanguage::Japanese, "言語" },
-    { ELanguage::German,   "Sprache" },
-    { ELanguage::French,   "Langue" },
-    { ELanguage::Spanish,  "Idioma" },
-    { ELanguage::Italian,  "Lingua" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Language)
-{
-    { ELanguage::English, "Change the language used for text and logos." }
+    { ELanguage::English,  { "Language", "Change the language used for text and logos." } },
+    { ELanguage::Japanese, { "言語", "[PLACEHOLDER]" } },
+    { ELanguage::German,   { "Sprache", "[PLACEHOLDER]" } },
+    { ELanguage::French,   { "Langue", "[PLACEHOLDER]" } },
+    { ELanguage::Spanish,  { "Idioma", "[PLACEHOLDER]" } },
+    { ELanguage::Italian,  { "Lingua", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(ELanguage)
@@ -56,54 +69,34 @@ CONFIG_DEFINE_ENUM_LOCALE(ELanguage)
     {
         ELanguage::English,
         {
-            { ELanguage::English,  "ENGLISH" },
-            { ELanguage::Japanese, "日本語" },
-            { ELanguage::German,   "DEUTSCH" },
-            { ELanguage::French,   "FRANÇAIS" },
-            { ELanguage::Spanish,  "ESPAÑOL" },
-            { ELanguage::Italian,  "ITALIANO" }
+            { ELanguage::English,  { "ENGLISH", "" } },
+            { ELanguage::Japanese, { "日本語", "" } },
+            { ELanguage::German,   { "DEUTSCH", "" } },
+            { ELanguage::French,   { "FRANÇAIS", "" } },
+            { ELanguage::Spanish,  { "ESPAÑOL", "" } },
+            { ELanguage::Italian,  { "ITALIANO", "" } }
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(Hints)
 {
-    { ELanguage::English, "Hints" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Hints)
-{
-    { ELanguage::English, "Show hint rings in stages." }
+    { ELanguage::English, { "Hints", "Show hint rings in stages." } }
 };
 
 CONFIG_DEFINE_LOCALE(ControlTutorial)
 {
-    { ELanguage::English, "Control Tutorial" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(ControlTutorial)
-{
-    { ELanguage::English, "Show controller hints in stages." }
+    { ELanguage::English, { "Control Tutorial", "Show controller hints in stages." } }
 };
 
 CONFIG_DEFINE_LOCALE(SaveScoreAtCheckpoints)
 {
-    { ELanguage::English, "Save Score at Checkpoints" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(SaveScoreAtCheckpoints)
-{
-    { ELanguage::English, "Keep your score from the last checkpoint upon respawning." }
+    { ELanguage::English, { "Save Score at Checkpoints", "Keep your score from the last checkpoint upon respawning." } }
 };
 
 CONFIG_DEFINE_LOCALE(UnleashGaugeBehaviour)
 {
-    { ELanguage::English, "Unleash Gauge Behavior" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(UnleashGaugeBehaviour)
-{
-    { ELanguage::English, "Change how the Unleash gauge behaves." }
+    { ELanguage::English, { "Unleash Gauge Behavior", "Change how the Unleash gauge behaves." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EUnleashGaugeBehaviour)
@@ -111,120 +104,65 @@ CONFIG_DEFINE_ENUM_LOCALE(EUnleashGaugeBehaviour)
     {
         ELanguage::English,
         {
-            { EUnleashGaugeBehaviour::Original, "ORIGINAL" },
-            { EUnleashGaugeBehaviour::Revised,  "REVISED" }
+            { EUnleashGaugeBehaviour::Original, { "ORIGINAL", "Original: the gauge will drain at all times regardless." } },
+            { EUnleashGaugeBehaviour::Revised,  { "REVISED", "Revised: the gauge will only drain when the player can move." } }
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(WerehogHubTransformVideo)
 {
-    { ELanguage::English, "Transformation Cutscene" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(WerehogHubTransformVideo)
-{
-    { ELanguage::English, "Play the Werehog transformation cutscene when changing the time of day in the hub areas." }
+    { ELanguage::English, { "Transformation Cutscene", "Play the Werehog transformation cutscene when changing the time of day in the hub areas." } }
 };
 
 CONFIG_DEFINE_LOCALE(LogoSkip)
 {
-    { ELanguage::English, "Skip Intro Logos" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(LogoSkip)
-{
-    { ELanguage::English, "Show the logos during the game's boot sequence." }
+    { ELanguage::English, { "Skip Intro Logos", "Skip the logos during the game's boot sequence." } }
 };
 
 CONFIG_DEFINE_LOCALE(CameraXInvert)
 {
-    { ELanguage::English, "Invert Camera X" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(CameraXInvert)
-{
-    { ELanguage::English, "Toggle between inverted left and right camera movement." }
+    { ELanguage::English, { "Invert Camera X", "Toggle between inverted left and right camera movement." } }
 };
 
 CONFIG_DEFINE_LOCALE(CameraYInvert)
 {
-    { ELanguage::English, "Invert Camera Y" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(CameraYInvert)
-{
-    { ELanguage::English, "Toggle between inverted up and down camera movement." }
+    { ELanguage::English, { "Invert Camera Y", "Toggle between inverted up and down camera movement." } }
 };
 
 CONFIG_DEFINE_LOCALE(XButtonHoming)
 {
-    { ELanguage::English, "Homing Attack on Boost" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(XButtonHoming)
-{
-    { ELanguage::English, "Toggle between using the boost button or the jump button for homing attack." }
+    { ELanguage::English, { "Homing Attack on Boost", "Toggle between using the boost button or the jump button for homing attack." } }
 };
 
 CONFIG_DEFINE_LOCALE(UnleashCancel)
 {
-    { ELanguage::English, "Allow Cancelling Unleash" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(UnleashCancel)
-{
-    { ELanguage::English, "Allow Unleash to be cancelled at the cost of some energy by pressing the input again." }
+    { ELanguage::English, { "Allow Cancelling Unleash", "Allow Unleash to be cancelled at the cost of some energy by pressing the input again." } }
 };
 
 CONFIG_DEFINE_LOCALE(BackgroundInput)
 {
-    { ELanguage::English, "Allow Background Input" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(BackgroundInput)
-{
-    { ELanguage::English, "Accept controller input whilst the game window is unfocused." }
+    { ELanguage::English, { "Allow Background Input", "Accept controller input whilst the game window is unfocused." } }
 };
 
 CONFIG_DEFINE_LOCALE(MusicVolume)
 {
-    { ELanguage::English, "Music Volume" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(MusicVolume)
-{
-    { ELanguage::English, "Adjust the volume for the music." }
+    { ELanguage::English, { "Music Volume", "Adjust the volume for the music." } }
 };
 
 CONFIG_DEFINE_LOCALE(SEVolume)
 {
-    { ELanguage::English, "SE Volume" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(SEVolume)
-{
-    { ELanguage::English, "Adjust the volume for sound effects." }
+    { ELanguage::English, { "Effects Volume", "Adjust the volume for sound effects." } }
 };
 
 CONFIG_DEFINE_LOCALE(MusicAttenuation)
 {
-    { ELanguage::English, "Music Attenuation" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(MusicAttenuation)
-{
-    { ELanguage::English, "Fade out the game's music when external media is playing.\n\nRequires Windows 10 or later." }
+    { ELanguage::English, { "Music Attenuation", "Fade out the game's music when external media is playing.\n\nRequires Windows 10 or later." } }
 };
 
 CONFIG_DEFINE_LOCALE(VoiceLanguage)
 {
-    { ELanguage::English, "Voice Language" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(VoiceLanguage)
-{
-    { ELanguage::English, "Change the language used for character voices." }
+    { ELanguage::English, { "Voice Language", "Change the language used for character voices." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EVoiceLanguage)
@@ -232,110 +170,60 @@ CONFIG_DEFINE_ENUM_LOCALE(EVoiceLanguage)
     {
         ELanguage::English,
         {
-            { EVoiceLanguage::English,  "ENGLISH" },
-            { EVoiceLanguage::Japanese, "日本語" }
+            { EVoiceLanguage::English,  { "ENGLISH", "" } },
+            { EVoiceLanguage::Japanese, { "日本語", "" } }
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(Subtitles)
 {
-    { ELanguage::English, "Subtitles" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Subtitles)
-{
-    { ELanguage::English, "Show subtitles during dialogue." }
+    { ELanguage::English, { "Subtitles", "Show subtitles during dialogue." } }
 };
 
 CONFIG_DEFINE_LOCALE(WerehogBattleMusic)
 {
-    { ELanguage::English, "Battle Theme" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(WerehogBattleMusic)
-{
-    { ELanguage::English, "Play the Werehog battle theme during combat.\n\nThis option will apply the next time you're in combat." }
+    { ELanguage::English, { "Battle Theme", "Play the Werehog battle theme during combat.\n\nThis option will apply the next time you're in combat." } }
 };
 
 CONFIG_DEFINE_LOCALE(WindowSize)
 {
-    { ELanguage::English, "Window Size" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(WindowSize)
-{
-    { ELanguage::English, "Adjust the size of the game window in windowed mode." }
+    { ELanguage::English, { "Window Size", "Adjust the size of the game window in windowed mode." } }
 };
 
 CONFIG_DEFINE_LOCALE(ResolutionScale)
 {
-    { ELanguage::English, "Resolution Scale" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(ResolutionScale)
-{
-    { ELanguage::English, "Adjust the internal resolution of the game.\n\n%dx%d" }
+    { ELanguage::English, { "Resolution Scale", "Adjust the internal resolution of the game.\n\n%dx%d" } }
 };
 
 CONFIG_DEFINE_LOCALE(Fullscreen)
 {
-    { ELanguage::English, "Fullscreen" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Fullscreen)
-{
-    { ELanguage::English, "Toggle between borderless fullscreen or windowed mode." }
+    { ELanguage::English, { "Fullscreen", "Toggle between borderless fullscreen or windowed mode." } }
 };
 
 CONFIG_DEFINE_LOCALE(VSync)
 {
-    { ELanguage::English, "V-Sync" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(VSync)
-{
-    { ELanguage::English, "[PLACEHOLDER]" }
+    { ELanguage::English, { "V-Sync", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_LOCALE(TripleBuffering)
 {
-    { ELanguage::English, "Triple Buffering" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(TripleBuffering)
-{
-    { ELanguage::English, "[PLACEHOLDER]" }
+    { ELanguage::English, { "Triple Buffering", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_LOCALE(FPS)
 {
-    { ELanguage::English, "FPS" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(FPS)
-{
-    { ELanguage::English, "[PLACEHOLDER]" }
+    { ELanguage::English, { "FPS", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_LOCALE(Brightness)
 {
-    { ELanguage::English, "Brightness" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Brightness)
-{
-    { ELanguage::English, "Adjust the brightness level of the game." }
+    { ELanguage::English, { "Brightness", "Adjust the brightness level of the game." } }
 };
 
 CONFIG_DEFINE_LOCALE(AntiAliasing)
 {
-    { ELanguage::English, "Anti-Aliasing" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(AntiAliasing)
-{
-    { ELanguage::English, "Adjust the amount of smoothing applied to jagged edges." }
+    { ELanguage::English, { "Anti-Aliasing", "Adjust the amount of smoothing applied to jagged edges." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EAntiAliasing)
@@ -343,29 +231,19 @@ CONFIG_DEFINE_ENUM_LOCALE(EAntiAliasing)
     {
         ELanguage::English,
         {
-            { EAntiAliasing::None, "NONE" },
+            { EAntiAliasing::None, { "NONE", "" } },
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(AlphaToCoverage)
 {
-    { ELanguage::English, "Transparency Anti-Aliasing" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(AlphaToCoverage)
-{
-    { ELanguage::English, "Apply anti-aliasing to alpha transparent textures." }
+    { ELanguage::English, { "Transparency Anti-Aliasing", "Apply anti-aliasing to alpha transparent textures." } }
 };
 
 CONFIG_DEFINE_LOCALE(ShadowResolution)
 {
-    { ELanguage::English, "Shadow Resolution" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(ShadowResolution)
-{
-    { ELanguage::English, "[PLACEHOLDER]" }
+    { ELanguage::English, { "Shadow Resolution", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EShadowResolution)
@@ -373,19 +251,14 @@ CONFIG_DEFINE_ENUM_LOCALE(EShadowResolution)
     {
         ELanguage::English,
         {
-            { EShadowResolution::Original, "ORIGINAL" },
+            { EShadowResolution::Original, { "ORIGINAL", "Original: the game will automatically determine the resolution of the shadows." } },
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(GITextureFiltering)
 {
-    { ELanguage::English, "GI Texture Filtering" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(GITextureFiltering)
-{
-    { ELanguage::English, "[PLACEHOLDER]" }
+    { ELanguage::English, { "GI Texture Filtering", "[PLACEHOLDER]" } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EGITextureFiltering)
@@ -393,40 +266,25 @@ CONFIG_DEFINE_ENUM_LOCALE(EGITextureFiltering)
     {
         ELanguage::English,
         {
-            { EGITextureFiltering::Bilinear, "BILINEAR" },
-            { EGITextureFiltering::Bicubic,  "BICUBIC" },
+            { EGITextureFiltering::Bilinear, { "BILINEAR", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICUBIC", "" } },
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(MotionBlur)
 {
-    { ELanguage::English, "Motion Blur" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(MotionBlur)
-{
-    { ELanguage::English, "Use per-object motion blur and radial blur." }
+    { ELanguage::English, { "Motion Blur", "Use per-object motion blur and radial blur." } }
 };
 
 CONFIG_DEFINE_LOCALE(Xbox360ColourCorrection)
 {
-    { ELanguage::English, "Xbox 360 Color Correction" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(Xbox360ColourCorrection)
-{
-    { ELanguage::English, "Use the warm tint from the Xbox 360 version of the game." }
+    { ELanguage::English, { "Xbox 360 Color Correction", "Use the warm tint from the Xbox 360 version of the game." } }
 };
 
 CONFIG_DEFINE_LOCALE(MovieScaleMode)
 {
-    { ELanguage::English, "Movie Scale Mode" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(MovieScaleMode)
-{
-    { ELanguage::English, "Change how the movie player scales to the display." }
+    { ELanguage::English, { "Movie Scale Mode", "Change how the movie player scales to the display." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EMovieScaleMode)
@@ -434,21 +292,16 @@ CONFIG_DEFINE_ENUM_LOCALE(EMovieScaleMode)
     {
         ELanguage::English,
         {
-            { EMovieScaleMode::Stretch, "STRETCH" },
-            { EMovieScaleMode::Fit,     "FIT" },
-            { EMovieScaleMode::Fill,    "FILL" },
+            { EMovieScaleMode::Stretch, { "STRETCH", "Stretch: the movie will stretch to the display." } },
+            { EMovieScaleMode::Fit,     { "FIT", "Fit: the movie will maintain its aspect ratio and fit to the display." } },
+            { EMovieScaleMode::Fill,    { "FILL", "Fill: the movie will scale past the bounds of the display if it doesn't match the aspect ratio." } },
         }
     }
 };
 
 CONFIG_DEFINE_LOCALE(UIScaleMode)
 {
-    { ELanguage::English, "UI Scale Mode" }
-};
-
-CONFIG_DEFINE_DESCRIPTION_LOCALE(UIScaleMode)
-{
-    { ELanguage::English, "Change how the UI scales to the display." }
+    { ELanguage::English, { "UI Scale Mode", "Change how the UI scales to the display." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EUIScaleMode)
@@ -456,9 +309,9 @@ CONFIG_DEFINE_ENUM_LOCALE(EUIScaleMode)
     {
         ELanguage::English,
         {
-            { EUIScaleMode::Stretch, "STRETCH" },
-            { EUIScaleMode::Edge,    "EDGE" },
-            { EUIScaleMode::Centre,  "CENTRE" },
+            { EUIScaleMode::Stretch, { "STRETCH", "Stretch: the UI will stretch to the display." } },
+            { EUIScaleMode::Edge,    { "EDGE", "Edge: the UI will anchor to the edges of the display." } },
+            { EUIScaleMode::Centre,  { "CENTER", "Center: the UI will anchor to the center of the display." } },
         }
     }
 };
diff --git a/UnleashedRecomp/patches/fps_patches.cpp b/UnleashedRecomp/patches/fps_patches.cpp
index d55c5e90..1ad63b10 100644
--- a/UnleashedRecomp/patches/fps_patches.cpp
+++ b/UnleashedRecomp/patches/fps_patches.cpp
@@ -2,6 +2,7 @@
 #include <api/SWA.h>
 #include <ui/window.h>
 #include <cfg/config.h>
+#include <app.h>
 
 float m_lastLoadingFrameDelta = 0.0f;
 std::chrono::steady_clock::time_point m_lastLoadingFrameTime;
@@ -36,14 +37,16 @@ static double ComputeLerpFactor(double t, double deltaTime)
     return 1.0 - pow(1.0 - t, (30.0 + bias) / (fps + bias));
 }
 
-void CameraLerpFixMidAsmHook(PPCRegister& t, PPCRegister& deltaTime)
+// It's important to use global delta time here instead of function provided
+// delta time, as it might be time scaled and not match with 30 FPS behavior.
+void CameraLerpFixMidAsmHook(PPCRegister& t)
 {
-    t.f64 = ComputeLerpFactor(t.f64, deltaTime.f64);
+    t.f64 = ComputeLerpFactor(t.f64, g_deltaTime);
 }
 
-void CameraTargetSideOffsetLerpFixMidAsmHook(PPCVRegister& v13, PPCVRegister& v62, PPCRegister& deltaTime)
+void CameraTargetSideOffsetLerpFixMidAsmHook(PPCVRegister& v13, PPCVRegister& v62)
 {
-    float factor = float(ComputeLerpFactor(double(v13.f32[0] * v62.f32[0]), deltaTime.f64));
+    float factor = float(ComputeLerpFactor(double(v13.f32[0] * v62.f32[0]), g_deltaTime));
 
     for (size_t i = 0; i < 4; i++)
     {
diff --git a/UnleashedRecomp/ui/options_menu.cpp b/UnleashedRecomp/ui/options_menu.cpp
index edce3bb5..cb5b17c8 100644
--- a/UnleashedRecomp/ui/options_menu.cpp
+++ b/UnleashedRecomp/ui/options_menu.cpp
@@ -316,6 +316,7 @@ static bool g_downWasHeld;
 static bool g_lockedOnOption;
 static double g_lastTappedTime;
 static double g_lastIncrementTime;
+static double g_lastIncrementSoundTime;
 
 static void ResetSelection()
 {
@@ -682,8 +683,13 @@ static void DrawConfigOption(int32_t rowIndex, float yOffset, ConfigDef<T>* conf
         bool fastIncrement = (time - g_lastTappedTime) > 0.5;
         constexpr double INCREMENT_TIME = 1.0 / 120.0;
 
+        constexpr double INCREMENT_SOUND_TIME = 1.0 / 7.5;
+        bool isPlayIncrementSound = true;
+
         if (fastIncrement)
         {
+            isPlayIncrementSound = (time - g_lastIncrementSoundTime) > INCREMENT_SOUND_TIME;
+
             if ((time - g_lastIncrementTime) < INCREMENT_TIME)
                 fastIncrement = false;
             else
@@ -747,8 +753,13 @@ static void DrawConfigOption(int32_t rowIndex, float yOffset, ConfigDef<T>* conf
                 deltaTime -= INCREMENT_TIME;
             } while (fastIncrement && deltaTime > 0.0f);
 
-            if ((increment || decrement) && (config->Value >= valueMin && config->Value <= valueMax))
+            bool isConfigValueInBounds = config->Value >= valueMin && config->Value <= valueMax;
+
+            if ((increment || decrement) && isConfigValueInBounds && isPlayIncrementSound) 
+            {
+                g_lastIncrementSoundTime = time;
                 Game_PlaySound("sys_actstg_twn_speechbutton");
+            }
 
             config->Value = std::clamp(config->Value, valueMin, valueMax);
         }
@@ -976,6 +987,8 @@ static void DrawInfoPanel()
             desc = buf;
         }
 
+        desc += "\n\n" + g_selectedItem->GetValueDescription();
+
         auto size = Scale(26.0f);
         auto textSize = g_seuratFont->CalcTextSizeA(size, FLT_MAX, 0.0f, desc.c_str());
 
diff --git a/UnleashedRecompLib/config/SWA.toml b/UnleashedRecompLib/config/SWA.toml
index 187729ec..de15070e 100644
--- a/UnleashedRecompLib/config/SWA.toml
+++ b/UnleashedRecompLib/config/SWA.toml
@@ -213,52 +213,52 @@ jump_address = 0x8247DD3C
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247DD48 # Slope
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247DDFC # Dash path binormal
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E280 # Target front offset
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E300 # Target
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E3C8 # Target
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E4A0 # Target up positive
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E4E8 # Target up negative
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247E9FC # Position
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247EA84 # Position up negative
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247EA50 # Position up positive
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraDeltaTimeFixMidAsmHook"
@@ -269,7 +269,7 @@ jump_address = 0x8247ED34
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247ED40 # Distance offset 1
-registers = ["f0", "f21"]
+registers = ["f0"]
 
 [[midasm_hook]]
 name = "CameraDeltaTimeFixMidAsmHook"
@@ -280,12 +280,12 @@ jump_address = 0x8247ED58
 [[midasm_hook]]
 name = "CameraLerpFixMidAsmHook"
 address = 0x8247ED64 # Distance offset 2
-registers = ["f13", "f21"]
+registers = ["f13"]
 
 [[midasm_hook]]
 name = "CameraTargetSideOffsetLerpFixMidAsmHook"
 address = 0x8247F12C # Target side offset
-registers = ["v13", "v62", "f21"]
+registers = ["v13", "v62"]
 
 # 2D camera HFR fixes
 [[midasm_hook]]