From 098da9de929f2148f5aaea62bf3477396cb749cf Mon Sep 17 00:00:00 2001
From: Egor Orachyov <egororachyov5@gmail.com>
Date: Thu, 10 Oct 2024 02:54:41 +0300
Subject: [PATCH] gh-83: rework app structure & remove globals entirely,
 explicit dependency propagation

---
 .gitignore                                    |   3 -
 engine/plugins/assimp/assimp_asset_loader.cpp |   4 +-
 .../freetype/freetype_asset_loader.cpp        |   3 +-
 engine/plugins/freetype/freetype_font.cpp     |  10 +-
 engine/plugins/freetype/freetype_font.hpp     |   2 +-
 .../runtime/asset/default_asset_loader.cpp    |   4 +-
 .../runtime/asset/shader_asset_loader.cpp     |   4 +-
 .../runtime/asset/texture_asset_loader.cpp    |  12 +-
 engine/runtime/asset/asset_library_fs.cpp     |   2 +-
 engine/runtime/asset/asset_loader.hpp         |   6 +-
 engine/runtime/asset/asset_manager.cpp        |  11 +-
 engine/runtime/asset/asset_manager.hpp        |   1 +
 engine/runtime/core/cmd_line.cpp              |  86 ++++++-
 engine/runtime/core/cmd_line.hpp              |  73 +++++-
 .../{system => core}/ioc_container.cpp        |  10 -
 .../{system => core}/ioc_container.hpp        |  25 +-
 engine/runtime/core/log.cpp                   |  43 ++--
 engine/runtime/core/log.hpp                   |   8 +-
 engine/runtime/core/task.cpp                  |  13 +-
 engine/runtime/core/task.hpp                  |  16 +-
 engine/runtime/core/task_parallel_for.cpp     |  13 +-
 engine/runtime/core/task_parallel_for.hpp     |  17 +-
 engine/runtime/ecs/ecs_core.cpp               |   7 +-
 engine/runtime/ecs/ecs_core.hpp               |   7 +-
 engine/runtime/ecs/ecs_memory.cpp             |  14 +-
 engine/runtime/ecs/ecs_memory.hpp             |   2 +-
 engine/runtime/ecs/ecs_registry.cpp           |   8 -
 engine/runtime/ecs/ecs_registry.hpp           |   3 -
 engine/runtime/ecs/ecs_world.cpp              |  13 +-
 engine/runtime/ecs/ecs_world.hpp              |   2 +-
 engine/runtime/engine.hpp                     |  12 +-
 engine/runtime/gfx/vulkan/vk_driver.cpp       |  27 +--
 engine/runtime/gfx/vulkan/vk_driver.hpp       |   2 +-
 engine/runtime/gfx/vulkan/vk_window.cpp       |   5 -
 engine/runtime/glsl/glsl_shader_compiler.cpp  |  16 +-
 engine/runtime/glsl/glsl_shader_compiler.hpp  |  23 +-
 engine/runtime/grc/image.cpp                  |   2 +-
 engine/runtime/grc/pso_cache.cpp              |  18 +-
 engine/runtime/grc/pso_cache.hpp              |   2 +-
 engine/runtime/grc/pso_file.cpp               |  22 --
 engine/runtime/grc/pso_file.hpp               |  10 -
 engine/runtime/grc/shader_cache.cpp           |  19 +-
 engine/runtime/grc/shader_cache.hpp           |   4 +-
 engine/runtime/grc/shader_library.cpp         |  43 ++--
 engine/runtime/grc/shader_library.hpp         |  13 +-
 engine/runtime/grc/shader_manager.cpp         |  55 ++---
 engine/runtime/grc/shader_manager.hpp         |   5 +-
 engine/runtime/grc/shader_pass.cpp            |  13 +-
 engine/runtime/grc/texture.cpp                |   2 +-
 engine/runtime/grc/texture_manager.cpp        |   6 +-
 engine/runtime/grc/texture_manager.hpp        |   2 +-
 engine/runtime/hooks/hook_engine.hpp          | 106 ---------
 engine/runtime/hooks/hook_logs.hpp            |  91 -------
 engine/runtime/hooks/hook_profiler.hpp        | 100 --------
 engine/runtime/hooks/hook_root_remap.hpp      |  66 ------
 engine/runtime/hooks/hook_uuid_gen.hpp        |  66 ------
 engine/runtime/io/async_file_system.cpp       |   5 +-
 engine/runtime/io/stream_file.cpp             |   8 +-
 engine/runtime/io/stream_file.hpp             |   2 +-
 engine/runtime/io/tree_yaml.cpp               |  16 +-
 engine/runtime/io/tree_yaml.hpp               |   4 +-
 engine/runtime/mesh/mesh_manager.cpp          |   6 +-
 engine/runtime/mesh/mesh_manager.hpp          |   2 +-
 engine/runtime/platform/dll_manager.cpp       |  10 +-
 engine/runtime/platform/dll_manager.hpp       |   3 +-
 engine/runtime/platform/file_system.cpp       |   2 +-
 engine/runtime/profiler/profiler.cpp          |  88 ++++---
 engine/runtime/profiler/profiler.hpp          |  18 +-
 engine/runtime/rdg/rdg_graph.cpp              |   5 +-
 engine/runtime/rdg/rdg_graph.hpp              |   2 +-
 engine/runtime/rdg/rdg_pool.cpp               |   9 +-
 engine/runtime/rdg/rdg_pool.hpp               |   6 +-
 engine/runtime/render/aux_draw_manager.cpp    |  20 +-
 engine/runtime/render/aux_draw_manager.hpp    |   3 -
 engine/runtime/render/culling.cpp             |   4 +-
 engine/runtime/render/culling.hpp             |   2 +-
 engine/runtime/render/render_engine.cpp       |   6 +-
 engine/runtime/render/render_engine.hpp       |   4 +-
 engine/runtime/rtti/struct.hpp                |   1 +
 engine/runtime/rtti/traits.hpp                |   5 +-
 engine/runtime/rtti/type_storage.cpp          |   3 +-
 engine/runtime/rtti/type_storage.hpp          |   3 +-
 engine/runtime/scene/scene.cpp                |   6 +-
 engine/runtime/scene/scene.hpp                |  13 +-
 engine/runtime/scene/scene_manager.cpp        |  15 +-
 engine/runtime/scene/scene_manager.hpp        |   3 +-
 engine/runtime/scene/scene_packed.cpp         |  34 ---
 engine/runtime/scene/scene_packed.hpp         |   3 -
 engine/runtime/scripting/_rtti.cpp            |  38 ---
 engine/runtime/scripting/_rtti.hpp            |  34 ---
 engine/runtime/scripting/lua/lua_defs.cpp     |  28 ---
 engine/runtime/scripting/lua/lua_defs.hpp     |  50 ----
 engine/runtime/scripting/lua/lua_script.cpp   |  93 --------
 engine/runtime/scripting/lua/lua_script.hpp   |  76 ------
 .../scripting/lua/lua_script_instance.cpp     | 108 ---------
 .../scripting/lua/lua_script_instance.hpp     |  75 ------
 .../scripting/lua/lua_script_system.cpp       | 146 ------------
 .../scripting/lua/lua_script_system.hpp       |  79 ------
 .../runtime/scripting/lua/lua_type_traits.cpp | 112 ---------
 .../scripting/lua_bindings/lua_bindings.hpp   |  86 -------
 .../lua_bindings/lua_bindings_asset.cpp       |  98 --------
 .../lua_bindings/lua_bindings_asset.hpp       | 135 -----------
 .../lua_bindings/lua_bindings_core.cpp        | 163 -------------
 .../lua_bindings/lua_bindings_core.hpp        | 105 --------
 .../lua_bindings/lua_bindings_math.cpp        | 188 ---------------
 .../lua_bindings/lua_bindings_math.hpp        |  47 ----
 .../lua_bindings/lua_bindings_platform.cpp    | 111 ---------
 .../lua_bindings/lua_bindings_platform.hpp    |  90 -------
 .../lua_bindings/lua_bindings_scene.cpp       |  35 ---
 .../lua_bindings/lua_bindings_scene.hpp       |  42 ----
 engine/runtime/scripting/script.cpp           |  54 -----
 engine/runtime/scripting/script.hpp           |  82 -------
 engine/runtime/scripting/script_instance.hpp  |  84 -------
 engine/runtime/scripting/script_native.hpp    |  84 -------
 engine/runtime/scripting/script_system.hpp    |  74 ------
 .../{platform => system}/application.cpp      | 180 ++++----------
 .../{platform => system}/application.hpp      |  67 ++++--
 engine/runtime/system/config.cpp              |  11 +-
 engine/runtime/system/config.hpp              |   5 +-
 engine/runtime/system/config_file.cpp         |  24 +-
 engine/runtime/system/config_file.hpp         |  25 +-
 engine/runtime/system/console.cpp             |  33 +--
 engine/runtime/system/console.hpp             |   4 +-
 engine/runtime/system/engine.cpp              | 142 +++++------
 engine/runtime/system/engine.hpp              | 118 +++++----
 .../game_application.cpp}                     |  33 ++-
 .../game_application.hpp}                     |  41 ++--
 engine/runtime/system/hook.cpp                |  50 ----
 engine/runtime/system/hook.hpp                |  85 -------
 engine/runtime/system/hooks.cpp               | 224 ++++++++++++++++++
 .../lua_type_traits.hpp => system/hooks.hpp}  |  32 +--
 engine/runtime/system/plugin_manager.cpp      |   2 +-
 template/main.cpp                             |  55 ++++-
 133 files changed, 1075 insertions(+), 3836 deletions(-)
 rename engine/runtime/{system => core}/ioc_container.cpp (93%)
 rename engine/runtime/{system => core}/ioc_container.hpp (94%)
 delete mode 100644 engine/runtime/hooks/hook_engine.hpp
 delete mode 100644 engine/runtime/hooks/hook_logs.hpp
 delete mode 100644 engine/runtime/hooks/hook_profiler.hpp
 delete mode 100644 engine/runtime/hooks/hook_root_remap.hpp
 delete mode 100644 engine/runtime/hooks/hook_uuid_gen.hpp
 delete mode 100644 engine/runtime/scripting/_rtti.cpp
 delete mode 100644 engine/runtime/scripting/_rtti.hpp
 delete mode 100644 engine/runtime/scripting/lua/lua_defs.cpp
 delete mode 100644 engine/runtime/scripting/lua/lua_defs.hpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script.cpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script.hpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script_instance.cpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script_instance.hpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script_system.cpp
 delete mode 100644 engine/runtime/scripting/lua/lua_script_system.hpp
 delete mode 100644 engine/runtime/scripting/lua/lua_type_traits.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings.hpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_asset.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_asset.hpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_core.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_core.hpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_math.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_math.hpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_platform.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_platform.hpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_scene.cpp
 delete mode 100644 engine/runtime/scripting/lua_bindings/lua_bindings_scene.hpp
 delete mode 100644 engine/runtime/scripting/script.cpp
 delete mode 100644 engine/runtime/scripting/script.hpp
 delete mode 100644 engine/runtime/scripting/script_instance.hpp
 delete mode 100644 engine/runtime/scripting/script_native.hpp
 delete mode 100644 engine/runtime/scripting/script_system.hpp
 rename engine/runtime/{platform => system}/application.cpp (63%)
 rename engine/runtime/{platform => system}/application.hpp (71%)
 rename engine/runtime/{scripting/script_native.cpp => system/game_application.cpp} (78%)
 rename engine/runtime/{hooks/hook_config.hpp => system/game_application.hpp} (77%)
 delete mode 100644 engine/runtime/system/hook.cpp
 delete mode 100644 engine/runtime/system/hook.hpp
 create mode 100644 engine/runtime/system/hooks.cpp
 rename engine/runtime/{scripting/lua/lua_type_traits.hpp => system/hooks.hpp} (75%)

diff --git a/.gitignore b/.gitignore
index 82b2d0844..daf359fe1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,9 +2,6 @@
 /.idea
 /.vscode
 
-# vs code setup
-!.vscode/launch.json
-
 # python cache files
 /**/__pycache__
 
diff --git a/engine/plugins/assimp/assimp_asset_loader.cpp b/engine/plugins/assimp/assimp_asset_loader.cpp
index 80e8920de..75f9e273b 100644
--- a/engine/plugins/assimp/assimp_asset_loader.cpp
+++ b/engine/plugins/assimp/assimp_asset_loader.cpp
@@ -30,13 +30,13 @@
 #include "assimp_import_data.hpp"
 #include "assimp_importer.hpp"
 #include "core/data.hpp"
+#include "core/ioc_container.hpp"
 #include "math/math_utils3d.hpp"
 #include "mesh/mesh.hpp"
 #include "mesh/mesh_builder.hpp"
 #include "mesh/mesh_manager.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <cstring>
@@ -76,7 +76,7 @@ namespace wmoge {
             return StatusCode::Error;
         }
 
-        MeshManager* mesh_manager = IocContainer::iresolve_v<MeshManager>();
+        MeshManager* mesh_manager = context.ioc->resolve_value<MeshManager>();
 
         MeshFlags flags;
         flags.set(MeshFlag::FromDisk);
diff --git a/engine/plugins/freetype/freetype_asset_loader.cpp b/engine/plugins/freetype/freetype_asset_loader.cpp
index 1564a1092..3811eab5e 100644
--- a/engine/plugins/freetype/freetype_asset_loader.cpp
+++ b/engine/plugins/freetype/freetype_asset_loader.cpp
@@ -27,6 +27,7 @@
 
 #include "freetype_asset_loader.hpp"
 
+#include "core/ioc_container.hpp"
 #include "freetype_font.hpp"
 #include "freetype_import_data.hpp"
 #include "profiler/profiler.hpp"
@@ -56,7 +57,7 @@ namespace wmoge {
         asset = make_ref<Font>();
         asset->set_id(asset_id);
 
-        FreetypeFont loader;
+        FreetypeFont loader(context.ioc);
         return loader.load(asset, result.get_data_file(FILE_TAG), import_data->height, import_data->glyphs_in_row);
     }
 
diff --git a/engine/plugins/freetype/freetype_font.cpp b/engine/plugins/freetype/freetype_font.cpp
index 480a4ae6d..283497436 100644
--- a/engine/plugins/freetype/freetype_font.cpp
+++ b/engine/plugins/freetype/freetype_font.cpp
@@ -27,21 +27,21 @@
 
 #include "freetype_font.hpp"
 
+#include "core/ioc_container.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "grc/image.hpp"
 #include "grc/texture.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <freetype/freetype.h>
 
 namespace wmoge {
 
-    FreetypeFont::FreetypeFont() {
-        m_gfx_driver      = IocContainer::iresolve_v<GfxDriver>();
-        m_file_system     = IocContainer::iresolve_v<FileSystem>();
-        m_texture_manager = IocContainer::iresolve_v<TextureManager>();
+    FreetypeFont::FreetypeFont(IocContainer* ioc) {
+        m_gfx_driver      = ioc->resolve_value<GfxDriver>();
+        m_file_system     = ioc->resolve_value<FileSystem>();
+        m_texture_manager = ioc->resolve_value<TextureManager>();
     }
 
     Status FreetypeFont::load(const Ref<Font>& font, array_view<const std::uint8_t> ttf_data, int height, int glyphs_in_row) {
diff --git a/engine/plugins/freetype/freetype_font.hpp b/engine/plugins/freetype/freetype_font.hpp
index 449b3bd7f..f10e07cde 100644
--- a/engine/plugins/freetype/freetype_font.hpp
+++ b/engine/plugins/freetype/freetype_font.hpp
@@ -43,7 +43,7 @@ namespace wmoge {
     */
     class FreetypeFont {
     public:
-        FreetypeFont();
+        FreetypeFont(class IocContainer* ioc);
 
         /**
          * @brief Loads font from a .ttf file from file system using specified height in pixels
diff --git a/engine/plugins/runtime/asset/default_asset_loader.cpp b/engine/plugins/runtime/asset/default_asset_loader.cpp
index 67af1477d..17f44ee2b 100644
--- a/engine/plugins/runtime/asset/default_asset_loader.cpp
+++ b/engine/plugins/runtime/asset/default_asset_loader.cpp
@@ -28,10 +28,10 @@
 
 #include "default_asset_loader.hpp"
 
+#include "core/ioc_container.hpp"
 #include "io/tree_yaml.hpp"
 #include "profiler/profiler.hpp"
 #include "rtti/type_storage.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -55,7 +55,7 @@ namespace wmoge {
         Ref<AssetImportData> import_data = context.asset_meta.import_data.cast<AssetImportData>();
         assert(import_data);
 
-        RttiClass* rtti = IocContainer::iresolve_v<RttiTypeStorage>()->find_class(context.asset_meta.rtti);
+        RttiClass* rtti = context.ioc->resolve_value<RttiTypeStorage>()->find_class(context.asset_meta.rtti);
         if (!rtti) {
             WG_LOG_ERROR("no rtti type for " << asset_id);
             return StatusCode::InvalidData;
diff --git a/engine/plugins/runtime/asset/shader_asset_loader.cpp b/engine/plugins/runtime/asset/shader_asset_loader.cpp
index 03eec6cfd..de9c3e6ae 100644
--- a/engine/plugins/runtime/asset/shader_asset_loader.cpp
+++ b/engine/plugins/runtime/asset/shader_asset_loader.cpp
@@ -27,12 +27,12 @@
 
 #include "shader_asset_loader.hpp"
 
+#include "core/ioc_container.hpp"
 #include "grc/shader.hpp"
 #include "grc/shader_file.hpp"
 #include "grc/shader_manager.hpp"
 #include "io/tree_yaml.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -61,7 +61,7 @@ namespace wmoge {
         WG_CHECKED(tree.parse_data(result.get_data_file(FILE_TAG)));
         WG_TREE_READ(context.io_context, tree, shader_file);
 
-        auto* shader_manager = IocContainer::iresolve_v<ShaderManager>();
+        auto* shader_manager = context.ioc->resolve_value<ShaderManager>();
 
         ShaderReflection shader_reflection;
         WG_CHECKED(shader_manager->load_shader_reflection(shader_file, shader_reflection));
diff --git a/engine/plugins/runtime/asset/texture_asset_loader.cpp b/engine/plugins/runtime/asset/texture_asset_loader.cpp
index 1f5f27eda..bd4a39f00 100644
--- a/engine/plugins/runtime/asset/texture_asset_loader.cpp
+++ b/engine/plugins/runtime/asset/texture_asset_loader.cpp
@@ -28,6 +28,7 @@
 #include "texture_asset_loader.hpp"
 
 #include "asset/texture_import_data.hpp"
+#include "core/ioc_container.hpp"
 #include "gfx/gfx_cmd_list.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "grc/image.hpp"
@@ -35,7 +36,6 @@
 #include "grc/texture_manager.hpp"
 #include "grc/texture_resize.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -71,8 +71,9 @@ namespace wmoge {
             return StatusCode::FailedResize;
         }
 
-        auto gfx_driver      = IocContainer::iresolve_v<GfxDriver>();
-        auto texture_manager = IocContainer::iresolve_v<TextureManager>();
+        auto ioc             = context.ioc;
+        auto gfx_driver      = ioc->resolve_value<GfxDriver>();
+        auto texture_manager = ioc->resolve_value<TextureManager>();
 
         TextureFlags flags;
         flags.set(TextureFlag::Pooled);
@@ -172,8 +173,9 @@ namespace wmoge {
             }
         }
 
-        auto gfx_driver      = IocContainer::iresolve_v<GfxDriver>();
-        auto texture_manager = IocContainer::iresolve_v<TextureManager>();
+        auto ioc             = context.ioc;
+        auto gfx_driver      = ioc->resolve_value<GfxDriver>();
+        auto texture_manager = ioc->resolve_value<TextureManager>();
 
         TextureFlags flags;
         flags.set(TextureFlag::Pooled);
diff --git a/engine/runtime/asset/asset_library_fs.cpp b/engine/runtime/asset/asset_library_fs.cpp
index ca6c239f5..320339260 100644
--- a/engine/runtime/asset/asset_library_fs.cpp
+++ b/engine/runtime/asset/asset_library_fs.cpp
@@ -28,6 +28,7 @@
 #include "asset_library_fs.hpp"
 
 #include "asset/asset_manager.hpp"
+#include "core/ioc_container.hpp"
 #include "core/string_utils.hpp"
 #include "io/async_file_system.hpp"
 #include "io/tree.hpp"
@@ -35,7 +36,6 @@
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
 #include "rtti/type_storage.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
diff --git a/engine/runtime/asset/asset_loader.hpp b/engine/runtime/asset/asset_loader.hpp
index fe94aae53..5723aae07 100644
--- a/engine/runtime/asset/asset_loader.hpp
+++ b/engine/runtime/asset/asset_loader.hpp
@@ -32,6 +32,7 @@
 #include "asset/asset_meta.hpp"
 #include "core/array_view.hpp"
 #include "core/flat_map.hpp"
+#include "core/ioc_container.hpp"
 #include "io/context.hpp"
 #include "rtti/traits.hpp"
 
@@ -65,8 +66,9 @@ namespace wmoge {
      * @brief Context passed to the loader
      */
     struct AssetLoadContext {
-        IoContext io_context;
-        AssetMeta asset_meta;
+        IocContainer* ioc;
+        IoContext     io_context;
+        AssetMeta     asset_meta;
     };
 
     /**
diff --git a/engine/runtime/asset/asset_manager.cpp b/engine/runtime/asset/asset_manager.cpp
index deba66fbe..dc8c3bff0 100644
--- a/engine/runtime/asset/asset_manager.cpp
+++ b/engine/runtime/asset/asset_manager.cpp
@@ -28,11 +28,11 @@
 #include "asset_manager.hpp"
 
 #include "asset/asset_library_fs.hpp"
+#include "core/ioc_container.hpp"
 #include "core/timer.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
 #include "rtti/type_storage.hpp"
-#include "system/ioc_container.hpp"
 
 #include <chrono>
 
@@ -42,6 +42,7 @@ namespace wmoge {
         m_ioc_container = ioc;
         m_file_system   = ioc->resolve_value<FileSystem>();
         m_type_storage  = ioc->resolve_value<RttiTypeStorage>();
+        m_task_manager  = ioc->resolve_value<TaskManager>();
 
         m_callback = std::make_shared<typename Asset::ReleaseCallback>([this](Asset* asset) {
             std::lock_guard guard(m_mutex);
@@ -100,8 +101,8 @@ namespace wmoge {
         load_state->async_op           = make_async_op<Ref<Asset>>();
         load_state->library            = asset_library.value();
         load_state->loader             = loader.value();
+        load_state->context.ioc        = m_ioc_container;
         load_state->context.asset_meta = std::move(asset_meta);
-        load_state->context.io_context.add<IocContainer*>(m_ioc_container);
 
         Task task_fill_requests(name, [=](TaskContext&) -> int {
             if (!load_state->loader->fill_request(load_state->context, name, load_state->request)) {
@@ -109,7 +110,7 @@ namespace wmoge {
                 return 1;
             }
 
-            buffered_vector<Async> file_data_requests;
+            buffered_vector<Async, 16> file_data_requests;
 
             file_data_requests.reserve(load_state->request.data_files.size());
             load_state->data_buffers.reserve(load_state->request.data_files.size());
@@ -152,7 +153,7 @@ namespace wmoge {
                 return 0;
             });
 
-            task_load.schedule(Async::join(array_view(file_data_requests))).add_on_completion([=](AsyncStatus status, std::optional<int>&) {
+            task_load.schedule(m_task_manager, Async::join(array_view(file_data_requests))).add_on_completion([=](AsyncStatus status, std::optional<int>&) {
                 if (status == AsyncStatus::Failed) {
                     load_state->async_op->set_failed();
                 }
@@ -163,7 +164,7 @@ namespace wmoge {
             return 0;
         });
 
-        task_fill_requests.schedule(Async::join(array_view(deps))).add_on_completion([=](AsyncStatus status, std::optional<int>&) {
+        task_fill_requests.schedule(m_task_manager, Async::join(array_view(deps))).add_on_completion([=](AsyncStatus status, std::optional<int>&) {
             if (status == AsyncStatus::Failed) {
                 load_state->async_op->set_failed();
             }
diff --git a/engine/runtime/asset/asset_manager.hpp b/engine/runtime/asset/asset_manager.hpp
index 65b3f3981..765018337 100644
--- a/engine/runtime/asset/asset_manager.hpp
+++ b/engine/runtime/asset/asset_manager.hpp
@@ -98,6 +98,7 @@ namespace wmoge {
         class FileSystem*      m_file_system   = nullptr;
         class RttiTypeStorage* m_type_storage  = nullptr;
         class IocContainer*    m_ioc_container = nullptr;
+        class TaskManager*     m_task_manager  = nullptr;
 
         mutable std::recursive_mutex m_mutex;
     };
diff --git a/engine/runtime/core/cmd_line.cpp b/engine/runtime/core/cmd_line.cpp
index c766ce4e3..2ee9772ca 100644
--- a/engine/runtime/core/cmd_line.cpp
+++ b/engine/runtime/core/cmd_line.cpp
@@ -28,45 +28,105 @@
 #include "cmd_line.hpp"
 
 #include <iostream>
+#include <sstream>
 
 namespace wmoge {
 
-    CmdLine::CmdLine() : m_options("wmoge", "wmoge engine runtime and tools") {
+    std::string CmdLineUtil::to_string(int argc, const char* const* argv) {
+        std::stringstream s;
+        for (int i = 0; i < argc; i++) {
+            s << argv[i] << " ";
+        }
+        return s.str();
+    }
+
+    std::vector<std::string> CmdLineUtil::to_vector(int argc, const char* const* argv) {
+        std::vector<std::string> v;
+        v.reserve(argc);
+        for (int i = 0; i < argc; i++) {
+            v.emplace_back(argv[i]);
+        }
+        return std::move(v);
     }
 
-    void CmdLine::add_int(const std::string& name, const std::string& desc, const std::string& value) {
+    CmdLineOptions::CmdLineOptions(const std::string& name, const std::string& desc)
+        : m_options(name, desc) {
+    }
+
+    void CmdLineOptions::add_int(const std::string& name, const std::string& desc, const std::string& value) {
         m_options.add_option("", cxxopts::Option(name, desc, cxxopts::value<int>()->default_value(value)));
     }
-    void CmdLine::add_bool(const std::string& name, const std::string& desc, const std::string& value) {
+
+    void CmdLineOptions::add_bool(const std::string& name, const std::string& desc, const std::string& value) {
         m_options.add_option("", cxxopts::Option(name, desc, cxxopts::value<bool>()->default_value(value)));
     }
-    void CmdLine::add_string(const std::string& name, const std::string& desc, const std::string& value) {
+
+    void CmdLineOptions::add_string(const std::string& name, const std::string& desc, const std::string& value) {
         m_options.add_option("", cxxopts::Option(name, desc, cxxopts::value<std::string>()->default_value(value)));
     }
 
-    bool CmdLine::parse(int argc, const char* const* argv) {
+    std::optional<CmdLineParseResult> CmdLineOptions::parse(const std::vector<std::string>& args) {
+        const int                argc = static_cast<int>(args.size());
+        std::vector<const char*> argv;
+
+        argv.reserve(argc);
+        for (auto& arg : args) {
+            argv.push_back(arg.c_str());
+        }
+
         try {
-            m_parsed = m_options.parse(argc, argv);
-            return true;
+            return CmdLineParseResult(m_options.parse(argc, argv.data()));
         } catch (const std::exception& e) {
             std::cerr << "failed to parse options due to: " << e.what();
         }
 
-        return false;
+        return std::nullopt;
     }
 
-    int CmdLine::get_int(const std::string& name) {
+    std::string CmdLineOptions::get_help() const {
+        return m_options.help();
+    }
+
+    CmdLineParseResult::CmdLineParseResult(cxxopts::ParseResult parsed)
+        : m_parsed(std::move(parsed)) {
+    }
+
+    int CmdLineParseResult::get_int(const std::string& name) {
         return m_parsed[name].as<int>();
     }
-    bool CmdLine::get_bool(const std::string& name) {
+
+    bool CmdLineParseResult::get_bool(const std::string& name) {
         return m_parsed[name].as<bool>();
     }
-    std::string CmdLine::get_string(const std::string& name) {
+
+    std::string CmdLineParseResult::get_string(const std::string& name) {
         return m_parsed[name].as<std::string>();
     }
 
-    std::string CmdLine::get_help() const {
-        return m_options.help();
+    void CmdLineHookList::add(CmdLineHook hook) {
+        m_storage.emplace_back(std::move(hook));
+    }
+
+    void CmdLineHookList::clear() {
+        m_storage.clear();
+    }
+
+    Status CmdLineHookList::process(CmdLineParseResult& cmd_line) {
+        for (auto& hook : m_storage) {
+            const Status     status = hook(cmd_line);
+            const StatusCode code   = status.code();
+
+            if (code == StatusCode::ExitCode0) {
+                return StatusCode::ExitCode0;
+            }
+            if (code == StatusCode::ExitCode1) {
+                return StatusCode::ExitCode1;
+            }
+            if (code != StatusCode::Ok) {
+                return status;
+            }
+        }
+        return WG_OK;
     }
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/core/cmd_line.hpp b/engine/runtime/core/cmd_line.hpp
index 11658051e..ec71fac79 100644
--- a/engine/runtime/core/cmd_line.hpp
+++ b/engine/runtime/core/cmd_line.hpp
@@ -27,33 +27,84 @@
 
 #pragma once
 
+#include "core/status.hpp"
+
 #include <cxxopts.hpp>
 
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
 namespace wmoge {
 
     /**
-     * @class CmdLine
-     * @brief Container for parsed command-line options
+     * @class CmdLineUtil
+     * @brief Util for command-line
+     */
+    class CmdLineUtil {
+    public:
+        static std::string              to_string(int argc, const char* const* argv);
+        static std::vector<std::string> to_vector(int argc, const char* const* argv);
+    };
+
+    /**
+     * @class CmdLineParseResult
+     * @brief Container for command-line parse result
      */
-    class CmdLine {
+    class CmdLineParseResult {
     public:
-        CmdLine();
+        CmdLineParseResult(cxxopts::ParseResult parsed);
+
+        [[nodiscard]] int         get_int(const std::string& name);
+        [[nodiscard]] bool        get_bool(const std::string& name);
+        [[nodiscard]] std::string get_string(const std::string& name);
+
+    private:
+        cxxopts::ParseResult m_parsed;
+    };
+
+    using CmdLineArgs = std::vector<std::string>;
+
+    /**
+     * @class CmdLineOptions
+     * @brief Container for command-line options
+     */
+    class CmdLineOptions {
+    public:
+        CmdLineOptions(const std::string& name, const std::string& desc);
 
         void add_int(const std::string& name, const std::string& desc, const std::string& value = "");
         void add_bool(const std::string& name, const std::string& desc, const std::string& value = "");
         void add_string(const std::string& name, const std::string& desc, const std::string& value = "");
 
-        bool parse(int argc, const char* const* argv);
+        [[nodiscard]] std::optional<CmdLineParseResult> parse(const std::vector<std::string>& args);
+        [[nodiscard]] std::string                       get_help() const;
+
+    private:
+        cxxopts::Options m_options;
+    };
+
+    /** 
+     * @brief Cmd line hook
+     */
+    using CmdLineHook = std::function<Status(CmdLineParseResult& cmd_line)>;
 
-        int         get_int(const std::string& name);
-        bool        get_bool(const std::string& name);
-        std::string get_string(const std::string& name);
+    /** 
+     * @class CmdLineHookList
+     * @brief Storage for cmd line hooks
+     */
+    class CmdLineHookList {
+    public:
+        CmdLineHookList() = default;
 
-        std::string get_help() const;
+        void   add(CmdLineHook hook);
+        void   clear();
+        Status process(CmdLineParseResult& cmd_line);
 
     private:
-        cxxopts::Options     m_options;
-        cxxopts::ParseResult m_parsed;
+        std::vector<CmdLineHook> m_storage;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/ioc_container.cpp b/engine/runtime/core/ioc_container.cpp
similarity index 93%
rename from engine/runtime/system/ioc_container.cpp
rename to engine/runtime/core/ioc_container.cpp
index 0e10f12be..2d791eae2 100644
--- a/engine/runtime/system/ioc_container.cpp
+++ b/engine/runtime/core/ioc_container.cpp
@@ -29,8 +29,6 @@
 
 namespace wmoge {
 
-    IocContainer* IocContainer::g_ioc_container = nullptr;
-
     void IocContainer::clear() {
         std::lock_guard guard(m_mutex);
 
@@ -73,12 +71,4 @@ namespace wmoge {
         return std::nullopt;
     }
 
-    void IocContainer::provide(IocContainer* ioc) {
-        g_ioc_container = ioc;
-    }
-
-    IocContainer* IocContainer::instance() {
-        return g_ioc_container;
-    }
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/ioc_container.hpp b/engine/runtime/core/ioc_container.hpp
similarity index 94%
rename from engine/runtime/system/ioc_container.hpp
rename to engine/runtime/core/ioc_container.hpp
index 36850e5b1..52510448a 100644
--- a/engine/runtime/system/ioc_container.hpp
+++ b/engine/runtime/core/ioc_container.hpp
@@ -69,9 +69,7 @@ namespace wmoge {
     */
     class IocContainer {
     public:
-        IocContainer()                        = default;
-        IocContainer(const IocContainer&)     = delete;
-        IocContainer(IocContainer&&) noexcept = delete;
+        IocContainer() = default;
 
         void                     clear();
         void                     add(IocEntry&& entry);
@@ -84,6 +82,9 @@ namespace wmoge {
         template<typename S>
         void bind_by_instance(std::shared_ptr<S> instance);
 
+        template<typename S>
+        void bind_by_pointer(S* instance);
+
         template<typename S>
         void bind_by_ioc();
 
@@ -99,17 +100,9 @@ namespace wmoge {
         template<typename S>
         S* resolve_value();
 
-        template<typename S>
-        static S* iresolve_v();
-
-        static void          provide(IocContainer* ioc);
-        static IocContainer* instance();
-
     private:
         std::unordered_map<std::type_index, IocEntry> m_entries;
         std::recursive_mutex                          m_mutex;
-
-        static IocContainer* g_ioc_container;
     };
 
     template<typename S, typename Factory>
@@ -136,6 +129,11 @@ namespace wmoge {
         });
     }
 
+    template<typename S>
+    inline void IocContainer::bind_by_pointer(S* instance) {
+        bind_by_instance(std::shared_ptr<S>(instance, [](auto p) {}));
+    }
+
     template<typename S>
     inline void IocContainer::bind_by_ioc() {
         std::lock_guard guard(m_mutex);
@@ -210,9 +208,4 @@ namespace wmoge {
         return resolve<S>().value();
     }
 
-    template<typename S>
-    inline S* IocContainer::iresolve_v() {
-        return instance()->resolve_value<S>();
-    }
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/core/log.cpp b/engine/runtime/core/log.cpp
index 24b57bc87..6c6841fcb 100644
--- a/engine/runtime/core/log.cpp
+++ b/engine/runtime/core/log.cpp
@@ -30,7 +30,6 @@
 #include "platform/file_system.hpp"
 #include "platform/time.hpp"
 #include "system/console.hpp"
-#include "system/ioc_container.hpp"
 
 #include <magic_enum.hpp>
 
@@ -45,28 +44,32 @@
 
 namespace wmoge {
 
-    Log  g_null_log;
-    Log* Log::g_log = &g_null_log;
+    Log  g_log_default;
+    Log* Log::g_log = &g_log_default;
 
     void Log::listen(const std::shared_ptr<LogListener>& listener) {
         assert(listener);
         std::lock_guard guard(m_mutex);
         m_listeners.push_back(listener);
     }
+
     void Log::remove(const std::shared_ptr<LogListener>& listener) {
         assert(listener);
         std::lock_guard guard(m_mutex);
         m_listeners.erase(std::find(m_listeners.begin(), m_listeners.end(), listener));
     }
+
     void Log::log(LogLevel level, std::string message, std::string file, std::string function, std::size_t line) {
         std::lock_guard guard(m_mutex);
         LogEntry        entry{std::move(message), std::move(file), std::move(function), line, level};
         for (auto& listener : m_listeners)
             listener->on_message(entry);
     }
+
     Log* Log::instance() {
         return g_log;
     }
+
     void Log::provide(Log* log) {
         g_log = log;
     }
@@ -74,6 +77,7 @@ namespace wmoge {
     LogListenerStdout::LogListenerStdout(std::string name, LogLevel level)
         : m_name(std::move(name)), m_level(level) {
     }
+
     void LogListenerStdout::on_message(const LogEntry& entry) {
         if (entry.level == LogLevel::Never || entry.level < m_level)
             return;
@@ -90,21 +94,10 @@ namespace wmoge {
             std::cout << output.str();
     }
 
-    LogListenerStream::LogListenerStream(std::string name, wmoge::LogLevel level)
-        : m_name(std::move(name)), m_level(level) {
-        FileSystem* file_system = IocContainer::iresolve_v<FileSystem>();
-        Time*       engine_time = IocContainer::iresolve_v<Time>();
-
-        std::time_t       time = engine_time->get_time();
-        std::stringstream log_file_name;
-
-        log_file_name << "logs/log_"
-                      << m_name << " "
-                      << engine_time->get_time_formatted("%Y-%m-%d %H-%M-%S", time)
-                      << ".log";
-
-        file_system->open_file_physical(log_file_name.str(), m_stream, std::ios::out);
+    LogListenerStream::LogListenerStream(std::fstream stream, std::string name, wmoge::LogLevel level)
+        : m_stream(std::move(stream)), m_name(std::move(name)), m_level(level) {
     }
+
     void LogListenerStream::on_message(const wmoge::LogEntry& entry) {
         if (entry.level == LogLevel::Never || entry.level < m_level)
             return;
@@ -115,9 +108,25 @@ namespace wmoge {
                  << entry.message << "\n";
     }
 
+    std::fstream LogListenerStream::open_file(FileSystem* file_system, const std::string& filename) {
+        std::fstream stream;
+        file_system->open_file_physical(filename, stream, std::ios::out);
+        return std::move(stream);
+    }
+
+    std::string LogListenerStream::make_file_name(Time* time, const std::string& logname) {
+        std::stringstream log_file_name;
+        log_file_name << "logs/log_"
+                      << logname << " "
+                      << time->get_time_formatted("%Y-%m-%d %H-%M-%S", time->get_time())
+                      << ".log";
+        return log_file_name.str();
+    }
+
     LogListenerConsole::LogListenerConsole(Console* console, LogLevel level)
         : m_console(console), m_level(level) {
     }
+
     void LogListenerConsole::on_message(const LogEntry& entry) {
         if (entry.level == LogLevel::Never || entry.level < m_level)
             return;
diff --git a/engine/runtime/core/log.hpp b/engine/runtime/core/log.hpp
index a09d70937..8042b5822 100644
--- a/engine/runtime/core/log.hpp
+++ b/engine/runtime/core/log.hpp
@@ -96,7 +96,6 @@ namespace wmoge {
     class LogListenerStdout final : public LogListener {
     public:
         LogListenerStdout(std::string name, LogLevel level);
-        ~LogListenerStdout() override = default;
         void on_message(const LogEntry& entry) override;
 
     private:
@@ -110,10 +109,12 @@ namespace wmoge {
      */
     class LogListenerStream final : public LogListener {
     public:
-        LogListenerStream(std::string name, LogLevel level);
-        ~LogListenerStream() override = default;
+        LogListenerStream(std::fstream stream, std::string name, LogLevel level);
         void on_message(const LogEntry& entry) override;
 
+        static std::fstream open_file(class FileSystem* file_system, const std::string& filename);
+        static std::string  make_file_name(class Time* time, const std::string& logname);
+
     private:
         std::fstream m_stream;
         std::string  m_name;
@@ -127,7 +128,6 @@ namespace wmoge {
     class LogListenerConsole : public LogListener {
     public:
         LogListenerConsole(class Console* console, LogLevel level);
-        ~LogListenerConsole() override = default;
         void on_message(const LogEntry& entry) override;
 
     private:
diff --git a/engine/runtime/core/task.cpp b/engine/runtime/core/task.cpp
index 547ee34cf..715a37e24 100644
--- a/engine/runtime/core/task.cpp
+++ b/engine/runtime/core/task.cpp
@@ -27,29 +27,28 @@
 
 #include "core/task.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/task_runtime.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
     Task::Task(Strid name, TaskRunnable runnable)
         : m_runnable(std::move(runnable)),
-          m_task_manager(IocContainer::iresolve_v<TaskManager>()),
           m_name(name) {
     }
 
-    TaskHnd Task::schedule() {
-        return schedule(Async{});
+    TaskHnd Task::schedule(TaskManager* task_manager) {
+        return schedule(task_manager, Async{});
     }
 
-    TaskHnd Task::schedule(Async depends_on) {
+    TaskHnd Task::schedule(TaskManager* task_manager, Async depends_on) {
         WG_AUTO_PROFILE_CORE("Task::schedule");
 
         assert(m_runnable);
-        assert(m_task_manager);
+        assert(task_manager);
 
-        auto runtime = make_ref<TaskRuntime>(m_name, m_runnable, m_task_manager);
+        auto runtime = make_ref<TaskRuntime>(m_name, m_runnable, task_manager);
 
         if (depends_on.is_not_null()) {
             depends_on.add_dependency(runtime.as<AsyncStateBase>());
diff --git a/engine/runtime/core/task.hpp b/engine/runtime/core/task.hpp
index 64b0f816d..a0ebbd629 100644
--- a/engine/runtime/core/task.hpp
+++ b/engine/runtime/core/task.hpp
@@ -70,10 +70,12 @@ namespace wmoge {
          * @brief Kick off task for execution
          *
          * The task will be scheduled for background execution in selected task manager.
-         *
+         * 
+         * @param task_manager Taask manager to run task
+         *  
          * @return Async task hnd to track task execution
          */
-        TaskHnd schedule();
+        TaskHnd schedule(TaskManager* task_manager);
 
         /**
          * @brief Kick off task for execution
@@ -81,16 +83,14 @@ namespace wmoge {
          * Schedule task to be executed only after and only of dependencies completed.
          * The task will be scheduled for background execution in selected task manager.
          *
+         * @param task_manager Taask manager to run task
          * @param depends_on Dependencies that must complete before this task actual execution.
          *                   As soon as dependencies completed, this task is executed. Use this
          *                   to construct task graphs for computations.
          *
          * @return Async task hnd to track task execution
          */
-        TaskHnd schedule(Async depends_on);
-
-        /** @brief Set manager where should execute this task */
-        void set_task_manager(TaskManager& manager) { m_task_manager = &manager; }
+        TaskHnd schedule(TaskManager* task_manager, Async depends_on);
 
         /** @brief Function called as a job of task; may be empty */
         [[nodiscard]] TaskRunnable& runnable() { return m_runnable; }
@@ -98,12 +98,8 @@ namespace wmoge {
         /** @brief Optional task label for debugging */
         [[nodiscard]] const Strid& name() const { return m_name; }
 
-        /** @brief Task manager to execute this task; null if used default engine manager */
-        [[nodiscard]] TaskManager* task_manager() const { return m_task_manager; }
-
     private:
         TaskRunnable m_runnable;
-        TaskManager* m_task_manager = nullptr;
         Strid        m_name;
     };
 
diff --git a/engine/runtime/core/task_parallel_for.cpp b/engine/runtime/core/task_parallel_for.cpp
index 81ad3b313..e2005d8f8 100644
--- a/engine/runtime/core/task_parallel_for.cpp
+++ b/engine/runtime/core/task_parallel_for.cpp
@@ -27,27 +27,26 @@
 
 #include "task_parallel_for.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/task_runtime.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
     TaskParallelFor::TaskParallelFor(Strid name, TaskRunnableFor runnable)
         : m_runnable(std::move(runnable)),
-          m_task_manager(IocContainer::iresolve_v<TaskManager>()),
           m_name(name) {
     }
 
-    TaskHnd TaskParallelFor::schedule(int num_elements, int batch_size) {
-        return schedule(num_elements, batch_size, Async{});
+    TaskHnd TaskParallelFor::schedule(TaskManager* task_manager, int num_elements, int batch_size) {
+        return schedule(task_manager, num_elements, batch_size, Async{});
     }
 
-    TaskHnd TaskParallelFor::schedule(int num_elements, int batch_size, Async depends_on) {
+    TaskHnd TaskParallelFor::schedule(TaskManager* task_manager, int num_elements, int batch_size, Async depends_on) {
         WG_AUTO_PROFILE_CORE("TaskParallelFor::schedule");
 
         assert(m_runnable);
-        assert(m_task_manager);
+        assert(task_manager);
         assert(batch_size > 0);
 
         if (num_elements <= 0) {
@@ -56,7 +55,7 @@ namespace wmoge {
             return TaskHnd(state);
         }
 
-        auto parallel_for_runtime = make_ref<TaskRuntimeParallelFor>(m_name, m_runnable, m_task_manager, num_elements, batch_size);
+        auto parallel_for_runtime = make_ref<TaskRuntimeParallelFor>(m_name, m_runnable, task_manager, num_elements, batch_size);
 
         if (depends_on.is_not_null()) {
             depends_on.add_dependency(parallel_for_runtime);
diff --git a/engine/runtime/core/task_parallel_for.hpp b/engine/runtime/core/task_parallel_for.hpp
index 3ccd3cf19..956fda1cf 100644
--- a/engine/runtime/core/task_parallel_for.hpp
+++ b/engine/runtime/core/task_parallel_for.hpp
@@ -73,20 +73,22 @@ namespace wmoge {
          * @brief Kick off task for execution
          *
          * The task will be scheduled for background execution in selected task manager.
-         *
+         * 
+         * @param task_manager Taask manager to run task
          * @param num_elements Total number of elements to process
          * @param batch_size Size of a batch, elements to be processed by a single job
          *
          * @return Async task hnd to track task execution
          */
-        TaskHnd schedule(int num_elements, int batch_size);
+        TaskHnd schedule(TaskManager* task_manager, int num_elements, int batch_size);
 
         /**
          * @brief Kick off task for execution
          *
          * Schedule parallel-for task to be executed only after and only of dependencies completed.
          * The jobs of the task will be scheduled for background execution in selected task manager.
-         *
+         * 
+         * @param task_manager Taask manager to run task
          * @param num_elements Total number of elements to process
          * @param batch_size Size of a batch, elements to be processed by a single job
          * @param depends_on Dependencies that must complete before this task actual execution.
@@ -95,10 +97,7 @@ namespace wmoge {
          *
          * @return Async task hnd to track task execution
          */
-        TaskHnd schedule(int num_elements, int batch_size, Async depends_on);
-
-        /** @brief Set manager where should execute this task */
-        void set_task_manager(TaskManager& manager) { m_task_manager = &manager; }
+        TaskHnd schedule(TaskManager* task_manager, int num_elements, int batch_size, Async depends_on);
 
         /** @brief Function called as a job of task; may be empty */
         [[nodiscard]] TaskRunnableFor& runnable() { return m_runnable; }
@@ -106,12 +105,8 @@ namespace wmoge {
         /** @brief Optional task label for debugging */
         [[nodiscard]] const Strid& name() const { return m_name; }
 
-        /** @brief Task manager to execute this task; null if used default engine manager */
-        [[nodiscard]] TaskManager* task_manager() const { return m_task_manager; }
-
     private:
         TaskRunnableFor m_runnable;
-        TaskManager*    m_task_manager = nullptr;
         Strid           m_name;
     };
 
diff --git a/engine/runtime/ecs/ecs_core.cpp b/engine/runtime/ecs/ecs_core.cpp
index 9a7e92306..91f1ddbb6 100644
--- a/engine/runtime/ecs/ecs_core.cpp
+++ b/engine/runtime/ecs/ecs_core.cpp
@@ -28,20 +28,17 @@
 #include "ecs_core.hpp"
 
 #include "ecs/ecs_registry.hpp"
-#include "system/ioc_container.hpp"
 
 #include <sstream>
 #include <string>
 
 namespace wmoge {
 
-    std::string EcsArch::to_string() const {
+    std::string EcsArch::to_string(EcsRegistry* ecs_registry) const {
         if (!any()) {
             return "'empty'";
         }
 
-        EcsRegistry* registry = IocContainer::iresolve_v<EcsRegistry>();
-
         std::stringstream stream;
 
         const int total_components = int(count());
@@ -51,7 +48,7 @@ namespace wmoge {
 
         for (int i = 0; i < EcsLimits::MAX_COMPONENTS; i++) {
             if (test(i)) {
-                const Strid& name = registry->get_component_info(i).name;
+                const Strid& name = ecs_registry->get_component_info(i).name;
                 stream << name << ",";
             }
         }
diff --git a/engine/runtime/ecs/ecs_core.hpp b/engine/runtime/ecs/ecs_core.hpp
index 53711e0e1..0e9973d27 100644
--- a/engine/runtime/ecs/ecs_core.hpp
+++ b/engine/runtime/ecs/ecs_core.hpp
@@ -77,7 +77,7 @@ namespace wmoge {
             }
         }
 
-        [[nodiscard]] std::string to_string() const;
+        [[nodiscard]] std::string to_string(class EcsRegistry* ecs_registry) const;
 
         friend Status tree_read(IoContext& context, IoTree& tree, EcsArch& arch) {
             return tree_read(context, tree, *((EcsArch::Bitset*) &arch));
@@ -93,11 +93,6 @@ namespace wmoge {
         }
     };
 
-    inline std::ostream& operator<<(std::ostream& stream, const EcsArch& arch) {
-        stream << arch.to_string();
-        return stream;
-    }
-
 }// namespace wmoge
 
 namespace std {
diff --git a/engine/runtime/ecs/ecs_memory.cpp b/engine/runtime/ecs/ecs_memory.cpp
index 264f595ca..36804f030 100644
--- a/engine/runtime/ecs/ecs_memory.cpp
+++ b/engine/runtime/ecs/ecs_memory.cpp
@@ -27,9 +27,9 @@
 
 #include "ecs_memory.hpp"
 
+#include "core/ioc_container.hpp"
 #include "ecs/ecs_registry.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -53,18 +53,16 @@ namespace wmoge {
         return ((std::uint8_t*) m_chunks[idx / m_chunk_size]) + m_element_size * (idx % m_chunk_size);
     }
 
-    EcsArchStorage::EcsArchStorage(EcsArch arch) : m_arch(arch) {
+    EcsArchStorage::EcsArchStorage(EcsRegistry* ecs_registry, EcsArch arch) : m_arch(arch) {
         WG_AUTO_PROFILE_ECS("EcsArchStorage::EcsArchStorage");
 
-        EcsRegistry* registry = IocContainer::iresolve_v<EcsRegistry>();
-
-        m_chunk_size  = registry->get_chunk_size();
-        m_pool.back() = EcsPool(sizeof(EcsEntity), m_chunk_size, &registry->get_entity_pool());
+        m_chunk_size  = ecs_registry->get_chunk_size();
+        m_pool.back() = EcsPool(sizeof(EcsEntity), m_chunk_size, &ecs_registry->get_entity_pool());
 
         m_components_info.fill(nullptr);
         m_arch.for_each_component([&](int idx) {
-            m_components_info[idx] = &registry->get_component_info(idx);
-            m_pool[idx]            = EcsPool(m_components_info[idx]->size, m_chunk_size, &registry->get_component_pool(idx));
+            m_components_info[idx] = &ecs_registry->get_component_info(idx);
+            m_pool[idx]            = EcsPool(m_components_info[idx]->size, m_chunk_size, &ecs_registry->get_component_pool(idx));
         });
     }
 
diff --git a/engine/runtime/ecs/ecs_memory.hpp b/engine/runtime/ecs/ecs_memory.hpp
index ec613cb25..2c903da1e 100644
--- a/engine/runtime/ecs/ecs_memory.hpp
+++ b/engine/runtime/ecs/ecs_memory.hpp
@@ -70,7 +70,7 @@ namespace wmoge {
      */
     class EcsArchStorage {
     public:
-        explicit EcsArchStorage(EcsArch arch);
+        explicit EcsArchStorage(class EcsRegistry* ecs_registry, EcsArch arch);
         EcsArchStorage(const EcsArchStorage&) = delete;
         EcsArchStorage(EcsArchStorage&&)      = delete;
         ~EcsArchStorage();
diff --git a/engine/runtime/ecs/ecs_registry.cpp b/engine/runtime/ecs/ecs_registry.cpp
index 138977fd5..1ad343785 100644
--- a/engine/runtime/ecs/ecs_registry.cpp
+++ b/engine/runtime/ecs/ecs_registry.cpp
@@ -27,17 +27,9 @@
 
 #include "ecs_registry.hpp"
 
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
-
 namespace wmoge {
 
     EcsRegistry::EcsRegistry() {
-        Config* config = IocContainer::iresolve_v<Config>();
-
-        config->get_int(SID("ecs.chunk_size"), m_chunk_size);
-        config->get_int(SID("ecs.expand_size"), m_expand_size);
-
         m_entity_pool = std::make_unique<MemPool>(m_chunk_size * sizeof(EcsEntity), m_expand_size);
     }
 
diff --git a/engine/runtime/ecs/ecs_registry.hpp b/engine/runtime/ecs/ecs_registry.hpp
index 13b7b10bd..30e764701 100644
--- a/engine/runtime/ecs/ecs_registry.hpp
+++ b/engine/runtime/ecs/ecs_registry.hpp
@@ -49,9 +49,6 @@ namespace wmoge {
     class EcsRegistry {
     public:
         EcsRegistry();
-        EcsRegistry(const EcsRegistry&) = delete;
-        EcsRegistry(EcsRegistry&&)      = delete;
-        ~EcsRegistry()                  = default;
 
         [[nodiscard]] int                     get_component_idx(const Strid& name);
         [[nodiscard]] const EcsComponentInfo& get_component_info(const Strid& name);
diff --git a/engine/runtime/ecs/ecs_world.cpp b/engine/runtime/ecs/ecs_world.cpp
index 6a6cbebb6..9f4795262 100644
--- a/engine/runtime/ecs/ecs_world.cpp
+++ b/engine/runtime/ecs/ecs_world.cpp
@@ -32,13 +32,12 @@
 #include "core/task_parallel_for.hpp"
 #include "math/math_utils.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
-    EcsWorld::EcsWorld() {
-        m_ecs_registry = IocContainer::iresolve_v<EcsRegistry>();
-        m_task_manager = IocContainer::iresolve_v<TaskManager>();
+    EcsWorld::EcsWorld(EcsRegistry* ecs_registry, TaskManager* task_manager) {
+        m_ecs_registry = ecs_registry;
+        m_task_manager = task_manager;
     }
 
     EcsWorld::~EcsWorld() {
@@ -185,7 +184,7 @@ namespace wmoge {
             const int arch_idx  = int(m_arch_storage.size());
             m_arch_to_idx[arch] = arch_idx;
             m_arch_by_idx.emplace_back(arch);
-            m_arch_storage.emplace_back() = std::make_unique<EcsArchStorage>(arch);
+            m_arch_storage.emplace_back() = std::make_unique<EcsArchStorage>(m_ecs_registry, arch);
         }
     }
 
@@ -230,7 +229,7 @@ namespace wmoge {
             return 0;
         });
 
-        return task.schedule(depends_on).as_async();
+        return task.schedule(m_task_manager, depends_on).as_async();
     }
 
     Async EcsWorld::execute_parallel(Async depends_on, const EcsQuery& query, const EcsQueuryFunction& func) {
@@ -252,7 +251,7 @@ namespace wmoge {
             return 0;
         });
 
-        return task.schedule(m_task_manager->get_num_workers(), 1, depends_on).as_async();
+        return task.schedule(m_task_manager, m_task_manager->get_num_workers(), 1, depends_on).as_async();
     }
 
     void EcsWorld::clear() {
diff --git a/engine/runtime/ecs/ecs_world.hpp b/engine/runtime/ecs/ecs_world.hpp
index eed0b6ce0..ff70d4e17 100644
--- a/engine/runtime/ecs/ecs_world.hpp
+++ b/engine/runtime/ecs/ecs_world.hpp
@@ -62,7 +62,7 @@ namespace wmoge {
      */
     class EcsWorld {
     public:
-        EcsWorld();
+        EcsWorld(class EcsRegistry* ecs_registry, class TaskManager* task_manager);
         ~EcsWorld();
 
         /** @brief Allocates new entity for later creation */
diff --git a/engine/runtime/engine.hpp b/engine/runtime/engine.hpp
index 2e67ef9f9..e44a8c9dd 100644
--- a/engine/runtime/engine.hpp
+++ b/engine/runtime/engine.hpp
@@ -53,6 +53,7 @@
 #include "core/date_time.hpp"
 #include "core/flat_map.hpp"
 #include "core/flat_set.hpp"
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "core/mask.hpp"
 #include "core/object.hpp"
@@ -165,7 +166,6 @@
 #include "pfx/pfx_emitter.hpp"
 #include "pfx/pfx_feature.hpp"
 
-#include "platform/application.hpp"
 #include "platform/dll_manager.hpp"
 #include "platform/file.hpp"
 #include "platform/file_system.hpp"
@@ -216,15 +216,11 @@
 #include "scene/scene_packed.hpp"
 #include "scene/scene_prefab.hpp"
 
-#include "scripting/script.hpp"
-#include "scripting/script_instance.hpp"
-#include "scripting/script_native.hpp"
-#include "scripting/script_system.hpp"
-
+#include "system/application.hpp"
 #include "system/config.hpp"
 #include "system/console.hpp"
 #include "system/engine.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
+#include "system/game_application.hpp"
+#include "system/hooks.hpp"
 #include "system/plugin.hpp"
 #include "system/plugin_manager.hpp"
diff --git a/engine/runtime/gfx/vulkan/vk_driver.cpp b/engine/runtime/gfx/vulkan/vk_driver.cpp
index 68e3d3d54..f02943620 100644
--- a/engine/runtime/gfx/vulkan/vk_driver.cpp
+++ b/engine/runtime/gfx/vulkan/vk_driver.cpp
@@ -27,6 +27,7 @@
 
 #include "vk_driver.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/string_utils.hpp"
 #include "core/task.hpp"
 #include "core/task_parallel_for.hpp"
@@ -39,8 +40,6 @@
 #include "gfx/vulkan/vk_texture.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <fstream>
@@ -53,13 +52,11 @@ namespace wmoge {
         return names_p;
     };
 
-    VKDriver::VKDriver(const VKInitInfo& info) {
+    VKDriver::VKDriver(IocContainer* ioc, const VKInitInfo& info) {
         WG_AUTO_PROFILE_VULKAN("VKDriver::VKDriver");
 
-        Config* config = IocContainer::iresolve_v<Config>();
-
-        m_file_system  = IocContainer::iresolve_v<FileSystem>();
-        m_task_manager = IocContainer::iresolve_v<TaskManager>();
+        m_file_system  = ioc->resolve_value<FileSystem>();
+        m_task_manager = ioc->resolve_value<TaskManager>();
 
         m_driver_name = SID("vulkan");
         m_clip_matrix = Mat4x4f(1.0f, 0.0f, 0.0f, 0.0f,
@@ -82,7 +79,7 @@ namespace wmoge {
 #endif
 
 #ifndef WMOGE_RELEASE
-        m_use_validation = config->get_bool_or_default(SID("gfx.vulkan.validation_layer"), true);
+        m_use_validation = true;
 #endif
 
         if (m_use_validation) {
@@ -96,7 +93,7 @@ namespace wmoge {
         m_required_device_extensions.emplace_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
         WG_LOG_INFO("request " << VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
-        m_pipeline_cache_path = config->get_string_or_default(SID("gfx.vulkan.pipeline_cache"), "cache/pipelines_vk.cache");
+        m_pipeline_cache_path = "cache/pipelines_vk.cache";
 
         // load vulkan functions from volk
         init_functions();
@@ -132,10 +129,6 @@ namespace wmoge {
 
         // init manager for desc sets allocation
         VKDescPoolConfig pool_config{};
-        config->get_int(SID("gfx.vulkan.desc_pool_max_images"), pool_config.max_images);
-        config->get_int(SID("gfx.vulkan.desc_pool_max_ub"), pool_config.max_ub);
-        config->get_int(SID("gfx.vulkan.desc_pool_max_sb"), pool_config.max_sb);
-        config->get_int(SID("gfx.vulkan.desc_pool_max_sets"), pool_config.max_sets);
         m_desc_manager = std::make_unique<VKDescManager>(pool_config, *this);
 
         // init pipeline cache
@@ -357,7 +350,7 @@ namespace wmoge {
             return 0;
         });
 
-        return task.schedule(int(request->desc.size()), 1).as_async();
+        return task.schedule(m_task_manager, int(request->desc.size()), 1).as_async();
     }
     Async VKDriver::make_psos_graphics(const Ref<GfxAsyncPsoRequestGraphics>& request) {
         WG_AUTO_PROFILE_VULKAN("VKDriver::make_psos_graphics");
@@ -372,7 +365,7 @@ namespace wmoge {
             return 0;
         });
 
-        return task.schedule(int(request->states.size()), 1).as_async();
+        return task.schedule(m_task_manager, int(request->states.size()), 1).as_async();
     }
     Async VKDriver::make_psos_compute(const Ref<GfxAsyncPsoRequestCompute>& request) {
         WG_AUTO_PROFILE_VULKAN("VKDriver::make_psos_compute");
@@ -387,9 +380,7 @@ namespace wmoge {
             return 0;
         });
 
-        task.set_task_manager(*m_task_manager);
-
-        return task.schedule(int(request->states.size()), 1).as_async();
+        return task.schedule(m_task_manager, int(request->states.size()), 1).as_async();
     }
 
     void VKDriver::begin_frame(std::size_t frame_id, const array_view<Ref<Window>>& windows) {
diff --git a/engine/runtime/gfx/vulkan/vk_driver.hpp b/engine/runtime/gfx/vulkan/vk_driver.hpp
index c5600f600..12a378a12 100644
--- a/engine/runtime/gfx/vulkan/vk_driver.hpp
+++ b/engine/runtime/gfx/vulkan/vk_driver.hpp
@@ -60,7 +60,7 @@ namespace wmoge {
      */
     class VKDriver final : public GfxDriver {
     public:
-        explicit VKDriver(const VKInitInfo& info);
+        explicit VKDriver(class IocContainer* ioc, const VKInitInfo& info);
         ~VKDriver() override;
 
         void shutdown() override;
diff --git a/engine/runtime/gfx/vulkan/vk_window.cpp b/engine/runtime/gfx/vulkan/vk_window.cpp
index de59871c8..121cb2c36 100644
--- a/engine/runtime/gfx/vulkan/vk_window.cpp
+++ b/engine/runtime/gfx/vulkan/vk_window.cpp
@@ -32,17 +32,12 @@
 #include "gfx/vulkan/vk_texture.hpp"
 #include "math/math_utils.hpp"
 #include "profiler/profiler.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
     VKWindow::VKWindow(Ref<Window> window, VkSurfaceKHR surface, class VKDriver& driver) : m_driver(driver) {
         m_window  = window;
         m_surface = surface;
-
-        Config* config = IocContainer::iresolve_v<Config>();
-        config->get_bool(SID("window.vsync"), m_use_vsync);
     }
 
     VKWindow::~VKWindow() {
diff --git a/engine/runtime/glsl/glsl_shader_compiler.cpp b/engine/runtime/glsl/glsl_shader_compiler.cpp
index 114465ad6..436f8d0fd 100644
--- a/engine/runtime/glsl/glsl_shader_compiler.cpp
+++ b/engine/runtime/glsl/glsl_shader_compiler.cpp
@@ -27,6 +27,7 @@
 
 #include "glsl_shader_compiler.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/string_utils.hpp"
 #include "core/task.hpp"
 #include "core/timer.hpp"
@@ -35,7 +36,6 @@
 #include "io/enum.hpp"
 #include "io/stream.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <SPIRV/GlslangToSpv.h>
 #include <StandAlone/ResourceLimits.h>
@@ -45,12 +45,11 @@
 
 namespace wmoge {
 
-    GlslShaderCompiler::GlslShaderCompiler() {
+    GlslShaderCompiler::GlslShaderCompiler(IocContainer* ioc) {
         if (!glslang::InitializeProcess()) {
             WG_LOG_ERROR("failed to init glslang");
         }
-
-        m_file_system = IocContainer::iresolve_v<FileSystem>();
+        m_file_system = ioc->resolve_value<FileSystem>();
     }
 
     GlslShaderCompiler::~GlslShaderCompiler() {
@@ -365,10 +364,10 @@ namespace wmoge {
         return ok;
     }
 
-    GlslShaderCompilerAdapter::GlslShaderCompilerAdapter(GfxShaderPlatform platform) {
+    GlslShaderCompilerAdapter::GlslShaderCompilerAdapter(IocContainer* ioc, GfxShaderPlatform platform) {
         m_platform      = platform;
-        m_glsl_compiler = IocContainer::iresolve_v<GlslShaderCompiler>();
-        m_task_manager  = IocContainer::iresolve_v<ShaderTaskManager>();
+        m_glsl_compiler = ioc->resolve_value<GlslShaderCompiler>();
+        m_task_manager  = ioc->resolve_value<ShaderTaskManager>();
     }
 
     Async GlslShaderCompilerAdapter::compile(const Ref<ShaderCompilerRequest>& request, const Async& depends_on) {
@@ -378,8 +377,7 @@ namespace wmoge {
             }
             return 0;
         });
-        task.set_task_manager(*m_task_manager);
-        return task.schedule(depends_on).as_async();
+        return task.schedule(m_task_manager, depends_on).as_async();
     }
 
     std::shared_ptr<ShaderCodeBuilder> GlslShaderCompilerAdapter::make_builder() {
diff --git a/engine/runtime/glsl/glsl_shader_compiler.hpp b/engine/runtime/glsl/glsl_shader_compiler.hpp
index fa79bb0f5..46eee3b94 100644
--- a/engine/runtime/glsl/glsl_shader_compiler.hpp
+++ b/engine/runtime/glsl/glsl_shader_compiler.hpp
@@ -44,7 +44,7 @@ namespace wmoge {
     */
     class GlslShaderCompiler {
     public:
-        GlslShaderCompiler();
+        GlslShaderCompiler(class IocContainer* ioc);
         ~GlslShaderCompiler();
 
         Status compile(ShaderCompilerRequest& request);
@@ -61,10 +61,8 @@ namespace wmoge {
     public:
         WG_RTTI_CLASS(GlslShaderCompilerAdapter, ShaderCompiler);
 
-        GlslShaderCompilerAdapter()  = default;
-        ~GlslShaderCompilerAdapter() = default;
-
-        GlslShaderCompilerAdapter(GfxShaderPlatform platform);
+        GlslShaderCompilerAdapter(class IocContainer* ioc, GfxShaderPlatform platform);
+        GlslShaderCompilerAdapter() = default;
 
         Async                              compile(const Ref<ShaderCompilerRequest>& request, const Async& depends_on) override;
         std::shared_ptr<ShaderCodeBuilder> make_builder() override;
@@ -89,13 +87,12 @@ namespace wmoge {
     public:
         WG_RTTI_CLASS(GlslShaderCompilerVulkanLinux, GlslShaderCompilerAdapter);
 
-        GlslShaderCompilerVulkanLinux() : GlslShaderCompilerAdapter(GfxShaderPlatform::VulkanLinux) {}
-        ~GlslShaderCompilerVulkanLinux() override = default;
+        GlslShaderCompilerVulkanLinux(class IocContainer* ioc) : GlslShaderCompilerAdapter(ioc, GfxShaderPlatform::VulkanLinux) {}
+        GlslShaderCompilerVulkanLinux() = default;
     };
 
     WG_RTTI_CLASS_BEGIN(GlslShaderCompilerVulkanLinux) {
         WG_RTTI_META_DATA();
-        WG_RTTI_FACTORY();
     }
     WG_RTTI_END;
 
@@ -107,13 +104,12 @@ namespace wmoge {
     public:
         WG_RTTI_CLASS(GlslShaderCompilerVulkanWindows, GlslShaderCompilerAdapter);
 
-        GlslShaderCompilerVulkanWindows() : GlslShaderCompilerAdapter(GfxShaderPlatform::VulkanWindows) {}
-        ~GlslShaderCompilerVulkanWindows() override = default;
+        GlslShaderCompilerVulkanWindows(class IocContainer* ioc) : GlslShaderCompilerAdapter(ioc, GfxShaderPlatform::VulkanWindows) {}
+        GlslShaderCompilerVulkanWindows() = default;
     };
 
     WG_RTTI_CLASS_BEGIN(GlslShaderCompilerVulkanWindows) {
         WG_RTTI_META_DATA();
-        WG_RTTI_FACTORY();
     }
     WG_RTTI_END;
 
@@ -125,13 +121,12 @@ namespace wmoge {
     public:
         WG_RTTI_CLASS(GlslShaderCompilerVulkanMacOS, GlslShaderCompilerAdapter);
 
-        GlslShaderCompilerVulkanMacOS() : GlslShaderCompilerAdapter(GfxShaderPlatform::VulkanMacOS) {}
-        ~GlslShaderCompilerVulkanMacOS() override = default;
+        GlslShaderCompilerVulkanMacOS(class IocContainer* ioc) : GlslShaderCompilerAdapter(ioc, GfxShaderPlatform::VulkanMacOS) {}
+        GlslShaderCompilerVulkanMacOS() = default;
     };
 
     WG_RTTI_CLASS_BEGIN(GlslShaderCompilerVulkanMacOS) {
         WG_RTTI_META_DATA();
-        WG_RTTI_FACTORY();
     }
     WG_RTTI_END;
 
diff --git a/engine/runtime/grc/image.cpp b/engine/runtime/grc/image.cpp
index abf28fd0f..6aff5a1c6 100644
--- a/engine/runtime/grc/image.cpp
+++ b/engine/runtime/grc/image.cpp
@@ -27,9 +27,9 @@
 
 #include "image.hpp"
 
+#include "core/ioc_container.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <stb_image.hpp>
 #include <stb_image_resize.hpp>
diff --git a/engine/runtime/grc/pso_cache.cpp b/engine/runtime/grc/pso_cache.cpp
index 7bb804c66..acb6e6431 100644
--- a/engine/runtime/grc/pso_cache.cpp
+++ b/engine/runtime/grc/pso_cache.cpp
@@ -27,12 +27,12 @@
 
 #include "pso_cache.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/task.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "grc/shader_compiler.hpp"
 #include "grc/shader_library.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 #include <cassert>
@@ -42,10 +42,10 @@
 
 namespace wmoge {
 
-    PsoCache::PsoCache() {
-        m_shader_library = IocContainer::iresolve_v<ShaderLibrary>();
-        m_task_manager   = IocContainer::iresolve_v<ShaderTaskManager>();
-        m_gfx_driver     = IocContainer::iresolve_v<GfxDriver>();
+    PsoCache::PsoCache(IocContainer* ioc) {
+        m_shader_library = ioc->resolve_value<ShaderLibrary>();
+        m_task_manager   = ioc->resolve_value<ShaderTaskManager>();
+        m_gfx_driver     = ioc->resolve_value<GfxDriver>();
     }
 
     Ref<GfxVertFormat> PsoCache::get_or_create_vert_format(const GfxVertElements& elements, const Strid& name) {
@@ -239,9 +239,7 @@ namespace wmoge {
             return 0;
         });
 
-        task.set_task_manager(*m_task_manager);
-
-        return task.schedule(depends_on).as_async();
+        return task.schedule(m_task_manager, depends_on).as_async();
     }
     Async PsoCache::precache_psos(const array_view<GfxPsoStateCompute>& states, const array_view<Strid>& names, Async depends_on) {
         WG_AUTO_PROFILE_GRC("PsoCache::precache_psos");
@@ -289,9 +287,7 @@ namespace wmoge {
             return 0;
         });
 
-        task.set_task_manager(*m_task_manager);
-
-        return task.schedule(depends_on).as_async();
+        return task.schedule(m_task_manager, depends_on).as_async();
     }
 
     PsoKey PsoCache::get_next_key() {
diff --git a/engine/runtime/grc/pso_cache.hpp b/engine/runtime/grc/pso_cache.hpp
index 77ca6678b..c4f9e1940 100644
--- a/engine/runtime/grc/pso_cache.hpp
+++ b/engine/runtime/grc/pso_cache.hpp
@@ -93,7 +93,7 @@ namespace wmoge {
     */
     class PsoCache {
     public:
-        PsoCache();
+        PsoCache(class IocContainer* ioc);
 
         Ref<GfxVertFormat>    get_or_create_vert_format(const GfxVertElements& elements, const Strid& name = Strid());
         Ref<GfxDescSetLayout> get_or_create_desc_layout(const GfxDescSetLayoutDesc& desc, const Strid& name = Strid());
diff --git a/engine/runtime/grc/pso_file.cpp b/engine/runtime/grc/pso_file.cpp
index 97021e819..83883e9c1 100644
--- a/engine/runtime/grc/pso_file.cpp
+++ b/engine/runtime/grc/pso_file.cpp
@@ -27,28 +27,6 @@
 
 #include "pso_file.hpp"
 
-#include "io/stream_file.hpp"
-
 namespace wmoge {
 
-    Status PsoFile::read(const std::string& path, FilePsoData& pso_data) {
-        IoStreamFile stream;
-        WG_CHECKED(stream.open(path, {FileOpenMode::In, FileOpenMode::Binary}));
-
-        IoContext context;
-        WG_ARCHIVE_READ(context, stream, pso_data);
-
-        return WG_OK;
-    }
-
-    Status PsoFile::write(const std::string& path, const FilePsoData& pso_data) {
-        IoStreamFile stream;
-        WG_CHECKED(stream.open(path, {FileOpenMode::Out, FileOpenMode::Binary}));
-
-        IoContext context;
-        WG_ARCHIVE_WRITE(context, stream, pso_data);
-
-        return WG_OK;
-    }
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/grc/pso_file.hpp b/engine/runtime/grc/pso_file.hpp
index 81afb9a4e..38c569d08 100644
--- a/engine/runtime/grc/pso_file.hpp
+++ b/engine/runtime/grc/pso_file.hpp
@@ -191,14 +191,4 @@ namespace wmoge {
     }
     WG_RTTI_END;
 
-    /**
-     * @class PsoFile
-     * @brief Util to access serialized pso file data
-    */
-    class PsoFile {
-    public:
-        static Status read(const std::string& path, FilePsoData& pso_data);
-        static Status write(const std::string& path, const FilePsoData& pso_data);
-    };
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/grc/shader_cache.cpp b/engine/runtime/grc/shader_cache.cpp
index f68d8c7fd..671d4c933 100644
--- a/engine/runtime/grc/shader_cache.cpp
+++ b/engine/runtime/grc/shader_cache.cpp
@@ -4,10 +4,9 @@
 #include "core/log.hpp"
 #include "grc/shader_library.hpp"
 #include "io/stream_file.hpp"
+#include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
 #include "rtti/traits.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <sstream>
@@ -97,12 +96,8 @@ namespace wmoge {
     }
 
     std::string ShaderCache::make_cache_file_name(const std::string& folder, const std::string& name, GfxShaderPlatform platform) {
-        std::string cache_prefix = "shader_cache";
-        std::string cache_suffix = "scf";
-
-        Config* config = IocContainer::iresolve_v<Config>();
-        config->get_string(SID("grc.shader.cache.prefix"), cache_prefix);
-        config->get_string(SID("grc.shader.cache.suffix"), cache_suffix);
+        const std::string cache_prefix = "shader_cache";
+        const std::string cache_suffix = "scf";
 
         std::stringstream stream;
         stream << folder;
@@ -113,13 +108,13 @@ namespace wmoge {
         return stream.str();
     }
 
-    Status ShaderCache::load_cache(const std::string& file_path, GfxShaderPlatform platform, bool allow_missing) {
+    Status ShaderCache::load_cache(FileSystem* file_system, const std::string& file_path, GfxShaderPlatform platform, bool allow_missing) {
         WG_AUTO_PROFILE_GRC("ShaderCache::load_cache");
 
         IoStreamFile stream;
         IoContext    context;
 
-        if (!stream.open(file_path, {FileOpenMode::In, FileOpenMode::Binary})) {
+        if (!stream.open(file_system, file_path, {FileOpenMode::In, FileOpenMode::Binary})) {
             if (allow_missing) {
                 return WG_OK;
             }
@@ -150,7 +145,7 @@ namespace wmoge {
         return WG_OK;
     }
 
-    Status ShaderCache::save_cache(const std::string& file_path, GfxShaderPlatform platform) {
+    Status ShaderCache::save_cache(FileSystem* file_system, const std::string& file_path, GfxShaderPlatform platform) {
         WG_AUTO_PROFILE_GRC("ShaderCache::save_cache");
 
         std::vector<ShaderProgram> programs;
@@ -173,7 +168,7 @@ namespace wmoge {
         IoStreamFile stream;
         IoContext    context;
 
-        if (!stream.open(file_path, {FileOpenMode::Out, FileOpenMode::Binary})) {
+        if (!stream.open(file_system, file_path, {FileOpenMode::Out, FileOpenMode::Binary})) {
             WG_LOG_ERROR("failed to open shader cache " << file_path << " for platform " << Enum::to_str(platform));
             return StatusCode::FailedOpenFile;
         }
diff --git a/engine/runtime/grc/shader_cache.hpp b/engine/runtime/grc/shader_cache.hpp
index 2925d7239..42d636fd3 100644
--- a/engine/runtime/grc/shader_cache.hpp
+++ b/engine/runtime/grc/shader_cache.hpp
@@ -101,8 +101,8 @@ namespace wmoge {
         void                          fit_program(GfxShaderPlatform platform, const ShaderProgram& program);
         void                          dump_programs(GfxShaderPlatform platform, std::vector<ShaderProgram>& out_programs);
         std::string                   make_cache_file_name(const std::string& folder, const std::string& name, GfxShaderPlatform platform);
-        Status                        load_cache(const std::string& file_path, GfxShaderPlatform platform, bool allow_missing = true);
-        Status                        save_cache(const std::string& file_path, GfxShaderPlatform platform);
+        Status                        load_cache(class FileSystem* file_system, const std::string& file_path, GfxShaderPlatform platform, bool allow_missing = true);
+        Status                        save_cache(class FileSystem* file_system, const std::string& file_path, GfxShaderPlatform platform);
 
     private:
         std::array<ShaderCacheMap, GfxLimits::NUM_PLATFORMS> m_maps;
diff --git a/engine/runtime/grc/shader_library.cpp b/engine/runtime/grc/shader_library.cpp
index 27c6bc6b8..3ca50eca1 100644
--- a/engine/runtime/grc/shader_library.cpp
+++ b/engine/runtime/grc/shader_library.cpp
@@ -29,14 +29,13 @@
 #include "shader_library.hpp"
 
 #include "core/date_time.hpp"
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "io/stream_file.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
 #include "rtti/traits.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 #include <cassert>
@@ -84,8 +83,8 @@ namespace wmoge {
     }
     WG_RTTI_END;
 
-    ShaderModuleMap::ShaderModuleMap() {
-        m_driver = IocContainer::iresolve_v<GfxDriver>();
+    ShaderModuleMap::ShaderModuleMap(GfxDriver* driver) {
+        m_driver = driver;
     }
 
     Ref<GfxShader> ShaderModuleMap::get_or_create_shader(GfxShaderModule module_type, const Sha256& bytecode_hash) {
@@ -144,35 +143,23 @@ namespace wmoge {
         }
     }
 
-    ShaderLibrary::ShaderLibrary() {
+    ShaderLibrary::ShaderLibrary(IocContainer* ioc) {
         rtti_type<FileShaderModule>();
         rtti_type<FileShaderLibrary>();
 
-        m_active_platform = IocContainer::iresolve_v<GfxDriver>()->get_shader_platform();
+        GfxDriver* driver = ioc->resolve_value<GfxDriver>();
+        m_active_platform = driver->get_shader_platform();
+
+        for (int i = 0; i < GfxLimits::NUM_PLATFORMS; i++) {
+            m_libraries.emplace_back(driver);
+        }
 
         m_library_path   = "cache/";
         m_library_prefix = "shader_library";
         m_library_suffix = "slf";
-        m_load_cache     = true;
-        m_save_cache     = true;
-
-        Config* config = IocContainer::iresolve_v<Config>();
-        config->get_string(SID("grc.shader.library.path"), m_library_path);
-        config->get_string(SID("grc.shader.library.prefix"), m_library_prefix);
-        config->get_string(SID("grc.shader.library.suffix"), m_library_suffix);
-        config->get_bool(SID("grc.shader.library.load_cache"), m_load_cache);
-        config->get_bool(SID("grc.shader.library.save_cache"), m_save_cache);
-
-        if (m_load_cache) {
-            load_cache(m_library_path, m_active_platform);
-        }
     }
 
-    ShaderLibrary::~ShaderLibrary() {
-        if (m_save_cache) {
-            save_cache(m_library_path, m_active_platform);
-        }
-    }
+    ShaderLibrary::~ShaderLibrary() = default;
 
     Ref<GfxShader> ShaderLibrary::get_or_create_shader(GfxShaderPlatform platform, GfxShaderModule module_type, const Sha256& bytecode_hash) {
         WG_AUTO_PROFILE_GRC("ShaderLibrary::get_or_create_shader");
@@ -225,14 +212,14 @@ namespace wmoge {
         return file_name.str();
     }
 
-    Status ShaderLibrary::load_cache(const std::string& folder, const GfxShaderPlatform platform) {
+    Status ShaderLibrary::load_cache(FileSystem* file_system, const std::string& folder, const GfxShaderPlatform platform) {
         WG_AUTO_PROFILE_GRC("ShaderLibrary::load_cache");
 
         const std::string file_path = make_cache_file_name(folder, platform);
         IoStreamFile      stream;
         IoContext         context;
 
-        if (!stream.open(file_path, {FileOpenMode::In, FileOpenMode::Binary})) {
+        if (!stream.open(file_system, file_path, {FileOpenMode::In, FileOpenMode::Binary})) {
             WG_LOG_ERROR("failed to open shader library " << file_path << " for platform " << Enum::to_str(platform));
             return StatusCode::FailedOpenFile;
         }
@@ -267,7 +254,7 @@ namespace wmoge {
         return WG_OK;
     }
 
-    Status ShaderLibrary::save_cache(const std::string& folder, const GfxShaderPlatform platform) {
+    Status ShaderLibrary::save_cache(FileSystem* file_system, const std::string& folder, const GfxShaderPlatform platform) {
         WG_AUTO_PROFILE_GRC("ShaderLibrary::save_cache");
 
         std::vector<ShaderModule> modules;
@@ -293,7 +280,7 @@ namespace wmoge {
         IoStreamFile      stream;
         IoContext         context;
 
-        if (!stream.open(file_path, {FileOpenMode::Out, FileOpenMode::Binary})) {
+        if (!stream.open(file_system, file_path, {FileOpenMode::Out, FileOpenMode::Binary})) {
             WG_LOG_ERROR("failed to open shader library " << file_path << " for platform " << Enum::to_str(platform));
             return StatusCode::FailedOpenFile;
         }
diff --git a/engine/runtime/grc/shader_library.hpp b/engine/runtime/grc/shader_library.hpp
index 18ada5294..60ca65429 100644
--- a/engine/runtime/grc/shader_library.hpp
+++ b/engine/runtime/grc/shader_library.hpp
@@ -27,6 +27,7 @@
 
 #pragma once
 
+#include "core/buffered_vector.hpp"
 #include "core/data.hpp"
 #include "core/flat_map.hpp"
 #include "core/sha256.hpp"
@@ -64,7 +65,7 @@ namespace wmoge {
      */
     class ShaderModuleMap {
     public:
-        ShaderModuleMap();
+        ShaderModuleMap(GfxDriver* driver);
 
         Ref<GfxShader>                get_or_create_shader(GfxShaderModule module_type, const Sha256& bytecode_hash);
         std::optional<Ref<GfxShader>> find_shader(GfxShaderModule module_type, const Sha256& bytecode_hash);
@@ -91,7 +92,7 @@ namespace wmoge {
     */
     class ShaderLibrary {
     public:
-        ShaderLibrary();
+        ShaderLibrary(class IocContainer* ioc);
         ~ShaderLibrary();
 
         Ref<GfxShader>                get_or_create_shader(GfxShaderPlatform platform, GfxShaderModule module_type, const Sha256& bytecode_hash);
@@ -99,17 +100,15 @@ namespace wmoge {
         void                          fit_module(GfxShaderPlatform platform, ShaderModule& module);
         void                          dump_modules(GfxShaderPlatform platform, std::vector<ShaderModule>& out_modules);
         std::string                   make_cache_file_name(const std::string& folder, const GfxShaderPlatform platform);
-        Status                        load_cache(const std::string& folder, const GfxShaderPlatform platform);
-        Status                        save_cache(const std::string& folder, const GfxShaderPlatform platform);
+        Status                        load_cache(class FileSystem* file_system, const std::string& folder, const GfxShaderPlatform platform);
+        Status                        save_cache(class FileSystem* file_system, const std::string& folder, const GfxShaderPlatform platform);
 
     private:
-        std::array<ShaderModuleMap, GfxLimits::NUM_PLATFORMS> m_libraries;
+        buffered_vector<ShaderModuleMap, GfxLimits::NUM_PLATFORMS> m_libraries;
 
         std::string       m_library_path;
         std::string       m_library_prefix;
         std::string       m_library_suffix;
-        bool              m_load_cache;
-        bool              m_save_cache;
         GfxShaderPlatform m_active_platform;
 
         mutable RwMutexReadPrefer m_mutex;
diff --git a/engine/runtime/grc/shader_manager.cpp b/engine/runtime/grc/shader_manager.cpp
index c1b1247d8..09120d2d7 100644
--- a/engine/runtime/grc/shader_manager.cpp
+++ b/engine/runtime/grc/shader_manager.cpp
@@ -27,6 +27,7 @@
 
 #include "shader_manager.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "core/string_utils.hpp"
 #include "core/task.hpp"
@@ -43,7 +44,6 @@
 #include "profiler/profiler.hpp"
 #include "rtti/type_storage.hpp"
 #include "system/console.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <functional>
@@ -53,16 +53,16 @@
 
 namespace wmoge {
 
-    ShaderManager::ShaderManager() {
+    ShaderManager::ShaderManager(IocContainer* ioc) {
         WG_AUTO_PROFILE_GRC("ShaderManager::ShaderManager");
 
-        m_task_manager    = IocContainer::iresolve_v<ShaderTaskManager>();
-        m_file_system     = IocContainer::iresolve_v<FileSystem>();
-        m_gfx_driver      = IocContainer::iresolve_v<GfxDriver>();
-        m_texture_manager = IocContainer::iresolve_v<TextureManager>();
-        m_shader_library  = IocContainer::iresolve_v<ShaderLibrary>();
-        m_pso_cache       = IocContainer::iresolve_v<PsoCache>();
-        m_console         = IocContainer::iresolve_v<Console>();
+        m_task_manager    = ioc->resolve_value<ShaderTaskManager>();
+        m_file_system     = ioc->resolve_value<FileSystem>();
+        m_gfx_driver      = ioc->resolve_value<GfxDriver>();
+        m_texture_manager = ioc->resolve_value<TextureManager>();
+        m_shader_library  = ioc->resolve_value<ShaderLibrary>();
+        m_pso_cache       = ioc->resolve_value<PsoCache>();
+        m_console         = ioc->resolve_value<Console>();
 
         m_shaders_folder          = "engine/shaders";
         m_shaders_cache_path      = "cache/";
@@ -396,8 +396,7 @@ namespace wmoge {
                 return 0;
             });
 
-            cache_task.set_task_manager(*m_task_manager);
-            auto cache_task_hnd = cache_task.schedule(compilation_task);
+            auto cache_task_hnd = cache_task.schedule(m_task_manager, compilation_task);
 
             cache_task_hnd.add_on_completion([platform, permutation, weak_shader_entry = WeakRef<Entry>(&shader_entry)](AsyncStatus status, std::optional<int>&) {
                 Ref<Entry> shader_entry = weak_shader_entry.acquire();
@@ -489,7 +488,7 @@ namespace wmoge {
         std::unique_lock lock(entry.mutex);
 
         const std::string path = entry.cache.make_cache_file_name(m_shaders_cache_path, shader->get_shader_name().str(), platform);
-        return entry.cache.load_cache(path, platform, allow_missing);
+        return entry.cache.load_cache(m_file_system, path, platform, allow_missing);
     }
 
     Status ShaderManager::save_cache(Shader* shader, GfxShaderPlatform platform) {
@@ -499,7 +498,7 @@ namespace wmoge {
         std::unique_lock lock(entry.mutex);
 
         const std::string path = entry.cache.make_cache_file_name(m_shaders_cache_path, shader->get_shader_name().str(), platform);
-        return entry.cache.save_cache(path, platform);
+        return entry.cache.save_cache(m_file_system, path, platform);
     }
 
     std::optional<Ref<ShaderType>> ShaderManager::find_global_type(Strid name) {
@@ -507,34 +506,28 @@ namespace wmoge {
         if (q != m_global_types.end()) {
             return q->second;
         }
-
         return std::optional<Ref<ShaderType>>();
     }
 
+    bool ShaderManager::is_global_type(Strid name) {
+        auto q = m_global_types.find(name);
+        return q != m_global_types.end();
+    }
+
     ShaderCompiler* ShaderManager::find_compiler(GfxShaderPlatform platform) {
         assert(int(platform) < GfxLimits::NUM_PLATFORMS);
         return m_compilers[int(platform)].get();
     }
 
-    void ShaderManager::add_global_type(const Ref<ShaderType>& type) {
-        m_global_types[type->name] = type;
+    void ShaderManager::add_compiler(Ref<ShaderCompiler> compiler) {
+        assert(compiler);
+        assert(int(compiler->get_platform()) < GfxLimits::NUM_PLATFORMS);
+        assert(!m_compilers[int(compiler->get_platform())]);
+        m_compilers[int(compiler->get_platform())] = std::move(compiler);
     }
 
-    void ShaderManager::load_compilers() {
-        WG_AUTO_PROFILE_GRC("ShaderManager::load_compilers");
-
-        RttiTypeStorage* type_storage = IocContainer::iresolve_v<RttiTypeStorage>();
-
-        auto compilers = type_storage->find_classes([](const Ref<RttiClass>& rtti) {
-            return rtti->is_subtype_of(ShaderCompiler::get_class_static()) && rtti->can_instantiate();
-        });
-
-        for (const auto& compiler_class : compilers) {
-            Ref<ShaderCompiler> compiler = compiler_class->instantiate().cast<ShaderCompiler>();
-            assert(compiler);
-            assert(int(compiler->get_platform()) < int(GfxShaderPlatform::Max));
-            m_compilers[int(compiler->get_platform())] = compiler;
-        }
+    void ShaderManager::add_global_type(const Ref<ShaderType>& type) {
+        m_global_types[type->name] = type;
     }
 
     ShaderManager::Entry* ShaderManager::get_entry(Shader* shader) {
diff --git a/engine/runtime/grc/shader_manager.hpp b/engine/runtime/grc/shader_manager.hpp
index 9e2520e3f..28e8e64ab 100644
--- a/engine/runtime/grc/shader_manager.hpp
+++ b/engine/runtime/grc/shader_manager.hpp
@@ -55,7 +55,7 @@ namespace wmoge {
     */
     class ShaderManager {
     public:
-        ShaderManager();
+        ShaderManager(class IocContainer* ioc);
 
         Status                         load_shader_reflection(const ShaderFile& file, ShaderReflection& reflection);
         void                           add_shader(const Ref<Shader>& shader);
@@ -71,9 +71,10 @@ namespace wmoge {
         Status                         load_cache(Shader* shader, GfxShaderPlatform platform, bool allow_missing = true);
         Status                         save_cache(Shader* shader, GfxShaderPlatform platform);
         std::optional<Ref<ShaderType>> find_global_type(Strid name);
+        bool                           is_global_type(Strid name);
         ShaderCompiler*                find_compiler(GfxShaderPlatform platform);
+        void                           add_compiler(Ref<ShaderCompiler> compiler);
         void                           add_global_type(const Ref<ShaderType>& type);
-        void                           load_compilers();
 
         [[nodiscard]] const std::string&           get_shaders_folder() const { return m_shaders_folder; }
         [[nodiscard]] const ShaderCompilerOptions& get_compiler_options() const { return m_compiler_options; }
diff --git a/engine/runtime/grc/shader_pass.cpp b/engine/runtime/grc/shader_pass.cpp
index f485274d3..c084ebe64 100644
--- a/engine/runtime/grc/shader_pass.cpp
+++ b/engine/runtime/grc/shader_pass.cpp
@@ -33,7 +33,6 @@
 #include "grc/pso_cache.hpp"
 #include "grc/shader.hpp"
 #include "grc/shader_manager.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 
@@ -144,8 +143,8 @@ namespace wmoge {
             return StatusCode::InvalidState;
         }
 
-        ShaderManager* shader_manager = IocContainer::iresolve_v<ShaderManager>();
-        GfxDriver*     driver         = IocContainer::iresolve_v<GfxDriver>();
+        ShaderManager* shader_manager = nullptr;
+        GfxDriver*     driver         = nullptr;
 
         const std::int16_t num_spaces = m_shader->get_num_spaces();
         for (std::int16_t i = 0; i < num_spaces; i++) {
@@ -159,7 +158,7 @@ namespace wmoge {
     }
 
     Status ShaderPass::configure_graphics(GfxCmdList& cmd_list) {
-        ShaderManager* shader_manager = IocContainer::iresolve_v<ShaderManager>();
+        ShaderManager* shader_manager = nullptr;
 
         auto platform = shader_manager->get_active_platform();
         auto program  = shader_manager->get_or_create_program(m_shader, platform, m_permutation);
@@ -168,7 +167,7 @@ namespace wmoge {
             return StatusCode::NoValue;
         }
 
-        PsoCache* pso_cache = IocContainer::iresolve_v<PsoCache>();
+        PsoCache* pso_cache = nullptr;
 
         GfxVertElements ve;
         for (int i = 0; i < GfxLimits::MAX_VERT_STREAMS; i++) {
@@ -199,7 +198,7 @@ namespace wmoge {
     }
 
     Status ShaderPass::configure_compute(GfxCmdList& cmd_list) {
-        ShaderManager* shader_manager = IocContainer::iresolve_v<ShaderManager>();
+        ShaderManager* shader_manager = nullptr;
 
         auto platform = shader_manager->get_active_platform();
         auto program  = shader_manager->get_or_create_program(m_shader, platform, m_permutation);
@@ -212,7 +211,7 @@ namespace wmoge {
         state.program = program;
         state.layout  = shader_manager->get_shader_pso_layout(m_shader);
 
-        PsoCache* pso_cache = IocContainer::iresolve_v<PsoCache>();
+        PsoCache* pso_cache = nullptr;
         GfxPsoRef pso_ref   = pso_cache->get_or_create_pso(state, program->name());
 
         if (!pso_ref) {
diff --git a/engine/runtime/grc/texture.cpp b/engine/runtime/grc/texture.cpp
index 5131b02f3..2fe528561 100644
--- a/engine/runtime/grc/texture.cpp
+++ b/engine/runtime/grc/texture.cpp
@@ -29,11 +29,11 @@
 
 #include "asset/asset_manager.hpp"
 #include "core/data.hpp"
+#include "core/ioc_container.hpp"
 #include "core/string_utils.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "io/tree.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 
diff --git a/engine/runtime/grc/texture_manager.cpp b/engine/runtime/grc/texture_manager.cpp
index 72670da20..c6e61d4eb 100644
--- a/engine/runtime/grc/texture_manager.cpp
+++ b/engine/runtime/grc/texture_manager.cpp
@@ -28,17 +28,17 @@
 #include "texture_manager.hpp"
 
 #include "core/array_view.hpp"
+#include "core/ioc_container.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 
 namespace wmoge {
 
-    TextureManager::TextureManager() {
+    TextureManager::TextureManager(IocContainer* ioc) {
         WG_AUTO_PROFILE_GRC("TextureManager::TextureManager");
 
-        m_gfx_driver = IocContainer::iresolve_v<GfxDriver>();
+        m_gfx_driver = ioc->resolve_value<GfxDriver>();
         m_pool       = std::make_unique<TexturePool>(*m_gfx_driver);
         m_callback   = std::make_shared<Texture::Callback>([this](Texture* texture) { remove(texture); });
 
diff --git a/engine/runtime/grc/texture_manager.hpp b/engine/runtime/grc/texture_manager.hpp
index 4edd5697e..9d85f2237 100644
--- a/engine/runtime/grc/texture_manager.hpp
+++ b/engine/runtime/grc/texture_manager.hpp
@@ -71,7 +71,7 @@ namespace wmoge {
     */
     class TextureManager {
     public:
-        TextureManager();
+        TextureManager(class IocContainer* ioc);
 
         Ref<Texture2d>   create_2d(TextureFlags flags, GfxFormat format, int width, int height, GfxTexSwizz swizz = GfxTexSwizz::None);
         Ref<TextureCube> create_cube(TextureFlags flags, GfxFormat format, int width, int height);
diff --git a/engine/runtime/hooks/hook_engine.hpp b/engine/runtime/hooks/hook_engine.hpp
deleted file mode 100644
index 6be53a45b..000000000
--- a/engine/runtime/hooks/hook_engine.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "platform/common/mount_volume_physical.hpp"
-#include "platform/file_system.hpp"
-#include "system/config.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
-
-namespace wmoge {
-
-    /** 
-     * @class HookEngine
-     * @brief Engine hook to setup runtime of the game
-     */
-    class HookEngine : public Hook {
-    public:
-        ~HookEngine() override = default;
-
-        std::string get_name() const override {
-            return "engine";
-        }
-
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-            cmd_line.add_string("game_config", "path to game config folder", "config/");
-            cmd_line.add_string("engine_config", "path to engine config folder", "engine/config/");
-            cmd_line.add_string("engine_remap", "remap for engine directory (for debug mostly)", "engine/");
-        }
-
-        Status on_process(CmdLine& cmd_line) override {
-            Config*     config = IocContainer::iresolve_v<Config>();
-            FileSystem* fs     = IocContainer::iresolve_v<FileSystem>();
-
-            const bool                  mount_front = true;
-            const std::filesystem::path root_path   = fs->root_path();
-
-            Ref<MountVolumePhysical> volume_engine = make_ref<MountVolumePhysical>(root_path / cmd_line.get_string("engine_remap"), "engine/");
-            fs->add_mounting({"engine/", std::move(volume_engine)}, mount_front);
-
-            Ref<MountVolumePhysical> volume_local = make_ref<MountVolumePhysical>(root_path / ".wgengine", "local/");
-            fs->add_mounting({"local/", std::move(volume_local)}, mount_front);
-
-            Ref<MountVolumePhysical> volume_logs = make_ref<MountVolumePhysical>(root_path / ".wgengine/logs", "logs/");
-            fs->add_mounting({"logs/", std::move(volume_logs)}, mount_front);
-
-            Ref<MountVolumePhysical> volume_debug = make_ref<MountVolumePhysical>(root_path / ".wgengine/debug", "debug/");
-            fs->add_mounting({"debug/", std::move(volume_debug)}, mount_front);
-
-            Ref<MountVolumePhysical> volume_cache = make_ref<MountVolumePhysical>(root_path / ".wgengine/cache", "cache/");
-            fs->add_mounting({"cache/", std::move(volume_cache)}, mount_front);
-
-            const std::string game_config   = cmd_line.get_string("game_config");
-            const std::string engine_config = cmd_line.get_string("engine_config");
-
-            if (!config->load(engine_config + "/engine.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load engine engine.cfg file, check your configuration file or path" << std::endl;
-            }
-            if (!config->load(engine_config + "/game.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load engine game.cfg file, check your configure file of path" << std::endl;
-            }
-            if (!config->load(engine_config + "/cvars.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load engine cvars.cfg file, check your configure file of path" << std::endl;
-            }
-
-            if (!config->load(game_config + "/engine.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load game engine.cfg file, check your configuration file or path" << std::endl;
-            }
-            if (!config->load(game_config + "/game.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load game game.cfg file, check your configure file of path" << std::endl;
-            }
-            if (!config->load(game_config + "/cvars.cfg", ConfigStackMode::Overwrite)) {
-                std::cerr << "failed to load game cvars.cfg file, check your configure file of path" << std::endl;
-            }
-
-            return WG_OK;
-        }
-    };
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/hooks/hook_logs.hpp b/engine/runtime/hooks/hook_logs.hpp
deleted file mode 100644
index caefbd14e..000000000
--- a/engine/runtime/hooks/hook_logs.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "core/log.hpp"
-#include "io/enum.hpp"
-#include "system/config.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
-
-namespace wmoge {
-
-    /** 
-     * @class HookLogs
-     * @brief Engine hook to configure and and init engine logs
-     */
-    class HookLogs : public Hook {
-    public:
-        ~HookLogs() override = default;
-
-        std::string get_name() const override {
-            return "logs";
-        }
-
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-            cmd_line.add_bool("disable_logs", "disable all logs entirely (overrides config)", "false");
-        }
-
-        Status on_process(CmdLine& cmd_line) override {
-            Config* config = IocContainer::iresolve_v<Config>();
-
-            const bool no_logs = cmd_line.get_bool("disable_logs");
-            if (no_logs) {
-                return WG_OK;
-            }
-
-            const bool log_to_out     = config->get_bool_or_default(SID("engine.log_to_out"), true);
-            const bool log_to_file    = config->get_bool_or_default(SID("engine.log_to_file"), true);
-            const bool log_to_console = config->get_bool_or_default(SID("engine.log_to_console"), true);
-
-            const auto log_to_out_level     = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_out_level"), "Info"));
-            const auto log_to_file_level    = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_file_level"), "Info"));
-            const auto log_to_console_level = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_console_level"), "Info"));
-
-            if (log_to_file) {
-                auto log_listener_stream = std::make_shared<LogListenerStream>("file", log_to_file_level);
-                Log::instance()->listen(log_listener_stream);
-                WG_LOG_INFO("attach file log listener");
-            }
-            if (log_to_out) {
-                auto log_listener_stdout = std::make_shared<LogListenerStdout>("out", log_to_out_level);
-                Log::instance()->listen(log_listener_stdout);
-                WG_LOG_INFO("attach stdout log listener");
-            }
-            if (log_to_console) {
-                auto log_listener_console = std::make_shared<LogListenerConsole>(IocContainer::iresolve_v<Console>(), log_to_console_level);
-                Log::instance()->listen(log_listener_console);
-                WG_LOG_INFO("attach console log listener");
-            }
-
-            return WG_OK;
-        }
-    };
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/hooks/hook_profiler.hpp b/engine/runtime/hooks/hook_profiler.hpp
deleted file mode 100644
index 233bcdbeb..000000000
--- a/engine/runtime/hooks/hook_profiler.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "core/log.hpp"
-#include "platform/application.hpp"
-#include "profiler/profiler.hpp"
-#include "system/config.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
-
-namespace wmoge {
-
-    /** 
-     * @class HookProfiler
-     * @brief Engine hook to setup profiler of game application
-     */
-    class HookProfiler : public Hook {
-    public:
-        ~HookProfiler() override = default;
-
-        std::string get_name() const override {
-            return "profiler";
-        }
-
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-            cmd_line.add_bool("profiler", "enable cpu profiler hook", "false");
-        }
-
-        Status on_process(CmdLine& cmd_line) override {
-            Config*      config      = IocContainer::iresolve_v<Config>();
-            Profiler*    profiler    = IocContainer::iresolve_v<Profiler>();
-            Application* application = IocContainer::iresolve_v<Application>();
-
-            enable_profiler = enable_profiler || cmd_line.get_bool("profiler");
-            enable_profiler = enable_profiler || config->get_bool_or_default(SID("profiler.enable"), false);
-
-            profiler->set_enabled(enable_profiler);
-
-            if (enable_profiler) {
-                WG_LOG_INFO("attach cpu performance profiler");
-
-                application->signal_before_init.bind([this]() {
-                    WG_PROFILE_CAPTURE_START(m_capture_startup, startup, "debug/profile_startup.json");
-                });
-                application->signal_after_init.bind([this]() {
-                    WG_PROFILE_CAPTURE_END(m_capture_startup);
-                });
-                application->signal_before_loop.bind([this]() {
-                    WG_PROFILE_CAPTURE_START(m_capture_runtime, runtime, "debug/profile_runtime.json");
-                });
-                application->signal_after_loop.bind([this]() {
-                    WG_PROFILE_CAPTURE_END(m_capture_runtime);
-                });
-                application->signal_before_shutdown.bind([this]() {
-                    WG_PROFILE_CAPTURE_START(m_capture_shutdown, shutdown, "debug/profile_shutdown.json");
-                });
-                application->signal_after_shutdown.bind([this]() {
-                    WG_PROFILE_CAPTURE_END(m_capture_shutdown);
-                });
-            }
-
-            return WG_OK;
-        }
-
-    private:
-        std::shared_ptr<ProfilerCapture> m_capture_startup;
-        std::shared_ptr<ProfilerCapture> m_capture_runtime;
-        std::shared_ptr<ProfilerCapture> m_capture_shutdown;
-
-        bool enable_profiler = false;
-    };
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/hooks/hook_root_remap.hpp b/engine/runtime/hooks/hook_root_remap.hpp
deleted file mode 100644
index bbd1d69a1..000000000
--- a/engine/runtime/hooks/hook_root_remap.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "platform/file_system.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
-
-namespace wmoge {
-
-    /** 
-     * @class HookRootRemap
-     * @brief Engine hook to remap root folder to other (for debug moslty)
-     */
-    class HookRootRemap : public Hook {
-    public:
-        ~HookRootRemap() override = default;
-
-        std::string get_name() const override {
-            return "root_remap";
-        }
-
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-            cmd_line.add_string("root_remap", "remap path to game root folder", "");
-        }
-
-        Status on_process(CmdLine& cmd_line) override {
-            FileSystem* fs = IocContainer::iresolve_v<FileSystem>();
-
-            const std::string root_remap = cmd_line.get_string("root_remap");
-            if (!root_remap.empty()) {
-                fs->root(root_remap);
-                std::cout << "remap game exe root direcory to " << root_remap << std::endl;
-            }
-
-            return WG_OK;
-        }
-    };
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/hooks/hook_uuid_gen.hpp b/engine/runtime/hooks/hook_uuid_gen.hpp
deleted file mode 100644
index c16ae5ec9..000000000
--- a/engine/runtime/hooks/hook_uuid_gen.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "core/uuid.hpp"
-#include "system/hook.hpp"
-
-namespace wmoge {
-
-    /** 
-     * @class HookUuidGen
-     * @brief Engine hook to generate uuids
-     */
-    class HookUuidGen : public Hook {
-    public:
-        ~HookUuidGen() override = default;
-
-        std::string get_name() const override {
-            return "uuid_gen";
-        }
-
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-            cmd_line.add_int("gen_uuids", "gen desired count of uuids' values and outputs them", "0");
-        }
-
-        Status on_process(CmdLine& cmd_line) override {
-            const int uuid_count = cmd_line.get_int("gen_uuids");
-
-            if (uuid_count > 0) {
-                for (int i = 0; i < uuid_count; i++) {
-                    std::cout << UUID::generate() << std::endl;
-                }
-                return StatusCode::ExitCode0;
-            }
-
-            return WG_OK;
-        }
-    };
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/io/async_file_system.cpp b/engine/runtime/io/async_file_system.cpp
index fe409b72d..dbba43eda 100644
--- a/engine/runtime/io/async_file_system.cpp
+++ b/engine/runtime/io/async_file_system.cpp
@@ -27,9 +27,9 @@
 
 #include "async_file_system.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/task.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -56,8 +56,7 @@ namespace wmoge {
             return 0;
         });
 
-        task.set_task_manager(m_task_manager);
-        task.schedule().add_on_completion([=](AsyncStatus status, std::optional<int>&) {
+        task.schedule(&m_task_manager).add_on_completion([=](AsyncStatus status, std::optional<int>&) {
             if (status == AsyncStatus::Ok) {
                 async_result->set_result(BufferView(buffer_view));
                 return;
diff --git a/engine/runtime/io/stream_file.cpp b/engine/runtime/io/stream_file.cpp
index 29ba8b3a0..bf7dcd3e3 100644
--- a/engine/runtime/io/stream_file.cpp
+++ b/engine/runtime/io/stream_file.cpp
@@ -30,7 +30,6 @@
 #include "io/compression.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <cstring>
@@ -59,12 +58,9 @@ namespace wmoge {
         return WG_OK;
     }
 
-    Status IoStreamFile::open(const std::string& file_path, FileOpenModeFlags flags) {
-        Ref<File>   file;
-        FileSystem* file_system = IocContainer::iresolve_v<FileSystem>();
-
+    Status IoStreamFile::open(FileSystem* file_system, const std::string& file_path, FileOpenModeFlags flags) {
+        Ref<File> file;
         WG_CHECKED(file_system->open_file(file_path, file, flags));
-
         return set(std::move(file), flags);
     }
 
diff --git a/engine/runtime/io/stream_file.hpp b/engine/runtime/io/stream_file.hpp
index 7a30623ab..3b07ae2ec 100644
--- a/engine/runtime/io/stream_file.hpp
+++ b/engine/runtime/io/stream_file.hpp
@@ -45,7 +45,7 @@ namespace wmoge {
         ~IoStreamFile() override;
 
         Status set(Ref<File> file, FileOpenModeFlags flags);
-        Status open(const std::string& file_path, FileOpenModeFlags flags);
+        Status open(class FileSystem* file_system, const std::string& file_path, FileOpenModeFlags flags);
         Status nwrite(std::size_t num_bytes, const void* bytes) override;
         Status nread(std::size_t num_bytes, void* bytes) override;
         Status begin_compressed() override;
diff --git a/engine/runtime/io/tree_yaml.cpp b/engine/runtime/io/tree_yaml.cpp
index fec798e73..017e3a25d 100644
--- a/engine/runtime/io/tree_yaml.cpp
+++ b/engine/runtime/io/tree_yaml.cpp
@@ -27,9 +27,9 @@
 
 #include "tree_yaml.hpp"
 
+#include "core/ioc_container.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <sstream>
@@ -46,6 +46,16 @@ namespace wmoge {
         return WG_OK;
     }
 
+    Status IoYamlTree::save_tree(std::string& data) {
+        ryml::emitrs_yaml(m_tree, 0, &data);
+        return WG_OK;
+    }
+
+    Status IoYamlTree::save_tree_json(std::string& data) {
+        ryml::emitrs_json(m_tree, 0, &data);
+        return WG_OK;
+    }
+
     Status IoYamlTree::parse_data(const array_view<const std::uint8_t>& data) {
         WG_AUTO_PROFILE_IO("IoYamlTree::parse_data");
         assert(m_stack.empty());
@@ -60,10 +70,6 @@ namespace wmoge {
         return WG_OK;
     }
 
-    Status IoYamlTree::parse_file(const std::string& path) {
-        return parse_file(IocContainer::iresolve_v<FileSystem>(), path);
-    }
-
     Status IoYamlTree::parse_file(FileSystem* fs, const std::string& path) {
         std::vector<std::uint8_t> data;
         WG_CHECKED(fs->read_file(path, data));
diff --git a/engine/runtime/io/tree_yaml.hpp b/engine/runtime/io/tree_yaml.hpp
index f3b1d1973..5864ea352 100644
--- a/engine/runtime/io/tree_yaml.hpp
+++ b/engine/runtime/io/tree_yaml.hpp
@@ -37,6 +37,7 @@
 #include <ryml.hpp>
 #include <ryml_std.hpp>
 
+#include <string>
 #include <vector>
 
 namespace wmoge {
@@ -51,8 +52,9 @@ namespace wmoge {
         ~IoYamlTree() = default;
 
         Status create_tree();
+        Status save_tree(std::string& data);
+        Status save_tree_json(std::string& data);
         Status parse_data(const array_view<const std::uint8_t>& data);
-        Status parse_file(const std::string& path);
         Status parse_file(class FileSystem* fs, const std::string& path);
 
         bool        node_is_empty() override;
diff --git a/engine/runtime/mesh/mesh_manager.cpp b/engine/runtime/mesh/mesh_manager.cpp
index 0a084c236..a04fa7626 100644
--- a/engine/runtime/mesh/mesh_manager.cpp
+++ b/engine/runtime/mesh/mesh_manager.cpp
@@ -27,16 +27,16 @@
 
 #include "mesh_manager.hpp"
 
+#include "core/ioc_container.hpp"
 #include "gfx/gfx_driver.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 
 namespace wmoge {
 
-    MeshManager::MeshManager() {
-        m_gfx_driver = IocContainer::iresolve_v<GfxDriver>();
+    MeshManager::MeshManager(IocContainer* ioc) {
+        m_gfx_driver = ioc->resolve_value<GfxDriver>();
         m_callback   = std::make_shared<Mesh::Callback>([this](Mesh* mesh) { remove_mesh(mesh); });
     }
 
diff --git a/engine/runtime/mesh/mesh_manager.hpp b/engine/runtime/mesh/mesh_manager.hpp
index 9e3da3532..cddee8307 100644
--- a/engine/runtime/mesh/mesh_manager.hpp
+++ b/engine/runtime/mesh/mesh_manager.hpp
@@ -52,7 +52,7 @@ namespace wmoge {
      */
     class MeshManager {
     public:
-        MeshManager();
+        MeshManager(class IocContainer* ioc);
 
         Ref<Mesh> create_mesh(MeshFlags flags);
         void      add_mesh(const Ref<Mesh>& mesh);
diff --git a/engine/runtime/platform/dll_manager.cpp b/engine/runtime/platform/dll_manager.cpp
index ead33020d..b3dfb3329 100644
--- a/engine/runtime/platform/dll_manager.cpp
+++ b/engine/runtime/platform/dll_manager.cpp
@@ -28,8 +28,8 @@
 
 #include "dll_manager.hpp"
 
+#include "core/ioc_container.hpp"
 #include "platform/file_system.hpp"
-#include "system/ioc_container.hpp"
 
 #include <dynalo/dynalo.hpp>
 
@@ -42,7 +42,9 @@ namespace wmoge {
         dynalo::native::handle handle{};
     };
 
-    DllManager::DllManager() = default;
+    DllManager::DllManager(IocContainer* ioc) {
+        m_file_system = ioc->resolve_value<FileSystem>();
+    }
 
     DllManager::~DllManager() {
         for (auto& lib : m_libraries) {
@@ -55,12 +57,10 @@ namespace wmoge {
             return StatusCode::InvalidState;
         }
 
-        FileSystem* fs = IocContainer::iresolve_v<FileSystem>();
-
         DllLibrary dll_library{};
         dll_library.name        = library;
         dll_library.name_native = dynalo::to_native_name(library.str());
-        dll_library.path        = std::filesystem::path(fs->resolve_physical(path)) / dll_library.name_native;
+        dll_library.path        = std::filesystem::path(m_file_system->resolve_physical(path)) / dll_library.name_native;
 
         try {
             dll_library.handle = dynalo::open(dll_library.path.string());
diff --git a/engine/runtime/platform/dll_manager.hpp b/engine/runtime/platform/dll_manager.hpp
index a8dc14890..b8720289f 100644
--- a/engine/runtime/platform/dll_manager.hpp
+++ b/engine/runtime/platform/dll_manager.hpp
@@ -42,7 +42,7 @@ namespace wmoge {
     */
     class DllManager {
     public:
-        DllManager();
+        DllManager(class IocContainer* ioc);
         ~DllManager();
 
         Status load(const Strid& library, const std::string& path);
@@ -51,6 +51,7 @@ namespace wmoge {
 
     private:
         buffered_vector<std::unique_ptr<struct DllLibrary>> m_libraries;
+        class FileSystem*                                   m_file_system;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/platform/file_system.cpp b/engine/runtime/platform/file_system.cpp
index 3ea525338..af71b9430 100644
--- a/engine/runtime/platform/file_system.cpp
+++ b/engine/runtime/platform/file_system.cpp
@@ -28,11 +28,11 @@
 #include "file_system.hpp"
 
 #include "core/data.hpp"
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "platform/common/mount_volume_physical.hpp"
 #include "profiler/profiler.hpp"
 #include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 #include <filesystem>
diff --git a/engine/runtime/profiler/profiler.cpp b/engine/runtime/profiler/profiler.cpp
index e93d0f1d2..c31479c46 100644
--- a/engine/runtime/profiler/profiler.cpp
+++ b/engine/runtime/profiler/profiler.cpp
@@ -27,10 +27,10 @@
 
 #include "profiler.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "platform/file_system.hpp"
 #include "platform/time.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
@@ -65,6 +65,7 @@ namespace wmoge {
         : m_mark(mark), m_desc(std::move(desc)) {
         m_timer.start();
     }
+
     ProfilerTimeEvent::~ProfilerTimeEvent() {
         m_timer.stop();
 
@@ -82,33 +83,66 @@ namespace wmoge {
     void ProfilerCapture::set_name(Strid name) {
         m_name = name;
     }
+
     void ProfilerCapture::set_file(std::string file) {
         m_file = std::move(file);
     }
+
     void ProfilerCapture::add_entry(ProfilerEntry&& entry) {
         m_entries.push_back(std::move(entry));
     }
-    void ProfilerCapture::save_to_json() {
-        using namespace std::chrono;
 
-        FileSystem* file_system = IocContainer::iresolve_v<FileSystem>();
-        Profiler*   profiler    = IocContainer::iresolve_v<Profiler>();
-        Time*       time        = IocContainer::iresolve_v<Time>();
+    Profiler  g_profiler_default;
+    Profiler* Profiler::g_profiler = &g_profiler_default;
+
+    void Profiler::configure(IocContainer* ioc) {
+        m_file_system = ioc->resolve_value<FileSystem>();
+        m_time        = ioc->resolve_value<Time>();
+
+        add_tid(std::this_thread::get_id(), SID("main-thread"));
+    }
+
+    void Profiler::set_enabled(bool value) {
+        std::lock_guard guard(m_mutex);
+
+        m_is_enabled.store(value);
+        m_is_collecting.store(value && m_capture);
+        WG_LOG_INFO("time profiler status is " << value);
+    }
+
+    void Profiler::start_capture(std::shared_ptr<ProfilerCapture> capture) {
+        std::lock_guard guard(m_mutex);
+
+        m_capture = std::move(capture);
+        if (is_enabled()) {
+            m_is_collecting.store(true);
+        }
+    }
+
+    void Profiler::end_capture() {
+        std::lock_guard guard(m_mutex);
+
+        m_is_collecting.store(false);
+        m_capture.reset();
+    }
+
+    void Profiler::save_capture_to_json(std::shared_ptr<ProfilerCapture> capture) {
+        using namespace std::chrono;
 
         std::fstream file_stream;
 
-        if (!file_system->open_file_physical(m_file, file_stream, std::ios_base::out | std::ios::binary)) {
-            WG_LOG_ERROR("failed to open capture file " << m_file);
+        if (!m_file_system->open_file_physical(capture->get_file(), file_stream, std::ios_base::out | std::ios::binary)) {
+            WG_LOG_ERROR("failed to open capture file " << capture->get_file());
             return;
         }
 
-        auto start     = time->get_start();
-        auto tid_names = profiler->get_tid_names();
+        auto start     = m_time->get_start();
+        auto tid_names = get_tid_names();
 
         file_stream << R"({"otherData":{}, "traceEvents":[)";
 
         bool first = true;
-        for (const auto& entry : m_entries) {
+        for (const auto& entry : capture->get_entries()) {
             auto entry_start = duration_cast<microseconds>(entry.start - start).count();
             auto entry_dur   = duration_cast<microseconds>(entry.stop - entry.start).count();
 
@@ -137,49 +171,27 @@ namespace wmoge {
         file_stream << "]}";
         file_stream.close();
 
-        WG_LOG_INFO("saved capture to " << m_file);
-    }
-
-    Profiler* Profiler::g_profiler = nullptr;
-
-    Profiler::Profiler() {
-        add_tid(std::this_thread::get_id(), SID("main-thread"));
-    }
-    void Profiler::set_enabled(bool value) {
-        std::lock_guard guard(m_mutex);
-
-        m_is_enabled.store(value);
-        m_is_collecting.store(value && m_capture);
-        WG_LOG_INFO("time profiler status is " << value);
+        WG_LOG_INFO("saved capture to " << capture->get_file());
     }
-    void Profiler::start_capture(std::shared_ptr<ProfilerCapture> capture) {
-        std::lock_guard guard(m_mutex);
 
-        m_capture = std::move(capture);
-        if (is_enabled()) {
-            m_is_collecting.store(true);
-        }
-    }
-    void Profiler::end_capture() {
-        std::lock_guard guard(m_mutex);
-
-        m_is_collecting.store(false);
-        m_capture.reset();
-    }
     void Profiler::add_entry(ProfilerEntry&& entry) {
         std::lock_guard guard(m_mutex);
         if (m_capture) m_capture->add_entry(std::move(entry));
     }
+
     void Profiler::add_tid(std::thread::id id, Strid name) {
         std::lock_guard guard(m_mutex);
         m_tid_names[id] = std::move(name);
     }
+
     bool Profiler::is_enabled() {
         return m_is_enabled;
     }
+
     bool Profiler::is_collecting() {
         return m_is_collecting.load();
     }
+
     std::unordered_map<std::thread::id, Strid> Profiler::get_tid_names() const {
         return m_tid_names;
     }
diff --git a/engine/runtime/profiler/profiler.hpp b/engine/runtime/profiler/profiler.hpp
index 65419ddef..e10407ea4 100644
--- a/engine/runtime/profiler/profiler.hpp
+++ b/engine/runtime/profiler/profiler.hpp
@@ -99,9 +99,9 @@ namespace wmoge {
         void set_name(Strid name);
         void set_file(std::string file);
         void add_entry(ProfilerEntry&& entry);
-        void save_to_json();
 
         [[nodiscard]] const Strid&                      get_name() const { return m_name; }
+        [[nodiscard]] const std::string&                get_file() const { return m_file; }
         [[nodiscard]] const std::vector<ProfilerEntry>& get_entries() const { return m_entries; }
 
     private:
@@ -116,11 +116,13 @@ namespace wmoge {
      */
     class Profiler {
     public:
-        Profiler();
+        Profiler() = default;
 
+        void configure(class IocContainer* ioc);
         void set_enabled(bool value);
         void start_capture(std::shared_ptr<ProfilerCapture> capture);
         void end_capture();
+        void save_capture_to_json(std::shared_ptr<ProfilerCapture> capture);
         void add_entry(ProfilerEntry&& entry);
         void add_tid(std::thread::id id, Strid name);
 
@@ -136,7 +138,11 @@ namespace wmoge {
         std::atomic_bool                           m_is_collecting{false};
         std::shared_ptr<ProfilerCapture>           m_capture;
         std::unordered_map<std::thread::id, Strid> m_tid_names;
-        SpinMutex                                  m_mutex;
+
+        class FileSystem* m_file_system;
+        class Time*       m_time;
+
+        mutable SpinMutex m_mutex;
 
         static Profiler* g_profiler;
     };
@@ -191,7 +197,7 @@ namespace wmoge {
     capture->set_file(file_path);                             \
     Profiler::instance()->start_capture(capture);
 
-#define WG_PROFILE_CAPTURE_END(capture)  \
-    Profiler::instance()->end_capture(); \
-    capture->save_to_json();             \
+#define WG_PROFILE_CAPTURE_END(capture)                  \
+    Profiler::instance()->end_capture();                 \
+    Profiler::instance()->save_capture_to_json(capture); \
     capture.reset();
diff --git a/engine/runtime/rdg/rdg_graph.cpp b/engine/runtime/rdg/rdg_graph.cpp
index 0d19c0673..79001aa7d 100644
--- a/engine/runtime/rdg/rdg_graph.cpp
+++ b/engine/runtime/rdg/rdg_graph.cpp
@@ -30,14 +30,13 @@
 
 #include "core/log.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 
 namespace wmoge {
 
-    RDGGraph::RDGGraph() {
-        m_pool = IocContainer::iresolve_v<RDGPool>();
+    RDGGraph::RDGGraph(RDGPool* pool) {
+        m_pool = pool;
     }
 
     RDGPass& RDGGraph::add_pass(Strid name, RDGPassFlags flags) {
diff --git a/engine/runtime/rdg/rdg_graph.hpp b/engine/runtime/rdg/rdg_graph.hpp
index 4aca335f7..95ba5538b 100644
--- a/engine/runtime/rdg/rdg_graph.hpp
+++ b/engine/runtime/rdg/rdg_graph.hpp
@@ -43,7 +43,7 @@ namespace wmoge {
     */
     class RDGGraph {
     public:
-        RDGGraph();
+        RDGGraph(RDGPool* pool);
 
         RDGPass& add_pass(Strid name, RDGPassFlags flags = {});
         RDGPass& add_compute_pass(Strid name, RDGPassFlags flags = {});
diff --git a/engine/runtime/rdg/rdg_pool.cpp b/engine/runtime/rdg/rdg_pool.cpp
index c3f0211b6..2ab97f272 100644
--- a/engine/runtime/rdg/rdg_pool.cpp
+++ b/engine/runtime/rdg/rdg_pool.cpp
@@ -28,18 +28,13 @@
 #include "rdg_pool.hpp"
 
 #include "gfx/gfx_driver.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 
 namespace wmoge {
 
-    RDGPool::RDGPool() {
-        Config* config = IocContainer::iresolve_v<Config>();
-
-        m_driver           = IocContainer::iresolve_v<GfxDriver>();
-        m_frames_before_gc = config->get_int_or_default(SID("rdg.pool.frames_before_gc"), 6);
+    RDGPool::RDGPool(GfxDriver* driver) {
+        m_driver = driver;
     }
 
     void RDGPool::update() {
diff --git a/engine/runtime/rdg/rdg_pool.hpp b/engine/runtime/rdg/rdg_pool.hpp
index 1f8a3a947..4a370f03b 100644
--- a/engine/runtime/rdg/rdg_pool.hpp
+++ b/engine/runtime/rdg/rdg_pool.hpp
@@ -40,7 +40,7 @@ namespace wmoge {
     */
     class RDGPool {
     public:
-        RDGPool();
+        RDGPool(class GfxDriver* driver);
 
         void update();
 
@@ -62,8 +62,8 @@ namespace wmoge {
         std::vector<PoolUniformBuffer> m_uniform_buffer_pool;
         std::vector<PoolStorageBuffer> m_storage_buffer_pool;
 
-        class GfxDriver* m_driver = nullptr;
-        int              m_frames_before_gc;
+        class GfxDriver* m_driver           = nullptr;
+        int              m_frames_before_gc = 6;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/render/aux_draw_manager.cpp b/engine/runtime/render/aux_draw_manager.cpp
index 60d0e942c..05a14114a 100644
--- a/engine/runtime/render/aux_draw_manager.cpp
+++ b/engine/runtime/render/aux_draw_manager.cpp
@@ -33,8 +33,6 @@
 #include "gfx/gfx_driver.hpp"
 #include "math/math_utils3d.hpp"
 #include "profiler/profiler.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 #include <utility>
@@ -456,20 +454,12 @@ namespace wmoge {
         }
     };
 
-    AuxDrawManager::AuxDrawManager()  = default;
-    AuxDrawManager::~AuxDrawManager() = default;
+    AuxDrawManager::AuxDrawManager() {
+        std::string font_name   = "assets/fonts/consolas";
+        m_screen_size.values[0] = 1280.0f;
+        m_screen_size.values[1] = 720.0f;
 
-    void AuxDrawManager::init() {
-        WG_AUTO_PROFILE_RENDER("AuxDrawManager::init");
-
-        Config*       config        = IocContainer::iresolve_v<Config>();
-        AssetManager* asset_manager = IocContainer::iresolve_v<AssetManager>();
-
-        std::string font_name = config->get_string_or_default(SID("render.aux.font"), "assets/fonts/consolas");
-        m_font                = asset_manager->load(SID(font_name)).cast<Font>();
-
-        m_screen_size.values[0] = config->get_float_or_default(SID("render.aux.screen_width"), 1280.0f);
-        m_screen_size.values[1] = config->get_float_or_default(SID("render.aux.screen_height"), 720.0f);
+        // m_font = asset_manager->load(SID(font_name)).cast<Font>();
 
         m_lines.set_name(SID("aux_lines"));
         m_tria_solid.set_name(SID("aux_tria_solid"));
diff --git a/engine/runtime/render/aux_draw_manager.hpp b/engine/runtime/render/aux_draw_manager.hpp
index c88774728..3ee978921 100644
--- a/engine/runtime/render/aux_draw_manager.hpp
+++ b/engine/runtime/render/aux_draw_manager.hpp
@@ -60,9 +60,6 @@ namespace wmoge {
         static constexpr float LIFETIME_INFINITY  = 2000000.0f;
 
         AuxDrawManager();
-        ~AuxDrawManager();
-
-        void init();
 
         void draw_line(const Vec3f& from, const Vec3f& to, const Color4f& color, float lifetime = LIFETIME_ONE_FRAME);
         void draw_triangle(const Vec3f& p0, const Vec3f& p1, const Vec3f& p2, const Color4f& color, bool solid = true, float lifetime = LIFETIME_ONE_FRAME);
diff --git a/engine/runtime/render/culling.cpp b/engine/runtime/render/culling.cpp
index e337d1215..a54c693c2 100644
--- a/engine/runtime/render/culling.cpp
+++ b/engine/runtime/render/culling.cpp
@@ -96,7 +96,7 @@ namespace wmoge {
         return m_result[item.id];
     }
 
-    void CullingManager::cull(const CameraList& cameras) {
+    void CullingManager::cull(TaskManager* task_manager, const CameraList& cameras) {
         WG_AUTO_PROFILE_RENDER("CullingManager::cull");
 
         const int total_items = int(m_items.size());
@@ -123,7 +123,7 @@ namespace wmoge {
                 return 0;
             });
 
-            task_cull_camera.schedule(total_items, m_task_batch).wait_completed();
+            task_cull_camera.schedule(task_manager, total_items, m_task_batch).wait_completed();
         }
     }
 
diff --git a/engine/runtime/render/culling.hpp b/engine/runtime/render/culling.hpp
index dc95198de..53da6550e 100644
--- a/engine/runtime/render/culling.hpp
+++ b/engine/runtime/render/culling.hpp
@@ -100,7 +100,7 @@ namespace wmoge {
         void              update_item_bbox(const CullingItem& item, const Aabbf& aabbf);
         CullingItemResult get_item_result(const CullingItem& item);
 
-        void cull(const CameraList& cameras);
+        void cull(class TaskManager* task_manager, const CameraList& cameras);
 
     private:
         std::vector<CullingItemData>   m_items;
diff --git a/engine/runtime/render/render_engine.cpp b/engine/runtime/render/render_engine.cpp
index 4ebba2cef..885bb6c8f 100644
--- a/engine/runtime/render/render_engine.cpp
+++ b/engine/runtime/render/render_engine.cpp
@@ -192,7 +192,7 @@ namespace wmoge {
             return 0;
         });
 
-        task_compile.schedule(int(batches.size()), m_batch_size).wait_completed();
+        task_compile.schedule(m_task_manager, int(batches.size()), m_batch_size).wait_completed();
     }
 
     void RenderEngine::group_queues() {
@@ -221,7 +221,7 @@ namespace wmoge {
             return 0;
         });
 
-        task_sort.schedule(int(m_queues.size()), 1).wait_completed();
+        task_sort.schedule(m_task_manager, int(m_queues.size()), 1).wait_completed();
     }
 
     void RenderEngine::merge_cmds() {
@@ -235,7 +235,7 @@ namespace wmoge {
             return 0;
         });
 
-        task_merge.schedule(int(m_queues.size()), 1).wait_completed();
+        task_merge.schedule(m_task_manager, int(m_queues.size()), 1).wait_completed();
     }
 
     void RenderEngine::flush_buffers() {
diff --git a/engine/runtime/render/render_engine.hpp b/engine/runtime/render/render_engine.hpp
index 727e7f7db..9da591443 100644
--- a/engine/runtime/render/render_engine.hpp
+++ b/engine/runtime/render/render_engine.hpp
@@ -31,6 +31,7 @@
 #include "core/buffered_vector.hpp"
 #include "core/status.hpp"
 #include "core/string_id.hpp"
+#include "core/task_manager.hpp"
 #include "gfx/gfx_buffers.hpp"
 #include "gfx/gfx_desc_set.hpp"
 #include "gfx/gfx_vector.hpp"
@@ -166,7 +167,8 @@ namespace wmoge {
         GfxVector<GfxVF_Pos2Uv2, GfxVertBuffer> m_fullscreen_tria;
         Ref<GfxUniformBuffer>                   m_frame_data;
 
-        RenderScene* m_scene = nullptr;
+        RenderScene* m_scene        = nullptr;
+        TaskManager* m_task_manager = nullptr;
         CameraList   m_cameras;
 
         RenderSettings m_settings;
diff --git a/engine/runtime/rtti/struct.hpp b/engine/runtime/rtti/struct.hpp
index b165c1755..1ad241e46 100644
--- a/engine/runtime/rtti/struct.hpp
+++ b/engine/runtime/rtti/struct.hpp
@@ -31,6 +31,7 @@
 #include "core/flat_set.hpp"
 #include "core/string_id.hpp"
 #include "core/string_utils.hpp"
+#include "io/context.hpp"
 #include "rtti/meta_data.hpp"
 #include "rtti/type.hpp"
 
diff --git a/engine/runtime/rtti/traits.hpp b/engine/runtime/rtti/traits.hpp
index 5ce6c66b5..bf46c5a10 100644
--- a/engine/runtime/rtti/traits.hpp
+++ b/engine/runtime/rtti/traits.hpp
@@ -69,10 +69,11 @@ namespace wmoge {
 
     template<typename T>
     inline RttiType* rtti_type() {
-        static RttiType* g_type = RttiTypeStorage::instance()->find_type(SID(RttiTypeOf<T>::name())).value_or(nullptr);
+        const Strid      rtti_name = SID(RttiTypeOf<T>::name());
+        static RttiType* g_type    = RttiTypeStorage::instance()->find_type(rtti_name).value_or(nullptr);
 
         if (!g_type) {
-            g_type = RttiTypeStorage::instance()->find_type(SID(RttiTypeOf<T>::name())).value_or(nullptr);
+            g_type = RttiTypeStorage::instance()->find_type(rtti_name).value_or(nullptr);
 
             if (!g_type) {
                 Ref<RttiType> type = RttiTypeOf<T>::make();
diff --git a/engine/runtime/rtti/type_storage.cpp b/engine/runtime/rtti/type_storage.cpp
index 74b37fd2a..dceaabc3f 100644
--- a/engine/runtime/rtti/type_storage.cpp
+++ b/engine/runtime/rtti/type_storage.cpp
@@ -31,7 +31,8 @@
 
 namespace wmoge {
 
-    RttiTypeStorage* RttiTypeStorage::g_storage = nullptr;
+    RttiTypeStorage  g_storage_default;
+    RttiTypeStorage* RttiTypeStorage::g_storage = &g_storage_default;
 
     std::optional<RttiType*> RttiTypeStorage::find_type(const Strid& name) {
         std::lock_guard guard(m_mutex);
diff --git a/engine/runtime/rtti/type_storage.hpp b/engine/runtime/rtti/type_storage.hpp
index f71ccc8fc..00e27127f 100644
--- a/engine/runtime/rtti/type_storage.hpp
+++ b/engine/runtime/rtti/type_storage.hpp
@@ -48,8 +48,7 @@ namespace wmoge {
     */
     class RttiTypeStorage {
     public:
-        RttiTypeStorage()  = default;
-        ~RttiTypeStorage() = default;
+        RttiTypeStorage() = default;
 
         std::optional<RttiType*> find_type(const Strid& name);
         RttiStruct*              find_struct(const Strid& name);
diff --git a/engine/runtime/scene/scene.cpp b/engine/runtime/scene/scene.cpp
index da4bca0d9..81a38c1be 100644
--- a/engine/runtime/scene/scene.cpp
+++ b/engine/runtime/scene/scene.cpp
@@ -35,11 +35,11 @@
 
 namespace wmoge {
 
-    Scene::Scene(Strid name) {
+    Scene::Scene(const SceneCreateInfo& info) {
         WG_AUTO_PROFILE_SCENE("Scene::Scene");
 
-        m_name            = name;
-        m_ecs_world       = std::make_unique<EcsWorld>();
+        m_name            = info.name;
+        m_ecs_world       = std::make_unique<EcsWorld>(info.ecs_registry, info.task_manager);
         m_culling_manager = std::make_unique<CullingManager>();
         m_render_scene    = std::make_unique<RenderScene>();
     }
diff --git a/engine/runtime/scene/scene.hpp b/engine/runtime/scene/scene.hpp
index e20197513..6ba09c480 100644
--- a/engine/runtime/scene/scene.hpp
+++ b/engine/runtime/scene/scene.hpp
@@ -52,6 +52,16 @@ namespace wmoge {
         Finished//< Scene finished and ready for deletion
     };
 
+    /**
+     * @class SceneCreateInfo 
+     * @brief Info for scene construction
+     */
+    struct SceneCreateInfo {
+        Strid              name;
+        class EcsRegistry* ecs_registry;
+        class TaskManager* task_manager;
+    };
+
     /**
      * @class Scene
      * @brief Scene objects container representing running game state
@@ -75,8 +85,7 @@ namespace wmoge {
      */
     class Scene final : public RefCnt {
     public:
-        Scene(Strid name = Strid());
-        ~Scene() override = default;
+        Scene(const SceneCreateInfo& info);
 
         Status build(const SceneData& data);
         void   advance(float delta_time);
diff --git a/engine/runtime/scene/scene_manager.cpp b/engine/runtime/scene/scene_manager.cpp
index 04181d5fe..ade216458 100644
--- a/engine/runtime/scene/scene_manager.cpp
+++ b/engine/runtime/scene/scene_manager.cpp
@@ -28,6 +28,7 @@
 #include "scene_manager.hpp"
 
 #include "core/async.hpp"
+#include "core/ioc_container.hpp"
 #include "core/task_parallel_for.hpp"
 #include "ecs/ecs_registry.hpp"
 #include "gfx/gfx_cmd_list.hpp"
@@ -38,18 +39,18 @@
 #include "profiler/profiler.hpp"
 #include "render/render_engine.hpp"
 #include "scene/scene_components.hpp"
-#include "system/ioc_container.hpp"
 
 #include <cassert>
 #include <utility>
 
 namespace wmoge {
 
-    SceneManager::SceneManager() {
+    SceneManager::SceneManager(IocContainer* ioc) {
         WG_LOG_INFO("init scene manager");
 
-        m_render_engine = IocContainer::iresolve_v<RenderEngine>();
-        m_ecs_registry  = IocContainer::iresolve_v<EcsRegistry>();
+        m_render_engine = ioc->resolve_value<RenderEngine>();
+        m_task_manager  = ioc->resolve_value<TaskManager>();
+        m_ecs_registry  = ioc->resolve_value<EcsRegistry>();
 
         m_ecs_registry->register_component<EcsComponentChildren>();
         m_ecs_registry->register_component<EcsComponentParent>();
@@ -107,7 +108,11 @@ namespace wmoge {
     Ref<Scene> SceneManager::make_scene(const Strid& name) {
         WG_AUTO_PROFILE_SCENE("SceneManager::make_scene");
 
-        return m_scenes.emplace_back(make_ref<Scene>(name));
+        SceneCreateInfo info;
+        info.name         = name;
+        info.ecs_registry = m_ecs_registry;
+        info.task_manager = m_task_manager;
+        return m_scenes.emplace_back(make_ref<Scene>(info));
     }
     std::optional<Ref<Scene>> SceneManager::find_by_name(const Strid& name) {
         WG_AUTO_PROFILE_SCENE("SceneManager::find_by_name");
diff --git a/engine/runtime/scene/scene_manager.hpp b/engine/runtime/scene/scene_manager.hpp
index a29ed15ab..4c0c52487 100644
--- a/engine/runtime/scene/scene_manager.hpp
+++ b/engine/runtime/scene/scene_manager.hpp
@@ -44,7 +44,7 @@ namespace wmoge {
      */
     class SceneManager final {
     public:
-        SceneManager();
+        SceneManager(class IocContainer* ioc);
 
         void                      clear();
         void                      update();
@@ -76,6 +76,7 @@ namespace wmoge {
         Ref<Scene> m_default;// default scene to always show something
 
         class EcsRegistry*  m_ecs_registry  = nullptr;
+        class TaskManager*  m_task_manager  = nullptr;
         class RenderEngine* m_render_engine = nullptr;
 
         struct SyncContext {
diff --git a/engine/runtime/scene/scene_packed.cpp b/engine/runtime/scene/scene_packed.cpp
index 3a6dc9da3..d942e23c1 100644
--- a/engine/runtime/scene/scene_packed.cpp
+++ b/engine/runtime/scene/scene_packed.cpp
@@ -33,41 +33,7 @@
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
 #include "scene/scene.hpp"
-#include "scene/scene_manager.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
-    AsyncResult<Ref<Scene>> ScenePacked::instantiate_async() {
-        WG_AUTO_PROFILE_ASSET("ScenePacked::instantiate_async");
-
-        AsyncOp<Ref<Scene>> scene_async = make_async_op<Ref<Scene>>();
-
-        Task scene_task(get_name(), [self = Ref<ScenePacked>(this), scene_async](TaskContext&) {
-            Ref<Scene> scene = IocContainer::iresolve_v<SceneManager>()->make_scene(self->get_name());
-
-            Timer timer;
-            timer.start();
-
-            timer.stop();
-            WG_LOG_INFO("instantiate scene " << self->get_name() << ", time: " << timer.get_elapsed_sec() << " sec");
-
-            scene_async->set_result(std::move(scene));
-
-            return 0;
-        });
-
-        scene_task.schedule();
-
-        return AsyncResult<Ref<Scene>>(scene_async);
-    }
-
-    Ref<Scene> ScenePacked::instantiate() {
-        WG_AUTO_PROFILE_ASSET("ScenePacked::instantiate");
-
-        auto async = instantiate_async();
-        async.wait_completed();
-        return async.is_failed() ? Ref<Scene>{} : async.result();
-    }
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scene/scene_packed.hpp b/engine/runtime/scene/scene_packed.hpp
index 60a28efdc..2a401b5ed 100644
--- a/engine/runtime/scene/scene_packed.hpp
+++ b/engine/runtime/scene/scene_packed.hpp
@@ -58,9 +58,6 @@ namespace wmoge {
         ScenePacked()           = default;
         ~ScenePacked() override = default;
 
-        AsyncResult<Ref<Scene>> instantiate_async();
-        Ref<Scene>              instantiate();
-
     private:
         SceneData m_data;
     };
diff --git a/engine/runtime/scripting/_rtti.cpp b/engine/runtime/scripting/_rtti.cpp
deleted file mode 100644
index 04fcc2d42..000000000
--- a/engine/runtime/scripting/_rtti.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "_rtti.hpp"
-
-#include "scripting/script.hpp"
-
-namespace wmoge {
-
-    void rtti_scripting() {
-        rtti_type<Script>();
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/_rtti.hpp b/engine/runtime/scripting/_rtti.hpp
deleted file mode 100644
index b20482826..000000000
--- a/engine/runtime/scripting/_rtti.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-namespace wmoge {
-
-    void rtti_scripting();
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua/lua_defs.cpp b/engine/runtime/scripting/lua/lua_defs.cpp
deleted file mode 100644
index c9b746b1f..000000000
--- a/engine/runtime/scripting/lua/lua_defs.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_defs.hpp"
diff --git a/engine/runtime/scripting/lua/lua_defs.hpp b/engine/runtime/scripting/lua/lua_defs.hpp
deleted file mode 100644
index 44469d330..000000000
--- a/engine/runtime/scripting/lua/lua_defs.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_DEFS_HPP
-#define WMOGE_LUA_DEFS_HPP
-
-#include "core/flat_map.hpp"
-#include "core/object.hpp"
-
-#include <lua.hpp>
-
-#include <LuaBridge/LuaBridge.h>
-
-#include <functional>
-
-namespace wmoge {
-
-    /**
-     * @class LuaConvCppToLua
-     * @brief Function used to dynamically obtain lua wrapped object by base object reference
-     */
-    using LuaConvCppToLua = std::function<luabridge::LuaRef(lua_State*, Object*)>;
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_DEFS_HPP
diff --git a/engine/runtime/scripting/lua/lua_script.cpp b/engine/runtime/scripting/lua/lua_script.cpp
deleted file mode 100644
index fdb15bbe1..000000000
--- a/engine/runtime/scripting/lua/lua_script.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_script.hpp"
-
-#include "core/object.hpp"
-#include "profiler/profiler.hpp"
-#include "scripting/lua/lua_script_instance.hpp"
-#include "scripting/lua/lua_script_system.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-#include "system/engine.hpp"
-
-namespace wmoge {
-
-    Ref<ScriptInstance> LuaScript::attach_to(Object* object) {
-        WG_AUTO_PROFILE_LUA("LuaScript::attach_to");
-
-        if (!object) {
-            WG_LOG_ERROR("passed null object to attach to");
-            return {};
-        }
-
-        std::lock_guard guard(m_system->get_mutex());
-        luaL_dostring(m_state, get_code().c_str());
-
-        auto user_object = luabridge::LuaRef::fromStack(m_state, -1);
-        if (!user_object.isTable()) {
-            std::stringstream out_error;
-            user_object.print(out_error);
-            WG_LOG_ERROR("expecting created instance to be an object (lua table)");
-            WG_LOG_ERROR("luabridge log: " << out_error.str());
-            return {};
-        }
-
-        auto parent_object = user_object[m_system->get_object_parent()];
-        if (!parent_object.isInstance<LuaObject>()) {
-            WG_LOG_ERROR("expecting object parent to sub-class <wmoge.Object> class");
-            return {};
-        }
-
-        parent_object.cast<LuaObject&>().ptr = std::move(Ref(object));
-        assert(parent_object.cast<LuaObject&>().ptr.get() == object);
-
-        return make_ref<LuaScriptInstance>(std::move(user_object), Ref<LuaScript>(this), object, m_state);
-    }
-    bool LuaScript::has_property(const Strid& property) {
-        return m_lua_properties.find(property) != m_lua_properties.end();
-    }
-    bool LuaScript::has_method(const Strid& method) {
-        return m_lua_methods.find(method) != m_lua_methods.end();
-    }
-
-    const flat_map<Strid, luabridge::LuaRef>& LuaScript::get_lua_properties() {
-        return m_lua_properties;
-    }
-    const flat_map<Strid, luabridge::LuaRef>& LuaScript::get_lua_methods() {
-        return m_lua_methods;
-    }
-    const std::optional<luabridge::LuaRef>& LuaScript::get_lua_class() {
-        return m_lua_class;
-    }
-    class LuaScriptSystem* LuaScript::get_system() {
-        return m_system;
-    }
-    lua_State* LuaScript::get_state() {
-        return m_state;
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua/lua_script.hpp b/engine/runtime/scripting/lua/lua_script.hpp
deleted file mode 100644
index 0ac517196..000000000
--- a/engine/runtime/scripting/lua/lua_script.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_SCRIPT_HPP
-#define WMOGE_LUA_SCRIPT_HPP
-
-#include "core/flat_map.hpp"
-#include "scripting/lua/lua_defs.hpp"
-#include "scripting/script.hpp"
-
-#include <optional>
-
-namespace wmoge {
-
-    /**
-     * @class LuaScript
-     * @brief Holds info about a lua declared class in a user script
-     */
-    class LuaScript final : public Script {
-    public:
-        WG_RTTI_CLASS(LuaScript, Script);
-
-        LuaScript()           = default;
-        ~LuaScript() override = default;
-
-        Ref<ScriptInstance> attach_to(Object* object) override;
-        bool                has_property(const Strid& property) override;
-        bool                has_method(const Strid& method) override;
-
-        const flat_map<Strid, luabridge::LuaRef>& get_lua_properties();
-        const flat_map<Strid, luabridge::LuaRef>& get_lua_methods();
-        const std::optional<luabridge::LuaRef>&   get_lua_class();
-        class LuaScriptSystem*                    get_system();
-        lua_State*                                get_state();
-
-    private:
-        flat_map<Strid, luabridge::LuaRef> m_lua_properties;
-        flat_map<Strid, luabridge::LuaRef> m_lua_methods;
-        std::optional<luabridge::LuaRef>   m_lua_class;
-        class LuaScriptSystem*             m_system = nullptr;
-        lua_State*                         m_state  = nullptr;
-    };
-
-    WG_RTTI_CLASS_BEGIN(LuaScript) {
-        WG_RTTI_META_DATA(RttiUiHint(""));
-        WG_RTTI_FACTORY();
-    }
-    WG_RTTI_END;
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_SCRIPT_HPP
diff --git a/engine/runtime/scripting/lua/lua_script_instance.cpp b/engine/runtime/scripting/lua/lua_script_instance.cpp
deleted file mode 100644
index 94de72925..000000000
--- a/engine/runtime/scripting/lua/lua_script_instance.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_script_instance.hpp"
-
-#include "profiler/profiler.hpp"
-#include "scripting/lua/lua_script.hpp"
-
-namespace wmoge {
-
-#define WG_SAFE_CALL(func, name, ...)                         \
-    try {                                                     \
-        std::lock_guard guard(m_system->get_mutex());         \
-        if (!m_mask.get(func)) return;                        \
-        if (m_mask_failed.get(func)) return;                  \
-                                                              \
-        auto callback = m_script_object[name];                \
-        assert(callback.isFunction());                        \
-                                                              \
-        if (!callback.isFunction()) {                         \
-            m_mask_failed.set(func);                          \
-            WG_LOG_ERROR("expected function to call " #func); \
-        }                                                     \
-                                                              \
-        callback(__VA_ARGS__);                                \
-    } catch (const std::exception& e) {                       \
-        m_mask_failed.set(func);                              \
-        WG_LOG_ERROR("lua error: " << e.what());              \
-    }
-
-    LuaScriptInstance::LuaScriptInstance(luabridge::LuaRef script_object, Ref<LuaScript> script, Object* object, lua_State* state)
-        : m_script_object(std::move(script_object)),
-          m_script(std::move(script)),
-          m_object(object),
-          m_state(state),
-          m_mask(m_script->get_mask()) {
-        m_system = m_script->get_system();
-    }
-    LuaScriptInstance::~LuaScriptInstance() = default;
-
-    ScriptFunctionsMask LuaScriptInstance::get_mask() {
-        return m_mask;
-    }
-    Script* LuaScriptInstance::get_script() {
-        return m_script.get();
-    }
-    Object* LuaScriptInstance::get_owner() {
-        return m_object;
-    }
-    void LuaScriptInstance::on_create() {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_create");
-        WG_SAFE_CALL(ScriptFunction::OnCreate, "on_create", m_script_object);
-    }
-    void LuaScriptInstance::on_scene_enter() {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_scene_enter");
-        WG_SAFE_CALL(ScriptFunction::OnSceneEnter, "on_scene_enter", m_script_object);
-    }
-    void LuaScriptInstance::on_scene_exit() {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_scene_exit");
-        WG_SAFE_CALL(ScriptFunction::OnSceneExit, "on_scene_exit", m_script_object);
-    }
-    void LuaScriptInstance::on_transform_updated() {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_transform_updated");
-        WG_SAFE_CALL(ScriptFunction::OnTransformUpdated, "on_transform_updated", m_script_object);
-    }
-    void LuaScriptInstance::on_update(float delta_time) {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_update");
-        WG_SAFE_CALL(ScriptFunction::OnUpdate, "on_update", m_script_object, delta_time);
-    }
-    void LuaScriptInstance::on_signal(const Strid& signal) {
-        WG_AUTO_PROFILE_LUA("LuaScriptInstance::on_signal");
-        WG_SAFE_CALL(ScriptFunction::OnSignal, "on_signal", m_script_object, luabridge::LuaRef(m_state, signal));
-    }
-    int LuaScriptInstance::set(const Strid& property, const Var& value) {
-        return ScriptInstance::set(property, value);
-    }
-    int LuaScriptInstance::get(const Strid& property, Var& value) {
-        return ScriptInstance::get(property, value);
-    }
-    int LuaScriptInstance::call(const Strid& method, int argc, const Var* argv, Var& ret) {
-        return ScriptInstance::call(method, argc, argv, ret);
-    }
-
-}// namespace wmoge
diff --git a/engine/runtime/scripting/lua/lua_script_instance.hpp b/engine/runtime/scripting/lua/lua_script_instance.hpp
deleted file mode 100644
index 516430886..000000000
--- a/engine/runtime/scripting/lua/lua_script_instance.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_SCRIPT_INSTANCE_HPP
-#define WMOGE_LUA_SCRIPT_INSTANCE_HPP
-
-#include "scripting/lua/lua_defs.hpp"
-#include "scripting/lua/lua_script_system.hpp"
-#include "scripting/script.hpp"
-#include "scripting/script_instance.hpp"
-
-namespace wmoge {
-    /**
-     * @class LuaScriptInstance
-     * @brief Lua script instance holding attached to an object script
-     */
-    class LuaScriptInstance final : public ScriptInstance {
-    public:
-        LuaScriptInstance(luabridge::LuaRef script_object, Ref<class LuaScript> script, Object* object, lua_State* state);
-        ~LuaScriptInstance() override;
-
-        ScriptFunctionsMask get_mask() override;
-        Script*             get_script() override;
-        Object*             get_owner() override;
-
-        void on_create() override;
-        void on_scene_enter() override;
-        void on_scene_exit() override;
-        void on_transform_updated() override;
-        void on_update(float delta_time) override;
-        void on_signal(const Strid& signal) override;
-
-        int set(const Strid& property, const Var& value) override;
-        int get(const Strid& property, Var& value) override;
-        int call(const Strid& method, int argc, const Var* argv, Var& ret) override;
-
-        luabridge::LuaRef& get_script_object() { return m_script_object; }
-
-    private:
-        luabridge::LuaRef    m_script_object;
-        Ref<class LuaScript> m_script;
-        Object*              m_object = nullptr;
-        LuaScriptSystem*     m_system = nullptr;
-        lua_State*           m_state  = nullptr;
-        ScriptFunctionsMask  m_mask;
-        ScriptFunctionsMask  m_mask_failed;
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_SCRIPT_INSTANCE_HPP
diff --git a/engine/runtime/scripting/lua/lua_script_system.cpp b/engine/runtime/scripting/lua/lua_script_system.cpp
deleted file mode 100644
index 5912aefd9..000000000
--- a/engine/runtime/scripting/lua/lua_script_system.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_script_system.hpp"
-
-#include "core/log.hpp"
-#include "profiler/profiler.hpp"
-#include "scripting/lua/lua_script.hpp"
-#include "scripting/lua_bindings/lua_bindings.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-#include "scripting/script.hpp"
-
-#include <sstream>
-
-namespace wmoge {
-
-    LuaScriptSystem::LuaScriptSystem() {
-        WG_AUTO_PROFILE_LUA("LuaScriptSystem::LuaScriptSystem");
-
-        m_global_state = luaL_newstate();
-        m_language     = SID("lua");
-        m_name         = SID("lua_script_system");
-
-        if (!m_global_state) {
-            WG_LOG_ERROR("failed to create lua state");
-            return;
-        }
-
-        luaL_openlibs(m_global_state);
-
-        auto ns = luabridge::getGlobalNamespace(m_global_state).beginNamespace("wmoge");
-        LuaBindings::bind_math(ns, m_object_to_lua);
-        LuaBindings::bind_core(ns, m_object_to_lua);
-        LuaBindings::bind_platform(ns, m_object_to_lua);
-        LuaBindings::bind_asset(ns, m_object_to_lua);
-        LuaBindings::bind_scene(ns, m_object_to_lua);
-        ns = ns.endNamespace();
-
-        luaL_dostring(m_global_state, "function new(target, base)\n"
-                                      "    base_instance = base()\n"
-                                      "    target.__index = target\n"
-                                      "    return setmetatable({ parent = base_instance, class = target }, target)\n"
-                                      "end\n"
-                                      "return new");
-
-        m_new_inst_func_lua = luabridge::LuaRef::fromStack(m_global_state, -1);
-        assert(m_new_inst_func_lua.value().isFunction());
-
-        m_object_callbacks = {"on_create",
-                              "on_scene_enter",
-                              "on_scene_exit",
-                              "on_transform_updated",
-                              "on_update",
-                              "on_signal",
-                              "on_input_mouse",
-                              "on_input_keyboard",
-                              "on_input_joystick",
-                              "on_input_drop",
-                              "on_action",
-                              "on_token"};
-
-        WG_LOG_INFO("init lua script engine v5.4.4");
-    }
-
-    LuaScriptSystem::~LuaScriptSystem() {
-        shutdown();
-    }
-
-    void LuaScriptSystem::gc() {
-        WG_AUTO_PROFILE_LUA("LuaScriptSystem::gc");
-
-        std::lock_guard guard(m_mutex);
-
-        lua_gc(m_global_state, LUA_GCCOLLECT);
-
-        m_gc_cycles += 1;
-        m_gc_frames_from_last = 0;
-    }
-    void LuaScriptSystem::update() {
-        WG_AUTO_PROFILE_LUA("LuaScriptSystem::update");
-
-        std::lock_guard guard(m_mutex);
-
-        m_gc_frames_from_last += 1;
-        m_queue.flush();
-
-        if (m_gc_frames_from_last >= m_gc_interval) {
-            gc();
-        }
-    }
-    void LuaScriptSystem::shutdown() {
-        WG_AUTO_PROFILE_LUA("LuaScriptSystem::shutdown");
-
-        if (m_global_state) {
-            m_new_inst_func_lua.reset();
-            lua_close(m_global_state);
-            m_global_state = nullptr;
-        }
-
-        WG_LOG_INFO("shutdown lua engine");
-    }
-
-    const std::vector<std::string>& LuaScriptSystem::get_object_callbacks() {
-        return m_object_callbacks;
-    }
-    const std::string& LuaScriptSystem::get_object_parent() {
-        return m_object_parent;
-    }
-    const std::string& LuaScriptSystem::get_object_class() {
-        return m_object_class;
-    }
-    const flat_map<const Class*, LuaConvCppToLua>& LuaScriptSystem::get_object_to_lua() {
-        return m_object_to_lua;
-    }
-    lua_State* LuaScriptSystem::get_global_state() {
-        return m_global_state;
-    }
-    std::recursive_mutex& LuaScriptSystem::get_mutex() {
-        return m_mutex;
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua/lua_script_system.hpp b/engine/runtime/scripting/lua/lua_script_system.hpp
deleted file mode 100644
index 616cb12fd..000000000
--- a/engine/runtime/scripting/lua/lua_script_system.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_SCRIPT_SYSTEM_HPP
-#define WMOGE_LUA_SCRIPT_SYSTEM_HPP
-
-#include "core/callback_queue.hpp"
-#include "core/class.hpp"
-#include "core/string_id.hpp"
-#include "scripting/lua/lua_defs.hpp"
-#include "scripting/script_system.hpp"
-#include <core/buffered_vector.hpp>
-#include <core/flat_map.hpp>
-
-#include <mutex>
-#include <optional>
-#include <vector>
-
-namespace wmoge {
-
-    /**
-     * @class LuaScriptSystem
-     * @brief Lua language based script system of the engine
-     */
-    class LuaScriptSystem final : public ScriptSystem {
-    public:
-        LuaScriptSystem();
-        ~LuaScriptSystem() override;
-
-        void gc() override;
-        void update() override;
-        void shutdown() override;
-
-        const std::vector<std::string>&                get_object_callbacks();
-        const std::string&                             get_object_parent();
-        const std::string&                             get_object_class();
-        const flat_map<const Class*, LuaConvCppToLua>& get_object_to_lua();
-        lua_State*                                     get_global_state();
-        std::recursive_mutex&                          get_mutex();
-
-    private:
-        flat_map<const Class*, LuaConvCppToLua> m_object_to_lua;
-        std::vector<std::string>                m_object_callbacks;
-        std::string                             m_object_parent = "parent";
-        std::string                             m_object_class  = "class";
-        lua_State*                              m_global_state  = nullptr;
-        std::optional<luabridge::LuaRef>        m_new_inst_func_lua;
-        CallbackQueue                           m_queue;
-
-        mutable std::recursive_mutex m_mutex;
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_SCRIPT_SYSTEM_HPP
diff --git a/engine/runtime/scripting/lua/lua_type_traits.cpp b/engine/runtime/scripting/lua/lua_type_traits.cpp
deleted file mode 100644
index 1840f8b99..000000000
--- a/engine/runtime/scripting/lua/lua_type_traits.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_type_traits.hpp"
-
-#include "scripting/lua/lua_script_instance.hpp"
-#include "scripting/lua/lua_script_system.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-
-namespace wmoge {
-
-    Strid LuaTypeTraits::to_sid(luabridge::LuaRef& ref) {
-        assert(ref.isString() || ref.isInstance<Strid>());
-
-        if (ref.isString()) {
-            return SID(ref.cast<std::string>());
-        }
-        if (ref.isInstance<Strid>()) {
-            return ref.cast<Strid>();
-        }
-
-        WG_LOG_ERROR("failed to convert lua object to string id");
-
-        return Strid();
-    }
-
-    Var LuaTypeTraits::to_var(luabridge::LuaRef& ref) {
-        if (ref.isNil()) {
-            return Var();
-        }
-        if (ref.isBool()) {
-            return Var(ref.cast<int>());
-        }
-        if (ref.isNumber()) {
-            return Var(ref.cast<float>());
-        }
-        if (ref.isString()) {
-            return Var(ref.cast<std::string>());
-        }
-
-        WG_LOG_ERROR("unsupported lua to var type");
-        return Var();
-    }
-
-    luabridge::LuaRef LuaTypeTraits::from_object(lua_State* state, Object* object) {
-        assert(state);
-
-        if (!object) {
-            // null object: ok, return nil
-            return luabridge::LuaRef(state);
-        }
-
-        // Look up to convert native object
-        auto*       script_system = reinterpret_cast<LuaScriptSystem*>(Engine::instance()->script_system());
-        const auto& mappings      = script_system->get_object_to_lua();
-        const auto* cls           = object->class_ptr();
-
-        auto rule = mappings.find(cls);
-        if (rule == mappings.end()) {
-            WG_LOG_ERROR("no such rule to map object of type " << cls->name());
-            return luabridge::LuaRef(state);
-        }
-
-        return rule->second(state, object);
-    }
-
-    luabridge::LuaRef LuaTypeTraits::from_var(lua_State* state, const Var& var) {
-        if (var.type() == VarType::Nil) {
-            return luabridge::LuaRef(state);
-        }
-        if (var.type() == VarType::Int) {
-            return luabridge::LuaRef(state, var.operator int());
-        }
-        if (var.type() == VarType::Float) {
-            return luabridge::LuaRef(state, var.operator float());
-        }
-        if (var.type() == VarType::String) {
-            return luabridge::LuaRef(state, var.operator std::string());
-        }
-        if (var.type() == VarType::Strid) {
-            return luabridge::LuaRef(state, var.operator Strid().str());
-        }
-
-        WG_LOG_ERROR("unsupported var to lua type");
-        return luabridge::LuaRef(state);
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings.hpp
deleted file mode 100644
index df32ba4dd..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BRIDGE_HPP
-#define WMOGE_LUA_BRIDGE_HPP
-
-#include "scripting/lua/lua_defs.hpp"
-#include "scripting/lua/lua_type_traits.hpp"
-
-#include <magic_enum.hpp>
-
-namespace wmoge {
-
-    /**
-     * @class LuaBindings
-     * @brief Binds internal various engine modules API to lua
-     */
-    class LuaBindings {
-    public:
-        static void bind_math(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping);
-        static void bind_core(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping);
-        static void bind_platform(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping);
-        static void bind_asset(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping);
-        static void bind_scene(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping);
-
-        template<typename Enum>
-        static void bind_enum(luabridge::Namespace& ns, const char* name) {
-            constexpr auto entries = magic_enum::enum_entries<Enum>();
-            ns                     = ns.beginNamespace(name);
-
-            for (const auto& entry : entries) {
-                auto entry_name = std::string(entry.second);
-                ns              = ns.addConstant(entry_name.c_str(), static_cast<int>(entry.first));
-            }
-
-            ns = ns.endNamespace();
-        }
-    };
-
-}// namespace wmoge
-
-#define WG_LUA_ARG(state, idx) luabridge::LuaRef::fromStack(state, idx + 1)
-
-#define WG_LUA_ADD_ENUM(class, name) addConstant(#name, static_cast<int>(class ::name))
-
-#define WG_LUA_MAP_CLASS_CUSTOM(mapping, EngineClass, rule) \
-    mapping[EngineClass::class_ptr_static()] = rule;
-
-#define WG_LUA_MAP_CLASS(mapping, EngineClass)                                        \
-    mapping[EngineClass::class_ptr_static()] = [](lua_State* state, Object* object) { \
-        return luabridge::LuaRef(state, Lua##EngineClass{Ref<Object>(object)});       \
-    }
-
-#define WG_LUA_CHECK_MSG(condition, message) \
-    do {                                     \
-        if (!(condition)) {                  \
-            WG_LOG_ERROR(message);           \
-            return 0;                        \
-        }                                    \
-    } while (false);
-
-#endif//WMOGE_LUA_BRIDGE_HPP
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_asset.cpp b/engine/runtime/scripting/lua_bindings/lua_bindings_asset.cpp
deleted file mode 100644
index 1f2e753e3..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_asset.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_bindings_asset.hpp"
-
-#include "scripting/lua/lua_type_traits.hpp"
-
-namespace wmoge {
-
-    static int lua_AssetManager_load(lua_State* state) {
-        auto asset_id = WG_LUA_ARG(state, 0);
-
-        auto* asset_manager = Engine::instance()->asset_manager();
-        auto  asset         = asset_manager->load(LuaTypeTraits::to_sid(asset_id));
-        // LuaTypeTraits::from_object(state, asset.get()).push();
-
-        return 1;
-    }
-
-    static int lua_AssetManager_find(lua_State* state) {
-        auto asset_id = WG_LUA_ARG(state, 0);
-
-        auto* asset_manager = Engine::instance()->asset_manager();
-        auto  asset         = asset_manager->find(LuaTypeTraits::to_sid(asset_id));
-        // LuaTypeTraits::from_object(state, asset.get()).push();
-
-        return 1;
-    }
-
-    void LuaBindings::bind_asset(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping) {
-        // WG_LUA_MAP_CLASS(mapping, Asset);
-        ns = ns.deriveClass<LuaAsset, LuaObject>("Asset")
-                     .addFunction("duplicate", &LuaAsset::duplicate)
-                     .addFunction("get_name", &LuaAsset::get_name)
-                     .endClass();
-
-        // WG_LUA_MAP_CLASS(mapping, AudioStream);
-        ns = ns.deriveClass<LuaAudioStream, LuaAsset>("AudioStream")
-                     .addFunction("get_length", &LuaAudioStream::get_length)
-                     .addFunction("get_samples_rate", &LuaAudioStream::get_samples_rate)
-                     .addFunction("get_bits_per_sample", &LuaAudioStream::get_bits_per_sample)
-                     .addFunction("get_num_samples", &LuaAudioStream::get_num_samples)
-                     .addFunction("get_num_channels", &LuaAudioStream::get_num_channels)
-                     .addFunction("is_stereo", &LuaAudioStream::is_stereo)
-                     .addFunction("is_mono", &LuaAudioStream::is_mono)
-                     .endClass();
-
-        // WG_LUA_MAP_CLASS(mapping, Texture);
-        ns = ns.deriveClass<LuaTexture, LuaAsset>("Texture")
-                     .addFunction("get_width", &LuaTexture::get_width)
-                     .addFunction("get_height", &LuaTexture::get_height)
-                     .addFunction("get_depth", &LuaTexture::get_depth)
-                     .addFunction("get_array_slices", &LuaTexture::get_array_slices)
-                     .addFunction("get_mips", &LuaTexture::get_mips)
-                     .addFunction("get_srgb", &LuaTexture::get_srgb)
-                     .endClass();
-
-        // WG_LUA_MAP_CLASS(mapping, PfxEffect);
-        ns = ns.deriveClass<LuaPfxEffect, LuaAsset>("PfxEffect")
-                     .addFunction("get_components_count", &LuaPfxEffect::get_components_count)
-                     .addFunction("get_type", &LuaPfxEffect::get_type)
-                     .endClass();
-
-        // WG_LUA_MAP_CLASS(mapping, Material);
-        ns = ns.deriveClass<LuaMaterial, LuaAsset>("Material")
-                     .endClass();
-
-        ns = ns.beginNamespace("AssetManager")
-                     .addCFunction("load", lua_AssetManager_load)
-                     .addCFunction("find", lua_AssetManager_find)
-                     .endNamespace();
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_asset.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings_asset.hpp
deleted file mode 100644
index 9a2a6163f..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_asset.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BINDINGS_RESOURCE_HPP
-#define WMOGE_LUA_BINDINGS_RESOURCE_HPP
-
-#include "scripting/lua_bindings/lua_bindings.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-
-#include "asset/asset_manager.hpp"
-#include "audio/audio_stream.hpp"
-#include "grc/font.hpp"
-#include "grc/image.hpp"
-#include "grc/texture.hpp"
-#include "material/material.hpp"
-#include "pfx/pfx_effect.hpp"
-#include "system/config.hpp"
-#include "system/engine.hpp"
-
-namespace wmoge {
-
-    struct LuaAsset : public LuaObject {
-        LuaAsset duplicate() const {
-            return LuaAsset{cast_unsafe<Asset>()->duplicate()};
-        }
-        const Strid& get_name() const {
-            return cast_unsafe<Asset>()->get_name();
-        }
-    };
-
-    struct LuaAudioStream : public LuaAsset {
-        float get_length() const {
-            return cast_unsafe<AudioStream>()->get_length();
-        }
-        int get_samples_rate() const {
-            return cast_unsafe<AudioStream>()->get_samples_rate();
-        }
-        int get_bits_per_sample() const {
-            return cast_unsafe<AudioStream>()->get_bits_per_sample();
-        }
-        int get_num_samples() const {
-            return cast_unsafe<AudioStream>()->get_num_samples();
-        }
-        int get_num_channels() const {
-            return cast_unsafe<AudioStream>()->get_num_channels();
-        }
-        bool is_stereo() const {
-            return cast_unsafe<AudioStream>()->is_stereo();
-        }
-        bool is_mono() const {
-            return cast_unsafe<AudioStream>()->is_mono();
-        }
-    };
-
-    struct LuaFont : public LuaAsset {
-        const std::string& get_family_name() {
-            return cast_unsafe<Font>()->get_family_name();
-        }
-        const std::string& get_style_name() {
-            return cast_unsafe<Font>()->get_style_name();
-        }
-        int get_height() {
-            return cast_unsafe<Font>()->get_height();
-        }
-        int get_glyphs_in_row() {
-            return cast_unsafe<Font>()->get_glyphs_in_row();
-        }
-        int get_max_width() {
-            return cast_unsafe<Font>()->get_max_width();
-        }
-        int get_max_height() {
-            return cast_unsafe<Font>()->get_max_height();
-        }
-    };
-
-    struct LuaTexture : public LuaAsset {
-        int get_width() const {
-            return cast_unsafe<Texture>()->get_width();
-        }
-        int get_height() const {
-            return cast_unsafe<Texture>()->get_height();
-        }
-        int get_depth() const {
-            return cast_unsafe<Texture>()->get_depth();
-        }
-        int get_array_slices() const {
-            return cast_unsafe<Texture>()->get_array_slices();
-        }
-        int get_mips() const {
-            return cast_unsafe<Texture>()->get_mips();
-        }
-        bool get_srgb() const {
-            return cast_unsafe<Texture>()->get_srgb();
-        }
-    };
-
-    struct LuaPfxEffect : public LuaAsset {
-        int get_components_count() const {
-            return cast_unsafe<PfxEffect>()->get_components_count();
-        }
-        std::string get_type() const {
-            return std::string(magic_enum::enum_name(cast_unsafe<PfxEffect>()->get_type()));
-        }
-    };
-
-    struct LuaMaterial : public LuaAsset {
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_BINDINGS_RESOURCE_HPP
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_core.cpp b/engine/runtime/scripting/lua_bindings/lua_bindings_core.cpp
deleted file mode 100644
index 87a9b1410..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_core.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_bindings_core.hpp"
-
-namespace wmoge {
-
-    static int lua_Log_log(lua_State* state) {
-        auto arg0 = WG_LUA_ARG(state, 0);
-        auto arg1 = WG_LUA_ARG(state, 1);
-        auto arg2 = WG_LUA_ARG(state, 2);
-        auto arg3 = WG_LUA_ARG(state, 3);
-        auto arg4 = WG_LUA_ARG(state, 4);
-
-        WG_LUA_CHECK_MSG(arg0.isNumber(), "expected number as log level");
-        const LogLevel level = static_cast<LogLevel>(arg0.cast<int>());
-
-        WG_LUA_CHECK_MSG(arg1.isString(), "expected string message");
-        const std::string message = arg1.cast<std::string>();
-
-        const std::string file     = arg2.isString() ? arg2.cast<std::string>() : __FILE__;
-        const std::string function = arg3.isString() ? arg3.cast<std::string>() : __FUNCTION__;
-        const std::size_t line     = arg4.isNumber() ? arg4.cast<int>() : __LINE__ + 2;
-
-        Log::instance()->log(level, std::move(message), std::move(file), std::move(function), line);
-
-        return 0;
-    }
-
-    static int lua_CmdLine_get_int(lua_State* state) {
-        auto  arg0     = WG_LUA_ARG(state, 0);
-        auto* cmd_line = Engine::instance()->cmd_line();
-
-        auto value = luabridge::LuaRef(state, cmd_line->get_int(arg0.cast<std::string>()));
-        value.push();
-
-        return 1;
-    }
-
-    static int lua_CmdLine_get_bool(lua_State* state) {
-        auto  arg0     = WG_LUA_ARG(state, 0);
-        auto* cmd_line = Engine::instance()->cmd_line();
-
-        auto value = luabridge::LuaRef(state, cmd_line->get_bool(arg0.cast<std::string>()));
-        value.push();
-
-        return 1;
-    }
-
-    static int lua_CmdLine_get_string(lua_State* state) {
-        auto  arg0     = WG_LUA_ARG(state, 0);
-        auto* cmd_line = Engine::instance()->cmd_line();
-
-        auto value = luabridge::LuaRef(state, cmd_line->get_string(arg0.cast<std::string>()));
-        value.push();
-
-        return 1;
-    }
-
-    static int lua_CmdLine_get_help(lua_State* state) {
-        auto* cmd_line = Engine::instance()->cmd_line();
-
-        auto help = luabridge::LuaRef(state, cmd_line->get_help());
-        help.push();
-
-        return 1;
-    }
-
-    static int lua_Random_next_float(lua_State* state) {
-        luabridge::LuaRef(state, Random::next_float()).push();
-        return 1;
-    }
-
-    static int lua_Random_next_float_in_range(lua_State* state) {
-        auto left  = WG_LUA_ARG(state, 0);
-        auto right = WG_LUA_ARG(state, 1);
-
-        WG_LUA_CHECK_MSG(left.isNumber(), "left must be number");
-        WG_LUA_CHECK_MSG(right.isNumber(), "right must be number");
-        luabridge::LuaRef(state, Random::next_float(left.cast<float>(), right.cast<float>())).push();
-        return 1;
-    }
-
-    void LuaBindings::bind_core(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping) {
-        ns = ns.beginClass<LuaRefCnt>("RefCnt")
-                     .addFunction("is_null", &LuaRefCnt::is_null)
-                     .addFunction("ref", &LuaRefCnt::ref)
-                     .addFunction("unref", &LuaRefCnt::unref)
-                     .addFunction("refs_count", &LuaRefCnt::refs_count)
-                     .endClass();
-
-        ns = ns.beginClass<Strid>("Strid")
-                     .addStaticFunction("new", std::function([](const std::string& id) { return SID(id); }))
-                     .addConstructor<void (*)(void)>()
-                     .addProperty("empty", &Strid::empty)
-                     .addProperty("id", &Strid::id)
-                     .addProperty("hash", &Strid::hash)
-                     .addProperty("str", &Strid::str)
-                     .addProperty("__tostring", &Strid::str)
-                     .endClass();
-
-        ns = ns.deriveClass<LuaData, LuaRefCnt>("Data")
-                     .addConstructor<void (*)(void)>()
-                     .addProperty("size", &LuaData::size)
-                     .addProperty("size_as_kib", &LuaData::size_as_kib)
-                     .addFunction("to_string", &LuaData::to_string)
-                     .addFunction("__tostring", &LuaData::to_string)
-                     .endClass();
-
-        WG_LUA_MAP_CLASS(mapping, Object);
-        ns = ns.deriveClass<LuaObject, LuaRefCnt>("Object")
-                     .addFunction("class_name", &LuaObject::class_name)
-                     .addFunction("signal", &LuaObject::signal)
-                     .addFunction("to_string", &LuaObject::to_string)
-                     .addFunction("__tostring", &LuaObject::to_string)
-                     .endClass();
-
-        ns = ns.beginNamespace("Log")
-                     .addCFunction("log", lua_Log_log)
-                     .WG_LUA_ADD_ENUM(LogLevel, Never)
-                     .WG_LUA_ADD_ENUM(LogLevel, Info)
-                     .WG_LUA_ADD_ENUM(LogLevel, Warning)
-                     .WG_LUA_ADD_ENUM(LogLevel, Error)
-                     .endNamespace();
-
-        ns = ns.beginNamespace("CmdLine")
-                     .addCFunction("get_bool", lua_CmdLine_get_bool)
-                     .addCFunction("get_int", lua_CmdLine_get_int)
-                     .addCFunction("get_string", lua_CmdLine_get_string)
-                     .addCFunction("get_help", lua_CmdLine_get_help)
-                     .endNamespace();
-
-        ns = ns.beginNamespace("Random")
-                     .addCFunction("next_float", lua_Random_next_float)
-                     .addCFunction("next_float", lua_Random_next_float_in_range)
-                     .endNamespace();
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_core.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings_core.hpp
deleted file mode 100644
index 06f409885..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_core.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BINDINGS_CORE_HPP
-#define WMOGE_LUA_BINDINGS_CORE_HPP
-
-#include "scripting/lua_bindings/lua_bindings.hpp"
-
-#include "core/cmd_line.hpp"
-#include "core/data.hpp"
-#include "core/log.hpp"
-#include "core/object.hpp"
-#include "core/random.hpp"
-#include "core/ref.hpp"
-#include "system/engine.hpp"
-
-#include <magic_enum.hpp>
-
-namespace wmoge {
-
-    struct LuaRefCnt {
-        bool is_null() const {
-            return !ptr.operator bool();
-        }
-        unsigned int ref() {
-            return ptr->ref();
-        }
-        unsigned int unref() {
-            return ptr->unref();
-        }
-        unsigned int refs_count() const {
-            return ptr->refs_count();
-        }
-
-        void set(Ref<RefCnt> new_ptr) {
-            ptr = std::move(new_ptr);
-        }
-        Ref<RefCnt> get() const {
-            return ptr;
-        };
-
-        template<typename T>
-        T* cast() const {
-            return dynamic_cast<T*>(ptr.get());
-        };
-
-        template<typename T>
-        T* cast_unsafe() const {
-            return reinterpret_cast<T*>(ptr.get());
-        };
-
-        Ref<RefCnt> ptr;
-    };
-
-    struct LuaData : public LuaRefCnt {
-        std::size_t size() const {
-            return cast_unsafe<Data>()->size();
-        }
-        std::size_t size_as_kib() const {
-            return cast_unsafe<Data>()->size_as_kib();
-        }
-        std::string to_string() const {
-            return cast_unsafe<Data>()->to_string();
-        }
-    };
-
-    struct LuaObject : public LuaRefCnt {
-        std::string to_string() const {
-            return cast_unsafe<Object>()->to_string();
-        }
-        const Strid& class_name() const {
-            return cast_unsafe<Object>()->class_name();
-        }
-        void signal(const Strid& signal) {
-            cast_unsafe<Object>()->signal(signal);
-        }
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_BINDINGS_CORE_HPP
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_math.cpp b/engine/runtime/scripting/lua_bindings/lua_bindings_math.cpp
deleted file mode 100644
index a0ccb85e4..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_math.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_bindings_math.hpp"
-
-namespace wmoge {
-
-#define WG_ADD_VEC_PROPS(Vec, p) \
-    addProperty(#p, &Vec::p, &Vec::set_##p)
-
-#define WG_ADD_VEC_FUNCS_F(Vec)                                                                     \
-    addFunction("__eq", std::function([](const Vec* v, const Vec& m) { return *v == m; }))          \
-            .addFunction("__mul", std::function([](const Vec* v, float a) { return *v * a; }))      \
-            .addFunction("__div", std::function([](const Vec* v, float a) { return *v / a; }))      \
-            .addFunction("__add", std::function([](const Vec* v, const Vec& m) { return *v + m; })) \
-            .addFunction("__sub", std::function([](const Vec* v, const Vec& m) { return *v - m; })) \
-            .addFunction("__tostring", &Vec::to_string)                                             \
-            .addFunction("to_string", &Vec::to_string)                                              \
-            .addFunction("abs", &Vec::abs)                                                          \
-            .addFunction("pow", &Vec::pow)                                                          \
-            .addProperty("length2", &Vec::length2)                                                  \
-            .addProperty("length", &Vec::length)                                                    \
-            .addProperty("normalized", &Vec::normalized)                                            \
-            .addStaticFunction("distance", &Vec::distance)                                          \
-            .addStaticFunction("distance2", &Vec::distance2)                                        \
-            .addStaticFunction("dot", &Vec::dot)                                                    \
-            .addStaticFunction("angle", &Vec::angle)                                                \
-            .addStaticFunction("cross", &Vec::cross)                                                \
-            .addStaticFunction("triple", &Vec::triple)                                              \
-            .addStaticFunction("lerp", &Vec::lerp)                                                  \
-            .addStaticFunction("slerp", &Vec::slerp)                                                \
-            .addStaticFunction("min", &Vec::min)                                                    \
-            .addStaticFunction("max", &Vec::max)                                                    \
-            .addStaticFunction("clamp", &Vec::clamp)
-
-#define WG_ADD_VEC_FUNCS_I(Vec)                                                                     \
-    addFunction("__eq", std::function([](const Vec* v, const Vec& m) { return *v == m; }))          \
-            .addFunction("__mul", std::function([](const Vec* v, float a) { return *v * a; }))      \
-            .addFunction("__div", std::function([](const Vec* v, float a) { return *v / a; }))      \
-            .addFunction("__add", std::function([](const Vec* v, const Vec& m) { return *v + m; })) \
-            .addFunction("__sub", std::function([](const Vec* v, const Vec& m) { return *v - m; })) \
-            .addFunction("__tostring", &Vec::to_string)                                             \
-            .addFunction("to_string", &Vec::to_string)                                              \
-            .addFunction("abs", &Vec::abs)                                                          \
-            .addFunction("pow", &Vec::pow)                                                          \
-            .addProperty("length2", &Vec::length2)                                                  \
-            .addProperty("length", &Vec::length)                                                    \
-            .addProperty("normalized", &Vec::normalized)                                            \
-            .addStaticFunction("distance", &Vec::distance)                                          \
-            .addStaticFunction("distance2", &Vec::distance2)                                        \
-            .addStaticFunction("dot", &Vec::dot)                                                    \
-            .addStaticFunction("angle", &Vec::angle)                                                \
-            .addStaticFunction("cross", &Vec::cross)                                                \
-            .addStaticFunction("triple", &Vec::triple)                                              \
-            .addStaticFunction("min", &Vec::min)                                                    \
-            .addStaticFunction("max", &Vec::max)                                                    \
-            .addStaticFunction("clamp", &Vec::clamp)
-
-    void LuaBindings::bind_math(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>&) {
-        ns = ns.beginClass<Vec2f>("Vec2f")
-                     .addStaticFunction("new", std::function([](float x, float y) { return Vec2f(x, y); }))
-                     .WG_ADD_VEC_PROPS(Vec2f, x)
-                     .WG_ADD_VEC_PROPS(Vec2f, y)
-                     .WG_ADD_VEC_FUNCS_F(Vec2f)
-                     .endClass();
-
-        ns = ns.beginClass<Vec3f>("Vec3f")
-                     .addStaticFunction("new", std::function([](float x, float y, float z) { return Vec3f(x, y, z); }))
-                     .WG_ADD_VEC_PROPS(Vec3f, x)
-                     .WG_ADD_VEC_PROPS(Vec3f, y)
-                     .WG_ADD_VEC_PROPS(Vec3f, z)
-                     .WG_ADD_VEC_FUNCS_F(Vec3f)
-                     .endClass();
-
-        ns = ns.beginClass<Vec4f>("Vec4f")
-                     .addStaticFunction("new", std::function([](float x, float y, float z, float w) { return Vec4f(x, y, z, w); }))
-                     .WG_ADD_VEC_PROPS(Vec4f, x)
-                     .WG_ADD_VEC_PROPS(Vec4f, y)
-                     .WG_ADD_VEC_PROPS(Vec4f, z)
-                     .WG_ADD_VEC_PROPS(Vec4f, w)
-                     .WG_ADD_VEC_FUNCS_F(Vec4f)
-                     .endClass();
-
-        ns = ns.beginClass<Vec2i>("Vec2i")
-                     .addStaticFunction("new", std::function([](int x, int y) { return Vec2i(x, y); }))
-                     .WG_ADD_VEC_PROPS(Vec2i, x)
-                     .WG_ADD_VEC_PROPS(Vec2i, y)
-                     .WG_ADD_VEC_FUNCS_I(Vec2i)
-                     .endClass();
-
-        ns = ns.beginClass<Vec3i>("Vec3i")
-                     .addStaticFunction("new", std::function([](int x, int y, int z) { return Vec3i(x, y, z); }))
-                     .WG_ADD_VEC_PROPS(Vec3i, x)
-                     .WG_ADD_VEC_PROPS(Vec3i, y)
-                     .WG_ADD_VEC_PROPS(Vec3i, z)
-                     .WG_ADD_VEC_FUNCS_I(Vec3i)
-                     .endClass();
-
-        ns = ns.beginClass<Vec4i>("Vec4i")
-                     .addStaticFunction("new", std::function([](int x, int y, int z, int w) { return Vec4i(x, y, z, w); }))
-                     .WG_ADD_VEC_PROPS(Vec4i, x)
-                     .WG_ADD_VEC_PROPS(Vec4i, y)
-                     .WG_ADD_VEC_PROPS(Vec4i, z)
-                     .WG_ADD_VEC_PROPS(Vec4i, w)
-                     .WG_ADD_VEC_FUNCS_I(Vec4i)
-                     .endClass();
-
-        ns = ns.beginClass<Mat2x2f>("Mat2x2f")
-                     .addFunction("to_string", &Mat2x2f::to_string)
-                     .endClass();
-
-        ns = ns.beginClass<Mat3x3f>("Mat3x3f")
-                     .addFunction("to_string", &Mat3x3f::to_string)
-                     .endClass();
-
-        ns = ns.beginClass<Mat4x4f>("Mat4x4f")
-                     .addFunction("to_string", &Mat4x4f::to_string)
-                     .endClass();
-
-        ns = ns.beginClass<Quatf>("Quatf")
-                     .addProperty("scalar", std::function([](const Quatf* q) { return q->scalar; }), std::function([](Quatf* q, float v) { q->scalar = v; }))
-                     .addProperty("vec", std::function([](const Quatf* q) { return q->vec; }), std::function([](Quatf* q, Vec3f v) { q->vec = v; }))
-                     .endClass();
-
-        ns = ns.beginClass<Transform2d>("Transform2d")
-                     .addConstructor<void (*)(void)>()
-                     .addProperty("translation", &Transform2d::get_translation, &Transform2d::set_translation)
-                     .addProperty("rotation", &Transform2d::get_rotation, &Transform2d::set_rotation)
-                     .addProperty("scale", &Transform2d::get_scale, &Transform2d::set_scale)
-                     .addFunction("translate", &Transform2d::translate)
-                     .addFunction("rotate", &Transform2d::rotate)
-                     .addFunction("scale", &Transform2d::scale)
-                     .endClass();
-
-        ns = ns.beginNamespace("Math")
-                     .addFunction("clampf", &Math::clamp<float>)
-                     .addConstant("PIf", Math::PIf)
-                     .addConstant("HALF_PIf", Math::HALF_PIf)
-                     .addConstant("QUARTER_PIf", Math::QUARTER_PIf)
-                     .addConstant("SQRT2f", Math::SQRT2f)
-                     .addConstant("Ef", Math::Ef)
-                     .endNamespace();
-
-        ns = ns.beginNamespace("Math2d")
-                     .addFunction("intersects", &Math2d::intersects)
-                     .endNamespace();
-
-        ns = ns.beginNamespace("Color")
-                     .addConstant("WHITE4f", &Color::WHITE4f)
-                     .addConstant("BLACK4f", &Color::BLACK4f)
-                     .addConstant("RED4f", &Color::RED4f)
-                     .addConstant("GREEN4f", &Color::GREEN4f)
-                     .addConstant("BLUE4f", &Color::BLUE4f)
-                     .addConstant("YELLOW4f", &Color::YELLOW4f)
-                     .addConstant("WHITE3f", &Color::WHITE3f)
-                     .addConstant("BLACK3f", &Color::BLACK3f)
-                     .addConstant("RED3f", &Color::RED3f)
-                     .addConstant("GREEN3f", &Color::GREEN3f)
-                     .addConstant("BLUE3f", &Color::BLUE3f)
-                     .addConstant("YELLOW3f", &Color::YELLOW3f)
-                     .endNamespace();
-    }
-
-}// namespace wmoge
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_math.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings_math.hpp
deleted file mode 100644
index b6d2ca3bd..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_math.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BINDINGS_MATH_HPP
-#define WMOGE_LUA_BINDINGS_MATH_HPP
-
-#include "scripting/lua_bindings/lua_bindings.hpp"
-
-#include "math/aabb.hpp"
-#include "math/color.hpp"
-#include "math/mat.hpp"
-#include "math/math_utils.hpp"
-#include "math/math_utils2d.hpp"
-#include "math/math_utils3d.hpp"
-#include "math/quat.hpp"
-#include "math/transform.hpp"
-#include "math/vec.hpp"
-
-namespace wmoge {
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_BINDINGS_MATH_HPP
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_platform.cpp b/engine/runtime/scripting/lua_bindings/lua_bindings_platform.cpp
deleted file mode 100644
index e60b1118a..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_platform.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_bindings_platform.hpp"
-
-namespace wmoge {
-
-    static int lua_FileSystem_resolve(lua_State* state) {
-        auto path = WG_LUA_ARG(state, 0);
-        WG_LUA_CHECK_MSG(path.isString(), "expecting path to be a string");
-
-        auto* file_system = Engine::instance()->file_system();
-
-        // luabridge::LuaRef(state, file_system->resolve(path.cast<std::string>())).push();
-        return 1;
-    }
-
-    static int lua_FileSystem_exists(lua_State* state) {
-        auto path = WG_LUA_ARG(state, 0);
-        WG_LUA_CHECK_MSG(path.isString(), "expecting path to be a string");
-
-        auto* file_system = Engine::instance()->file_system();
-
-        luabridge::LuaRef(state, file_system->exists(path.cast<std::string>())).push();
-        return 1;
-    }
-
-    static int lua_FileSystem_read_file(lua_State* state) {
-        auto path = WG_LUA_ARG(state, 0);
-        auto data = WG_LUA_ARG(state, 1);
-        WG_LUA_CHECK_MSG(path.isString(), "expecting path to be a string");
-
-        auto* file_system = Engine::instance()->file_system();
-
-        if (data.isInstance<LuaData>()) {
-            Ref<Data> ret;
-            bool      status            = file_system->read_file(path.cast<std::string>(), ret);
-            data.cast<LuaObject&>().ptr = ret;
-            luabridge::LuaRef(state, file_system->exists(path.cast<std::string>())).push();
-            return 1;
-        }
-
-        WG_LOG_ERROR("invalid return argument where to store read result");
-
-        return 0;
-    }
-
-    static int lua_WindowManager_primary_window(lua_State* state) {
-        auto* window_manager = Engine::instance()->window_manager();
-
-        luabridge::LuaRef(state, LuaWindow{window_manager->get_primary_window()}).push();
-        return 1;
-    }
-
-    void LuaBindings::bind_platform(luabridge::Namespace& ns, flat_map<const Class*, LuaConvCppToLua>& mapping) {
-        LuaBindings::bind_enum<InputDeviceType>(ns, "InputDeviceType");
-        LuaBindings::bind_enum<InputDeviceState>(ns, "InputDeviceState");
-        LuaBindings::bind_enum<InputAction>(ns, "InputAction");
-        LuaBindings::bind_enum<InputModifier>(ns, "InputModifier");
-        LuaBindings::bind_enum<InputMouseButton>(ns, "InputMouseButton");
-        LuaBindings::bind_enum<InputKeyboardKey>(ns, "InputKeyboardKey");
-
-        ns = ns.beginNamespace("FileSystem")
-                     .addFunction("resolve", lua_FileSystem_resolve)
-                     .addFunction("exists", lua_FileSystem_exists)
-                     .addFunction("read_file", lua_FileSystem_read_file)
-                     .endNamespace();
-
-        ns = ns.beginNamespace("WindowManager")
-                     .addFunction("primary_window", lua_WindowManager_primary_window)
-                     .endNamespace();
-
-        ns = ns.deriveClass<LuaWindow, LuaRefCnt>("Window")
-                     .addFunction("close", &LuaWindow::close)
-                     .addProperty("width", &LuaWindow::width)
-                     .addProperty("height", &LuaWindow::height)
-                     .addProperty("fbo_width", &LuaWindow::fbo_width)
-                     .addProperty("fbo_height", &LuaWindow::fbo_height)
-                     .addProperty("scale_x", &LuaWindow::scale_x)
-                     .addProperty("scale_y", &LuaWindow::scale_y)
-                     .addProperty("in_focus", &LuaWindow::in_focus)
-                     .addProperty("id", &LuaWindow::id)
-                     .addProperty("title", &LuaWindow::title)
-                     .endClass();
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_platform.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings_platform.hpp
deleted file mode 100644
index ae42264dc..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_platform.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BINDINGS_PLATFORM_HPP
-#define WMOGE_LUA_BINDINGS_PLATFORM_HPP
-
-#include "scripting/lua_bindings/lua_bindings.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-
-#include "platform/file_system.hpp"
-#include "platform/input.hpp"
-#include "platform/input_devices.hpp"
-#include "platform/window.hpp"
-#include "platform/window_manager.hpp"
-#include "system/engine.hpp"
-
-namespace wmoge {
-
-    struct LuaWindow : public LuaRefCnt {
-        void close() {
-            cast_unsafe<Window>()->close();
-        }
-        int width() const {
-            return cast_unsafe<Window>()->width();
-        }
-        int height() const {
-            return cast_unsafe<Window>()->height();
-        }
-        int fbo_width() const {
-            return cast_unsafe<Window>()->fbo_width();
-        }
-        int fbo_height() const {
-            return cast_unsafe<Window>()->fbo_height();
-        }
-        float scale_x() const {
-            return cast_unsafe<Window>()->scale_x();
-        }
-        float scale_y() const {
-            return cast_unsafe<Window>()->scale_y();
-        }
-        bool in_focus() const {
-            return cast_unsafe<Window>()->in_focus();
-        }
-        const Strid& id() const {
-            return cast_unsafe<Window>()->id();
-        }
-        const std::string& title() const {
-            return cast_unsafe<Window>()->title();
-        }
-    };
-
-    struct LuaInputDevice : public LuaRefCnt {
-    };
-
-    struct LuaMouse : public LuaInputDevice {
-    };
-
-    struct LuaKeyboard : public LuaInputDevice {
-    };
-
-    struct LuaJoystick : public LuaInputDevice {
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_BINDINGS_PLATFORM_HPP
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_scene.cpp b/engine/runtime/scripting/lua_bindings/lua_bindings_scene.cpp
deleted file mode 100644
index 45019b926..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_scene.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "lua_bindings_scene.hpp"
-
-namespace wmoge {
-
-    void LuaBindings::bind_scene(luabridge::Namespace& ns, flat_map<const wmoge::Class*, wmoge::LuaConvCppToLua>& mapping) {
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/lua_bindings/lua_bindings_scene.hpp b/engine/runtime/scripting/lua_bindings/lua_bindings_scene.hpp
deleted file mode 100644
index e09ff652c..000000000
--- a/engine/runtime/scripting/lua_bindings/lua_bindings_scene.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_LUA_BINDINGS_SCENE_HPP
-#define WMOGE_LUA_BINDINGS_SCENE_HPP
-
-#include "scripting/lua_bindings/lua_bindings.hpp"
-#include "scripting/lua_bindings/lua_bindings_core.hpp"
-
-#include "scene/scene.hpp"
-#include "scene/scene_manager.hpp"
-#include "system/engine.hpp"
-
-namespace wmoge {
-
-}// namespace wmoge
-
-#endif//WMOGE_LUA_BINDINGS_SCENE_HPP
diff --git a/engine/runtime/scripting/script.cpp b/engine/runtime/scripting/script.cpp
deleted file mode 100644
index 53198688a..000000000
--- a/engine/runtime/scripting/script.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "script.hpp"
-
-#include "platform/file_system.hpp"
-#include "scripting/script_system.hpp"
-
-namespace wmoge {
-
-    Ref<ScriptInstance> Script::attach_to(Object* object) {
-        return Ref<ScriptInstance>{};
-    }
-    bool Script::has_property(const Strid& property) {
-        return false;
-    }
-    bool Script::has_method(const Strid& method) {
-        return false;
-    }
-    ScriptFunctionsMask Script::get_mask() {
-        return m_mask;
-    }
-    const Strid& Script::get_language() {
-        return m_language;
-    }
-    const std::string& Script::get_code() {
-        return m_code;
-    }
-
-}// namespace wmoge
diff --git a/engine/runtime/scripting/script.hpp b/engine/runtime/scripting/script.hpp
deleted file mode 100644
index ba7241af7..000000000
--- a/engine/runtime/scripting/script.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "asset/asset.hpp"
-#include "scripting/script_instance.hpp"
-
-namespace wmoge {
-
-    /**
-     * @class Script
-     * @brief Base class for any script which can be used to extend an object logic
-     *
-     * Script allows to extend a functionality of any engine object which inherits
-     * engine core `Object` class. Script provides mechanism for the user to
-     * declare a custom class with custom methods, properties and event handles
-     * which can be trigger on the object. Script itself is a class, which must
-     * be instanced and attached to an object.
-     *
-     * Script instance is an actual instance of the script, which can be attached
-     * to an object. In order to extend object call `script->attach_to(object)`.
-     * It creates new instance and attaches it to object.
-     *
-     * Script can be internally implemented as an native C++ class or as a text
-     * file with script code using scriptable language, such as Lua.
-     *
-     * @see ScriptInstance
-     * @see Object
-     */
-    class Script : public Asset {
-    public:
-        WG_RTTI_CLASS(Script, Asset);
-
-        Script()           = default;
-        ~Script() override = default;
-
-        virtual Ref<ScriptInstance> attach_to(Object* object);
-        virtual bool                has_property(const Strid& property);
-        virtual bool                has_method(const Strid& method);
-
-        ScriptFunctionsMask get_mask();
-        const Strid&        get_language();
-        const std::string&  get_code();
-
-    protected:
-        Strid               m_language;
-        std::string         m_code;
-        ScriptFunctionsMask m_mask;
-    };
-
-    WG_RTTI_CLASS_BEGIN(Script) {
-        WG_RTTI_META_DATA(RttiUiHint(""));
-        WG_RTTI_FACTORY();
-    }
-    WG_RTTI_END;
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/script_instance.hpp b/engine/runtime/scripting/script_instance.hpp
deleted file mode 100644
index 142696427..000000000
--- a/engine/runtime/scripting/script_instance.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_SCRIPT_INSTANCE_HPP
-#define WMOGE_SCRIPT_INSTANCE_HPP
-
-#include "core/mask.hpp"
-#include "core/object.hpp"
-#include "core/ref.hpp"
-#include "core/var.hpp"
-
-namespace wmoge {
-
-    /**
-     * @class ScriptFunction
-     * @brief On-event function exposed by script
-     */
-    enum class ScriptFunction {
-        OnCreate,
-        OnSceneEnter,
-        OnSceneExit,
-        OnTransformUpdated,
-        OnUpdate,
-        OnSignal,
-        Total
-    };
-
-    /**
-     * @class ScriptFunctionsMask
-     * @brief Mask with script defined functions
-     */
-    using ScriptFunctionsMask = Mask<ScriptFunction>;
-
-    /**
-     * @class ScriptInstance
-     * @brief An instance of the script which can control an object logic
-     */
-    class ScriptInstance : public RefCnt {
-    public:
-        ~ScriptInstance() override = default;
-
-        virtual ScriptFunctionsMask get_mask() { return ScriptFunctionsMask(); };
-        virtual class Script*       get_script() { return nullptr; };
-        virtual class Object*       get_owner() { return nullptr; };
-
-        virtual void on_create() {}
-        virtual void on_scene_enter() {}
-        virtual void on_scene_exit() {}
-        virtual void on_transform_updated() {}
-        virtual void on_update(float delta_time) {}
-        virtual void on_signal(const Strid& signal) {}
-
-        virtual int set(const Strid& property, const Var& value) { return -2; }
-        virtual int get(const Strid& property, Var& value) { return -2; }
-        virtual int call(const Strid& method, int argc, const Var* argv, Var& ret) { return -2; }
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_SCRIPT_INSTANCE_HPP
diff --git a/engine/runtime/scripting/script_native.hpp b/engine/runtime/scripting/script_native.hpp
deleted file mode 100644
index f4b48639e..000000000
--- a/engine/runtime/scripting/script_native.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_SCRIPT_NATIVE_HPP
-#define WMOGE_SCRIPT_NATIVE_HPP
-
-#include "core/class.hpp"
-#include "core/object.hpp"
-#include "scripting/script.hpp"
-#include "scripting/script_instance.hpp"
-
-namespace wmoge {
-
-    /**
-     * @class ScriptNativeInstance
-     * @brief An extension to simplify C++ native scripts creation
-     */
-    class ScriptNativeInstance : public ScriptInstance {
-    public:
-        ScriptNativeInstance(Ref<Script> script, Object* object, ScriptFunctionsMask mask);
-
-        ScriptFunctionsMask get_mask() override;
-        Script*             get_script() override;
-        Object*             get_owner() override;
-
-    private:
-        Ref<Script>         m_script;
-        Object*             m_object;
-        ScriptFunctionsMask m_mask;
-    };
-
-}// namespace wmoge
-
-#define WG_BEGIN_NATIVE_SCRIPT(name, ...)                                                    \
-    class name final : public Script {                                                       \
-    public:                                                                                  \
-        WG_OBJECT(name, Script)                                                              \
-                                                                                             \
-        ref_ptr<ScriptInstance> attach_to(Object* object) override {                         \
-            return make_ref<name##Instance>(ref_ptr<Script>(this), object, get_mask());      \
-        }                                                                                    \
-        ScriptFunctionsMask get_mask() override {                                            \
-            return __VA_ARGS__;                                                              \
-        }                                                                                    \
-                                                                                             \
-        class name##Instance final : public ScriptNativeInstance {                           \
-        public:                                                                              \
-            name##Instance(ref_ptr<Script> script, Object* object, ScriptFunctionsMask mask) \
-                : ScriptNativeInstance(std::move(script), object, mask) {}
-
-#define WG_END_NATIVE_SCRIPT(name)                 \
-    }                                              \
-    ;                                              \
-    }                                              \
-    ;                                              \
-    void name::register_class() {                  \
-        auto* cls = Class::register_class<name>(); \
-    }
-
-#endif//WMOGE_SCRIPT_NATIVE_HPP
diff --git a/engine/runtime/scripting/script_system.hpp b/engine/runtime/scripting/script_system.hpp
deleted file mode 100644
index 6d2d5b498..000000000
--- a/engine/runtime/scripting/script_system.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#ifndef WMOGE_SCRIPT_MANAGER_HPP
-#define WMOGE_SCRIPT_MANAGER_HPP
-
-#include "core/string_id.hpp"
-
-namespace wmoge {
-
-    /**
-     * @class ScriptSystem
-     * @brief Engine script system responsible for scripting features for a game
-     *
-     * Scripting system allows to attach scripts to any engine objects to extend
-     * their logic, get notifications on events, create objects from scripting,
-     * manage scene, process events, updates, etc.
-     *
-     * Scripting system takes responsibility on managing objects lifetime,
-     * scripts and class loading, global states, and error tracking.
-     *
-     * From a user perspective it is enough to create script and attach it to
-     * a scene object. The engine will do the rest.
-     *
-     * @see Script
-     * @see ScriptInstance
-     * @see ScriptContainer
-     */
-    class ScriptSystem {
-    public:
-        virtual ~ScriptSystem() = default;
-
-        virtual void gc()       = 0;
-        virtual void update()   = 0;
-        virtual void shutdown() = 0;
-
-        const Strid& get_name() { return m_name; }
-        const Strid& get_language() { return m_language; }
-
-    protected:
-        Strid       m_name                = SID("none");
-        Strid       m_language            = SID("none");
-        std::size_t m_gc_interval         = 15;
-        std::size_t m_gc_cycles           = 0;
-        std::size_t m_gc_frames_from_last = 0;
-    };
-
-}// namespace wmoge
-
-#endif//WMOGE_SCRIPT_MANAGER_HPP
diff --git a/engine/runtime/platform/application.cpp b/engine/runtime/system/application.cpp
similarity index 63%
rename from engine/runtime/platform/application.cpp
rename to engine/runtime/system/application.cpp
index 066b7a80c..090dd95df 100644
--- a/engine/runtime/platform/application.cpp
+++ b/engine/runtime/system/application.cpp
@@ -32,6 +32,7 @@
 #include "core/callback_queue.hpp"
 #include "core/class.hpp"
 #include "core/cmd_line.hpp"
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "core/task_manager.hpp"
 #include "ecs/ecs_registry.hpp"
@@ -42,16 +43,9 @@
 #include "grc/shader_library.hpp"
 #include "grc/shader_manager.hpp"
 #include "grc/texture_manager.hpp"
-#include "hooks/hook_config.hpp"
-#include "hooks/hook_engine.hpp"
-#include "hooks/hook_logs.hpp"
-#include "hooks/hook_profiler.hpp"
-#include "hooks/hook_root_remap.hpp"
-#include "hooks/hook_uuid_gen.hpp"
 #include "io/async_file_system.hpp"
 #include "io/enum.hpp"
 #include "mesh/mesh_manager.hpp"
-#include "platform/application.hpp"
 #include "platform/dll_manager.hpp"
 #include "platform/file_system.hpp"
 #include "platform/glfw/glfw_window_manager.hpp"
@@ -63,13 +57,9 @@
 #include "render/view_manager.hpp"
 #include "rtti/type_storage.hpp"
 #include "scene/scene_manager.hpp"
-#include "scripting/lua/lua_script_system.hpp"
-#include "scripting/script_system.hpp"
 #include "system/config.hpp"
 #include "system/console.hpp"
 #include "system/engine.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
 #include "system/plugin_manager.hpp"
 
 #include "asset/_rtti.hpp"
@@ -82,31 +72,31 @@
 #include "render/_rtti.hpp"
 #include "rtti/_rtti.hpp"
 #include "scene/_rtti.hpp"
-#include "scripting/_rtti.hpp"
 #include "system/_rtti.hpp"
 
 namespace wmoge {
 
     static void bind_globals(IocContainer* ioc) {
-        ioc->bind<HookList>();
-        ioc->bind<CmdLine>();
-        ioc->bind<DllManager>();
+        ioc->bind_by_pointer<Log>(Log::instance());
+        ioc->bind_by_pointer<Profiler>(Profiler::instance());
+        ioc->bind_by_pointer<RttiTypeStorage>(RttiTypeStorage::instance());
+        ioc->bind_by_ioc<DllManager>();
         ioc->bind<PluginManager>();
         ioc->bind<Time>();
-        ioc->bind<Config>();
+        ioc->bind_by_ioc<Config>();
         ioc->bind<FileSystem>();
         ioc->bind<Console>();
         ioc->bind<CallbackQueue>();
-        ioc->bind<GlslShaderCompiler>();
-        ioc->bind<ShaderLibrary>();
-        ioc->bind<ShaderManager>();
-        ioc->bind<PsoCache>();
-        ioc->bind<TextureManager>();
-        ioc->bind<MeshManager>();
+        ioc->bind_by_ioc<GlslShaderCompiler>();
+        ioc->bind_by_ioc<ShaderLibrary>();
+        ioc->bind_by_ioc<ShaderManager>();
+        ioc->bind_by_ioc<PsoCache>();
+        ioc->bind_by_ioc<TextureManager>();
+        ioc->bind_by_ioc<MeshManager>();
         ioc->bind<RenderEngine>();
         ioc->bind_by_ioc<AssetManager>();
         ioc->bind<EcsRegistry>();
-        ioc->bind<SceneManager>();
+        ioc->bind_by_ioc<SceneManager>();
         ioc->bind<ViewManager>();
 
         ioc->bind_by_factory<IoAsyncFileSystem>([ioc]() {
@@ -150,36 +140,14 @@ namespace wmoge {
             init_info.required_ext = window_manager->extensions();
             init_info.factory      = window_manager->factory();
 
-            return std::make_shared<VKDriver>(std::move(init_info));
+            return std::make_shared<VKDriver>(ioc, init_info);
         });
 
         ioc->bind_by_factory<GfxDriver>([ioc]() {
             return std::shared_ptr<GfxDriver>(ioc->resolve_value<VKDriver>(), [](auto p) {});
         });
 
-        ioc->bind_by_factory<RttiTypeStorage>([]() {
-            auto type_storage = std::make_shared<RttiTypeStorage>();
-            RttiTypeStorage::provide(type_storage.get());
-            return type_storage;
-        });
-
-        ioc->bind_by_factory<Profiler>([]() {
-            auto profiler = std::make_shared<Profiler>();
-            Profiler::provide(profiler.get());
-            return profiler;
-        });
-
-        ioc->bind_by_factory<Log>([]() {
-            auto log = std::make_shared<Log>();
-            Log::provide(log.get());
-            return log;
-        });
-
-        ioc->bind_by_factory<Engine>([]() {
-            auto engine = std::make_shared<Engine>();
-            Engine::provide(engine.get());
-            return engine;
-        });
+        ioc->bind_by_ioc<Engine>();
     }
 
     static void unbind_globals(IocContainer* ioc) {
@@ -215,71 +183,55 @@ namespace wmoge {
         rtti_pfx();
         rtti_render();
         rtti_scene();
-        rtti_scripting();
         rtti_system();
     }
 
-    int Application::run(int argc, const char* const* argv) {
-        IocContainer ioc;
-        IocContainer::provide(&ioc);
+    Application::Application(ApplicationConfig& config) : m_config(config) {
+    }
 
-        bind_globals(&ioc);
-        bind_rtti(&ioc);
+    int Application::run() {
+        IocContainer* ioc = m_config.ioc;
 
-        Log* log = ioc.resolve<Log>().value();
+        bind_globals(ioc);
+        bind_rtti(ioc);
 
-        ioc.bind_by_instance<Application>(std::shared_ptr<Application>(this, [](auto p) {}));
+        ioc->bind_by_pointer<Application>(this);
 
         on_register();
 
-        CmdLine* cmd_line = ioc.resolve<CmdLine>().value();
-        cmd_line->add_bool("h,help", "display help message", "false");
-
-        signal_hook.emit();
+        CmdLineOptions*  cmd_line_options = m_config.cmd_line.options;
+        CmdLineHookList* cmd_line_hooks   = m_config.cmd_line.hooks;
 
-        HookList* hook_list = ioc.resolve<HookList>().value();
-        hook_list->each([&](HookList::HookPtr& hook) {
-            hook->on_add_cmd_line_options(*cmd_line);
-            return false;
-        });
+        cmd_line_options->add_bool("h,help", "display help message", "false");
 
-        if (!cmd_line->parse(argc, argv)) {
+        auto cmd_parse_result = cmd_line_options->parse(m_config.cmd_line.args);
+        if (!cmd_parse_result) {
             return 1;
         }
-        if (cmd_line->get_bool("help")) {
-            std::cout << cmd_line->get_help();
+
+        if (cmd_parse_result->get_bool("help")) {
+            std::cout << cmd_line_options->get_help();
             return 0;
         }
 
-        std::optional<int> ret_code;
-
-        hook_list->each([&](HookList::HookPtr& hook) {
-            const Status     status = hook->on_process(*cmd_line);
-            const StatusCode code   = status.code();
-
-            if (code == StatusCode::ExitCode0) {
-                ret_code = 0;
-                std::cout << "exit code 0" << std::endl;
-                return true;
-            }
-            if (code == StatusCode::ExitCode1) {
-                ret_code = 1;
-                std::cerr << "exit code 1 after " << hook->get_name() << std::endl;
-                return true;
-            }
-            if (code != StatusCode::Ok) {
-                std::cerr << "error " << status << " after " << hook->get_name() << std::endl;
-                return true;
-            }
-
-            return false;
-        });
+        const Status status = cmd_line_hooks->process(*cmd_parse_result);
 
-        if (ret_code.has_value()) {
-            return ret_code.value();
+        if (status.code() == StatusCode::ExitCode0) {
+            std::cout << "exit code 0" << std::endl;
+            return true;
+        }
+        if (status.code() == StatusCode::ExitCode1) {
+            std::cerr << "exit code 1" << std::endl;
+            return 1;
+        }
+        if (status.code() != StatusCode::Ok) {
+            std::cerr << "error " << status << std::endl;
+            return 2;
         }
 
-        signal_before_init.emit();
+        ApplicationSignals& signals = m_config.signals;
+
+        signals.before_init.emit();
         {
             WG_AUTO_PROFILE_PLATFORM("Application::initialize");
 
@@ -287,9 +239,9 @@ namespace wmoge {
                 return 1;
             }
         }
-        signal_after_init.emit();
+        signals.after_init.emit();
 
-        signal_before_loop.emit();
+        signals.before_loop.emit();
         {
             while (!should_close()) {
                 WG_AUTO_PROFILE_PLATFORM("Application::iteration");
@@ -299,9 +251,9 @@ namespace wmoge {
                 }
             }
         }
-        signal_after_loop.emit();
+        signals.after_loop.emit();
 
-        signal_before_shutdown.emit();
+        signals.before_shutdown.emit();
         {
             WG_AUTO_PROFILE_PLATFORM("Application::shutdown");
 
@@ -309,41 +261,11 @@ namespace wmoge {
                 return 1;
             }
 
-            unbind_globals(&ioc);
+            unbind_globals(ioc);
         }
-        signal_after_shutdown.emit();
+        signals.after_shutdown.emit();
 
         return 0;
     }
 
-    Status GameApplication::on_register() {
-        signal_hook.bind([]() {
-            HookList* hook_list = IocContainer::iresolve_v<HookList>();
-
-            hook_list->attach(std::make_shared<HookUuidGen>());
-            hook_list->attach(std::make_shared<HookRootRemap>());
-            hook_list->attach(std::make_shared<HookEngine>());
-            hook_list->attach(std::make_shared<HookLogs>());
-            hook_list->attach(std::make_shared<HookProfiler>());
-        });
-
-        return IocContainer::iresolve_v<Engine>()->setup(this);
-    }
-
-    Status GameApplication::on_init() {
-        return Engine::instance()->init();
-    }
-
-    Status GameApplication::on_loop() {
-        return Engine::instance()->iteration();
-    }
-
-    Status GameApplication::on_shutdown() {
-        return Engine::instance()->shutdown();
-    }
-
-    bool GameApplication::should_close() {
-        return Engine::instance()->close_requested();
-    }
-
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/platform/application.hpp b/engine/runtime/system/application.hpp
similarity index 71%
rename from engine/runtime/platform/application.hpp
rename to engine/runtime/system/application.hpp
index 25c679cef..e725f08f9 100644
--- a/engine/runtime/platform/application.hpp
+++ b/engine/runtime/system/application.hpp
@@ -27,27 +27,60 @@
 
 #pragma once
 
+#include "core/cmd_line.hpp"
+#include "core/ioc_container.hpp"
 #include "core/signal.hpp"
 #include "core/status.hpp"
 
+#include <string>
+#include <vector>
+
 namespace wmoge {
 
+    /**
+     * @class ApplicationCmdLine
+     * @brief App command line processing params
+     */
+    struct ApplicationCmdLine {
+        CmdLineOptions*          options;
+        CmdLineHookList*         hooks;
+        std::string              line;
+        std::vector<std::string> args;
+    };
+
+    /**
+     * @class ApplicationSignals
+     * @brief App signals to intercept some events
+     */
+    struct ApplicationSignals {
+        Signal<> before_init;
+        Signal<> after_init;
+        Signal<> before_loop;
+        Signal<> after_loop;
+        Signal<> before_shutdown;
+        Signal<> after_shutdown;
+    };
+
+    /**
+     * @class ApplicationConfig
+     * @brief Desc containing info to setup application
+     */
+    struct ApplicationConfig {
+        std::string        name;
+        IocContainer*      ioc;
+        ApplicationSignals signals;
+        ApplicationCmdLine cmd_line;
+    };
+
     /**
      * @class Application
      * @brief Base class for any application which is an entry point to run
      */
     class Application {
     public:
+        Application(ApplicationConfig& config);
         virtual ~Application() = default;
 
-        Signal<> signal_hook;
-        Signal<> signal_before_init;
-        Signal<> signal_after_init;
-        Signal<> signal_before_loop;
-        Signal<> signal_after_loop;
-        Signal<> signal_before_shutdown;
-        Signal<> signal_after_shutdown;
-
         virtual Status on_register() { return WG_OK; }
         virtual Status on_init() { return WG_OK; }
         virtual Status on_loop() { return WG_OK; }
@@ -55,22 +88,10 @@ namespace wmoge {
         virtual bool   should_close() { return true; }
         virtual void   requiest_close() {}
 
-        [[nodiscard]] int run(int argc, const char* const* argv);
-    };
-
-    /**
-     * @class GameApplication
-     * @brief Base class for application to run stand-alone game
-    */
-    class GameApplication : public Application {
-    public:
-        ~GameApplication() override = default;
+        [[nodiscard]] int run();
 
-        Status on_register() override;
-        Status on_init() override;
-        Status on_loop() override;
-        Status on_shutdown() override;
-        bool   should_close() override;
+    protected:
+        ApplicationConfig& m_config;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/config.cpp b/engine/runtime/system/config.cpp
index fbdc05e7a..9272d7922 100644
--- a/engine/runtime/system/config.cpp
+++ b/engine/runtime/system/config.cpp
@@ -27,10 +27,19 @@
 
 #include "config.hpp"
 
+#include "core/ioc_container.hpp"
+#include "platform/file_system.hpp"
+
 namespace wmoge {
+    Config::Config(IocContainer* ioc) {
+        m_file_system = ioc->resolve_value<FileSystem>();
+    }
 
     Status Config::load(const std::string& path, ConfigStackMode mode) {
-        return m_file->load_and_stack(path, mode);
+        ConfigFile config;
+        WG_CHECKED(config.load_from_file(m_file_system, path));
+        WG_CHECKED(m_file->stack(config, mode));
+        return WG_OK;
     }
 
     Status Config::set_bool(const Strid& key, const bool& value, bool overwrite) {
diff --git a/engine/runtime/system/config.hpp b/engine/runtime/system/config.hpp
index 1222661f4..dd17e678f 100644
--- a/engine/runtime/system/config.hpp
+++ b/engine/runtime/system/config.hpp
@@ -41,7 +41,7 @@ namespace wmoge {
     */
     class Config {
     public:
-        Config() = default;
+        Config(class IocContainer* ioc);
 
         Status load(const std::string& path, ConfigStackMode mode = ConfigStackMode::Overwrite);
 
@@ -63,7 +63,8 @@ namespace wmoge {
         [[nodiscard]] Color4f     get_color4f_or_default(const Strid& key, Color4f def_value = {}) const;
 
     private:
-        Ref<ConfigFile> m_file = make_ref<ConfigFile>();
+        Ref<ConfigFile>   m_file        = make_ref<ConfigFile>();
+        class FileSystem* m_file_system = nullptr;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/config_file.cpp b/engine/runtime/system/config_file.cpp
index b7343b598..cefb550e5 100644
--- a/engine/runtime/system/config_file.cpp
+++ b/engine/runtime/system/config_file.cpp
@@ -32,23 +32,26 @@
 #include "io/ini.hpp"
 #include "platform/file_system.hpp"
 #include "profiler/profiler.hpp"
-#include "system/ioc_container.hpp"
 
 #include <fstream>
 
 namespace wmoge {
 
-    Status ConfigFile::load(const std::string& path) {
-        WG_AUTO_PROFILE_ASSET("ConfigFile::load");
+    Status ConfigFile::load_from_file(FileSystem* file_system, const std::string& path) {
+        WG_AUTO_PROFILE_ASSET("ConfigFile::load_from_file");
 
         std::string content;
-        FileSystem* file_system = IocContainer::iresolve_v<FileSystem>();
-
         if (!file_system->read_file(path, content)) {
             WG_LOG_ERROR("failed to read config file from " << path);
             return StatusCode::FailedRead;
         }
 
+        return load_from_content(content);
+    }
+
+    Status ConfigFile::load_from_content(const std::string& content) {
+        WG_AUTO_PROFILE_ASSET("ConfigFile::load_from_content");
+
         IniFile file;
         WG_CHECKED(file.parse(content));
 
@@ -79,17 +82,6 @@ namespace wmoge {
         return WG_OK;
     }
 
-    Status ConfigFile::load_and_stack(const std::string& path, ConfigStackMode mode) {
-        ConfigFile config_file;
-
-        if (!config_file.load(path)) {
-            return StatusCode::FailedRead;
-        }
-
-        stack(config_file, mode);
-        return WG_OK;
-    }
-
     void ConfigFile::clear() {
         m_entries.clear();
     }
diff --git a/engine/runtime/system/config_file.hpp b/engine/runtime/system/config_file.hpp
index 80cc4f02b..5521813a7 100644
--- a/engine/runtime/system/config_file.hpp
+++ b/engine/runtime/system/config_file.hpp
@@ -53,12 +53,18 @@ namespace wmoge {
 
         /**
          * @brief Loads config file from a engine directory
-         *
+         * @param file_system File system access
          * @param path Relative path to the file to load
-         *
          * @return True if successfully loaded and parsed
          */
-        Status load(const std::string& path);
+        Status load_from_file(class FileSystem* file_system, const std::string& path);
+
+        /**
+         * @brief Loads config file from string with content
+         * @param content Confing content
+         * @return True if successfully loaded and parsed
+         */
+        Status load_from_content(const std::string& content);
 
         /**
          * @brief Stack other config on top of this
@@ -68,16 +74,6 @@ namespace wmoge {
          */
         Status stack(const ConfigFile& other, ConfigStackMode mode = ConfigStackMode::Overwrite);
 
-        /**
-         * @brief Loads config by path and stacks into this
-         *
-         * @param path Path to config to load and stack
-         * @param mode Stacking mode
-         *
-         * @return True if loaded and stacked
-         */
-        Status load_and_stack(const std::string& path, ConfigStackMode mode = ConfigStackMode::Overwrite);
-
         /** @brief Clears config file */
         void clear();
 
@@ -111,8 +107,7 @@ namespace wmoge {
     WG_RTTI_CLASS_BEGIN(ConfigFile) {
         WG_RTTI_META_DATA();
         WG_RTTI_FACTORY();
-        WG_RTTI_METHOD(load, {"path"}, {});
-        WG_RTTI_METHOD(load_and_stack, {"path", "mode"}, {});
+        WG_RTTI_METHOD(load_from_content, {"content"}, {});
         WG_RTTI_METHOD(clear, {}, {});
         WG_RTTI_METHOD(is_empty, {}, {});
         WG_RTTI_METHOD(set_bool, {"key", "value", "overwrite"}, {});
diff --git a/engine/runtime/system/console.cpp b/engine/runtime/system/console.cpp
index b0186d6a5..99c0aa845 100644
--- a/engine/runtime/system/console.cpp
+++ b/engine/runtime/system/console.cpp
@@ -36,8 +36,6 @@
 #include "platform/window_manager.hpp"
 #include "profiler/profiler.hpp"
 #include "render/canvas.hpp"
-#include "system/config.hpp"
-#include "system/ioc_container.hpp"
 
 #include <algorithm>
 #include <sstream>
@@ -137,9 +135,9 @@ namespace wmoge {
         }
     }
 
-    void Console::init() {
+    void Console::init(AssetManager* asset_manager) {
         register_commands();
-        load_settings();
+        load_settings(asset_manager);
     }
 
     void Console::shutdown() {
@@ -310,35 +308,14 @@ namespace wmoge {
             return 0;
         });
     }
-    void Console::load_settings() {
+    void Console::load_settings(AssetManager* asset_manager) {
         WG_AUTO_PROFILE_DEBUG("Console::load_settings");
 
-        auto config        = IocContainer::iresolve_v<Config>();
-        auto asset_manager = IocContainer::iresolve_v<AssetManager>();
+        const std::string font_name = "assets/fonts/anonymous_pro";
 
         // m_canvas       = Engine::instance()->canvas_debug();
-        m_console_font = asset_manager->load(SID(config->get_string_or_default(SID("debug.console.font"), "assets/fonts/anonymous_pro"))).cast<Font>();
+        m_console_font = asset_manager->load(AssetId(font_name)).cast<Font>();
         m_margin_line  = m_margin + m_console_font->get_string_size("> ", m_text_size).x();
-
-        config->get_color4f(SID("debug.console.color_back"), m_color_back);
-        config->get_color4f(SID("debug.console.color_line"), m_color_line);
-        config->get_color4f(SID("debug.console.color_text"), m_color_text);
-        config->get_color4f(SID("debug.console.color_input"), m_color_input);
-        config->get_color4f(SID("debug.console.color_warning"), m_color_warning);
-        config->get_color4f(SID("debug.console.color_error"), m_color_error);
-        config->get_color4f(SID("debug.console.color_suggestion"), m_color_suggestion);
-        config->get_color4f(SID("debug.console.color_cursor"), m_color_cursor);
-        config->get_float(SID("debug.console.speed_open"), m_speed_open);
-        config->get_float(SID("debug.console.speed_blink"), m_speed_blink);
-        config->get_float(SID("debug.console.blink_threshold"), m_blink_threshold);
-        config->get_float(SID("debug.console.size"), m_size);
-        config->get_float(SID("debug.console.text_size"), m_text_size);
-        config->get_float(SID("debug.console.line_size"), m_line_size);
-        config->get_float(SID("debug.console.cursor_width"), m_cursor_width);
-        config->get_float(SID("debug.console.cursor_height"), m_cursor_height);
-        config->get_float(SID("debug.console.text_line"), m_text_line);
-        config->get_float(SID("debug.console.margin"), m_margin);
-        config->get_float(SID("debug.console.margin_line"), m_margin_line);
     }
     void Console::add_message_internal(const std::string& message, const Color4f& color, bool merge_lines) {
         std::lock_guard lock(m_mutex);
diff --git a/engine/runtime/system/console.hpp b/engine/runtime/system/console.hpp
index 8680a0649..0cd4dc350 100644
--- a/engine/runtime/system/console.hpp
+++ b/engine/runtime/system/console.hpp
@@ -147,14 +147,14 @@ namespace wmoge {
         /** @brief Process console input as a string */
         void process(const std::string& input);
 
-        void init();
+        void init(class AssetManager* asset_manager);
         void shutdown();
         void update();
         void render();
 
     private:
         void register_commands();
-        void load_settings();
+        void load_settings(class AssetManager* asset_manager);
         void add_message_internal(const std::string& message, const Color4f& color, bool merge_lines = false);
 
         enum class ConsoleState {
diff --git a/engine/runtime/system/engine.cpp b/engine/runtime/system/engine.cpp
index 6036c33bb..45b1eab0b 100644
--- a/engine/runtime/system/engine.cpp
+++ b/engine/runtime/system/engine.cpp
@@ -33,22 +33,18 @@
 #include "core/callback_queue.hpp"
 #include "core/class.hpp"
 #include "core/cmd_line.hpp"
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
 #include "core/task_manager.hpp"
 #include "ecs/ecs_registry.hpp"
 #include "gfx/vulkan/vk_driver.hpp"
+#include "glsl/glsl_shader_compiler.hpp"
 #include "grc/pso_cache.hpp"
 #include "grc/shader_library.hpp"
 #include "grc/shader_manager.hpp"
 #include "grc/texture_manager.hpp"
-#include "hooks/hook_config.hpp"
-#include "hooks/hook_logs.hpp"
-#include "hooks/hook_profiler.hpp"
-#include "hooks/hook_root_remap.hpp"
-#include "hooks/hook_uuid_gen.hpp"
 #include "io/enum.hpp"
 #include "mesh/mesh_manager.hpp"
-#include "platform/application.hpp"
 #include "platform/dll_manager.hpp"
 #include "platform/file_system.hpp"
 #include "platform/glfw/glfw_window_manager.hpp"
@@ -60,37 +56,31 @@
 #include "render/view_manager.hpp"
 #include "rtti/type_storage.hpp"
 #include "scene/scene_manager.hpp"
-#include "scripting/lua/lua_script_system.hpp"
-#include "scripting/script_system.hpp"
+#include "system/application.hpp"
 #include "system/config.hpp"
 #include "system/console.hpp"
 #include "system/engine.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
 #include "system/plugin_manager.hpp"
 
 #include <cassert>
 
 namespace wmoge {
 
-    Engine* Engine::g_engine = nullptr;
-
-    Status Engine::setup(Application* application) {
-        m_application = application;
+    Engine::Engine(IocContainer* ioc_container) {
+        m_ioc_container = ioc_container;
+    }
 
-        IocContainer* ioc = IocContainer::instance();
+    Status Engine::setup() {
+        m_class_db = ClassDB::instance();
 
-        m_class_db       = ClassDB::instance();
-        m_type_storage   = ioc->resolve_value<RttiTypeStorage>();
-        m_time           = ioc->resolve_value<Time>();
-        m_cmd_line       = ioc->resolve_value<CmdLine>();
-        m_hook_list      = ioc->resolve_value<HookList>();
-        m_file_system    = ioc->resolve_value<FileSystem>();
-        m_config         = ioc->resolve_value<Config>();
-        m_console        = ioc->resolve_value<Console>();
-        m_profiler       = ioc->resolve_value<Profiler>();
-        m_dll_manager    = ioc->resolve_value<DllManager>();
-        m_plugin_manager = ioc->resolve_value<PluginManager>();
+        m_application    = m_ioc_container->resolve_value<Application>();
+        m_time           = m_ioc_container->resolve_value<Time>();
+        m_file_system    = m_ioc_container->resolve_value<FileSystem>();
+        m_config         = m_ioc_container->resolve_value<Config>();
+        m_console        = m_ioc_container->resolve_value<Console>();
+        m_profiler       = m_ioc_container->resolve_value<Profiler>();
+        m_dll_manager    = m_ioc_container->resolve_value<DllManager>();
+        m_plugin_manager = m_ioc_container->resolve_value<PluginManager>();
 
         m_plugin_manager->setup();
 
@@ -100,13 +90,11 @@ namespace wmoge {
     Status Engine::init() {
         WG_AUTO_PROFILE_SYSTEM("Engine::init");
 
-        IocContainer* ioc = IocContainer::instance();
-
-        m_task_manager  = ioc->resolve_value<TaskManager>();
-        m_asset_manager = ioc->resolve_value<AssetManager>();
+        m_task_manager  = m_ioc_container->resolve_value<TaskManager>();
+        m_asset_manager = m_ioc_container->resolve_value<AssetManager>();
 
-        m_window_manager = ioc->resolve_value<GlfwWindowManager>();
-        m_input          = ioc->resolve_value<GlfwInput>();
+        m_window_manager = m_ioc_container->resolve_value<GlfwWindowManager>();
+        m_input          = m_ioc_container->resolve_value<GlfwInput>();
 
         WindowInfo window_info;
         window_info.width    = m_config->get_int_or_default(SID("engine.window.width"), 1280);
@@ -120,24 +108,26 @@ namespace wmoge {
         auto window = m_window_manager->create_window(window_info);
         WG_LOG_INFO("init window " << window_info.id);
 
-        m_gfx_driver = ioc->resolve_value<GfxDriver>();
+        m_gfx_driver = m_ioc_container->resolve_value<GfxDriver>();
 
-        m_shader_manager = ioc->resolve_value<ShaderManager>();
-        m_shader_manager->load_compilers();
+        m_shader_manager = m_ioc_container->resolve_value<ShaderManager>();
+        m_shader_manager->add_compiler(make_ref<GlslShaderCompilerVulkanMacOS>(m_ioc_container));
+        m_shader_manager->add_compiler(make_ref<GlslShaderCompilerVulkanLinux>(m_ioc_container));
+        m_shader_manager->add_compiler(make_ref<GlslShaderCompilerVulkanWindows>(m_ioc_container));
 
         m_asset_manager->load_loaders();
-        m_asset_manager->add_library(std::make_shared<AssetLibraryFileSystem>("", ioc));
+        m_asset_manager->add_library(std::make_shared<AssetLibraryFileSystem>("", m_ioc_container));
 
-        m_shader_library  = ioc->resolve_value<ShaderLibrary>();
-        m_pso_cache       = ioc->resolve_value<PsoCache>();
-        m_texture_manager = ioc->resolve_value<TextureManager>();
-        m_mesh_manager    = ioc->resolve_value<MeshManager>();
-        m_render_engine   = ioc->resolve_value<RenderEngine>();
-        m_ecs_registry    = ioc->resolve_value<EcsRegistry>();
-        m_scene_manager   = ioc->resolve_value<SceneManager>();
-        m_view_manager    = ioc->resolve_value<ViewManager>();
+        m_shader_library  = m_ioc_container->resolve_value<ShaderLibrary>();
+        m_pso_cache       = m_ioc_container->resolve_value<PsoCache>();
+        m_texture_manager = m_ioc_container->resolve_value<TextureManager>();
+        m_mesh_manager    = m_ioc_container->resolve_value<MeshManager>();
+        m_render_engine   = m_ioc_container->resolve_value<RenderEngine>();
+        m_ecs_registry    = m_ioc_container->resolve_value<EcsRegistry>();
+        m_scene_manager   = m_ioc_container->resolve_value<SceneManager>();
+        m_view_manager    = m_ioc_container->resolve_value<ViewManager>();
 
-        m_console->init();
+        m_console->init(m_asset_manager);
 
         m_config->get_bool(SID("engine.window.exit"), m_exit_on_close);
 
@@ -197,42 +187,30 @@ namespace wmoge {
         return m_close_requested.load();
     }
 
-    Application*     Engine::application() { return m_application; }
-    RttiTypeStorage* Engine::type_storage() { return m_type_storage; }
-    ClassDB*         Engine::class_db() { return m_class_db; }
-    Time*            Engine::time() { return m_time; }
-    HookList*        Engine::hook_list() { return m_hook_list; }
-    CmdLine*         Engine::cmd_line() { return m_cmd_line; }
-    DllManager*      Engine::dll_manager() { return m_dll_manager; }
-    PluginManager*   Engine::plugin_manager() { return m_plugin_manager; }
-    Config*          Engine::config() { return m_config; }
-    CallbackQueue*   Engine::main_queue() { return m_main_queue; }
-    FileSystem*      Engine::file_system() { return m_file_system; }
-    TaskManager*     Engine::task_manager() { return m_task_manager; }
-    AssetManager*    Engine::asset_manager() { return m_asset_manager; }
-    WindowManager*   Engine::window_manager() { return m_window_manager; }
-    Input*           Engine::input() { return m_input; }
-    GfxDriver*       Engine::gfx_driver() { return m_gfx_driver; }
-    ShaderManager*   Engine::shader_manager() { return m_shader_manager; }
-    ShaderLibrary*   Engine::shader_library() { return m_shader_library; }
-    PsoCache*        Engine::pso_cache() { return m_pso_cache; }
-    TextureManager*  Engine::texture_manager() { return m_texture_manager; }
-    MeshManager*     Engine::mesh_manager() { return m_mesh_manager; }
-    SceneManager*    Engine::scene_manager() { return m_scene_manager; }
-    Profiler*        Engine::profiler() { return m_profiler; }
-    Console*         Engine::console() { return m_console; }
-    ScriptSystem*    Engine::script_system() { return m_script_system; }
-    AudioEngine*     Engine::audio_engine() { return m_audio_engine; }
-    RenderEngine*    Engine::render_engine() { return m_render_engine; }
-    ViewManager*     Engine::view_manager() { return m_view_manager; }
-    EcsRegistry*     Engine::ecs_registry() { return m_ecs_registry; }
-
-    Engine* Engine::instance() {
-        return g_engine;
-    }
-
-    void Engine::provide(Engine* engine) {
-        g_engine = engine;
-    }
+    Application*    Engine::application() { return m_application; }
+    ClassDB*        Engine::class_db() { return m_class_db; }
+    Time*           Engine::time() { return m_time; }
+    DllManager*     Engine::dll_manager() { return m_dll_manager; }
+    PluginManager*  Engine::plugin_manager() { return m_plugin_manager; }
+    Config*         Engine::config() { return m_config; }
+    CallbackQueue*  Engine::main_queue() { return m_main_queue; }
+    FileSystem*     Engine::file_system() { return m_file_system; }
+    TaskManager*    Engine::task_manager() { return m_task_manager; }
+    AssetManager*   Engine::asset_manager() { return m_asset_manager; }
+    WindowManager*  Engine::window_manager() { return m_window_manager; }
+    Input*          Engine::input() { return m_input; }
+    GfxDriver*      Engine::gfx_driver() { return m_gfx_driver; }
+    ShaderManager*  Engine::shader_manager() { return m_shader_manager; }
+    ShaderLibrary*  Engine::shader_library() { return m_shader_library; }
+    PsoCache*       Engine::pso_cache() { return m_pso_cache; }
+    TextureManager* Engine::texture_manager() { return m_texture_manager; }
+    MeshManager*    Engine::mesh_manager() { return m_mesh_manager; }
+    SceneManager*   Engine::scene_manager() { return m_scene_manager; }
+    Profiler*       Engine::profiler() { return m_profiler; }
+    Console*        Engine::console() { return m_console; }
+    AudioEngine*    Engine::audio_engine() { return m_audio_engine; }
+    RenderEngine*   Engine::render_engine() { return m_render_engine; }
+    ViewManager*    Engine::view_manager() { return m_view_manager; }
+    EcsRegistry*    Engine::ecs_registry() { return m_ecs_registry; }
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/engine.hpp b/engine/runtime/system/engine.hpp
index b5fc7705b..5cdb87b6e 100644
--- a/engine/runtime/system/engine.hpp
+++ b/engine/runtime/system/engine.hpp
@@ -47,9 +47,9 @@ namespace wmoge {
      */
     class Engine {
     public:
-        Engine() = default;
+        Engine(class IocContainer* ioc_container);
 
-        Status setup(class Application* application);
+        Status setup();
         Status init();
         Status iteration();
         Status shutdown();
@@ -57,76 +57,64 @@ namespace wmoge {
         void request_close();
         bool close_requested() const;
 
-        class Application*     application();
-        class RttiTypeStorage* type_storage();
-        class ClassDB*         class_db();
-        class Time*            time();
-        class HookList*        hook_list();
-        class CmdLine*         cmd_line();
-        class DllManager*      dll_manager();
-        class PluginManager*   plugin_manager();
-        class Config*          config();
-        class CallbackQueue*   main_queue();
-        class FileSystem*      file_system();
-        class TaskManager*     task_manager();
-        class AssetManager*    asset_manager();
-        class WindowManager*   window_manager();
-        class Input*           input();
-        class GfxDriver*       gfx_driver();
-        class ShaderManager*   shader_manager();
-        class ShaderLibrary*   shader_library();
-        class PsoCache*        pso_cache();
-        class TextureManager*  texture_manager();
-        class MeshManager*     mesh_manager();
-        class SceneManager*    scene_manager();
-        class Profiler*        profiler();
-        class Console*         console();
-        class ScriptSystem*    script_system();
-        class AudioEngine*     audio_engine();
-        class RenderEngine*    render_engine();
-        class ViewManager*     view_manager();
-        class EcsRegistry*     ecs_registry();
-
-        static Engine* instance();
-        static void    provide(Engine* engine);
+        class Application*    application();
+        class ClassDB*        class_db();
+        class Time*           time();
+        class DllManager*     dll_manager();
+        class PluginManager*  plugin_manager();
+        class Config*         config();
+        class CallbackQueue*  main_queue();
+        class FileSystem*     file_system();
+        class TaskManager*    task_manager();
+        class AssetManager*   asset_manager();
+        class WindowManager*  window_manager();
+        class Input*          input();
+        class GfxDriver*      gfx_driver();
+        class ShaderManager*  shader_manager();
+        class ShaderLibrary*  shader_library();
+        class PsoCache*       pso_cache();
+        class TextureManager* texture_manager();
+        class MeshManager*    mesh_manager();
+        class SceneManager*   scene_manager();
+        class Profiler*       profiler();
+        class Console*        console();
+        class AudioEngine*    audio_engine();
+        class RenderEngine*   render_engine();
+        class ViewManager*    view_manager();
+        class EcsRegistry*    ecs_registry();
 
     private:
         std::atomic_bool m_close_requested{false};
         std::size_t      m_frame_id = 0;
 
-        class Application*     m_application     = nullptr;
-        class RttiTypeStorage* m_type_storage    = nullptr;
-        class ClassDB*         m_class_db        = nullptr;
-        class Time*            m_time            = nullptr;
-        class HookList*        m_hook_list       = nullptr;
-        class CmdLine*         m_cmd_line        = nullptr;
-        class DllManager*      m_dll_manager     = nullptr;
-        class PluginManager*   m_plugin_manager  = nullptr;
-        class Config*          m_config          = nullptr;
-        class CallbackQueue*   m_main_queue      = nullptr;
-        class FileSystem*      m_file_system     = nullptr;
-        class TaskManager*     m_task_manager    = nullptr;
-        class AssetManager*    m_asset_manager   = nullptr;
-        class WindowManager*   m_window_manager  = nullptr;
-        class Input*           m_input           = nullptr;
-        class GfxDriver*       m_gfx_driver      = nullptr;
-        class ShaderManager*   m_shader_manager  = nullptr;
-        class ShaderLibrary*   m_shader_library  = nullptr;
-        class PsoCache*        m_pso_cache       = nullptr;
-        class TextureManager*  m_texture_manager = nullptr;
-        class MeshManager*     m_mesh_manager    = nullptr;
-        class SceneManager*    m_scene_manager   = nullptr;
-        class Profiler*        m_profiler        = nullptr;
-        class Console*         m_console         = nullptr;
-        class ScriptSystem*    m_script_system   = nullptr;
-        class AudioEngine*     m_audio_engine    = nullptr;
-        class RenderEngine*    m_render_engine   = nullptr;
-        class ViewManager*     m_view_manager    = nullptr;
-        class EcsRegistry*     m_ecs_registry    = nullptr;
+        class Application*    m_application     = nullptr;
+        class ClassDB*        m_class_db        = nullptr;
+        class Time*           m_time            = nullptr;
+        class DllManager*     m_dll_manager     = nullptr;
+        class PluginManager*  m_plugin_manager  = nullptr;
+        class Config*         m_config          = nullptr;
+        class CallbackQueue*  m_main_queue      = nullptr;
+        class FileSystem*     m_file_system     = nullptr;
+        class TaskManager*    m_task_manager    = nullptr;
+        class AssetManager*   m_asset_manager   = nullptr;
+        class WindowManager*  m_window_manager  = nullptr;
+        class Input*          m_input           = nullptr;
+        class GfxDriver*      m_gfx_driver      = nullptr;
+        class ShaderManager*  m_shader_manager  = nullptr;
+        class ShaderLibrary*  m_shader_library  = nullptr;
+        class PsoCache*       m_pso_cache       = nullptr;
+        class TextureManager* m_texture_manager = nullptr;
+        class MeshManager*    m_mesh_manager    = nullptr;
+        class SceneManager*   m_scene_manager   = nullptr;
+        class Profiler*       m_profiler        = nullptr;
+        class Console*        m_console         = nullptr;
+        class AudioEngine*    m_audio_engine    = nullptr;
+        class RenderEngine*   m_render_engine   = nullptr;
+        class ViewManager*    m_view_manager    = nullptr;
+        class EcsRegistry*    m_ecs_registry    = nullptr;
+        class IocContainer*   m_ioc_container   = nullptr;
 
         bool m_exit_on_close = true;
-
-        static Engine* g_engine;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/scripting/script_native.cpp b/engine/runtime/system/game_application.cpp
similarity index 78%
rename from engine/runtime/scripting/script_native.cpp
rename to engine/runtime/system/game_application.cpp
index 588c0d081..85783d462 100644
--- a/engine/runtime/scripting/script_native.cpp
+++ b/engine/runtime/system/game_application.cpp
@@ -25,24 +25,35 @@
 /* SOFTWARE.                                                                      */
 /**********************************************************************************/
 
-#include "script_native.hpp"
+#include "game_application.hpp"
+
+#include "system/engine.hpp"
 
 namespace wmoge {
 
-    ScriptNativeInstance::ScriptNativeInstance(Ref<Script> script, Object* object, ScriptFunctionsMask mask) {
-        m_script = std::move(script);
-        m_object = object;
-        m_mask   = mask;
+    GameApplication::GameApplication(GameApplicationConfig& config) : Application(config) {
+    }
+
+    Status GameApplication::on_register() {
+        m_engine = m_config.ioc->resolve_value<Engine>();
+
+        return m_engine->setup();
     }
 
-    ScriptFunctionsMask ScriptNativeInstance::get_mask() {
-        return m_mask;
+    Status GameApplication::on_init() {
+        return m_engine->init();
     }
-    Script* ScriptNativeInstance::get_script() {
-        return m_script.get();
+
+    Status GameApplication::on_loop() {
+        return m_engine->iteration();
+    }
+
+    Status GameApplication::on_shutdown() {
+        return m_engine->shutdown();
     }
-    Object* ScriptNativeInstance::get_owner() {
-        return m_object;
+
+    bool GameApplication::should_close() {
+        return m_engine->close_requested();
     }
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/hooks/hook_config.hpp b/engine/runtime/system/game_application.hpp
similarity index 77%
rename from engine/runtime/hooks/hook_config.hpp
rename to engine/runtime/system/game_application.hpp
index 2b26e4b22..455b9dd63 100644
--- a/engine/runtime/hooks/hook_config.hpp
+++ b/engine/runtime/system/game_application.hpp
@@ -27,31 +27,34 @@
 
 #pragma once
 
-#include "core/cmd_line.hpp"
-#include "system/config.hpp"
-#include "system/hook.hpp"
-#include "system/ioc_container.hpp"
+#include "system/application.hpp"
 
 namespace wmoge {
 
-    /** 
-     * @class HookConfig
-     * @brief Engine hook to setup common config workflow
-     */
-    class HookConfig : public Hook {
-    public:
-        ~HookConfig() override = default;
+    /**
+     * @class GameApplication
+     * @brief Game app config
+    */
+    struct GameApplicationConfig : ApplicationConfig {
+        std::string game_info;
+    };
 
-        std::string get_name() const override {
-            return "config";
-        }
+    /**
+     * @class GameApplication
+     * @brief Base class for application to run stand-alone game
+    */
+    class GameApplication : public Application {
+    public:
+        GameApplication(GameApplicationConfig& config);
 
-        void on_add_cmd_line_options(CmdLine& cmd_line) override {
-        }
+        Status on_register() override;
+        Status on_init() override;
+        Status on_loop() override;
+        Status on_shutdown() override;
+        bool   should_close() override;
 
-        Status on_process(CmdLine& cmd_line) override {
-            return WG_OK;
-        }
+    protected:
+        class Engine* m_engine = nullptr;
     };
 
 }// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/hook.cpp b/engine/runtime/system/hook.cpp
deleted file mode 100644
index b2dcb9851..000000000
--- a/engine/runtime/system/hook.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#include "hook.hpp"
-
-#include <algorithm>
-#include <cassert>
-
-namespace wmoge {
-
-    void HookList::attach(HookPtr hook) {
-        assert(hook);
-        m_storage.push_back(std::move(hook));
-        m_storage.back()->on_attach();
-    }
-
-    void HookList::remove(HookPtr hook) {
-        assert(hook);
-        m_storage.erase(std::find(m_storage.begin(), m_storage.end(), hook));
-    }
-
-    void HookList::clear() {
-        m_storage.clear();
-    }
-
-}// namespace wmoge
diff --git a/engine/runtime/system/hook.hpp b/engine/runtime/system/hook.hpp
deleted file mode 100644
index b54cd52bd..000000000
--- a/engine/runtime/system/hook.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**********************************************************************************/
-/* Wmoge game engine                                                              */
-/* Available at github https://github.com/EgorOrachyov/wmoge                      */
-/**********************************************************************************/
-/* MIT License                                                                    */
-/*                                                                                */
-/* Copyright (c) 2023 Egor Orachyov                                               */
-/*                                                                                */
-/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
-/* of this software and associated documentation files (the "Software"), to deal  */
-/* in the Software without restriction, including without limitation the rights   */
-/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
-/* copies of the Software, and to permit persons to whom the Software is          */
-/* furnished to do so, subject to the following conditions:                       */
-/*                                                                                */
-/* The above copyright notice and this permission notice shall be included in all */
-/* copies or substantial portions of the Software.                                */
-/*                                                                                */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
-/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
-/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
-/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
-/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
-/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
-/* SOFTWARE.                                                                      */
-/**********************************************************************************/
-
-#pragma once
-
-#include "core/cmd_line.hpp"
-#include "core/status.hpp"
-
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace wmoge {
-
-    /**
-     * @class Hook
-     * @brief Interface for an engine hook to perform some actions on lower engine levels
-     */
-    class Hook {
-    public:
-        virtual ~Hook() = default;
-
-        virtual std::string get_name() const { return ""; }
-        virtual void        on_attach() {}
-        virtual void        on_add_cmd_line_options(CmdLine& cmd_line) {}
-        virtual Status      on_process(CmdLine& cmd_line) { return WG_OK; }
-    };
-
-    /** 
-     * @class HookList
-     * @brief Storage for application hooks
-     */
-    class HookList {
-    public:
-        HookList()                = default;
-        HookList(const HookList&) = delete;
-        HookList(HookList&&)      = delete;
-        ~HookList()               = default;
-
-        using HookPtr     = std::shared_ptr<Hook>;
-        using HookStorage = std::vector<HookPtr>;
-
-        template<typename F>
-        void each(F&& f);
-
-        void attach(HookPtr hook);
-        void remove(HookPtr hook);
-        void clear();
-
-    private:
-        HookStorage m_storage;
-    };
-
-    template<typename F>
-    inline void HookList::each(F&& f) {
-        for (auto& hook : m_storage) {
-            if (f(hook)) { break; }
-        }
-    }
-
-}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/hooks.cpp b/engine/runtime/system/hooks.cpp
new file mode 100644
index 000000000..03814e5d8
--- /dev/null
+++ b/engine/runtime/system/hooks.cpp
@@ -0,0 +1,224 @@
+/**********************************************************************************/
+/* Wmoge game engine                                                              */
+/* Available at github https://github.com/EgorOrachyov/wmoge                      */
+/**********************************************************************************/
+/* MIT License                                                                    */
+/*                                                                                */
+/* Copyright (c) 2023 Egor Orachyov                                               */
+/*                                                                                */
+/* Permission is hereby granted, free of charge, to any person obtaining a copy   */
+/* of this software and associated documentation files (the "Software"), to deal  */
+/* in the Software without restriction, including without limitation the rights   */
+/* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      */
+/* copies of the Software, and to permit persons to whom the Software is          */
+/* furnished to do so, subject to the following conditions:                       */
+/*                                                                                */
+/* The above copyright notice and this permission notice shall be included in all */
+/* copies or substantial portions of the Software.                                */
+/*                                                                                */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     */
+/* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       */
+/* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    */
+/* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         */
+/* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  */
+/* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  */
+/* SOFTWARE.                                                                      */
+/**********************************************************************************/
+
+#include "hooks.hpp"
+
+#include "core/log.hpp"
+#include "core/uuid.hpp"
+#include "io/enum.hpp"
+#include "platform/common/mount_volume_physical.hpp"
+#include "platform/file_system.hpp"
+#include "platform/time.hpp"
+#include "profiler/profiler.hpp"
+#include "system/application.hpp"
+#include "system/config.hpp"
+#include "system/console.hpp"
+
+namespace wmoge {
+
+    void EngineCmdLineHooks::hook_uuid_gen(CmdLineOptions& options, CmdLineHookList& list) {
+        options.add_int("gen_uuids", "gen desired count of uuids' values and outputs them", "0");
+
+        list.add([](CmdLineParseResult& result) {
+            const int uuid_count = result.get_int("gen_uuids");
+
+            if (uuid_count > 0) {
+                for (int i = 0; i < uuid_count; i++) {
+                    std::cout << UUID::generate() << std::endl;
+                }
+                return StatusCode::ExitCode0;
+            }
+
+            return WG_OK;
+        });
+    }
+
+    void EngineCmdLineHooks::hook_root_remap(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc) {
+        options.add_string("root_remap", "remap path to game root folder", "");
+
+        list.add([ioc](CmdLineParseResult& result) {
+            FileSystem* file_system = ioc->resolve_value<FileSystem>();
+
+            const std::string root_remap = result.get_string("root_remap");
+
+            if (!root_remap.empty()) {
+                file_system->root(root_remap);
+                std::cout << "remap game exe root direcory to " << root_remap << std::endl;
+            }
+
+            return WG_OK;
+        });
+    }
+
+    void EngineCmdLineHooks::hook_root_engine(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc) {
+        options.add_string("game_config", "path to game config folder", "config/");
+        options.add_string("engine_config", "path to engine config folder", "engine/config/");
+        options.add_string("engine_remap", "remap for engine directory (for debug mostly)", "engine/");
+
+        list.add([ioc](CmdLineParseResult& result) {
+            Config*     config      = ioc->resolve_value<Config>();
+            FileSystem* file_system = ioc->resolve_value<FileSystem>();
+
+            const bool                  mount_front = true;
+            const std::filesystem::path root_path   = file_system->root_path();
+
+            Ref<MountVolumePhysical> volume_engine = make_ref<MountVolumePhysical>(root_path / result.get_string("engine_remap"), "engine/");
+            file_system->add_mounting({"engine/", std::move(volume_engine)}, mount_front);
+
+            Ref<MountVolumePhysical> volume_local = make_ref<MountVolumePhysical>(root_path / ".wgengine", "local/");
+            file_system->add_mounting({"local/", std::move(volume_local)}, mount_front);
+
+            Ref<MountVolumePhysical> volume_logs = make_ref<MountVolumePhysical>(root_path / ".wgengine/logs", "logs/");
+            file_system->add_mounting({"logs/", std::move(volume_logs)}, mount_front);
+
+            Ref<MountVolumePhysical> volume_debug = make_ref<MountVolumePhysical>(root_path / ".wgengine/debug", "debug/");
+            file_system->add_mounting({"debug/", std::move(volume_debug)}, mount_front);
+
+            Ref<MountVolumePhysical> volume_cache = make_ref<MountVolumePhysical>(root_path / ".wgengine/cache", "cache/");
+            file_system->add_mounting({"cache/", std::move(volume_cache)}, mount_front);
+
+            const std::string game_config   = result.get_string("game_config");
+            const std::string engine_config = result.get_string("engine_config");
+
+            if (!config->load(engine_config + "/engine.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load engine engine.cfg file, check your configuration file or path" << std::endl;
+            }
+            if (!config->load(engine_config + "/game.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load engine game.cfg file, check your configure file of path" << std::endl;
+            }
+            if (!config->load(engine_config + "/cvars.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load engine cvars.cfg file, check your configure file of path" << std::endl;
+            }
+
+            if (!config->load(game_config + "/engine.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load game engine.cfg file, check your configuration file or path" << std::endl;
+            }
+            if (!config->load(game_config + "/game.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load game game.cfg file, check your configure file of path" << std::endl;
+            }
+            if (!config->load(game_config + "/cvars.cfg", ConfigStackMode::Overwrite)) {
+                std::cerr << "failed to load game cvars.cfg file, check your configure file of path" << std::endl;
+            }
+
+            return WG_OK;
+        });
+    }
+
+    void EngineCmdLineHooks::hook_root_logs(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc) {
+        options.add_bool("disable_logs", "disable all logs entirely (overrides config)", "false");
+
+        list.add([ioc](CmdLineParseResult& result) {
+            Config*     config      = ioc->resolve_value<Config>();
+            FileSystem* file_system = ioc->resolve_value<FileSystem>();
+            Console*    console     = ioc->resolve_value<Console>();
+            Time*       time        = ioc->resolve_value<Time>();
+
+            const bool no_logs = result.get_bool("disable_logs");
+            if (no_logs) {
+                return WG_OK;
+            }
+
+            const bool log_to_out     = config->get_bool_or_default(SID("engine.log_to_out"), true);
+            const bool log_to_file    = config->get_bool_or_default(SID("engine.log_to_file"), true);
+            const bool log_to_console = config->get_bool_or_default(SID("engine.log_to_console"), true);
+
+            const auto log_to_out_level     = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_out_level"), "Info"));
+            const auto log_to_file_level    = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_file_level"), "Info"));
+            const auto log_to_console_level = Enum::parse<LogLevel>(config->get_string_or_default(SID("engine.log_to_console_level"), "Info"));
+
+            if (log_to_file) {
+                auto log_name            = "file";
+                auto file                = LogListenerStream::open_file(file_system, LogListenerStream::make_file_name(time, log_name));
+                auto log_listener_stream = std::make_shared<LogListenerStream>(std::move(file), log_name, log_to_file_level);
+                Log::instance()->listen(log_listener_stream);
+                WG_LOG_INFO("attach file log listener");
+            }
+            if (log_to_out) {
+                auto log_listener_stdout = std::make_shared<LogListenerStdout>("out", log_to_out_level);
+                Log::instance()->listen(log_listener_stdout);
+                WG_LOG_INFO("attach stdout log listener");
+            }
+            if (log_to_console) {
+                auto log_listener_console = std::make_shared<LogListenerConsole>(console, log_to_console_level);
+                Log::instance()->listen(log_listener_console);
+                WG_LOG_INFO("attach console log listener");
+            }
+
+            return WG_OK;
+        });
+    }
+
+    void EngineCmdLineHooks::hook_root_profiler(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc, ApplicationSignals* app_signals) {
+        options.add_bool("profiler", "enable cpu profiler hook", "false");
+
+        struct Captures {
+            std::shared_ptr<ProfilerCapture> startup;
+            std::shared_ptr<ProfilerCapture> runtime;
+            std::shared_ptr<ProfilerCapture> shutdown;
+        };
+
+        list.add([ioc, app_signals, captures = std::make_shared<Captures>()](CmdLineParseResult& result) {
+            Config*   config   = ioc->resolve_value<Config>();
+            Profiler* profiler = ioc->resolve_value<Profiler>();
+
+            bool enable_profiler = false;
+
+            enable_profiler = enable_profiler || result.get_bool("profiler");
+            enable_profiler = enable_profiler || config->get_bool_or_default(SID("profiler.enable"), false);
+
+            profiler->set_enabled(enable_profiler);
+
+            if (enable_profiler) {
+                WG_LOG_INFO("attach cpu performance profiler");
+
+                profiler->configure(ioc);
+
+                app_signals->before_init.bind([=]() {
+                    WG_PROFILE_CAPTURE_START(captures->startup, startup, "debug/profile_startup.json");
+                });
+                app_signals->after_init.bind([=]() {
+                    WG_PROFILE_CAPTURE_END(captures->startup);
+                });
+                app_signals->before_loop.bind([=]() {
+                    WG_PROFILE_CAPTURE_START(captures->runtime, runtime, "debug/profile_runtime.json");
+                });
+                app_signals->after_loop.bind([=]() {
+                    WG_PROFILE_CAPTURE_END(captures->runtime);
+                });
+                app_signals->before_shutdown.bind([=]() {
+                    WG_PROFILE_CAPTURE_START(captures->shutdown, shutdown, "debug/profile_shutdown.json");
+                });
+                app_signals->after_shutdown.bind([=]() {
+                    WG_PROFILE_CAPTURE_END(captures->shutdown);
+                });
+            }
+
+            return WG_OK;
+        });
+    }
+
+}// namespace wmoge
diff --git a/engine/runtime/scripting/lua/lua_type_traits.hpp b/engine/runtime/system/hooks.hpp
similarity index 75%
rename from engine/runtime/scripting/lua/lua_type_traits.hpp
rename to engine/runtime/system/hooks.hpp
index f33e36879..998c73776 100644
--- a/engine/runtime/scripting/lua/lua_type_traits.hpp
+++ b/engine/runtime/system/hooks.hpp
@@ -25,32 +25,24 @@
 /* SOFTWARE.                                                                      */
 /**********************************************************************************/
 
-#ifndef WMOGE_LUA_TYPE_TRAITS_HPP
-#define WMOGE_LUA_TYPE_TRAITS_HPP
+#pragma once
 
-#include "scripting/lua/lua_defs.hpp"
-
-#include "core/ref.hpp"
-#include "core/string_id.hpp"
-#include "core/var.hpp"
-#include "math/mat.hpp"
-#include "math/quat.hpp"
-#include "math/vec.hpp"
+#include "core/cmd_line.hpp"
+#include "core/ioc_container.hpp"
 
 namespace wmoge {
 
     /**
-     * @class LuaTypeTraits
-     * @brief Utility class to simplify common engine primitive types marshaling
+     * @class EngineCmdLineHooks
+     * @brief Provides common comand line hooks
      */
-    class LuaTypeTraits {
+    class EngineCmdLineHooks {
     public:
-        static Strid             to_sid(luabridge::LuaRef& ref);
-        static Var               to_var(luabridge::LuaRef& ref);
-        static luabridge::LuaRef from_object(lua_State* state, Object* object);
-        static luabridge::LuaRef from_var(lua_State* state, const Var& var);
+        static void hook_uuid_gen(CmdLineOptions& options, CmdLineHookList& list);
+        static void hook_root_remap(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc);
+        static void hook_root_engine(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc);
+        static void hook_root_logs(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc);
+        static void hook_root_profiler(CmdLineOptions& options, CmdLineHookList& list, IocContainer* ioc, struct ApplicationSignals* app_signals);
     };
 
-}// namespace wmoge
-
-#endif//WMOGE_LUA_TYPE_TRAITS_HPP
+}// namespace wmoge
\ No newline at end of file
diff --git a/engine/runtime/system/plugin_manager.cpp b/engine/runtime/system/plugin_manager.cpp
index 8c89b8324..55f2bbacb 100644
--- a/engine/runtime/system/plugin_manager.cpp
+++ b/engine/runtime/system/plugin_manager.cpp
@@ -27,8 +27,8 @@
 
 #include "plugin_manager.hpp"
 
+#include "core/ioc_container.hpp"
 #include "core/log.hpp"
-#include "system/ioc_container.hpp"
 
 namespace wmoge {
 
diff --git a/template/main.cpp b/template/main.cpp
index 00bfb78c1..82549ec1c 100644
--- a/template/main.cpp
+++ b/template/main.cpp
@@ -27,6 +27,9 @@
 
 #include <engine.hpp>
 
+#include "io/stream_file.hpp"
+#include "io/tree_yaml.hpp"
+
 #include "assimp_plugin.hpp"
 #include "freetype_plugin.hpp"
 #include "runtime_plugin.hpp"
@@ -75,10 +78,11 @@ using namespace wmoge;
 
 class TemplateApplication : public GameApplication {
 public:
-    ~TemplateApplication() override = default;
+    TemplateApplication(GameApplicationConfig& config) : GameApplication(config) {
+    }
 
     Status on_register() override {
-        PluginManager* plugin_manager = IocContainer::iresolve_v<PluginManager>();
+        PluginManager* plugin_manager = m_config.ioc->resolve_value<PluginManager>();
         plugin_manager->add<RuntimePlugin>();
         plugin_manager->add<AssimpPlugin>();
         plugin_manager->add<FreetypePlugin>();
@@ -94,11 +98,11 @@ class TemplateApplication : public GameApplication {
 
         GameApplication::on_init();
 
-        mesh = Engine::instance()->asset_manager()->load(SID("assets/mesh/suzanne")).cast<Mesh>();
+        mesh = m_engine->asset_manager()->load(SID("assets/mesh/suzanne")).cast<Mesh>();
 
         // Engine::instance()->scene_manager()->change(scene);
 
-        ShaderStructRegister rdc(SID("CanvasDrawCmd"), 80, Engine::instance()->shader_manager());
+        ShaderStructRegister rdc(SID("CanvasDrawCmd"), 80, m_engine->shader_manager());
         rdc
                 .add_field(SID("Transform0"), ShaderTypes::VEC4)
                 .add_field(SID("Transform1"), ShaderTypes::VEC4)
@@ -110,12 +114,12 @@ class TemplateApplication : public GameApplication {
                 .add_field(SID("Padding2"), ShaderTypes::INT)
                 .finish();
 
-        ShaderStructRegister rdcs(SID("CanvasDrawCmdsBuffer"), 0, Engine::instance()->shader_manager());
+        ShaderStructRegister rdcs(SID("CanvasDrawCmdsBuffer"), 0, m_engine->shader_manager());
         rdcs
                 .add_field_array(SID("DrawCmds"), SID("CanvasDrawCmd"))
                 .finish();
 
-        shader = Engine::instance()->asset_manager()->load(SID("engine/shaders/canvas")).cast<Shader>();
+        shader = m_engine->asset_manager()->load(SID("engine/shaders/canvas")).cast<Shader>();
 
         ShaderParamId p_clip_proj_view = shader->find_param_id(SID("ClipProjView"));
         ShaderParamId p_inverse_gamma  = shader->find_param_id(SID("InverseGamma"));
@@ -125,7 +129,20 @@ class TemplateApplication : public GameApplication {
         block.set_var(p_inverse_gamma, 1.0f / 4.0f);
         // block.validate(Engine::instance()->gfx_driver(), Engine::instance()->gfx_ctx());
 
-        Engine* engine = Engine::instance();
+        Engine* engine = m_engine;
+
+        // IoContext context;
+        // context.add<ShaderManager*>(Engine::instance()->shader_manager());
+        // IoYamlTree   tree;
+        // IoStreamFile stream;
+        // std::string  content;
+
+        // WG_CHECKED(tree.create_tree());
+        // WG_TREE_WRITE(context, tree, shader->get_reflection());
+        // WG_CHECKED(tree.save_tree(content));
+        // WG_CHECKED(Engine::instance()->file_system()->save_file("canvas.reflection.yaml", content));
+        // WG_CHECKED(stream.open("canvas.reflection.bin", {FileOpenMode::Out, FileOpenMode::Binary}));
+        // WG_ARCHIVE_WRITE(context, stream, shader->get_reflection());
 
         WG_LOG_INFO("init");
         return StatusCode::Ok;
@@ -134,7 +151,7 @@ class TemplateApplication : public GameApplication {
     void debug_draw() {
         WG_AUTO_PROFILE(app, "TemplateApplication::debug_draw");
 
-        Engine*        engine         = Engine::instance();
+        Engine*        engine         = m_engine;
         ShaderManager* shader_manager = engine->shader_manager();
 
         ShaderPermutation permutation;
@@ -197,6 +214,24 @@ class TemplateApplication : public GameApplication {
 };
 
 int main(int argc, const char* const* argv) {
-    TemplateApplication app;
-    return app.run(argc, argv);
+    IocContainer    ioc_containter;
+    CmdLineOptions  options("template-app", "wmoge engine template app for testing");
+    CmdLineHookList hooks;
+
+    GameApplicationConfig app_config;
+    app_config.name             = "test app";
+    app_config.ioc              = &ioc_containter;
+    app_config.cmd_line.options = &options;
+    app_config.cmd_line.hooks   = &hooks;
+    app_config.cmd_line.line    = CmdLineUtil::to_string(argc, argv);
+    app_config.cmd_line.args    = CmdLineUtil::to_vector(argc, argv);
+
+    EngineCmdLineHooks::hook_uuid_gen(options, hooks);
+    EngineCmdLineHooks::hook_root_remap(options, hooks, &ioc_containter);
+    EngineCmdLineHooks::hook_root_engine(options, hooks, &ioc_containter);
+    EngineCmdLineHooks::hook_root_logs(options, hooks, &ioc_containter);
+    EngineCmdLineHooks::hook_root_profiler(options, hooks, &ioc_containter, &app_config.signals);
+
+    TemplateApplication app(app_config);
+    return app.run();
 }
\ No newline at end of file