diff --git a/scwx-qt/source/scwx/qt/main/main_window.cpp b/scwx-qt/source/scwx/qt/main/main_window.cpp
index 6c51e615..e5326729 100644
--- a/scwx-qt/source/scwx/qt/main/main_window.cpp
+++ b/scwx-qt/source/scwx/qt/main/main_window.cpp
@@ -77,7 +77,7 @@ public:
       }
 
       std::string mapboxApiKey =
-         manager::SettingsManager::general_settings()->mapbox_api_key();
+         manager::SettingsManager::general_settings().mapbox_api_key();
 
       settings_.resetToTemplate(QMapLibreGL::Settings::MapboxSettings);
       settings_.setApiKey(QString {mapboxApiKey.c_str()});
@@ -172,7 +172,7 @@ MainWindow::MainWindow(QWidget* parent) :
    ui->actionAlerts->setVisible(false);
 
    ui->menuDebug->menuAction()->setVisible(
-      manager::SettingsManager::general_settings()->debug_enabled());
+      manager::SettingsManager::general_settings().debug_enabled());
 
    // Configure Resource Explorer Dock
    ui->resourceExplorerDock->setVisible(false);
@@ -211,12 +211,12 @@ MainWindow::MainWindow(QWidget* parent) :
    // ImGui Debug Dialog
    p->imGuiDebugDialog_ = new ui::ImGuiDebugDialog(this);
 
-   auto mapSettings = manager::SettingsManager::map_settings();
+   auto& mapSettings = manager::SettingsManager::map_settings();
    for (size_t i = 0; i < p->maps_.size(); i++)
    {
       p->SelectRadarProduct(p->maps_.at(i),
-                            mapSettings->radar_product_group(i),
-                            mapSettings->radar_product(i),
+                            mapSettings.radar_product_group(i),
+                            mapSettings.radar_product(i),
                             0);
    }
 
@@ -365,10 +365,10 @@ void MainWindow::on_resourceTreeExpandAllButton_clicked()
 
 void MainWindowImpl::ConfigureMapLayout()
 {
-   auto generalSettings = manager::SettingsManager::general_settings();
+   auto& generalSettings = manager::SettingsManager::general_settings();
 
-   const int64_t gridWidth  = generalSettings->grid_width();
-   const int64_t gridHeight = generalSettings->grid_height();
+   const int64_t gridWidth  = generalSettings.grid_width();
+   const int64_t gridHeight = generalSettings.grid_height();
    const int64_t mapCount   = gridWidth * gridHeight;
 
    size_t mapIndex = 0;
diff --git a/scwx-qt/source/scwx/qt/manager/resource_manager.cpp b/scwx-qt/source/scwx/qt/manager/resource_manager.cpp
index ac719023..839e07ea 100644
--- a/scwx-qt/source/scwx/qt/manager/resource_manager.cpp
+++ b/scwx-qt/source/scwx/qt/manager/resource_manager.cpp
@@ -1,6 +1,5 @@
 #include <scwx/qt/manager/resource_manager.hpp>
 #include <scwx/qt/config/county_database.hpp>
-#include <scwx/qt/manager/settings_manager.hpp>
 #include <scwx/qt/model/imgui_context_model.hpp>
 #include <scwx/qt/util/font.hpp>
 #include <scwx/qt/util/texture_atlas.hpp>
@@ -37,12 +36,8 @@ static void LoadFonts()
    util::Font::Create(":/res/fonts/din1451alt.ttf");
    util::Font::Create(":/res/fonts/din1451alt_g.ttf");
 
-   if (manager::SettingsManager::general_settings()->debug_enabled())
-   {
-      ImFontAtlas* fontAtlas =
-         model::ImGuiContextModel::Instance().font_atlas();
-      fontAtlas->AddFontDefault();
-   }
+   ImFontAtlas* fontAtlas = model::ImGuiContextModel::Instance().font_atlas();
+   fontAtlas->AddFontDefault();
 }
 
 static void LoadTextures()
diff --git a/scwx-qt/source/scwx/qt/manager/settings_manager.cpp b/scwx-qt/source/scwx/qt/manager/settings_manager.cpp
index 3cc51275..4063fb0c 100644
--- a/scwx-qt/source/scwx/qt/manager/settings_manager.cpp
+++ b/scwx-qt/source/scwx/qt/manager/settings_manager.cpp
@@ -20,14 +20,6 @@ namespace SettingsManager
 static const std::string logPrefix_ = "scwx::qt::manager::settings_manager";
 static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
 
-static const std::string kGeneralKey = "general";
-static const std::string kMapKey     = "maps";
-static const std::string kPaletteKey = "palette";
-
-static std::shared_ptr<settings::GeneralSettings> generalSettings_ = nullptr;
-static std::shared_ptr<settings::MapSettings>     mapSettings_     = nullptr;
-static std::shared_ptr<settings::PaletteSettings> paletteSettings_ = nullptr;
-
 static boost::json::value ConvertSettingsToJson();
 static void               GenerateDefaultSettings();
 static bool               LoadSettings(const boost::json::object& settingsJson);
@@ -79,18 +71,21 @@ void ReadSettings(const std::string& settingsPath)
    };
 }
 
-std::shared_ptr<settings::GeneralSettings> general_settings()
+settings::GeneralSettings& general_settings()
 {
+   static settings::GeneralSettings generalSettings_;
    return generalSettings_;
 }
 
-std::shared_ptr<settings::MapSettings> map_settings()
+settings::MapSettings& map_settings()
 {
+   static settings::MapSettings mapSettings_;
    return mapSettings_;
 }
 
-std::shared_ptr<settings::PaletteSettings> palette_settings()
+settings::PaletteSettings& palette_settings()
 {
+   static settings::PaletteSettings paletteSettings_;
    return paletteSettings_;
 }
 
@@ -98,9 +93,9 @@ static boost::json::value ConvertSettingsToJson()
 {
    boost::json::object settingsJson;
 
-   generalSettings_->WriteJson(settingsJson);
-   settingsJson[kMapKey]     = mapSettings_->ToJson();
-   settingsJson[kPaletteKey] = paletteSettings_->ToJson();
+   general_settings().WriteJson(settingsJson);
+   map_settings().WriteJson(settingsJson);
+   palette_settings().WriteJson(settingsJson);
 
    return settingsJson;
 }
@@ -109,9 +104,9 @@ static void GenerateDefaultSettings()
 {
    logger_->info("Generating default settings");
 
-   generalSettings_ = std::make_shared<settings::GeneralSettings>();
-   mapSettings_     = settings::MapSettings::Create();
-   paletteSettings_ = settings::PaletteSettings::Create();
+   general_settings().SetDefaults();
+   map_settings().SetDefaults();
+   palette_settings().SetDefaults();
 }
 
 static bool LoadSettings(const boost::json::object& settingsJson)
@@ -120,13 +115,9 @@ static bool LoadSettings(const boost::json::object& settingsJson)
 
    bool jsonDirty = false;
 
-   generalSettings_ = std::make_shared<settings::GeneralSettings>();
-
-   jsonDirty |= !generalSettings_->ReadJson(settingsJson);
-   mapSettings_ =
-      settings::MapSettings::Load(settingsJson.if_contains(kMapKey), jsonDirty);
-   paletteSettings_ = settings::PaletteSettings::Load(
-      settingsJson.if_contains(kPaletteKey), jsonDirty);
+   jsonDirty |= !general_settings().ReadJson(settingsJson);
+   jsonDirty |= !map_settings().ReadJson(settingsJson);
+   jsonDirty |= !palette_settings().ReadJson(settingsJson);
 
    return jsonDirty;
 }
diff --git a/scwx-qt/source/scwx/qt/manager/settings_manager.hpp b/scwx-qt/source/scwx/qt/manager/settings_manager.hpp
index 64dcc692..df4f6919 100644
--- a/scwx-qt/source/scwx/qt/manager/settings_manager.hpp
+++ b/scwx-qt/source/scwx/qt/manager/settings_manager.hpp
@@ -16,9 +16,9 @@ namespace SettingsManager
 void Initialize();
 void ReadSettings(const std::string& settingsPath);
 
-std::shared_ptr<settings::GeneralSettings> general_settings();
-std::shared_ptr<settings::MapSettings>     map_settings();
-std::shared_ptr<settings::PaletteSettings> palette_settings();
+settings::GeneralSettings& general_settings();
+settings::MapSettings&     map_settings();
+settings::PaletteSettings& palette_settings();
 
 } // namespace SettingsManager
 } // namespace manager
diff --git a/scwx-qt/source/scwx/qt/map/map_widget.cpp b/scwx-qt/source/scwx/qt/map/map_widget.cpp
index 4f015e62..e2817192 100644
--- a/scwx-qt/source/scwx/qt/map/map_widget.cpp
+++ b/scwx-qt/source/scwx/qt/map/map_widget.cpp
@@ -81,7 +81,7 @@ public:
        prevPitch_ {0.0}
    {
       SetRadarSite(scwx::qt::manager::SettingsManager::general_settings()
-                      ->default_radar_site());
+                      .default_radar_site());
 
       // Create ImGui Context
       static size_t currentMapId_ {0u};
@@ -835,7 +835,7 @@ void MapWidgetImpl::InitializeNewRadarProductView(
          auto radarProductView = context_->radar_product_view();
 
          std::string colorTableFile =
-            manager::SettingsManager::palette_settings()->palette(colorPalette);
+            manager::SettingsManager::palette_settings().palette(colorPalette);
          if (!colorTableFile.empty())
          {
             std::shared_ptr<common::ColorTable> colorTable =
diff --git a/scwx-qt/source/scwx/qt/settings/general_settings.cpp b/scwx-qt/source/scwx/qt/settings/general_settings.cpp
index 01ec05f6..4506f9fb 100644
--- a/scwx-qt/source/scwx/qt/settings/general_settings.cpp
+++ b/scwx-qt/source/scwx/qt/settings/general_settings.cpp
@@ -1,7 +1,4 @@
 #include <scwx/qt/settings/general_settings.hpp>
-#include <scwx/qt/util/json.hpp>
-#include <scwx/util/logger.hpp>
-
 #include <scwx/qt/settings/settings_container.hpp>
 
 namespace scwx
@@ -12,7 +9,6 @@ namespace settings
 {
 
 static const std::string logPrefix_ = "scwx::qt::settings::general_settings";
-static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
 
 class GeneralSettingsImpl
 {
diff --git a/scwx-qt/source/scwx/qt/settings/map_settings.cpp b/scwx-qt/source/scwx/qt/settings/map_settings.cpp
index 7dd3d7e1..06f25bd1 100644
--- a/scwx-qt/source/scwx/qt/settings/map_settings.cpp
+++ b/scwx-qt/source/scwx/qt/settings/map_settings.cpp
@@ -1,5 +1,6 @@
 #include <scwx/qt/settings/map_settings.hpp>
 #include <scwx/qt/config/radar_site.hpp>
+#include <scwx/qt/settings/settings_variable.hpp>
 #include <scwx/qt/util/json.hpp>
 #include <scwx/util/logger.hpp>
 
@@ -16,11 +17,16 @@ namespace settings
 static const std::string logPrefix_ = "scwx::qt::settings::map_settings";
 static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
 
-static constexpr size_t  kCount_            = 4u;
-static const std::string kDefaultRadarSite_ = "KLSX";
+static constexpr std::size_t kCount_            = 4u;
+static const std::string     kDefaultRadarSite_ = "KLSX";
 
-static const common::RadarProductGroup kDefaultRadarProductGroup_ =
+static const std::string kRadarSiteName_ {"radar_site"};
+static const std::string kRadarProductGroupName_ {"radar_product_group"};
+static const std::string kRadarProductName_ {"radar_product"};
+
+static constexpr common::RadarProductGroup kDefaultRadarProductGroup_ =
    common::RadarProductGroup::Level3;
+static const std::string kDefaultRadarProductGroupString_ = "L3";
 static const std::array<std::string, kCount_> kDefaultRadarProduct_ {
    "N0B", "N0G", "N0C", "N0X"};
 
@@ -29,180 +35,182 @@ class MapSettingsImpl
 public:
    struct MapData
    {
-      std::string               radarSite_;
-      common::RadarProductGroup radarProductGroup_;
-      std::string               radarProduct_;
+      SettingsVariable<std::string> radarSite_ {kRadarSiteName_};
+      SettingsVariable<std::string> radarProductGroup_ {
+         kRadarProductGroupName_};
+      SettingsVariable<std::string> radarProduct_ {kRadarProductName_};
    };
 
-   explicit MapSettingsImpl() { SetDefaults(); }
-
-   ~MapSettingsImpl() {}
-
-   void SetDefaults(size_t i)
+   explicit MapSettingsImpl()
    {
-      map_[i].radarSite_         = kDefaultRadarSite_;
-      map_[i].radarProductGroup_ = kDefaultRadarProductGroup_;
-      map_[i].radarProduct_      = kDefaultRadarProduct_[i];
-   }
-
-   void SetDefaults()
-   {
-      for (size_t i = 0; i < kCount_; i++)
+      for (std::size_t i = 0; i < kCount_; i++)
       {
-         SetDefaults(i);
+         map_[i].radarSite_.SetDefault(kDefaultRadarSite_);
+         map_[i].radarProductGroup_.SetDefault(
+            kDefaultRadarProductGroupString_);
+         map_[i].radarProduct_.SetDefault(kDefaultRadarProduct_[i]);
+
+         map_[i].radarSite_.SetValidator(
+            [](const std::string& value)
+            {
+               // Radar site must exist
+               return config::RadarSite::Get(value) != nullptr;
+            });
+
+         map_[i].radarProductGroup_.SetValidator(
+            [](const std::string& value)
+            {
+               // Radar product group must be valid
+               common::RadarProductGroup radarProductGroup =
+                  common::GetRadarProductGroup(value);
+               return radarProductGroup != common::RadarProductGroup::Unknown;
+            });
+
+         map_[i].radarProduct_.SetValidator(
+            [this, i](const std::string& value)
+            {
+               common::RadarProductGroup radarProductGroup =
+                  common::GetRadarProductGroup(
+                     map_[i].radarProductGroup_.GetValue());
+
+               if (radarProductGroup == common::RadarProductGroup::Level2)
+               {
+                  // Radar product must be valid
+                  return common::GetLevel2Product(value) !=
+                         common::Level2Product::Unknown;
+               }
+               else
+               {
+                  // TODO: Validate level 3 product
+                  return true;
+               }
+            });
+
+         variables_.insert(variables_.cend(),
+                           {&map_[i].radarSite_,
+                            &map_[i].radarProductGroup_,
+                            &map_[i].radarProduct_});
       }
    }
 
-   std::array<MapData, kCount_> map_;
+   ~MapSettingsImpl() {}
+
+   void SetDefaults(std::size_t i)
+   {
+      map_[i].radarSite_.SetValueToDefault();
+      map_[i].radarProductGroup_.SetValueToDefault();
+      map_[i].radarProduct_.SetValueToDefault();
+   }
+
+   std::array<MapData, kCount_>       map_ {};
+   std::vector<SettingsVariableBase*> variables_ {};
 };
 
-MapSettings::MapSettings() : p(std::make_unique<MapSettingsImpl>()) {}
+MapSettings::MapSettings() :
+    SettingsCategory("maps"), p(std::make_unique<MapSettingsImpl>())
+{
+   RegisterVariables(p->variables_);
+   SetDefaults();
+
+   p->variables_.clear();
+}
 MapSettings::~MapSettings() = default;
 
 MapSettings::MapSettings(MapSettings&&) noexcept            = default;
 MapSettings& MapSettings::operator=(MapSettings&&) noexcept = default;
 
-size_t MapSettings::count() const
+std::size_t MapSettings::count() const
 {
    return kCount_;
 }
 
-std::string MapSettings::radar_site(size_t i) const
+std::string MapSettings::radar_site(std::size_t i) const
 {
-   return p->map_[i].radarSite_;
+   return p->map_[i].radarSite_.GetValue();
 }
 
-common::RadarProductGroup MapSettings::radar_product_group(size_t i) const
+common::RadarProductGroup MapSettings::radar_product_group(std::size_t i) const
 {
-   return p->map_[i].radarProductGroup_;
+   return common::GetRadarProductGroup(
+      p->map_[i].radarProductGroup_.GetValue());
 }
 
-std::string MapSettings::radar_product(size_t i) const
+std::string MapSettings::radar_product(std::size_t i) const
 {
-   return p->map_[i].radarProduct_;
+   return p->map_[i].radarProduct_.GetValue();
 }
 
-boost::json::value MapSettings::ToJson() const
+bool MapSettings::ReadJson(const boost::json::object& json)
 {
-   boost::json::value json;
+   bool validated = true;
 
-   json = boost::json::value_from(p->map_);
+   const boost::json::value* value = json.if_contains(name());
 
-   return json;
-}
-
-std::shared_ptr<MapSettings> MapSettings::Create()
-{
-   std::shared_ptr<MapSettings> generalSettings =
-      std::make_shared<MapSettings>();
-
-   generalSettings->p->SetDefaults();
-
-   return generalSettings;
-}
-
-std::shared_ptr<MapSettings> MapSettings::Load(const boost::json::value* json,
-                                               bool& jsonDirty)
-{
-   std::shared_ptr<MapSettings> mapSettings = std::make_shared<MapSettings>();
-
-   if (json != nullptr && json->is_array())
+   if (value != nullptr && value->is_array())
    {
-      const boost::json::array& mapArray = json->as_array();
+      const boost::json::array& mapArray = value->as_array();
 
-      for (size_t i = 0; i < kCount_; ++i)
+      for (std::size_t i = 0; i < kCount_; ++i)
       {
          if (i < mapArray.size() && mapArray.at(i).is_object())
          {
             const boost::json::object& mapRecord = mapArray.at(i).as_object();
-            MapSettingsImpl::MapData&  mapRecordSettings =
-               mapSettings->p->map_[i];
-
-            std::string radarProductGroup;
+            MapSettingsImpl::MapData&  mapRecordSettings = p->map_[i];
 
             // Load JSON Elements
-            jsonDirty |=
-               !util::json::FromJsonString(mapRecord,
-                                           "radar_site",
-                                           mapRecordSettings.radarSite_,
-                                           kDefaultRadarSite_);
-            jsonDirty |= !util::json::FromJsonString(mapRecord,
-                                                     "radar_product_group",
-                                                     radarProductGroup,
-                                                     kDefaultRadarSite_);
-            jsonDirty |=
-               !util::json::FromJsonString(mapRecord,
-                                           "radar_product",
-                                           mapRecordSettings.radarProduct_,
-                                           kDefaultRadarProduct_[i]);
+            validated &= mapRecordSettings.radarSite_.ReadValue(mapRecord);
+            validated &=
+               mapRecordSettings.radarProductGroup_.ReadValue(mapRecord);
 
-            // Validate Radar Site
-            if (config::RadarSite::Get(mapRecordSettings.radarSite_) == nullptr)
+            bool productValidated =
+               mapRecordSettings.radarProduct_.ReadValue(mapRecord);
+            if (!productValidated)
             {
-               mapRecordSettings.radarSite_ = kDefaultRadarSite_;
-               jsonDirty                    = true;
+               // Product was set to default, reset group to default to match
+               mapRecordSettings.radarProductGroup_.SetValueToDefault();
+               validated = false;
             }
-
-            // Validate Radar Product Group
-            mapRecordSettings.radarProductGroup_ =
-               common::GetRadarProductGroup(radarProductGroup);
-            if (mapRecordSettings.radarProductGroup_ ==
-                common::RadarProductGroup::Unknown)
-            {
-               mapRecordSettings.radarProductGroup_ =
-                  kDefaultRadarProductGroup_;
-               jsonDirty = true;
-            }
-
-            // Validate Radar Product
-            if (mapRecordSettings.radarProductGroup_ ==
-                   common::RadarProductGroup::Level2 &&
-                common::GetLevel2Product(mapRecordSettings.radarProduct_) ==
-                   common::Level2Product::Unknown)
-            {
-               mapRecordSettings.radarProductGroup_ =
-                  kDefaultRadarProductGroup_;
-               mapRecordSettings.radarProduct_ = kDefaultRadarProduct_[i];
-               jsonDirty                       = true;
-            }
-
-            // TODO: Validate level 3 product
          }
          else
          {
             logger_->warn(
                "Too few array entries, resetting record {} to defaults", i + 1);
-            jsonDirty = true;
-            mapSettings->p->SetDefaults(i);
+            validated = false;
+            p->SetDefaults(i);
          }
       }
    }
    else
    {
-      if (json == nullptr)
+      if (value == nullptr)
       {
          logger_->warn("Key is not present, resetting to defaults");
       }
-      else if (!json->is_array())
+      else if (!value->is_array())
       {
          logger_->warn("Invalid json, resetting to defaults");
       }
 
-      mapSettings->p->SetDefaults();
-      jsonDirty = true;
+      SetDefaults();
+      validated = false;
    }
 
-   return mapSettings;
+   return validated;
+}
+
+void MapSettings::WriteJson(boost::json::object& json) const
+{
+   boost::json::value object = boost::json::value_from(p->map_);
+   json.insert_or_assign(name(), object);
 }
 
 void tag_invoke(boost::json::value_from_tag,
                 boost::json::value&             jv,
                 const MapSettingsImpl::MapData& data)
 {
-   jv = {{"radar_site", data.radarSite_},
-         {"radar_product_group",
-          common::GetRadarProductGroupName(data.radarProductGroup_)},
-         {"radar_product", data.radarProduct_}};
+   jv = {{kRadarSiteName_, data.radarSite_.GetValue()},
+         {kRadarProductGroupName_, data.radarProductGroup_.GetValue()},
+         {kRadarProductName_, data.radarProduct_.GetValue()}};
 }
 
 bool operator==(const MapSettings& lhs, const MapSettings& rhs)
diff --git a/scwx-qt/source/scwx/qt/settings/map_settings.hpp b/scwx-qt/source/scwx/qt/settings/map_settings.hpp
index 75ed3598..299eaf82 100644
--- a/scwx-qt/source/scwx/qt/settings/map_settings.hpp
+++ b/scwx-qt/source/scwx/qt/settings/map_settings.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
 #include <scwx/common/products.hpp>
+#include <scwx/qt/settings/settings_category.hpp>
 
 #include <memory>
 #include <string>
 
-#include <boost/json.hpp>
-
 namespace scwx
 {
 namespace qt
@@ -16,28 +15,39 @@ namespace settings
 
 class MapSettingsImpl;
 
-class MapSettings
+class MapSettings : public SettingsCategory
 {
 public:
    explicit MapSettings();
    ~MapSettings();
 
-   MapSettings(const MapSettings&) = delete;
+   MapSettings(const MapSettings&)            = delete;
    MapSettings& operator=(const MapSettings&) = delete;
 
    MapSettings(MapSettings&&) noexcept;
    MapSettings& operator=(MapSettings&&) noexcept;
 
-   size_t                    count() const;
-   std::string               radar_site(size_t i) const;
-   common::RadarProductGroup radar_product_group(size_t i) const;
-   std::string               radar_product(size_t i) const;
+   std::size_t               count() const;
+   std::string               radar_site(std::size_t i) const;
+   common::RadarProductGroup radar_product_group(std::size_t i) const;
+   std::string               radar_product(std::size_t i) const;
 
-   boost::json::value ToJson() const;
+   /**
+    * Reads the variables from the JSON object.
+    *
+    * @param json JSON object to read
+    *
+    * @return true if the values read are valid, false if any values were
+    * modified.
+    */
+   bool ReadJson(const boost::json::object& json) override;
 
-   static std::shared_ptr<MapSettings> Create();
-   static std::shared_ptr<MapSettings> Load(const boost::json::value* json,
-                                            bool& jsonDirty);
+   /**
+    * Writes the variables to the JSON object.
+    *
+    * @param json JSON object to write
+    */
+   void WriteJson(boost::json::object& json) const override;
 
    friend bool operator==(const MapSettings& lhs, const MapSettings& rhs);
 
diff --git a/scwx-qt/source/scwx/qt/settings/palette_settings.cpp b/scwx-qt/source/scwx/qt/settings/palette_settings.cpp
index 241e0048..a0146e58 100644
--- a/scwx-qt/source/scwx/qt/settings/palette_settings.cpp
+++ b/scwx-qt/source/scwx/qt/settings/palette_settings.cpp
@@ -1,6 +1,5 @@
 #include <scwx/qt/settings/palette_settings.hpp>
-#include <scwx/qt/util/json.hpp>
-#include <scwx/util/logger.hpp>
+#include <scwx/qt/settings/settings_variable.hpp>
 
 namespace scwx
 {
@@ -10,7 +9,6 @@ namespace settings
 {
 
 static const std::string logPrefix_ = "scwx::qt::settings::palette_settings";
-static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
 
 static const std::vector<std::string> paletteNames_ = {
    // Level 2 / Common Products
@@ -33,29 +31,43 @@ static const std::vector<std::string> paletteNames_ = {
    "VIL",
    "???"};
 
-static const std::string DEFAULT_KEY     = "Default";
-static const std::string DEFAULT_PALETTE = "";
+static const std::string kDefaultKey     = "???";
+static const std::string kDefaultPalette = "";
 
 class PaletteSettingsImpl
 {
 public:
-   explicit PaletteSettingsImpl() {}
-
-   ~PaletteSettingsImpl() {}
-
-   void SetDefaults()
+   explicit PaletteSettingsImpl()
    {
       std::for_each(paletteNames_.cbegin(),
                     paletteNames_.cend(),
                     [&](const std::string& name)
-                    { palette_[name] = DEFAULT_PALETTE; });
+                    {
+                       auto result = palette_.emplace(
+                          name, SettingsVariable<std::string> {name});
+
+                       SettingsVariable<std::string>& settingsVariable =
+                          result.first->second;
+
+                       settingsVariable.SetDefault(kDefaultPalette);
+
+                       variables_.push_back(&settingsVariable);
+                    });
    }
 
-   std::unordered_map<std::string, std::string> palette_;
+   ~PaletteSettingsImpl() {}
+
+   std::unordered_map<std::string, SettingsVariable<std::string>> palette_;
+   std::vector<SettingsVariableBase*>                             variables_;
 };
 
-PaletteSettings::PaletteSettings() : p(std::make_unique<PaletteSettingsImpl>())
+PaletteSettings::PaletteSettings() :
+    SettingsCategory("palette"), p(std::make_unique<PaletteSettingsImpl>())
 {
+   RegisterVariables(p->variables_);
+   SetDefaults();
+
+   p->variables_.clear();
 }
 PaletteSettings::~PaletteSettings() = default;
 
@@ -63,80 +75,21 @@ PaletteSettings::PaletteSettings(PaletteSettings&&) noexcept = default;
 PaletteSettings&
 PaletteSettings::operator=(PaletteSettings&&) noexcept = default;
 
-const std::string& PaletteSettings::palette(const std::string& name) const
+std::string PaletteSettings::palette(const std::string& name) const
 {
    auto palette = p->palette_.find(name);
 
    if (palette == p->palette_.cend())
    {
-      palette = p->palette_.find("Default");
+      palette = p->palette_.find(kDefaultKey);
    }
 
    if (palette == p->palette_.cend())
    {
-      return DEFAULT_PALETTE;
+      return kDefaultPalette;
    }
 
-   return palette->second;
-}
-
-boost::json::value PaletteSettings::ToJson() const
-{
-   boost::json::object json;
-
-   std::for_each(paletteNames_.cbegin(),
-                 paletteNames_.cend(),
-                 [&](const std::string& name)
-                 { json[name] = p->palette_[name]; });
-
-   return json;
-}
-
-std::shared_ptr<PaletteSettings> PaletteSettings::Create()
-{
-   std::shared_ptr<PaletteSettings> generalSettings =
-      std::make_shared<PaletteSettings>();
-
-   generalSettings->p->SetDefaults();
-
-   return generalSettings;
-}
-
-std::shared_ptr<PaletteSettings>
-PaletteSettings::Load(const boost::json::value* json, bool& jsonDirty)
-{
-   std::shared_ptr<PaletteSettings> generalSettings =
-      std::make_shared<PaletteSettings>();
-
-   if (json != nullptr && json->is_object())
-   {
-      std::for_each(paletteNames_.cbegin(),
-                    paletteNames_.cend(),
-                    [&](const std::string& name)
-                    {
-                       jsonDirty |= !util::json::FromJsonString(
-                          json->as_object(),
-                          name,
-                          generalSettings->p->palette_[name],
-                          DEFAULT_PALETTE);
-                    });
-   }
-   else
-   {
-      if (json == nullptr)
-      {
-         logger_->warn("Key is not present, resetting to defaults");
-      }
-      else if (!json->is_object())
-      {
-         logger_->warn("Invalid json, resetting to defaults");
-      }
-
-      generalSettings->p->SetDefaults();
-      jsonDirty = true;
-   }
-
-   return generalSettings;
+   return palette->second.GetValue();
 }
 
 bool operator==(const PaletteSettings& lhs, const PaletteSettings& rhs)
diff --git a/scwx-qt/source/scwx/qt/settings/palette_settings.hpp b/scwx-qt/source/scwx/qt/settings/palette_settings.hpp
index d032a380..d67ded18 100644
--- a/scwx-qt/source/scwx/qt/settings/palette_settings.hpp
+++ b/scwx-qt/source/scwx/qt/settings/palette_settings.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
+#include <scwx/qt/settings/settings_category.hpp>
+
 #include <memory>
 #include <string>
 
-#include <boost/json.hpp>
-
 namespace scwx
 {
 namespace qt
@@ -14,25 +14,19 @@ namespace settings
 
 class PaletteSettingsImpl;
 
-class PaletteSettings
+class PaletteSettings : public SettingsCategory
 {
 public:
    explicit PaletteSettings();
    ~PaletteSettings();
 
-   PaletteSettings(const PaletteSettings&) = delete;
+   PaletteSettings(const PaletteSettings&)            = delete;
    PaletteSettings& operator=(const PaletteSettings&) = delete;
 
    PaletteSettings(PaletteSettings&&) noexcept;
    PaletteSettings& operator=(PaletteSettings&&) noexcept;
 
-   const std::string& palette(const std::string& name) const;
-
-   boost::json::value ToJson() const;
-
-   static std::shared_ptr<PaletteSettings> Create();
-   static std::shared_ptr<PaletteSettings> Load(const boost::json::value* json,
-                                                bool& jsonDirty);
+   std::string palette(const std::string& name) const;
 
    friend bool operator==(const PaletteSettings& lhs,
                           const PaletteSettings& rhs);
diff --git a/scwx-qt/source/scwx/qt/settings/settings_category.cpp b/scwx-qt/source/scwx/qt/settings/settings_category.cpp
index cce10c6c..75daf41d 100644
--- a/scwx-qt/source/scwx/qt/settings/settings_category.cpp
+++ b/scwx-qt/source/scwx/qt/settings/settings_category.cpp
@@ -34,6 +34,11 @@ SettingsCategory::SettingsCategory(SettingsCategory&&) noexcept = default;
 SettingsCategory&
 SettingsCategory::operator=(SettingsCategory&&) noexcept = default;
 
+std::string SettingsCategory::name() const
+{
+   return p->name_;
+}
+
 void SettingsCategory::SetDefaults()
 {
    for (auto& variable : p->variables_)
@@ -95,6 +100,13 @@ void SettingsCategory::RegisterVariables(
    p->variables_.insert(p->variables_.end(), variables);
 }
 
+void SettingsCategory::RegisterVariables(
+   std::vector<SettingsVariableBase*> variables)
+{
+   p->variables_.insert(
+      p->variables_.end(), variables.cbegin(), variables.cend());
+}
+
 } // namespace settings
 } // namespace qt
 } // namespace scwx
diff --git a/scwx-qt/source/scwx/qt/settings/settings_category.hpp b/scwx-qt/source/scwx/qt/settings/settings_category.hpp
index 3ead3dae..cc07a7d7 100644
--- a/scwx-qt/source/scwx/qt/settings/settings_category.hpp
+++ b/scwx-qt/source/scwx/qt/settings/settings_category.hpp
@@ -26,10 +26,12 @@ public:
    SettingsCategory(SettingsCategory&&) noexcept;
    SettingsCategory& operator=(SettingsCategory&&) noexcept;
 
+   std::string name() const;
+
    /**
     * Set all variables to their defaults.
     */
-   virtual void SetDefaults();
+   void SetDefaults();
 
    /**
     * Reads the variables from the JSON object.
@@ -51,6 +53,7 @@ public:
 protected:
    void
    RegisterVariables(std::initializer_list<SettingsVariableBase*> variables);
+   void RegisterVariables(std::vector<SettingsVariableBase*> variables);
 
 private:
    class Impl;
diff --git a/scwx-qt/source/scwx/qt/util/font.cpp b/scwx-qt/source/scwx/qt/util/font.cpp
index 939838c7..8e49369a 100644
--- a/scwx-qt/source/scwx/qt/util/font.cpp
+++ b/scwx-qt/source/scwx/qt/util/font.cpp
@@ -311,7 +311,7 @@ std::shared_ptr<Font> Font::Create(const std::string& resource)
    font->p->CreateImGuiFont(
       fontFile,
       fontData,
-      manager::SettingsManager::general_settings()->font_sizes());
+      manager::SettingsManager::general_settings().font_sizes());
 
    font->p->atlas_                   = ftgl::texture_atlas_new(512, 512, 1);
    ftgl::texture_font_t* textureFont = ftgl::texture_font_new_from_memory(
diff --git a/test/source/scwx/qt/manager/settings_manager.test.cpp b/test/source/scwx/qt/manager/settings_manager.test.cpp
index d4535bdf..f946fdfe 100644
--- a/test/source/scwx/qt/manager/settings_manager.test.cpp
+++ b/test/source/scwx/qt/manager/settings_manager.test.cpp
@@ -36,13 +36,13 @@ class BadSettingsTest :
 
 void VerifyDefaults()
 {
-   std::shared_ptr<settings::GeneralSettings> defaultGeneralSettings =
-      std::make_shared<settings::GeneralSettings>();
-   std::shared_ptr<settings::PaletteSettings> defaultPaletteSettings =
-      settings::PaletteSettings::Create();
+   settings::GeneralSettings defaultGeneralSettings {};
+   settings::MapSettings     defaultMapSettings {};
+   settings::PaletteSettings defaultPaletteSettings {};
 
-   EXPECT_EQ(*defaultGeneralSettings, *SettingsManager::general_settings());
-   EXPECT_EQ(*defaultPaletteSettings, *SettingsManager::palette_settings());
+   EXPECT_EQ(defaultGeneralSettings, SettingsManager::general_settings());
+   EXPECT_EQ(defaultMapSettings, SettingsManager::map_settings());
+   EXPECT_EQ(defaultPaletteSettings, SettingsManager::palette_settings());
 }
 
 void CompareFiles(const std::string& file1, const std::string& file2)
@@ -85,10 +85,10 @@ TEST_F(SettingsManagerTest, SettingsKeax)
 
    SettingsManager::ReadSettings(filename);
 
-   EXPECT_EQ(SettingsManager::general_settings()->default_radar_site(), "KEAX");
-   for (size_t i = 0; i < SettingsManager::map_settings()->count(); ++i)
+   EXPECT_EQ(SettingsManager::general_settings().default_radar_site(), "KEAX");
+   for (size_t i = 0; i < SettingsManager::map_settings().count(); ++i)
    {
-      EXPECT_EQ(SettingsManager::map_settings()->radar_site(i), "KEAX");
+      EXPECT_EQ(SettingsManager::map_settings().radar_site(i), "KEAX");
    }
 }