diff --git a/editor/Editor.cpp b/editor/Editor.cpp
index 2a58a78..13fa27d 100644
--- a/editor/Editor.cpp
+++ b/editor/Editor.cpp
@@ -160,53 +160,18 @@ void Editor::reloadScriptLib()
         [](const auto& e) -> bool { return e.template get<0>().instance == nullptr; }
     ));
 
-    m_listScriptNames = {};
-    m_listScriptParameters = {};
-    m_makeScriptInstance = {};
-
     if (m_project.scriptLib().empty())
-        m_scriptLibHandle.reset();
-    else
-        m_scriptLibHandle.reset(dlLoad(m_project.scriptLib().string().c_str()));
-
-    if (m_scriptLibHandle == nullptr)
-        throw std::runtime_error(std::format("unable to load shared lib : {}", m_project.scriptLib().string()));
-
-    void* listScriptNamesSym = getSym(m_scriptLibHandle.get(), "listScriptNames");
-    void* listScriptParametersSym = getSym(m_scriptLibHandle.get(), "listScriptParameters");
-    void* makeScriptInstanceSym = getSym(m_scriptLibHandle.get(), "makeScriptInstance");
-
-    if (listScriptNamesSym == nullptr || listScriptParametersSym == nullptr || makeScriptInstanceSym == nullptr)
     {
-        m_scriptLibHandle.reset();
-        throw std::runtime_error(std::format("unable to get symbols in lib : {}", m_project.scriptLib().string()));
+        m_listScriptNames = {};
+        m_listScriptParameters = {};
+        m_makeScriptInstance = {};
+        return;
     }
 
-    m_listScriptNames = [listScriptNamesSym]() -> std::vector<std::string> {
-        const char** names = nullptr;
-        unsigned long count = 0;
-        reinterpret_cast<GE::ListScriptNamesFn>(listScriptNamesSym)(&names, &count);
-        std::vector<std::string> output;
-        for (unsigned long i = 0; i < count; i++)
-            if (names[i] != nullptr)
-                output.emplace_back(names[i]);
-        return output;
-    };
-
-    m_listScriptParameters = [listScriptParametersSym](const std::string& name) -> std::vector<GE::ScriptParameterDescriptor> {
-        const GE::ScriptParameterDescriptor* parameters = nullptr;
-        unsigned long count = 0;
-        reinterpret_cast<GE::ListScriptParametersFn>(listScriptParametersSym)(name.c_str(), &parameters, &count);
-        std::vector<GE::ScriptParameterDescriptor> output;
-        output.reserve(count);
-        for (unsigned long i = 0; i < count; i++)
-            output.emplace_back(parameters[i]);
-        return output;
-    };
-
-    m_makeScriptInstance = [makeScriptInstanceSym](const std::string& name) -> std::shared_ptr<GE::Script> {
-        return std::shared_ptr<GE::Script>(reinterpret_cast<GE::MakeScriptInstanceFn>(makeScriptInstanceSym)(name.c_str()));
-    };
+    GE::ScriptLibraryManager manager(m_project.scriptLib());
+    m_listScriptNames = manager.listScriptNamesFunction();
+    m_listScriptParameters = manager.listScriptParametersFunction();
+    m_makeScriptInstance = manager.makeScriptInstanceFunction();
 }
 
 void Editor::startGame()
diff --git a/editor/Editor.hpp b/editor/Editor.hpp
index 1f2893f..20e3926 100644
--- a/editor/Editor.hpp
+++ b/editor/Editor.hpp
@@ -18,22 +18,15 @@
 #include <Game-Engine/FrameGraph.hpp>
 #include <Game-Engine/InputContext.hpp>
 #include <Game-Engine/Input.hpp>
-#include <Game-Engine/Script.hpp>
+#include <Game-Engine/ScriptLibraryManager.hpp>
 #include <Game-Engine/Scene.hpp>
 
-#include <dlLoad/dlLoad.h>
-
 #include <imgui.h>
 
 #include <cstdint>
 #include <filesystem>
-#include <memory>
 #include <optional>
-#include <string>
-#include <type_traits>
 #include <utility>
-#include <vector>
-#include <functional>
 
 namespace GE_Editor
 {
@@ -53,16 +46,6 @@ class Editor : public GE::Application
     ~Editor() override = default;
 
 private:
-    struct DlHandleDeleter
-    {
-        void operator()(DlHandle handle) const
-        {
-            if (handle != nullptr)
-                dlFree(handle);
-        }
-    };
-    using UniqueDlHandle = std::unique_ptr<std::remove_pointer_t<DlHandle>, DlHandleDeleter>;
-
     void loadProject(const std::filesystem::path&);
     void saveEditedScene();
     void saveProject();
@@ -76,11 +59,6 @@ class Editor : public GE::Application
     void rebuildFrameGraph();
     void renderImgui();
 
-    UniqueDlHandle m_scriptLibHandle; // need to be before m_edited scene so it is destroyed after
-    std::function<std::vector<std::string>()> m_listScriptNames;
-    std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> m_listScriptParameters;
-    std::function<std::shared_ptr<GE::Script>(const std::string&)> m_makeScriptInstance;
-
     std::filesystem::path m_projectFilePath;
     Project m_project;
 
@@ -97,6 +75,10 @@ class Editor : public GE::Application
     std::pair<uint32_t, uint32_t> m_viewportSize = {0, 0};
     GE::FrameGraph m_frameGraph; // TODO move into render (something like render->setGraph())
 
+    GE::ListScriptNamesFn m_listScriptNames;
+    GE::ListScriptParametersFn m_listScriptParameters;
+    GE::MakeScriptInstanceFn m_makeScriptInstance;
+
 public:
     Editor& operator=(const Editor&) = delete;
     Editor& operator=(Editor&&) = delete;
diff --git a/editor/UI/EntityInspectorPanel.cpp b/editor/UI/EntityInspectorPanel.cpp
index 31bd5ad..36b0323 100644
--- a/editor/UI/EntityInspectorPanel.cpp
+++ b/editor/UI/EntityInspectorPanel.cpp
@@ -12,7 +12,7 @@
 #include <Game-Engine/Components.hpp>
 #include <Game-Engine/ECSWorld.hpp>
 #include <Game-Engine/Entity.hpp>
-#include <Game-Engine/Script.hpp>
+#include <Game-Engine/ScriptLibraryManager.hpp>
 
 #include <imgui.h>
 
@@ -92,11 +92,15 @@ template<>
 void EntityInspectorPanel::componentEditWidget<GE::ScriptComponent>()
 {
     GE::ScriptComponent& scriptComponent = m_entity.get<GE::ScriptComponent>();
+    if (!m_listScriptNames || !m_listScriptParameters)
+    {
+        ImGui::TextDisabled("No script library loaded");
+        return;
+    }
 
     const char* previewValue = scriptComponent.name.empty() ? "none" : scriptComponent.name.c_str();
     if (ImGui::BeginCombo("Script##ScriptComponent_name", previewValue))
     {
-        assert(m_listScriptNames);
         for (const std::string& scriptName : m_listScriptNames())
         {
             const bool isSelected = scriptComponent.name == scriptName;
@@ -104,7 +108,6 @@ void EntityInspectorPanel::componentEditWidget<GE::ScriptComponent>()
             {
                 scriptComponent.name = scriptName;
                 scriptComponent.parameters.clear();
-                assert(m_listScriptParameters);
                 for (const GE::ScriptParameterDescriptor& parameter : m_listScriptParameters(scriptName))
                 {
                     auto [parameterIt, inserted] = scriptComponent.parameters.try_emplace(parameter.name, parameter.defaultValue);
@@ -150,8 +153,8 @@ void EntityInspectorPanel::componentEditWidget<GE::ScriptComponent>()
 
 EntityInspectorPanel::EntityInspectorPanel(
     const GE::Entity& entity,
-    std::function<std::vector<std::string>()> listScriptNames,
-    std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> listScriptParameters
+    GE::ListScriptNamesFn listScriptNames,
+    GE::ListScriptParametersFn listScriptParameters
 )
     : m_entity(entity)
     , m_listScriptNames(std::move(listScriptNames))
diff --git a/editor/UI/EntityInspectorPanel.hpp b/editor/UI/EntityInspectorPanel.hpp
index 36cf109..f32a951 100644
--- a/editor/UI/EntityInspectorPanel.hpp
+++ b/editor/UI/EntityInspectorPanel.hpp
@@ -11,10 +11,9 @@
 #define ENTITYINSPECTORPANEL_HPP
 
 #include <Game-Engine/Entity.hpp>
-#include <Game-Engine/Script.hpp>
+#include <Game-Engine/ScriptLibraryManager.hpp>
+
 #include <functional>
-#include <string>
-#include <vector>
 
 namespace GE_Editor
 {
@@ -28,8 +27,8 @@ class EntityInspectorPanel
 
     EntityInspectorPanel(
         const GE::Entity& entity,
-        std::function<std::vector<std::string>()> listScriptNames,
-        std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> listScriptParameters
+        GE::ListScriptNamesFn listScriptNames,
+        GE::ListScriptParametersFn listScriptParameters
     );
 
     EntityInspectorPanel& onEntityDelete(std::function<void()>&& f) { return m_onEntityDelete = std::move(f), *this; }
@@ -44,8 +43,8 @@ class EntityInspectorPanel
     void addComponentPopUp();
 
     GE::Entity m_entity;
-    std::function<std::vector<std::string>()> m_listScriptNames;
-    std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> m_listScriptParameters;
+    GE::ListScriptNamesFn m_listScriptNames;
+    GE::ListScriptParametersFn m_listScriptParameters;
 
     std::function<void()> m_onEntityDelete;
 
diff --git a/include/Game-Engine/Game.hpp b/include/Game-Engine/Game.hpp
index d58917e..118399b 100644
--- a/include/Game-Engine/Game.hpp
+++ b/include/Game-Engine/Game.hpp
@@ -13,13 +13,10 @@
 #include "Game-Engine/InputContext.hpp"
 #include "Game-Engine/Scene.hpp"
 #include "Game-Engine/AssetManager.hpp"
-#include "Game-Engine/Script.hpp"
+#include "Game-Engine/ScriptLibraryManager.hpp"
 
 #include <map>
-#include <memory>
 #include <string>
-#include <functional>
-#include <vector>
 
 namespace GE
 {
@@ -41,8 +38,8 @@ class GE_API Game
 
     Game(
         AssetManager* assetManager,
-        std::function<std::shared_ptr<GE::Script>(const std::string&)> makeScriptInstance,
-        std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> listScriptParameters,
+        MakeScriptInstanceFn makeScriptInstance,
+        ListScriptParametersFn listScriptParameters,
         const Descriptor& descriptor
     );
 
@@ -54,8 +51,8 @@ class GE_API Game
     ~Game();
 
 private:
-    std::function<std::shared_ptr<GE::Script>(const std::string&)> m_makeScriptInstance;
-    std::function<std::vector<GE::ScriptParameterDescriptor>(const std::string&)> m_listScriptParameters;
+    MakeScriptInstanceFn m_makeScriptInstance;
+    ListScriptParametersFn m_listScriptParameters;
     std::map<std::string, Scene> m_scenes;
     Scene* m_activeScene = nullptr;
     InputContext m_inputContext;
diff --git a/include/Game-Engine/Script.hpp b/include/Game-Engine/Script.hpp
index 15903f4..f310adc 100644
--- a/include/Game-Engine/Script.hpp
+++ b/include/Game-Engine/Script.hpp
@@ -71,10 +71,6 @@ class GE_API Script
 template<typename T>
 concept ScriptClass = std::derived_from<T, Script>;
 
-using MakeScriptInstanceFn = Script* (*)(const char*);
-using ListScriptNamesFn = void (*)(const char***, unsigned long*);
-using ListScriptParametersFn = void (*)(const char*, const ScriptParameterDescriptor**, unsigned long*);
-
 class GE_API ScriptRegistry
 {
 public:
diff --git a/include/Game-Engine/ScriptLibraryManager.hpp b/include/Game-Engine/ScriptLibraryManager.hpp
new file mode 100644
index 0000000..3ed89d5
--- /dev/null
+++ b/include/Game-Engine/ScriptLibraryManager.hpp
@@ -0,0 +1,60 @@
+/*
+ * ---------------------------------------------------
+ * ScriptLibraryManager.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef SCRIPT_LIBRARY_MANAGER_HPP
+#define SCRIPT_LIBRARY_MANAGER_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Script.hpp"
+
+#include <filesystem>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace GE
+{
+
+
+using ListScriptNamesFn = std::function<std::vector<std::string>()>;
+using ListScriptParametersFn = std::function<std::vector<ScriptParameterDescriptor>(const std::string&)>;
+using MakeScriptInstanceFn = std::function<std::shared_ptr<Script>(const std::string&)>;
+
+class GE_API ScriptLibraryManager
+{
+public:
+
+    ScriptLibraryManager(const std::filesystem::path& path);
+    ScriptLibraryManager(const ScriptLibraryManager&) = delete;
+    ScriptLibraryManager(ScriptLibraryManager&&) = default;
+
+    ListScriptNamesFn listScriptNamesFunction() const;
+    ListScriptParametersFn listScriptParametersFunction() const;
+    MakeScriptInstanceFn makeScriptInstanceFunction() const;
+
+    ~ScriptLibraryManager();
+
+    ScriptLibraryManager& operator=(const ScriptLibraryManager&) = delete;
+    ScriptLibraryManager& operator=(ScriptLibraryManager&&) = default;
+
+private:
+    using MakeScriptInstanceSym = Script* (*)(const char*);
+    using ListScriptNamesSym = void (*)(const char***, unsigned long*);
+    using ListScriptParametersSym = void (*)(const char*, const ScriptParameterDescriptor**, unsigned long*);
+
+    std::shared_ptr<void> m_libraryHandle;
+
+    ListScriptNamesSym m_listScriptNames = nullptr;
+    ListScriptParametersSym m_listScriptParameters = nullptr;
+    MakeScriptInstanceSym m_makeScriptInstance = nullptr;
+};
+
+} // namespace GE
+
+#endif // SCRIPT_LIBRARY_MANAGER_HPP
diff --git a/src/Game.cpp b/src/Game.cpp
index feea4ad..55a33e2 100644
--- a/src/Game.cpp
+++ b/src/Game.cpp
@@ -7,12 +7,15 @@
  */
 
 #include "Game-Engine/Game.hpp"
+#include "Game-Engine/ScriptLibraryManager.hpp"
 #include "Game-Engine/ECSView.hpp"
 #include "Game-Engine/Scene.hpp"
 #include "Game-Engine/AssetManager.hpp"
 
+#include <format>
 #include <cassert>
 #include <ranges>
+#include <stdexcept>
 #include <utility>
 
 namespace GE
@@ -24,8 +27,8 @@ namespace
 void setupScene(
     Game& game,
     Scene& scene,
-    const std::function<std::shared_ptr<Script>(const std::string&)>& makeScriptInstance,
-    const std::function<std::vector<ScriptParameterDescriptor>(const std::string&)>& listScriptParameters
+    const MakeScriptInstanceFn& makeScriptInstance,
+    const ListScriptParametersFn& listScriptParameters
 )
 {
     scene.load();
@@ -33,8 +36,8 @@ void setupScene(
                              | ECSView<ScriptComponent>()
                              | std::views::transform([&](auto id) { return Entity{ &scene.ecsWorld(), id }; }))
     {
-        assert(makeScriptInstance);
-        assert(listScriptParameters);
+        if (!makeScriptInstance || !listScriptParameters)
+            throw std::runtime_error(std::format("unable to create script '{}' without a loaded script library", entity.get<ScriptComponent>().name));
         ScriptComponent& scriptComponent = entity.get<ScriptComponent>();
         scriptComponent.instance = makeScriptInstance(scriptComponent.name);
         assert(scriptComponent.instance);
@@ -65,8 +68,8 @@ void tearDownScene(Game& game, Scene& scene)
 
 Game::Game(
     AssetManager* assetManager,
-    std::function<std::shared_ptr<Script>(const std::string&)> makeScriptInstance,
-    std::function<std::vector<ScriptParameterDescriptor>(const std::string&)> listScriptParameters,
+    MakeScriptInstanceFn makeScriptInstance,
+    ListScriptParametersFn listScriptParameters,
     const Descriptor& descriptor
 )
     : m_makeScriptInstance(std::move(makeScriptInstance))
diff --git a/src/ScriptLibraryManager.cpp b/src/ScriptLibraryManager.cpp
new file mode 100644
index 0000000..4e342b5
--- /dev/null
+++ b/src/ScriptLibraryManager.cpp
@@ -0,0 +1,99 @@
+/*
+ * ---------------------------------------------------
+ * ScriptLibraryManager.cpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/ScriptLibraryManager.hpp"
+
+#include <dlLoad/dlLoad.h>
+
+#include <format>
+#include <stdexcept>
+namespace GE
+{
+
+ScriptLibraryManager::ScriptLibraryManager(const std::filesystem::path& path)
+{
+    DlHandle handle = dlLoad(path.string().c_str());
+    if (handle == nullptr)
+        throw std::runtime_error(std::format("unable to load shared lib : {}", path.string()));
+
+    m_libraryHandle = std::shared_ptr<void>(handle, [](void* ptr){
+        if (ptr != nullptr)
+            dlFree(ptr);
+    });
+    m_listScriptNames = reinterpret_cast<ListScriptNamesSym>(getSym(handle, "listScriptNames"));
+    m_listScriptParameters = reinterpret_cast<ListScriptParametersSym>(getSym(handle, "listScriptParameters"));
+    m_makeScriptInstance = reinterpret_cast<MakeScriptInstanceSym>(getSym(handle, "makeScriptInstance"));
+
+    if (m_listScriptNames == nullptr || m_listScriptParameters == nullptr || m_makeScriptInstance == nullptr)
+        throw std::runtime_error(std::format("unable to get symbols in lib : {}", path.string()));
+}
+
+ListScriptNamesFn ScriptLibraryManager::listScriptNamesFunction() const
+{
+    return [libraryHandle = m_libraryHandle, listScriptNamesFn = m_listScriptNames]() -> std::vector<std::string> {
+        (void)libraryHandle;
+        if (listScriptNamesFn == nullptr)
+            return {};
+
+        const char** names = nullptr;
+        unsigned long count = 0;
+        listScriptNamesFn(&names, &count);
+
+        std::vector<std::string> output;
+        output.reserve(count);
+        for (unsigned long i = 0; i < count; i++)
+            if (names[i] != nullptr)
+                output.emplace_back(names[i]);
+        return output;
+    };
+}
+
+ListScriptParametersFn ScriptLibraryManager::listScriptParametersFunction() const
+{
+    return [libraryHandle = m_libraryHandle, listScriptParametersFn = m_listScriptParameters](const std::string& scriptName) -> std::vector<ScriptParameterDescriptor> {
+        (void)libraryHandle;
+        if (listScriptParametersFn == nullptr)
+            return {};
+
+        const ScriptParameterDescriptor* parameters = nullptr;
+        unsigned long count = 0;
+        listScriptParametersFn(scriptName.c_str(), &parameters, &count);
+
+        std::vector<ScriptParameterDescriptor> output;
+        output.reserve(count);
+        for (unsigned long i = 0; i < count; i++)
+            output.emplace_back(parameters[i]);
+        return output;
+    };
+}
+
+MakeScriptInstanceFn ScriptLibraryManager::makeScriptInstanceFunction() const
+{
+    return [libraryHandle = m_libraryHandle, makeScriptInstanceFn = m_makeScriptInstance](const std::string& scriptName) -> std::shared_ptr<Script> {
+        if (makeScriptInstanceFn == nullptr)
+            return {};
+
+        Script* script = makeScriptInstanceFn(scriptName.c_str());
+        if (script == nullptr)
+            return {};
+
+        return std::shared_ptr<Script>(script, [libraryHandle](Script* ptr) {
+            delete ptr;
+        });
+    };
+}
+
+ScriptLibraryManager::~ScriptLibraryManager()
+{
+    m_listScriptNames = nullptr;
+    m_listScriptParameters = nullptr;
+    m_makeScriptInstance = nullptr;
+    m_libraryHandle.reset();
+}
+
+} // namespace GE
diff --git a/tests/Script_testCases.cpp b/tests/Script_testCases.cpp
index 82a8ff7..bcafe44 100644
--- a/tests/Script_testCases.cpp
+++ b/tests/Script_testCases.cpp
@@ -1,4 +1,5 @@
 #include <Game-Engine/Script.hpp>
+#include <Game-Engine/ScriptLibraryManager.hpp>
 
 #include <dlLoad/dlLoad.h>
 #include <gtest/gtest.h>
@@ -8,6 +9,7 @@
 #include <memory>
 #include <string>
 #include <type_traits>
+#include <vector>
 
 static_assert(GE::ScriptValueType<bool>);
 static_assert(GE::ScriptValueType<int64_t>);
@@ -52,48 +54,66 @@ const GE::ScriptParameterDescriptor* findParameter(const GE::ScriptParameterDesc
 
 TEST(ScriptLibraryTest, loadsGeneratedScriptLibraryExports)
 {
-    UniqueDlHandle handle(dlLoad(GE_TEST_SCRIPT_LIB));
-    ASSERT_NE(handle, nullptr);
+    EXPECT_NO_THROW({
+        GE::ScriptLibraryManager manager(GE_TEST_SCRIPT_LIB);
+        GE::ListScriptNamesFn listScriptNames = manager.listScriptNamesFunction();
+        GE::ListScriptParametersFn listScriptParameters = manager.listScriptParametersFunction();
+        GE::MakeScriptInstanceFn makeScriptInstance = manager.makeScriptInstanceFunction();
 
-    auto listScriptNames = loadFunction<GE::ListScriptNamesFn>(handle.get(), "listScriptNames");
-    auto listScriptParameters = loadFunction<GE::ListScriptParametersFn>(handle.get(), "listScriptParameters");
-    auto makeScriptInstance = loadFunction<GE::MakeScriptInstanceFn>(handle.get(), "makeScriptInstance");
+        std::vector<std::string> names = listScriptNames();
 
-    const char** names = nullptr;
-    unsigned long nameCount = 0;
-    listScriptNames(&names, &nameCount);
+        ASSERT_EQ(names.size(), 1u);
+        EXPECT_EQ(names[0], std::string("TestScript"));
 
-    ASSERT_NE(names, nullptr);
-    ASSERT_EQ(nameCount, 1u);
-    EXPECT_STREQ(names[0], "TestScript");
+        std::vector<GE::ScriptParameterDescriptor> parameters = listScriptParameters("TestScript");
 
-    const GE::ScriptParameterDescriptor* parameters = nullptr;
-    unsigned long parameterCount = 0;
-    listScriptParameters("TestScript", &parameters, &parameterCount);
+        ASSERT_EQ(parameters.size(), 3u);
 
-    ASSERT_NE(parameters, nullptr);
-    ASSERT_EQ(parameterCount, 3u);
+        const GE::ScriptParameterDescriptor* speed = findParameter(parameters.data(), parameters.size(), "speed");
+        const GE::ScriptParameterDescriptor* enabled = findParameter(parameters.data(), parameters.size(), "enabled");
+        const GE::ScriptParameterDescriptor* label = findParameter(parameters.data(), parameters.size(), "label");
 
-    const GE::ScriptParameterDescriptor* speed = findParameter(parameters, parameterCount, "speed");
-    const GE::ScriptParameterDescriptor* enabled = findParameter(parameters, parameterCount, "enabled");
-    const GE::ScriptParameterDescriptor* label = findParameter(parameters, parameterCount, "label");
+        ASSERT_NE(speed, nullptr);
+        ASSERT_NE(enabled, nullptr);
+        ASSERT_NE(label, nullptr);
 
-    ASSERT_NE(speed, nullptr);
-    ASSERT_NE(enabled, nullptr);
-    ASSERT_NE(label, nullptr);
+        EXPECT_EQ(std::get<float>(speed->defaultValue), 2.5f);
+        EXPECT_EQ(std::get<bool>(enabled->defaultValue), true);
+        EXPECT_EQ(std::get<std::string>(label->defaultValue), "default");
+
+        std::shared_ptr<GE::Script> script = makeScriptInstance("TestScript");
+        ASSERT_NE(script, nullptr);
+
+        speed->set(*script, 7.0f);
+        enabled->set(*script, false);
+        label->set(*script, std::string("changed"));
+
+        EXPECT_EQ(std::get<float>(speed->get(*script)), 7.0f);
+        EXPECT_EQ(std::get<bool>(enabled->get(*script)), false);
+        EXPECT_EQ(std::get<std::string>(label->get(*script)), "changed");
+    });
+}
 
-    EXPECT_EQ(std::get<float>(speed->defaultValue), 2.5f);
-    EXPECT_EQ(std::get<bool>(enabled->defaultValue), true);
-    EXPECT_EQ(std::get<std::string>(label->defaultValue), "default");
+TEST(ScriptLibraryManagerTest, keepsLibraryAliveForScriptInstanceLifetime)
+{
+    GE::ListScriptParametersFn listScriptParameters;
+    GE::MakeScriptInstanceFn makeScriptInstance;
+    {
+        GE::ScriptLibraryManager manager(GE_TEST_SCRIPT_LIB);
+        listScriptParameters = manager.listScriptParametersFunction();
+        makeScriptInstance = manager.makeScriptInstanceFunction();
+    }
+
+    std::vector<GE::ScriptParameterDescriptor> parameters = listScriptParameters("TestScript");
+    ASSERT_EQ(parameters.size(), 3u);
+    const GE::ScriptParameterDescriptor* speed = findParameter(parameters.data(), parameters.size(), "speed");
+    ASSERT_NE(speed, nullptr);
 
-    std::unique_ptr<GE::Script> script(makeScriptInstance("TestScript"));
+    std::shared_ptr<GE::Script> script = makeScriptInstance("TestScript");
     ASSERT_NE(script, nullptr);
 
-    speed->set(*script, 7.0f);
-    enabled->set(*script, false);
-    label->set(*script, std::string("changed"));
+    speed->set(*script, 11.0f);
+    EXPECT_EQ(std::get<float>(speed->get(*script)), 11.0f);
 
-    EXPECT_EQ(std::get<float>(speed->get(*script)), 7.0f);
-    EXPECT_EQ(std::get<bool>(enabled->get(*script)), false);
-    EXPECT_EQ(std::get<std::string>(label->get(*script)), "changed");
+    script.reset();
 }