diff --git a/include/loot/api.h b/include/loot/api.h
index ef8d927d..1aaf7fec 100644
--- a/include/loot/api.h
+++ b/include/loot/api.h
@@ -105,7 +105,7 @@ LOOT_API bool IsCompatible(const unsigned int major,
  *        variable (eg. Linux) can still use the API.
  * @returns The new game handle.
  */
-LOOT_API std::shared_ptr<GameInterface> CreateGameHandle(
+LOOT_API std::unique_ptr<GameInterface> CreateGameHandle(
     const GameType game,
     const std::filesystem::path& game_path,
     const std::filesystem::path& game_local_path = "");
diff --git a/include/loot/game_interface.h b/include/loot/game_interface.h
index 588c7238..8770a355 100644
--- a/include/loot/game_interface.h
+++ b/include/loot/game_interface.h
@@ -33,6 +33,8 @@ namespace loot {
 /** @brief The interface provided for accessing game-specific functionality. */
 class GameInterface {
 public:
+  virtual ~GameInterface() = default;
+
   /**
    *  @name Metadata Access
    *  @{
@@ -41,9 +43,10 @@ public:
   /**
    * @brief Get the database interface used for accessing metadata-related
    *        functionality.
-   * @returns A shared pointer to the game's DatabaseInterface
+   * @returns A reference to the game's DatabaseInterface. The reference remains
+   *          valid for the lifetime of the GameInterface instance.
    */
-  virtual std::shared_ptr<DatabaseInterface> GetDatabase() = 0;
+  virtual DatabaseInterface& GetDatabase() = 0;
 
   /**
    * @}
@@ -84,7 +87,7 @@ public:
    * @returns A shared pointer to a const PluginInterface implementation. The
    *          pointer is null if the given plugin has not been loaded.
    */
-  virtual std::shared_ptr<const PluginInterface> GetPlugin(
+  virtual const PluginInterface* GetPlugin(
       const std::string& pluginName) const = 0;
 
   /**
@@ -94,8 +97,7 @@ public:
    *          valid until the ``LoadPlugins()`` or ``SortPlugins()`` functions
    *          are next called or this GameInterface is destroyed.
    */
-  virtual std::vector<std::shared_ptr<const PluginInterface>> GetLoadedPlugins()
-      const = 0;
+  virtual std::vector<const PluginInterface*> GetLoadedPlugins() const = 0;
 
   /**
    *  @}
diff --git a/src/api/api.cpp b/src/api/api.cpp
index 7d84d1d0..760a1ba0 100644
--- a/src/api/api.cpp
+++ b/src/api/api.cpp
@@ -72,7 +72,7 @@ LOOT_API bool IsCompatible(const unsigned int versionMajor,
     return versionMinor == loot::LootVersion::minor;
 }
 
-LOOT_API std::shared_ptr<GameInterface> CreateGameHandle(
+LOOT_API std::unique_ptr<GameInterface> CreateGameHandle(
     const GameType game,
     const std::filesystem::path& gamePath,
     const std::filesystem::path& gameLocalPath) {
@@ -96,6 +96,6 @@ LOOT_API std::shared_ptr<GameInterface> CreateGameHandle(
                                 gameLocalPath.u8string() +
                                 "\" does not resolve to a valid directory.");
 
-  return std::make_shared<Game>(game, resolvedGamePath, resolvedGameLocalPath);
+  return std::make_unique<Game>(game, resolvedGamePath, resolvedGameLocalPath);
 }
 }
diff --git a/src/api/api_database.h b/src/api/api_database.h
index a69b8ac7..df789820 100644
--- a/src/api/api_database.h
+++ b/src/api/api_database.h
@@ -29,8 +29,6 @@
 #include <string>
 #include <vector>
 
-#include "api/game/game_cache.h"
-#include "api/game/load_order_handler.h"
 #include "api/metadata/condition_evaluator.h"
 #include "api/metadata_list.h"
 #include "loot/database_interface.h"
diff --git a/src/api/game/game.cpp b/src/api/game/game.cpp
index 70e2efe6..f59fb9ed 100644
--- a/src/api/game/game.cpp
+++ b/src/api/game/game.cpp
@@ -59,8 +59,9 @@ Game::Game(const GameType gameType,
            const std::filesystem::path& localDataPath) :
     type_(gameType),
     gamePath_(gamePath),
-    cache_(std::make_shared<GameCache>()),
-    loadOrderHandler_(std::make_shared<LoadOrderHandler>()) {
+    conditionEvaluator_(
+        std::make_shared<ConditionEvaluator>(Type(), DataPath())),
+    database_(ApiDatabase(conditionEvaluator_)) {
   auto logger = getLogger();
   if (logger) {
     logger->info("Initialising load order data for game of type {} at: {}",
@@ -68,12 +69,7 @@ Game::Game(const GameType gameType,
                  gamePath_.u8string());
   }
 
-  loadOrderHandler_->Init(type_, gamePath_, localDataPath);
-
-  conditionEvaluator_ =
-      std::make_shared<ConditionEvaluator>(Type(), DataPath());
-
-  database_ = std::make_shared<ApiDatabase>(conditionEvaluator_);
+  loadOrderHandler_.Init(type_, gamePath_, localDataPath);
 }
 
 GameType Game::Type() const { return type_; }
@@ -86,13 +82,11 @@ std::filesystem::path Game::DataPath() const {
   }
 }
 
-std::shared_ptr<GameCache> Game::GetCache() { return cache_; }
+GameCache& Game::GetCache() { return cache_; }
 
-std::shared_ptr<LoadOrderHandler> Game::GetLoadOrderHandler() {
-  return loadOrderHandler_;
-}
+LoadOrderHandler& Game::GetLoadOrderHandler() { return loadOrderHandler_; }
 
-std::shared_ptr<DatabaseInterface> Game::GetDatabase() { return database_; }
+DatabaseInterface& Game::GetDatabase() { return database_; }
 
 bool Game::IsValidPlugin(const std::string& plugin) const {
   return Plugin::IsValid(Type(), DataPath() / u8path(plugin));
@@ -150,7 +144,7 @@ void Game::LoadPlugins(const std::vector<std::string>& plugins,
   }
 
   // Clear the existing plugin and archive caches.
-  cache_->ClearCachedPlugins();
+  cache_.ClearCachedPlugins();
 
   // Search for and cache archives.
   CacheArchives();
@@ -170,7 +164,7 @@ void Game::LoadPlugins(const std::vector<std::string>& plugins,
           const bool loadHeader =
               loadHeadersOnly || loot::equivalent(pluginPath, masterPath);
 
-          cache_->AddPlugin(Plugin(Type(), cache_, pluginPath, loadHeader));
+          cache_.AddPlugin(Plugin(Type(), cache_, pluginPath, loadHeader));
         } catch (const std::exception& e) {
           if (logger) {
             logger->error(
@@ -192,17 +186,14 @@ void Game::LoadPlugins(const std::vector<std::string>& plugins,
   conditionEvaluator_->RefreshLoadedPluginsState(GetLoadedPlugins());
 }
 
-std::shared_ptr<const PluginInterface> Game::GetPlugin(
-    const std::string& pluginName) const {
-  return cache_->GetPlugin(pluginName);
+const PluginInterface* Game::GetPlugin(const std::string& pluginName) const {
+  return cache_.GetPlugin(pluginName);
 }
 
-std::vector<std::shared_ptr<const PluginInterface>> Game::GetLoadedPlugins()
-    const {
-  std::vector<std::shared_ptr<const PluginInterface>> interfacePointers;
-  for (auto& plugin : cache_->GetPlugins()) {
-    interfacePointers.push_back(
-        std::static_pointer_cast<const PluginInterface>(plugin));
+std::vector<const PluginInterface*> Game::GetLoadedPlugins() const {
+  std::vector<const PluginInterface*> interfacePointers;
+  for (const auto plugin : cache_.GetPlugins()) {
+    interfacePointers.push_back(plugin);
   }
 
   return interfacePointers;
@@ -221,21 +212,21 @@ std::vector<std::string> Game::SortPlugins(
 }
 
 void Game::LoadCurrentLoadOrderState() {
-  loadOrderHandler_->LoadCurrentState();
+  loadOrderHandler_.LoadCurrentState();
   conditionEvaluator_->RefreshActivePluginsState(
-      loadOrderHandler_->GetActivePlugins());
+      loadOrderHandler_.GetActivePlugins());
 }
 
 bool Game::IsPluginActive(const std::string& pluginName) const {
-  return loadOrderHandler_->IsPluginActive(pluginName);
+  return loadOrderHandler_.IsPluginActive(pluginName);
 }
 
 std::vector<std::string> Game::GetLoadOrder() const {
-  return loadOrderHandler_->GetLoadOrder();
+  return loadOrderHandler_.GetLoadOrder();
 }
 
 void Game::SetLoadOrder(const std::vector<std::string>& loadOrder) {
-  loadOrderHandler_->SetLoadOrder(loadOrder);
+  loadOrderHandler_.SetLoadOrder(loadOrder);
 }
 
 void Game::CacheArchives() {
@@ -255,6 +246,6 @@ void Game::CacheArchives() {
     }
   }
 
-  cache_->CacheArchivePaths(std::move(archivePaths));
+  cache_.CacheArchivePaths(std::move(archivePaths));
 }
 }
diff --git a/src/api/game/game.h b/src/api/game/game.h
index 60f8d1d7..abc4df18 100644
--- a/src/api/game/game.h
+++ b/src/api/game/game.h
@@ -28,6 +28,7 @@
 #include <filesystem>
 #include <string>
 
+#include "api/api_database.h"
 #include "api/game/game_cache.h"
 #include "api/game/load_order_handler.h"
 #include "api/metadata/condition_evaluator.h"
@@ -46,24 +47,23 @@ public:
   GameType Type() const;
   std::filesystem::path DataPath() const;
 
-  std::shared_ptr<GameCache> GetCache();
-  std::shared_ptr<LoadOrderHandler> GetLoadOrderHandler();
+  GameCache& GetCache();
+  LoadOrderHandler& GetLoadOrderHandler();
 
   // Game Interface Methods //
   ////////////////////////////
 
-  std::shared_ptr<DatabaseInterface> GetDatabase() override;
+  DatabaseInterface& GetDatabase() override;
 
   bool IsValidPlugin(const std::string& plugin) const override;
 
   void LoadPlugins(const std::vector<std::string>& plugins,
                    bool loadHeadersOnly) override;
 
-  std::shared_ptr<const PluginInterface> GetPlugin(
+  const PluginInterface* GetPlugin(
       const std::string& pluginName) const override;
 
-  std::vector<std::shared_ptr<const PluginInterface>> GetLoadedPlugins()
-      const override;
+  std::vector<const PluginInterface*> GetLoadedPlugins() const override;
 
   void IdentifyMainMasterFile(const std::string& masterFile) override;
 
@@ -84,10 +84,10 @@ private:
   const GameType type_;
   const std::filesystem::path gamePath_;
 
-  std::shared_ptr<GameCache> cache_;
-  std::shared_ptr<LoadOrderHandler> loadOrderHandler_;
+  GameCache cache_;
+  LoadOrderHandler loadOrderHandler_;
   std::shared_ptr<ConditionEvaluator> conditionEvaluator_;
-  std::shared_ptr<DatabaseInterface> database_;
+  ApiDatabase database_;
 
   std::string masterFilename_;
 };
diff --git a/src/api/game/game_cache.cpp b/src/api/game/game_cache.cpp
index ce910f50..6d3b7bb8 100644
--- a/src/api/game/game_cache.cpp
+++ b/src/api/game/game_cache.cpp
@@ -72,24 +72,23 @@ GameCache& GameCache::operator=(GameCache&& cache) {
   return *this;
 }
 
-std::vector<std::shared_ptr<const Plugin>> GameCache::GetPlugins() const {
+std::vector<const Plugin*> GameCache::GetPlugins() const {
   lock_guard<mutex> lock(mutex_);
 
-  std::vector<std::shared_ptr<const Plugin>> output(plugins_.size());
+  std::vector<const Plugin*> output(plugins_.size());
   std::transform(
       begin(plugins_), end(plugins_), begin(output), [](const auto& pair) {
-        return pair.second;
+        return pair.second.get();
       });
   return output;
 }
 
-std::shared_ptr<const Plugin> GameCache::GetPlugin(
-    const std::string& pluginName) const {
+const Plugin* GameCache::GetPlugin(const std::string& pluginName) const {
   lock_guard<mutex> lock(mutex_);
 
   const auto it = plugins_.find(NormalizeFilename(pluginName));
   if (it != end(plugins_))
-    return it->second;
+    return it->second.get();
 
   return nullptr;
 }
diff --git a/src/api/game/game_cache.h b/src/api/game/game_cache.h
index 4ecf1465..26282317 100644
--- a/src/api/game/game_cache.h
+++ b/src/api/game/game_cache.h
@@ -42,8 +42,8 @@ public:
   GameCache& operator=(const GameCache& cache);
   GameCache& operator=(GameCache&& cache);
 
-  std::vector<std::shared_ptr<const Plugin>> GetPlugins() const;
-  std::shared_ptr<const Plugin> GetPlugin(const std::string& pluginName) const;
+  std::vector<const Plugin*> GetPlugins() const;
+  const Plugin* GetPlugin(const std::string& pluginName) const;
   void AddPlugin(Plugin&& plugin);
 
   std::set<std::filesystem::path> GetArchivePaths() const;
diff --git a/src/api/metadata/condition_evaluator.cpp b/src/api/metadata/condition_evaluator.cpp
index 964d99a9..b4c5fd78 100644
--- a/src/api/metadata/condition_evaluator.cpp
+++ b/src/api/metadata/condition_evaluator.cpp
@@ -89,7 +89,10 @@ std::string IntToHexString(const uint32_t value) {
 }
 
 ConditionEvaluator::ConditionEvaluator(const GameType gameType,
-                                       const std::filesystem::path& dataPath) {
+                                       const std::filesystem::path& dataPath) :
+    lciState_(std::unique_ptr<lci_state, decltype(&lci_state_destroy)>(
+        nullptr,
+        lci_state_destroy)) {
   lci_state* state = nullptr;
 
   // This probably isn't correct for API users other than LOOT.
@@ -102,7 +105,8 @@ ConditionEvaluator::ConditionEvaluator(const GameType gameType,
                                 lootPath.u8string().c_str());
   HandleError("create state object for condition evaluation", result);
 
-  lciState_ = std::shared_ptr<lci_state>(state, lci_state_destroy);
+  lciState_ = std::unique_ptr<lci_state, decltype(&lci_state_destroy)>(
+      state, lci_state_destroy);
 }
 
 bool ConditionEvaluator::Evaluate(const std::string& condition) {
@@ -191,7 +195,7 @@ void ConditionEvaluator::ClearConditionCache() {
 }
 
 void ConditionEvaluator::RefreshActivePluginsState(
-    std::vector<std::string> activePluginNames) {
+    const std::vector<std::string>& activePluginNames) {
   ClearConditionCache();
 
   std::vector<const char*> activePluginNameCStrings;
@@ -207,7 +211,7 @@ void ConditionEvaluator::RefreshActivePluginsState(
 }
 
 void ConditionEvaluator::RefreshLoadedPluginsState(
-    std::vector<std::shared_ptr<const PluginInterface>> plugins) {
+    const std::vector<const PluginInterface*>& plugins) {
   ClearConditionCache();
 
   std::vector<std::string> pluginNames;
diff --git a/src/api/metadata/condition_evaluator.h b/src/api/metadata/condition_evaluator.h
index e37bfc61..70ecbf2b 100644
--- a/src/api/metadata/condition_evaluator.h
+++ b/src/api/metadata/condition_evaluator.h
@@ -28,12 +28,13 @@
 #include <loot_condition_interpreter.h>
 
 #include <filesystem>
+#include <memory>
 #include <string>
 
-#include "api/game/game_cache.h"
-#include "api/game/load_order_handler.h"
+#include "loot/enum/game_type.h"
 #include "loot/metadata/plugin_cleaning_data.h"
 #include "loot/metadata/plugin_metadata.h"
+#include "loot/plugin_interface.h"
 
 namespace loot {
 class ConditionEvaluator {
@@ -45,15 +46,16 @@ public:
   PluginMetadata EvaluateAll(const PluginMetadata& pluginMetadata);
 
   void ClearConditionCache();
-  void RefreshActivePluginsState(std::vector<std::string> activePluginNames);
+  void RefreshActivePluginsState(
+      const std::vector<std::string>& activePluginNames);
   void RefreshLoadedPluginsState(
-      std::vector<std::shared_ptr<const PluginInterface>> plugins);
+      const std::vector<const PluginInterface*>& plugins);
 
 private:
   bool Evaluate(const PluginCleaningData& cleaningData,
                 const std::string& pluginName);
 
-  std::shared_ptr<lci_state> lciState_;
+  std::unique_ptr<lci_state, decltype(&lci_state_destroy)> lciState_;
 };
 
 void ParseCondition(const std::string& condition);
diff --git a/src/api/metadata_list.h b/src/api/metadata_list.h
index 494301f2..8dd32929 100644
--- a/src/api/metadata_list.h
+++ b/src/api/metadata_list.h
@@ -28,6 +28,7 @@
 #include <filesystem>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
diff --git a/src/api/plugin.cpp b/src/api/plugin.cpp
index ffd1af9e..9ba8bca0 100644
--- a/src/api/plugin.cpp
+++ b/src/api/plugin.cpp
@@ -38,11 +38,13 @@ using std::string;
 
 namespace loot {
 Plugin::Plugin(const GameType gameType,
-               std::shared_ptr<GameCache> gameCache,
+               const GameCache& gameCache,
                std::filesystem::path pluginPath,
                const bool headerOnly) :
     name_(pluginPath.filename().u8string()),
-    esPlugin(nullptr),
+    esPlugin(
+        std::unique_ptr<::Plugin, decltype(&esp_plugin_free)>(nullptr,
+                                                              esp_plugin_free)),
     isEmpty_(true),
     loadsArchive_(false),
     numOverrideRecords_(0) {
@@ -169,7 +171,7 @@ bool Plugin::LoadsArchive() const { return loadsArchive_; }
 
 bool Plugin::DoFormIDsOverlap(const PluginInterface& plugin) const {
   try {
-    auto otherPlugin = dynamic_cast<const Plugin&>(plugin);
+    auto& otherPlugin = dynamic_cast<const Plugin&>(plugin);
 
     bool doPluginsOverlap = false;
     const auto ret = esp_plugin_do_records_overlap(
@@ -192,8 +194,7 @@ bool Plugin::DoFormIDsOverlap(const PluginInterface& plugin) const {
   return false;
 }
 
-size_t Plugin::GetOverlapSize(
-    const std::vector<std::shared_ptr<const Plugin>> plugins) const {
+size_t Plugin::GetOverlapSize(const std::vector<const Plugin*> plugins) const {
   if (plugins.empty()) {
     return 0;
   }
@@ -278,7 +279,7 @@ void Plugin::Load(const std::filesystem::path& path,
                           " : esplugin error code: " + std::to_string(ret));
   }
 
-  esPlugin = std::shared_ptr<std::remove_pointer<::Plugin>::type>(
+  esPlugin = std::unique_ptr<::Plugin, decltype(&esp_plugin_free)>(
       plugin, esp_plugin_free);
 
   ret = esp_plugin_parse(esPlugin.get(), headerOnly);
@@ -352,7 +353,7 @@ bool equivalent(const std::filesystem::path& path1,
 
 // Get whether the plugin loads an archive (BSA/BA2) or not.
 bool Plugin::LoadsArchive(const GameType gameType,
-                          const std::shared_ptr<GameCache> gameCache,
+                          const GameCache& gameCache,
                           const std::filesystem::path& pluginPath) {
   if (gameType == GameType::tes3) {
     return false;
@@ -386,7 +387,7 @@ bool Plugin::LoadsArchive(const GameType gameType,
     auto basenameLength = pluginPath.stem().native().length();
     auto pluginExtension = pluginPath.extension().native();
 
-    for (const auto& archivePath : gameCache->GetArchivePaths()) {
+    for (const auto& archivePath : gameCache.GetArchivePaths()) {
       // Need to check if it starts with the given plugin's basename,
       // but case insensitively. This is hard to do accurately, so
       // instead check if the plugin with the same length basename and
diff --git a/src/api/plugin.h b/src/api/plugin.h
index 21675a00..a7f864ea 100644
--- a/src/api/plugin.h
+++ b/src/api/plugin.h
@@ -43,7 +43,7 @@ class GameCache;
 class Plugin final : public PluginInterface {
 public:
   explicit Plugin(const GameType gameType,
-                  std::shared_ptr<GameCache> gameCache,
+                  const GameCache& gameCache,
                   std::filesystem::path pluginPath,
                   const bool headerOnly);
 
@@ -62,8 +62,7 @@ public:
   bool IsEmpty() const override;
   bool LoadsArchive() const override;
   bool DoFormIDsOverlap(const PluginInterface& plugin) const override;
-  size_t GetOverlapSize(
-      const std::vector<std::shared_ptr<const Plugin>> plugins) const;
+  size_t GetOverlapSize(const std::vector<const Plugin*> plugins) const;
 
   // Load ordering functions.
   size_t NumOverrideFormIDs() const;
@@ -81,12 +80,12 @@ private:
   std::string GetDescription() const;
 
   static bool LoadsArchive(const GameType gameType,
-                           const std::shared_ptr<GameCache> gameCache,
+                           const GameCache& gameCache,
                            const std::filesystem::path& pluginPath);
   static unsigned int GetEspluginGameId(GameType gameType);
 
   const std::string name_;
-  std::shared_ptr<std::remove_pointer<::Plugin>::type> esPlugin;
+  std::unique_ptr<::Plugin, decltype(&esp_plugin_free)> esPlugin;
   bool isEmpty_;  // Does the plugin contain any records other than the TES4
                   // header?
   bool loadsArchive_;
diff --git a/src/api/sorting/plugin_graph.cpp b/src/api/sorting/plugin_graph.cpp
index ee4f43d4..7657b733 100644
--- a/src/api/sorting/plugin_graph.cpp
+++ b/src/api/sorting/plugin_graph.cpp
@@ -187,7 +187,7 @@ void PluginGraph::AddPluginVertices(Game& game,
   // doesn't strictly need this, there is no guarantee that this
   // unspecified behaviour will remain in future compiler updates, so
   // implement it generally.
-  auto loadedPlugins = game.GetCache()->GetPlugins();
+  auto loadedPlugins = game.GetCache().GetPlugins();
   std::sort(loadedPlugins.begin(),
             loadedPlugins.end(),
             [](const auto& lhs, const auto& rhs) {
@@ -205,10 +205,10 @@ void PluginGraph::AddPluginVertices(Game& game,
   for (const auto& plugin : loadedPlugins) {
     auto masterlistMetadata =
         game.GetDatabase()
-            ->GetPluginMetadata(plugin->GetName(), false, true)
+            .GetPluginMetadata(plugin->GetName(), false, true)
             .value_or(PluginMetadata(plugin->GetName()));
     auto userMetadata = game.GetDatabase()
-                            ->GetPluginUserMetadata(plugin->GetName(), true)
+                            .GetPluginUserMetadata(plugin->GetName(), true)
                             .value_or(PluginMetadata(plugin->GetName()));
 
     auto pluginSortingData = PluginSortingData(*plugin,
@@ -232,8 +232,8 @@ void PluginGraph::AddPluginVertices(Game& game,
 
   // Map sets of transitive group dependencies to sets of transitive plugin
   // dependencies.
-  auto groups = GetTransitiveAfterGroups(game.GetDatabase()->GetGroups(false),
-                                         game.GetDatabase()->GetUserGroups());
+  auto groups = GetTransitiveAfterGroups(game.GetDatabase().GetGroups(false),
+                                         game.GetDatabase().GetUserGroups());
   for (auto& group : groups) {
     std::unordered_set<std::string> transitivePlugins;
     for (const auto& afterGroup : group.second) {
@@ -382,7 +382,7 @@ void PluginGraph::AddHardcodedPluginEdges(Game& game) {
   using std::filesystem::u8path;
 
   auto implicitlyActivePlugins =
-      game.GetLoadOrderHandler()->GetImplicitlyActivePlugins();
+      game.GetLoadOrderHandler().GetImplicitlyActivePlugins();
 
   auto logger = getLogger();
   std::set<std::string> processedPluginPaths;
diff --git a/src/api/sorting/plugin_sort.cpp b/src/api/sorting/plugin_sort.cpp
index 2db206aa..a38ab8a7 100644
--- a/src/api/sorting/plugin_sort.cpp
+++ b/src/api/sorting/plugin_sort.cpp
@@ -53,7 +53,7 @@ std::vector<std::string> SortPlugins(
   graph.AddHardcodedPluginEdges(game);
 
   std::unordered_map<std::string, Group> groups;
-  for (const auto& group : game.GetDatabase()->GetGroups()) {
+  for (const auto& group : game.GetDatabase().GetGroups()) {
     groups.emplace(group.GetName(), group);
   }
   graph.AddGroupEdges(groups);
diff --git a/src/api/sorting/plugin_sorting_data.cpp b/src/api/sorting/plugin_sorting_data.cpp
index 628fea81..1148dd41 100644
--- a/src/api/sorting/plugin_sorting_data.cpp
+++ b/src/api/sorting/plugin_sorting_data.cpp
@@ -31,10 +31,10 @@
 #include "api/helpers/text.h"
 
 namespace loot {
-std::vector<std::shared_ptr<const Plugin>> GetPluginsSubset(
-    const std::vector<std::shared_ptr<const Plugin>>& plugins,
+std::vector<const Plugin*> GetPluginsSubset(
+    const std::vector<const Plugin*>& plugins,
     const std::vector<std::string>& pluginNames) {
-  std::vector<std::shared_ptr<const Plugin>> pluginsSubset;
+  std::vector<const Plugin*> pluginsSubset;
 
   for (const auto& pluginName : pluginNames) {
     auto pos = std::find_if(plugins.begin(), plugins.end(), [&](auto plugin) {
@@ -55,7 +55,7 @@ PluginSortingData::PluginSortingData(
     const PluginMetadata& userMetadata,
     const std::vector<std::string>& loadOrder,
     const GameType gameType,
-    const std::vector<std::shared_ptr<const Plugin>>& loadedPlugins) :
+    const std::vector<const Plugin*>& loadedPlugins) :
     plugin_(plugin),
     masterlistLoadAfter_(masterlistMetadata.GetLoadAfterFiles()),
     userLoadAfter_(userMetadata.GetLoadAfterFiles()),
diff --git a/src/api/sorting/plugin_sorting_data.h b/src/api/sorting/plugin_sorting_data.h
index 8fd5f3ce..6f2d6d88 100644
--- a/src/api/sorting/plugin_sorting_data.h
+++ b/src/api/sorting/plugin_sorting_data.h
@@ -31,13 +31,12 @@
 namespace loot {
 class PluginSortingData {
 public:
-  explicit PluginSortingData(
-      const Plugin& plugin,
-      const PluginMetadata& masterlistMetadata,
-      const PluginMetadata& userMetadata,
-      const std::vector<std::string>& loadOrder,
-      const GameType gameType,
-      const std::vector<std::shared_ptr<const Plugin>>& loadedPlugins);
+  explicit PluginSortingData(const Plugin& plugin,
+                             const PluginMetadata& masterlistMetadata,
+                             const PluginMetadata& userMetadata,
+                             const std::vector<std::string>& loadOrder,
+                             const GameType gameType,
+                             const std::vector<const Plugin*>& loadedPlugins);
 
   std::string GetName() const;
   bool IsMaster() const;
diff --git a/src/tests/api/interface/api_game_operations_test.h b/src/tests/api/interface/api_game_operations_test.h
index 8c283025..8c4e8426 100644
--- a/src/tests/api/interface/api_game_operations_test.h
+++ b/src/tests/api/interface/api_game_operations_test.h
@@ -115,7 +115,7 @@ protected:
     masterlist.close();
   }
 
-  std::shared_ptr<GameInterface> handle_;
+  std::unique_ptr<GameInterface> handle_;
 
   const std::filesystem::path masterlistPath;
 
diff --git a/src/tests/api/interface/create_game_handle_test.h b/src/tests/api/interface/create_game_handle_test.h
index ce863122..4192351b 100644
--- a/src/tests/api/interface/create_game_handle_test.h
+++ b/src/tests/api/interface/create_game_handle_test.h
@@ -70,9 +70,11 @@ protected:
     std::filesystem::current_path(dataPath.parent_path().parent_path());
   }
 
-  void TearDown() override { std::filesystem::current_path(originalWorkingDirectory); }
+  void TearDown() override {
+    std::filesystem::current_path(originalWorkingDirectory);
+  }
 
-  std::shared_ptr<GameInterface> handle_;
+  std::unique_ptr<GameInterface> handle_;
 
   const std::filesystem::path gamePathSymlink;
   const std::filesystem::path localPathSymlink;
diff --git a/src/tests/api/interface/database_interface_test.h b/src/tests/api/interface/database_interface_test.h
index 55968e30..e46af5d6 100644
--- a/src/tests/api/interface/database_interface_test.h
+++ b/src/tests/api/interface/database_interface_test.h
@@ -38,14 +38,11 @@ protected:
       url_("./testing-metadata.git"),
       branch_("master"),
       oldBranch_("old-branch"),
-      generalUserlistMessage("A general userlist message."),
-      db_(nullptr) {}
+      generalUserlistMessage("A general userlist message.") {}
 
   void SetUp() override {
     ApiGameOperationsTest::SetUp();
 
-    db_ = handle_->GetDatabase();
-
     ASSERT_FALSE(std::filesystem::exists(minimalOutputPath_));
   }
 
@@ -116,8 +113,6 @@ protected:
   const std::string branch_;
   const std::string oldBranch_;
   const std::string generalUserlistMessage;
-
-  std::shared_ptr<DatabaseInterface> db_;
 };
 
 // Pass an empty first argument, as it's a prefix for the test instantation,
@@ -133,23 +128,24 @@ INSTANTIATE_TEST_SUITE_P(,
 
 TEST_P(DatabaseInterfaceTest,
        loadListsShouldSucceedEvenIfGameHandleIsDiscarded) {
-  db_ = CreateGameHandle(GetParam(), dataPath.parent_path(), localPath)
-            ->GetDatabase();
+  handle_ = CreateGameHandle(GetParam(), dataPath.parent_path(), localPath);
 
   ASSERT_NO_THROW(GenerateMasterlist());
 
-  EXPECT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  EXPECT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 }
 
 TEST_P(DatabaseInterfaceTest, loadListsShouldThrowIfNoMasterlistIsPresent) {
-  EXPECT_THROW(db_->LoadLists(masterlistPath, ""), FileAccessError);
+  EXPECT_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""),
+               FileAccessError);
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     loadListsShouldThrowIfAMasterlistIsPresentButAUserlistDoesNotExistAtTheGivenPath) {
   ASSERT_NO_THROW(GenerateMasterlist());
-  EXPECT_THROW(db_->LoadLists(masterlistPath, userlistPath_), FileAccessError);
+  EXPECT_THROW(handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_),
+               FileAccessError);
 }
 
 TEST_P(
@@ -157,7 +153,7 @@ TEST_P(
     loadListsShouldSucceedIfTheMasterlistIsPresentAndTheUserlistPathIsAnEmptyString) {
   ASSERT_NO_THROW(GenerateMasterlist());
 
-  EXPECT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  EXPECT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 }
 
 TEST_P(DatabaseInterfaceTest,
@@ -165,7 +161,8 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(std::filesystem::copy(masterlistPath, userlistPath_));
 
-  EXPECT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 }
 
 TEST_P(
@@ -175,8 +172,9 @@ TEST_P(
 
   auto preludePath = localPath / "prelude.yaml";
 
-  EXPECT_THROW(db_->LoadLists(masterlistPath, "", preludePath),
-               FileAccessError);
+  EXPECT_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, "", preludePath),
+      FileAccessError);
 }
 
 TEST_P(DatabaseInterfaceTest,
@@ -200,9 +198,10 @@ TEST_P(DatabaseInterfaceTest,
       << "    type: say" << endl
       << "    content: Loaded from prelude" << endl;
 
-  EXPECT_NO_THROW(db_->LoadLists(masterlistPath, "", preludePath));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, "", preludePath));
 
-  auto messages = db_->GetGeneralMessages();
+  auto messages = handle_->GetDatabase().GetGeneralMessages();
   ASSERT_EQ(1, messages.size());
   EXPECT_EQ(MessageType::say, messages[0].GetType());
   ASSERT_EQ(1, messages[0].GetContent().size());
@@ -212,48 +211,56 @@ TEST_P(DatabaseInterfaceTest,
 TEST_P(
     DatabaseInterfaceTest,
     writeUserMetadataShouldThrowIfTheFileAlreadyExistsAndTheOverwriteArgumentIsFalse) {
-  ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
-  EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_, false),
-               FileAccessError);
+  EXPECT_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, false),
+      FileAccessError);
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     writeUserMetadataShouldReturnOkAndWriteToFileIfTheArgumentsAreValidAndTheOverwriteArgumentIsTrue) {
-  EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, true));
   EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     writeUserMetadataShouldReturnOkIfTheFileAlreadyExistsAndTheOverwriteArgumentIsTrue) {
-  ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
-  EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, true));
 }
 
 TEST_P(DatabaseInterfaceTest,
        writeUserMetadataShouldThrowIfPathGivenExistsAndIsReadOnly) {
-  ASSERT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
   std::filesystem::permissions(minimalOutputPath_,
                                std::filesystem::perms::owner_read,
                                std::filesystem::perm_options::replace);
 
-  EXPECT_THROW(db_->WriteUserMetadata(minimalOutputPath_, true),
-               FileAccessError);
+  EXPECT_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, true),
+      FileAccessError);
 }
 
 TEST_P(DatabaseInterfaceTest,
        writeUserMetadataShouldShouldNotWriteMasterlistMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 
-  EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, true));
 
   EXPECT_EQ("{}", GetFileContent(minimalOutputPath_));
 }
@@ -266,9 +273,11 @@ TEST_P(DatabaseInterfaceTest, writeUserMetadataShouldShouldWriteUserMetadata) {
   masterlist << "bash_tags:\n  []\nglobals:\n  []\nplugins:\n  []";
   masterlist.close();
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  EXPECT_NO_THROW(db_->WriteUserMetadata(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteUserMetadata(minimalOutputPath_, true));
 
   EXPECT_FALSE(GetFileContent(minimalOutputPath_).empty());
 }
@@ -278,9 +287,10 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto groups = db_->GetGroups();
+  auto groups = handle_->GetDatabase().GetGroups();
 
   ASSERT_EQ(4, groups.size());
 
@@ -300,7 +310,7 @@ TEST_P(DatabaseInterfaceTest,
 
 TEST_P(DatabaseInterfaceTest,
        getGroupsShouldReturnDefaultGroupEvenIfNoMetadataIsLoaded) {
-  auto groups = db_->GetGroups();
+  auto groups = handle_->GetDatabase().GetGroups();
 
   ASSERT_EQ(1, groups.size());
 
@@ -313,9 +323,10 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto groups = db_->GetGroups(false);
+  auto groups = handle_->GetDatabase().GetGroups(false);
 
   ASSERT_EQ(3, groups.size());
 
@@ -332,7 +343,7 @@ TEST_P(DatabaseInterfaceTest,
 TEST_P(
     DatabaseInterfaceTest,
     getGroupsShouldReturnDefaultGroupIfNoMasterlistIsLoadedAndUserlistMetadataIsNotIncluded) {
-  auto groups = db_->GetGroups(false);
+  auto groups = handle_->GetDatabase().GetGroups(false);
 
   EXPECT_EQ(1, groups.size());
 
@@ -345,9 +356,10 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto groups = db_->GetUserGroups();
+  auto groups = handle_->GetDatabase().GetUserGroups();
 
   ASSERT_EQ(3, groups.size());
 
@@ -367,13 +379,14 @@ TEST_P(
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->SetUserGroups(std::vector<Group>({
+  handle_->GetDatabase().SetUserGroups(std::vector<Group>({
       Group("group4"),
   }));
 
-  auto groups = db_->GetUserGroups();
+  auto groups = handle_->GetDatabase().GetUserGroups();
 
   ASSERT_EQ(2, groups.size());
 
@@ -389,9 +402,10 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto path = db_->GetGroupsPath("group1", "group3");
+  auto path = handle_->GetDatabase().GetGroupsPath("group1", "group3");
 
   ASSERT_EQ(2, path.size());
   EXPECT_EQ("group1", path[0].GetName());
@@ -405,9 +419,10 @@ TEST_P(DatabaseInterfaceTest,
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
 
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto tags = db_->GetKnownBashTags();
+  auto tags = handle_->GetDatabase().GetKnownBashTags();
 
   std::vector<std::string> expectedTags({
       "Actors.ACBS",
@@ -422,9 +437,10 @@ TEST_P(DatabaseInterfaceTest,
        getGeneralMessagesShouldGetGeneralMessagesFromTheMasterlistAndUserlist) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto messages = db_->GetGeneralMessages();
+  auto messages = handle_->GetDatabase().GetGeneralMessages();
 
   std::vector<Message> expectedMessages({
       Message(MessageType::say,
@@ -439,16 +455,16 @@ TEST_P(
     DatabaseInterfaceTest,
     getGeneralMessagesShouldReturnOnlyValidMessagesIfConditionsAreEvaluated) {
   ASSERT_NO_THROW(GenerateMasterlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 
-  auto messages = db_->GetGeneralMessages(true);
+  auto messages = handle_->GetDatabase().GetGeneralMessages(true);
 
   EXPECT_TRUE(messages.empty());
 }
 
 TEST_P(DatabaseInterfaceTest,
        getPluginMetadataShouldReturnAnEmptyOptionalIfThePluginHasNoMetadata) {
-  EXPECT_FALSE(db_->GetPluginMetadata(blankEsm));
+  EXPECT_FALSE(handle_->GetDatabase().GetPluginMetadata(blankEsm));
 }
 
 TEST_P(
@@ -456,9 +472,11 @@ TEST_P(
     getPluginMetadataShouldReturnMergedMasterAndUserMetadataForTheGivenPluginIfIncludeUserMetadataIsTrue) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm, true).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginMetadata(blankEsm, true).value();
 
   std::vector<File> expectedLoadAfter({
       File(blankDifferentEsm),
@@ -471,9 +489,11 @@ TEST_P(DatabaseInterfaceTest,
        getPluginMetadataShouldPreferUserMetadataWhenMergingMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm, true).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginMetadata(blankEsm, true).value();
 
   std::vector<Tag> expectedTags({
       Tag("Actors.ACBS", true, "file(\"" + missingEsp + "\")"),
@@ -491,9 +511,11 @@ TEST_P(
     getPluginMetadataShouldReturnOnlyMasterlistMetadataForTheGivenPluginIfIncludeUserMetadataIsFalse) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm, false).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginMetadata(blankEsm, false).value();
 
   std::vector<File> expectedLoadAfter({
       File(masterFile),
@@ -505,9 +527,10 @@ TEST_P(
     DatabaseInterfaceTest,
     getPluginMetadataShouldReturnOnlyValidMetadataForTheGivenPluginIfConditionsAreEvaluated) {
   ASSERT_NO_THROW(GenerateMasterlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm, false, true).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginMetadata(blankEsm, false, true).value();
 
   EXPECT_TRUE(metadata.GetMessages().empty());
 }
@@ -517,18 +540,21 @@ TEST_P(
     getPluginUserMetadataShouldReturnAnEmptyPluginMetadataObjectIfThePluginHasNoUserMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  EXPECT_FALSE(db_->GetPluginUserMetadata(blankDifferentEsm));
+  EXPECT_FALSE(handle_->GetDatabase().GetPluginUserMetadata(blankDifferentEsm));
 }
 
 TEST_P(DatabaseInterfaceTest,
        getPluginUserMetadataShouldReturnOnlyUserMetadataForTheGivenPlugin) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto metadata = db_->GetPluginUserMetadata(blankEsm).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginUserMetadata(blankEsm).value();
 
   std::vector<File> expectedLoadAfter({
       File(blankDifferentEsm),
@@ -541,9 +567,11 @@ TEST_P(
     getPluginUserMetadataShouldReturnOnlyValidMetadataForTheGivenPluginIfConditionsAreEvaluated) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm, false, true).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginMetadata(blankEsm, false, true).value();
 
   EXPECT_TRUE(metadata.GetMessages().empty());
 }
@@ -553,14 +581,16 @@ TEST_P(
     setPluginUserMetadataShouldReplaceExistingUserMetadataWithTheGivenMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
   PluginMetadata newMetadata(blankDifferentEsp);
   newMetadata.SetRequirements(std::vector<File>({File(masterFile)}));
 
-  db_->SetPluginUserMetadata(newMetadata);
+  handle_->GetDatabase().SetPluginUserMetadata(newMetadata);
 
-  auto metadata = db_->GetPluginUserMetadata(blankDifferentEsp).value();
+  auto metadata =
+      handle_->GetDatabase().GetPluginUserMetadata(blankDifferentEsp).value();
 
   std::set<File> expectedLoadAfter({
       File(blankDifferentEsm),
@@ -573,14 +603,15 @@ TEST_P(DatabaseInterfaceTest,
        setPluginUserMetadataShouldNotAffectExistingMasterlistMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
   PluginMetadata newMetadata(blankEsm);
   newMetadata.SetRequirements(std::vector<File>({File(masterFile)}));
 
-  db_->SetPluginUserMetadata(newMetadata);
+  handle_->GetDatabase().SetPluginUserMetadata(newMetadata);
 
-  auto metadata = db_->GetPluginMetadata(blankEsm).value();
+  auto metadata = handle_->GetDatabase().GetPluginMetadata(blankEsm).value();
 
   std::vector<File> expectedLoadAfter({
       File(masterFile),
@@ -592,11 +623,12 @@ TEST_P(DatabaseInterfaceTest,
        discardPluginUserMetadataShouldDiscardAllUserMetadataForTheGivenPlugin) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardPluginUserMetadata(blankEsm);
+  handle_->GetDatabase().DiscardPluginUserMetadata(blankEsm);
 
-  EXPECT_FALSE(db_->GetPluginUserMetadata(blankEsm));
+  EXPECT_FALSE(handle_->GetDatabase().GetPluginUserMetadata(blankEsm));
 }
 
 TEST_P(
@@ -604,11 +636,12 @@ TEST_P(
     discardPluginUserMetadataShouldNotDiscardMasterlistMetadataForTheGivenPlugin) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardPluginUserMetadata(blankEsm);
+  handle_->GetDatabase().DiscardPluginUserMetadata(blankEsm);
 
-  auto metadata = db_->GetPluginMetadata(blankEsm).value();
+  auto metadata = handle_->GetDatabase().GetPluginMetadata(blankEsm).value();
 
   std::vector<File> expectedLoadAfter({
       File(masterFile),
@@ -620,11 +653,13 @@ TEST_P(DatabaseInterfaceTest,
        discardPluginUserMetadataShouldNotDiscardUserMetadataForOtherPlugins) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardPluginUserMetadata(blankEsm);
+  handle_->GetDatabase().DiscardPluginUserMetadata(blankEsm);
 
-  auto metadata = db_->GetPluginUserMetadata(blankDifferentEsp);
+  auto metadata =
+      handle_->GetDatabase().GetPluginUserMetadata(blankDifferentEsp);
 
   EXPECT_TRUE(metadata);
 }
@@ -633,11 +668,12 @@ TEST_P(DatabaseInterfaceTest,
        discardPluginUserMetadataShouldNotDiscardGeneralMessages) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardPluginUserMetadata(blankEsm);
+  handle_->GetDatabase().DiscardPluginUserMetadata(blankEsm);
 
-  auto messages = db_->GetGeneralMessages();
+  auto messages = handle_->GetDatabase().GetGeneralMessages();
 
   std::vector<Message> expectedMessages({
       Message(MessageType::say,
@@ -652,11 +688,12 @@ TEST_P(DatabaseInterfaceTest,
        discardPluginUserMetadataShouldNotDiscardKnownBashTags) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardPluginUserMetadata(blankEsm);
+  handle_->GetDatabase().DiscardPluginUserMetadata(blankEsm);
 
-  auto tags = db_->GetKnownBashTags();
+  auto tags = handle_->GetDatabase().GetKnownBashTags();
 
   std::vector<std::string> expectedTags({
       "Actors.ACBS",
@@ -672,21 +709,22 @@ TEST_P(
     discardAllUserMetadataShouldDiscardAllUserMetadataAndNoMasterlistMetadata) {
   ASSERT_NO_THROW(GenerateMasterlist());
   ASSERT_NO_THROW(GenerateUserlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, userlistPath_));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().LoadLists(masterlistPath, userlistPath_));
 
-  db_->DiscardAllUserMetadata();
+  handle_->GetDatabase().DiscardAllUserMetadata();
 
-  EXPECT_FALSE(db_->GetPluginUserMetadata(blankEsm));
-  EXPECT_FALSE(db_->GetPluginUserMetadata(blankDifferentEsp));
+  EXPECT_FALSE(handle_->GetDatabase().GetPluginUserMetadata(blankEsm));
+  EXPECT_FALSE(handle_->GetDatabase().GetPluginUserMetadata(blankDifferentEsp));
 
-  auto metadata = db_->GetPluginMetadata(blankEsm).value();
+  auto metadata = handle_->GetDatabase().GetPluginMetadata(blankEsm).value();
 
   std::vector<File> expectedLoadAfter({
       File(masterFile),
   });
   EXPECT_EQ(expectedLoadAfter, metadata.GetLoadAfterFiles());
 
-  auto messages = db_->GetGeneralMessages();
+  auto messages = handle_->GetDatabase().GetGeneralMessages();
 
   std::vector<Message> expectedMessages({
       Message(MessageType::say,
@@ -695,7 +733,7 @@ TEST_P(
   });
   EXPECT_EQ(expectedMessages, messages);
 
-  auto tags = db_->GetKnownBashTags();
+  auto tags = handle_->GetDatabase().GetKnownBashTags();
 
   std::vector<std::string> expectedTags({
       "Actors.ACBS",
@@ -706,55 +744,64 @@ TEST_P(
 
 TEST_P(DatabaseInterfaceTest,
        writeMinimalListShouldReturnOkAndWriteToFileIfArgumentsGivenAreValid) {
-  EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, false));
   EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     writeMinimalListShouldThrowIfTheFileAlreadyExistsAndTheOverwriteArgumentIsFalse) {
-  ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
-  EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_, false),
-               FileAccessError);
+  EXPECT_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, false),
+      FileAccessError);
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     writeMinimalListShouldReturnOkAndWriteToFileIfTheArgumentsAreValidAndTheOverwriteArgumentIsTrue) {
-  EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, true));
   EXPECT_TRUE(std::filesystem::exists(minimalOutputPath_));
 }
 
 TEST_P(
     DatabaseInterfaceTest,
     writeMinimalListShouldReturnOkIfTheFileAlreadyExistsAndTheOverwriteArgumentIsTrue) {
-  ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
-  EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, true));
 }
 
 TEST_P(DatabaseInterfaceTest,
        writeMinimalListShouldThrowIfPathGivenExistsAndIsReadOnly) {
-  ASSERT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, false));
+  ASSERT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, false));
   ASSERT_TRUE(std::filesystem::exists(minimalOutputPath_));
 
   std::filesystem::permissions(minimalOutputPath_,
                                std::filesystem::perms::owner_read,
                                std::filesystem::perm_options::replace);
 
-  EXPECT_THROW(db_->WriteMinimalList(minimalOutputPath_, true),
-               FileAccessError);
+  EXPECT_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, true),
+      FileAccessError);
 }
 
 TEST_P(DatabaseInterfaceTest,
        writeMinimalListShouldWriteOnlyBashTagsAndDirtyInfo) {
   ASSERT_NO_THROW(GenerateMasterlist());
-  ASSERT_NO_THROW(db_->LoadLists(masterlistPath, ""));
+  ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 
-  EXPECT_NO_THROW(db_->WriteMinimalList(minimalOutputPath_, true));
+  EXPECT_NO_THROW(
+      handle_->GetDatabase().WriteMinimalList(minimalOutputPath_, true));
 
   EXPECT_EQ(GetExpectedMinimalContent(), GetFileContent(minimalOutputPath_));
 }
diff --git a/src/tests/api/interface/game_interface_test.h b/src/tests/api/interface/game_interface_test.h
index c92733a3..9f3b891a 100644
--- a/src/tests/api/interface/game_interface_test.h
+++ b/src/tests/api/interface/game_interface_test.h
@@ -161,7 +161,7 @@ TEST_P(GameInterfaceTest, sortPluginsShouldSucceedIfPassedValidArguments) {
   }
 
   ASSERT_NO_THROW(GenerateMasterlist());
-  ASSERT_NO_THROW(handle_->GetDatabase()->LoadLists(masterlistPath, ""));
+  ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, ""));
 
   std::vector<std::string> pluginsToSort({
       blankEsp,
diff --git a/src/tests/api/internals/game/game_cache_test.h b/src/tests/api/internals/game/game_cache_test.h
index db45c00d..3336a682 100644
--- a/src/tests/api/internals/game/game_cache_test.h
+++ b/src/tests/api/internals/game/game_cache_test.h
@@ -52,25 +52,19 @@ protected:
 INSTANTIATE_TEST_SUITE_P(, GameCacheTest, ::testing::Values(GameType::tes5));
 
 TEST_P(GameCacheTest, addingAPluginThatDoesNotExistShouldSucceed) {
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          true));
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, true));
   EXPECT_EQ(blankEsm, cache_.GetPlugin(blankEsm)->GetName());
 }
 
 TEST_P(GameCacheTest,
        addingAPluginThatIsAlreadyCachedShouldOverwriteExistingEntry) {
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          true));
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, true));
   EXPECT_FALSE(cache_.GetPlugin(blankEsm)->GetCRC());
 
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          false));
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, false));
   EXPECT_EQ(blankEsmCrc, cache_.GetPlugin(blankEsm)->GetCRC().value());
 }
 
@@ -79,10 +73,8 @@ TEST_P(GameCacheTest, gettingAPluginThatIsNotCachedShouldReturnANullPointer) {
 }
 
 TEST_P(GameCacheTest, gettingAPluginShouldBeCaseInsensitive) {
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          true));
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, true));
   EXPECT_EQ(blankEsm, cache_.GetPlugin(blankEsm)->GetName());
 }
 
@@ -93,12 +85,10 @@ TEST_P(GameCacheTest,
 
 TEST_P(GameCacheTest,
        gettingPluginsShouldReturnASetOfCachedPluginsIfPluginsHaveBeenCached) {
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, true));
   cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          true));
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
+                          GameCache(),
                           game_.DataPath() / blankMasterDependentEsm,
                           true));
 
@@ -128,10 +118,8 @@ TEST_P(GameCacheTest, clearingCachedPluginsShouldNotThrowIfNoPluginsAreCached) {
 }
 
 TEST_P(GameCacheTest, clearingCachedPluginsShouldClearAnyCachedPlugins) {
-  cache_.AddPlugin(Plugin(game_.Type(),
-                          std::make_shared<GameCache>(GameCache()),
-                          game_.DataPath() / blankEsm,
-                          true));
+  cache_.AddPlugin(
+      Plugin(game_.Type(), GameCache(), game_.DataPath() / blankEsm, true));
   cache_.ClearCachedPlugins();
 
   EXPECT_TRUE(cache_.GetPlugins().empty());
diff --git a/src/tests/api/internals/game/game_test.h b/src/tests/api/internals/game/game_test.h
index eec4f361..7697887e 100644
--- a/src/tests/api/internals/game/game_test.h
+++ b/src/tests/api/internals/game/game_test.h
@@ -101,7 +101,7 @@ TEST_P(
   Game game = Game(GetParam(), dataPath.parent_path(), localPath);
 
   EXPECT_NO_THROW(loadInstalledPlugins(game, true));
-  EXPECT_EQ(11, game.GetCache()->GetPlugins().size());
+  EXPECT_EQ(11, game.GetCache().GetPlugins().size());
 
   // Check that one plugin's header has been read.
   ASSERT_NO_THROW(game.GetPlugin(masterFile));
@@ -142,7 +142,7 @@ TEST_P(GameTest,
   Game game = Game(GetParam(), dataPath.parent_path(), localPath);
 
   EXPECT_NO_THROW(loadInstalledPlugins(game, false));
-  EXPECT_EQ(11, game.GetCache()->GetPlugins().size());
+  EXPECT_EQ(11, game.GetCache().GetPlugins().size());
 
   // Check that one plugin's header has been read.
   ASSERT_NO_THROW(game.GetPlugin(blankEsm));
@@ -161,7 +161,7 @@ TEST_P(
   EXPECT_NO_THROW(loadInstalledPlugins(game, false));
 
   auto expected = std::set<std::filesystem::path>({dataPath / blankArchive});
-  EXPECT_EQ(expected, game.GetCache()->GetArchivePaths());
+  EXPECT_EQ(expected, game.GetCache().GetArchivePaths());
 }
 
 TEST_P(GameTest, loadPluginsShouldClearTheArchivesCacheBeforeFindingArchives) {
@@ -169,7 +169,7 @@ TEST_P(GameTest, loadPluginsShouldClearTheArchivesCacheBeforeFindingArchives) {
 
   EXPECT_NO_THROW(loadInstalledPlugins(game, false));
   EXPECT_NO_THROW(loadInstalledPlugins(game, false));
-  EXPECT_EQ(1, game.GetCache()->GetArchivePaths().size());
+  EXPECT_EQ(1, game.GetCache().GetArchivePaths().size());
 }
 
 TEST_P(
diff --git a/src/tests/api/internals/metadata/condition_evaluator_test.h b/src/tests/api/internals/metadata/condition_evaluator_test.h
index 90767ab7..cdeaf18b 100644
--- a/src/tests/api/internals/metadata/condition_evaluator_test.h
+++ b/src/tests/api/internals/metadata/condition_evaluator_test.h
@@ -54,7 +54,7 @@ protected:
     loadInstalledPlugins();
     evaluator_.RefreshLoadedPluginsState(game_.GetLoadedPlugins());
     evaluator_.RefreshActivePluginsState(
-        game_.GetLoadOrderHandler()->GetActivePlugins());
+        game_.GetLoadOrderHandler().GetActivePlugins());
   }
 
   std::string IntToHexString(const uint32_t value) {
diff --git a/src/tests/api/internals/plugin_test.h b/src/tests/api/internals/plugin_test.h
index 5489bbae..20f80882 100644
--- a/src/tests/api/internals/plugin_test.h
+++ b/src/tests/api/internals/plugin_test.h
@@ -90,10 +90,10 @@ protected:
     out.open(nonAsciiPrefixArchivePath);
     out.close();
 
-    game_.GetCache()->CacheArchivePaths({dataPath / blankArchive,
-                                         dataPath / blankSuffixArchive,
-                                         dataPath / nonAsciiArchivePath,
-                                         dataPath / nonAsciiPrefixArchivePath});
+    game_.GetCache().CacheArchivePaths({dataPath / blankArchive,
+                                        dataPath / blankSuffixArchive,
+                                        dataPath / nonAsciiArchivePath,
+                                        dataPath / nonAsciiPrefixArchivePath});
   }
 
   uintmax_t getGhostedPluginFileSize() {
@@ -493,11 +493,7 @@ TEST_P(PluginTest, getOverlapSizeShouldCountEachRecordOnce) {
                  game_.DataPath() / blankMasterDependentEsm,
                  false);
 
-  std::vector<std::shared_ptr<const Plugin>> plugins = {
-      std::make_shared<const Plugin>(plugin2),
-      std::make_shared<const Plugin>(plugin2)};
-
-  EXPECT_EQ(4, plugin1.GetOverlapSize(plugins));
+  EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin2}));
 }
 
 TEST_P(PluginTest, getOverlapSizeShouldCheckAgainstAllGivenPlugins) {
@@ -510,11 +506,7 @@ TEST_P(PluginTest, getOverlapSizeShouldCheckAgainstAllGivenPlugins) {
                  game_.DataPath() / blankMasterDependentEsm,
                  false);
 
-  std::vector<std::shared_ptr<const Plugin>> plugins = {
-      std::make_shared<const Plugin>(plugin2),
-      std::make_shared<const Plugin>(plugin3)};
-
-  EXPECT_EQ(4, plugin1.GetOverlapSize(plugins));
+  EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin3}));
 }
 
 TEST_P(PluginTest,
@@ -526,10 +518,7 @@ TEST_P(PluginTest,
                  game_.DataPath() / blankMasterDependentEsm,
                  true);
 
-  std::vector<std::shared_ptr<const Plugin>> plugins = {
-      std::make_shared<const Plugin>(plugin2)};
-
-  EXPECT_EQ(0, plugin1.GetOverlapSize(plugins));
+  EXPECT_EQ(0, plugin1.GetOverlapSize({&plugin2}));
 }
 
 TEST_P(PluginTest, getOverlapSizeShouldReturnZeroForPluginsThatDoNotOverlap) {
@@ -538,10 +527,7 @@ TEST_P(PluginTest, getOverlapSizeShouldReturnZeroForPluginsThatDoNotOverlap) {
   Plugin plugin2(
       game_.Type(), game_.GetCache(), game_.DataPath() / blankEsp, false);
 
-  std::vector<std::shared_ptr<const Plugin>> plugins = {
-      std::make_shared<const Plugin>(plugin2)};
-
-  EXPECT_EQ(0, plugin1.GetOverlapSize(plugins));
+  EXPECT_EQ(0, plugin1.GetOverlapSize({&plugin2}));
 }
 
 TEST_P(PluginTest, getRecordAndGroupCountShouldReturnTheHeaderFieldValue) {
diff --git a/src/tests/api/internals/sorting/plugin_sort_test.h b/src/tests/api/internals/sorting/plugin_sort_test.h
index 03a257d0..7d01885a 100644
--- a/src/tests/api/internals/sorting/plugin_sort_test.h
+++ b/src/tests/api/internals/sorting/plugin_sort_test.h
@@ -153,15 +153,15 @@ TEST_P(PluginSortTest, sortingShouldResolveGroupsAsTransitiveLoadAfterSets) {
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankDifferentEsm);
   plugin.SetGroup("group1");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankEsm);
   plugin.SetGroup("group3");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -190,7 +190,7 @@ TEST_P(PluginSortTest, sortingShouldThrowIfAPluginHasAGroupThatDoesNotExist) {
 
   PluginMetadata plugin(blankDifferentEsm);
   plugin.SetGroup("group1");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   EXPECT_THROW(SortPlugins(game_, game_.GetLoadOrder()), UndefinedGroupError);
 }
@@ -200,11 +200,11 @@ TEST_P(PluginSortTest,
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankEsm);
   plugin.SetGroup("group4");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -234,21 +234,21 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankEsp);
 
   plugin = PluginMetadata(blankDifferentMasterDependentEsp);
   plugin.SetLoadAfterFiles({File(blankMasterDependentEsp)});
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankDifferentEsp);
   plugin.SetGroup("group1");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankMasterDependentEsp);
   plugin.SetGroup("group2");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -278,15 +278,15 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankMasterDependentEsm);
   plugin.SetGroup("earliest");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankDifferentEsm);
   plugin.SetGroup("earlier");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       blankEsm,
@@ -318,19 +318,19 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankMasterDependentEsm);
   plugin.SetGroup("earliest");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankDifferentEsm);
   plugin.SetGroup("earlier");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankEsm);
   plugin.SetGroup("group4");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   try {
     SortPlugins(game_, game_.GetLoadOrder());
@@ -353,15 +353,15 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankMasterDependentEsp);
   plugin.SetGroup("earliest");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankDifferentEsm);
   plugin.SetGroup("earlier");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       blankDifferentEsm,
@@ -393,15 +393,15 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   GenerateMasterlist();
-  game_.GetDatabase()->LoadLists(masterlistPath_);
+  game_.GetDatabase().LoadLists(masterlistPath_);
 
   PluginMetadata plugin(blankEsm);
   plugin.SetGroup("group4");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   plugin = PluginMetadata(blankDifferentMasterDependentEsm);
   plugin.SetGroup("group4");
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -433,7 +433,7 @@ TEST_P(PluginSortTest,
       File(blankDifferentEsp),
       File(blankDifferentPluginDependentEsp),
   });
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -465,7 +465,7 @@ TEST_P(PluginSortTest,
       File(blankDifferentEsp),
       File(blankDifferentPluginDependentEsp),
   });
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   std::vector<std::string> expectedSortedOrder({
       masterFile,
@@ -525,7 +525,7 @@ TEST_P(PluginSortTest, sortingShouldThrowIfACyclicInteractionIsEncountered) {
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
   PluginMetadata plugin(blankEsm);
   plugin.SetLoadAfterFiles({File(blankMasterDependentEsm)});
-  game_.GetDatabase()->SetPluginUserMetadata(plugin);
+  game_.GetDatabase().SetPluginUserMetadata(plugin);
 
   EXPECT_THROW(SortPlugins(game_, game_.GetLoadOrder()),
                CyclicInteractionError);
diff --git a/src/tests/api/internals/sorting/plugin_sorting_data_test.h b/src/tests/api/internals/sorting/plugin_sorting_data_test.h
index 254608d9..4a85da0b 100644
--- a/src/tests/api/internals/sorting/plugin_sorting_data_test.h
+++ b/src/tests/api/internals/sorting/plugin_sorting_data_test.h
@@ -85,40 +85,40 @@ TEST_P(PluginSortingDataTest, lightFlaggedEspFilesShouldNotBeTreatedAsMasters) {
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   auto esp = PluginSortingData(
-      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsp).get()),
+      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsp)),
       PluginMetadata(),
       PluginMetadata(),
       getLoadOrder(),
       game_.Type(),
-      game_.GetCache()->GetPlugins());
+      game_.GetCache().GetPlugins());
   EXPECT_FALSE(esp.IsMaster());
 
   auto master = PluginSortingData(
-      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsm).get()),
+      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsm)),
       PluginMetadata(),
       PluginMetadata(),
       getLoadOrder(),
       game_.Type(),
-      game_.GetCache()->GetPlugins());
+      game_.GetCache().GetPlugins());
   EXPECT_TRUE(master.IsMaster());
 
   if (GetParam() == GameType::fo4 || GetParam() == GameType::tes5se) {
     auto lightMaster = PluginSortingData(
-        *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsl).get()),
+        *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEsl)),
         PluginMetadata(),
         PluginMetadata(),
         getLoadOrder(),
         game_.Type(),
-        game_.GetCache()->GetPlugins());
+        game_.GetCache().GetPlugins());
     EXPECT_TRUE(lightMaster.IsMaster());
 
     auto lightPlugin = PluginSortingData(
-        *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEslEsp).get()),
+        *dynamic_cast<const Plugin *>(game_.GetPlugin(blankEslEsp)),
         PluginMetadata(),
         PluginMetadata(),
         getLoadOrder(),
         game_.Type(),
-        game_.GetCache()->GetPlugins());
+        game_.GetCache().GetPlugins());
     EXPECT_FALSE(lightPlugin.IsMaster());
   }
 }
@@ -127,14 +127,13 @@ TEST_P(PluginSortingDataTest,
        numOverrideFormIdsShouldEqualSizeOfOverlapWithThePluginsMasters) {
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
-  auto plugin =
-      PluginSortingData(*dynamic_cast<const Plugin *>(
-                            game_.GetPlugin(blankMasterDependentEsm).get()),
-                        PluginMetadata(),
-                        PluginMetadata(),
-                        getLoadOrder(),
-                        game_.Type(),
-                        game_.GetCache()->GetPlugins());
+  auto plugin = PluginSortingData(
+      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankMasterDependentEsm)),
+      PluginMetadata(),
+      PluginMetadata(),
+      getLoadOrder(),
+      game_.Type(),
+      game_.GetCache().GetPlugins());
   EXPECT_EQ(4, plugin.NumOverrideFormIDs());
 }
 
@@ -148,7 +147,7 @@ TEST_P(
   ASSERT_NO_THROW(loadInstalledPlugins(game_, false));
 
   // Pretend that blankEsm isn't loaded.
-  auto loadedPlugins = game_.GetCache()->GetPlugins();
+  auto loadedPlugins = game_.GetCache().GetPlugins();
   for (auto it = loadedPlugins.begin(); it != loadedPlugins.end();) {
     if ((*it)->GetName() == blankEsm) {
       it = loadedPlugins.erase(it);
@@ -157,14 +156,13 @@ TEST_P(
     }
   }
 
-  auto plugin =
-      PluginSortingData(*dynamic_cast<const Plugin *>(
-                            game_.GetPlugin(blankMasterDependentEsm).get()),
-                        PluginMetadata(),
-                        PluginMetadata(),
-                        getLoadOrder(),
-                        game_.Type(),
-                        loadedPlugins);
+  auto plugin = PluginSortingData(
+      *dynamic_cast<const Plugin *>(game_.GetPlugin(blankMasterDependentEsm)),
+      PluginMetadata(),
+      PluginMetadata(),
+      getLoadOrder(),
+      game_.Type(),
+      loadedPlugins);
 
   EXPECT_EQ(10, plugin.NumOverrideFormIDs());
 }