diff --git a/.255.cache.bin b/.255.cache.bin
new file mode 100644
index 000000000..43721a4a6
Binary files /dev/null and b/.255.cache.bin differ
diff --git a/.gitmodules b/.gitmodules
index f454c8c3c..a0a21affc 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,3 @@
-[submodule "modules/thirdparty-yaml-cpp/yaml-cppmodules/thirdparty-yaml-cpp/yaml-cpp"]
-	path = modules/thirdparty-yaml-cpp/yaml-cppmodules/thirdparty-yaml-cpp/yaml-cpp
-	url = https://github.com/EldarMuradov/yaml-cpp.git
 [submodule "modules/thirdparty-yaml-cpp/yaml-cpp"]
 	path = modules/thirdparty-yaml-cpp/yaml-cpp
 	url = https://github.com/EldarMuradov/yaml-cpp.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d3ad87f71..580741eae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.12)
 set(ERA_ENGINE_PATH ${CMAKE_SOURCE_DIR})
 
 include(cmake/common.cmake)
+include(cmake/deploy.cmake)
 
 project(EraEngine VERSION 1.0)
 
@@ -17,5 +18,9 @@ add_subdirectory(modules/physics)
 
 add_subdirectory(apps/editor)
 add_subdirectory(apps/example_game)
+add_subdirectory(apps/assets_compiler)
+
+era_add_deploy_target(editor)
+era_add_deploy_target(example_game)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
\ No newline at end of file
diff --git a/README.md b/README.md
index cd811272c..c96c3918c 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,151 @@
-# Engine
\ No newline at end of file
+
+![EraEngine Logo](https://github.com/EldarMuradov/EldarMuradov/blob/a4d76f9ec241f35d76237f3e637cbf1921de5d2d/Editor.png)
+
+![EraEngine Logo](https://github.com/EldarMuradov/EldarMuradov/blob/99a6272b7b5f123c8f20b7c39f773714f79810cd/MESH_EDITOR.png)
+
+![EraEngine Logo](https://github.com/EldarMuradov/EldarMuradov/blob/56c453501a5edb8bdbd7747548e99b94ff188e14/AKT2.png)
+
+
+# Era Game Engine
+
+[![C++](https://img.shields.io/badge/language-C%2B%2B-%23f34b7d.svg?style=plastic)](https://en.wikipedia.org/wiki/C%2B%2B) 
+[![x64](https://img.shields.io/badge/arch-x64-red.svg?style=plastic)](https://en.wikipedia.org/wiki/X64) 
+
+<a href="https://github.com/EldarMuradov/EraEngine"><img alt="platforms" src="https://img.shields.io/badge/platforms-Windows-blue?style=flat-square"/></a>
+
+![Build workflow](https://github.com/EldarMuradov/EraEngine/actions/workflows/cmake-windows-platform.yml/badge.svg)
+
+# About
+
+Era Engine is a modern ECS-based game engine that provides developers with powerful tools for creating 2D/3D games. It includes the following features and functionality:
+
+### Entity Component System:
+Era Engine uses ECS to manage game objects and their behavior. This allows developers to easily create and modify complex systems in the game.
+
+### Rendering: 
+The engine uses DirectX 12 to provide high-quality and efficient rendering, allowing you to create visually appealing games with advanced graphical effects. DLSS 3.5 and FSR 2.0 supported.
+
+### Physics: 
+Integration with PhysX 5.3.1 and CUDA provides realistic simulation of game physics, including collisions, GJK (overlapping, raycasting etc), gravity, aggregates, articulations, soft bodies, GPU particles, GPU clothes, joints, Blast Physics Destructions, Mesh destructions, ragdolls, vehicles, CPU-based tasks, physics event system etc.
+
+### User Interface: 
+ImGui is integrated into the engine to create intuitive and customizable user interfaces in games. 
+
+## Audio:
+Engine provides API and tools to work with 3D Audio. You can customize all audio settings and preferences to create realistic high quality sounds. 
+
+### Scripting: 
+Era Engine uses .NET 8.0 Native AOT and Runtime. This allows developers to write scripts in C# with all the benefits of .NET, including high performance and a rich class library.
+
+# Dependencies
+
+-PhysX 5.3.1
+
+-DirectX 12
+
+-EnTT
+
+-ImGUI
+
+-CUDA
+
+-Blast
+
+-.NET 8.0 (Native AOT and Runtime)
+
+# Features
+
+-Real-time raytracing (DXR)
+
+-DLSS 3.5
+
+-FSR 2.0
+
+-Rigidbodies and colliders
+
+-Fluid Physics 
+
+-Blast Physics Destructions
+
+-PBR Rendering 
+
+-GPU PBD Particle Systems
+
+-GPU PBD Clothing Systems
+
+-Physics Joints
+
+-Physics Aggregates
+
+-CPU Tasks
+
+-GPU Physics
+
+-Forward rendering
+
+-Decals
+
+-Material editing
+
+-ECS
+
+-Horizon-based ambient occlusion
+
+-Screen space shadows
+
+-CCD
+
+-Skeletal animation
+
+-Editor
+
+-MSAA
+
+-Building
+
+-Spot lights
+
+-Resource system
+
+-Temporal anti-aliasing
+
+-Mesh shaders
+
+-Mesh and Audio Editors
+
+-Scene management
+
+-Saving system
+
+-Undoable components
+
+-Custom physics engine
+
+-.NET 8 scripting
+
+-Job system
+
+-Screen space reflections
+
+-Path tracing
+
+-Cascaded shadow maps
+
+-GI
+
+-Point lights
+
+-Audio system
+
+-Child-parent system
+
+-Post processing
+
+# TODO:
+
+-Console support
+
+-Networking components
+
+
+Some other researches and repositories were used while developing game engine. Thanks P. Kurth, O. Ocornut, M. Caini, NVIDIA, Ubisoft and Microsoft.
diff --git a/apps/assets_compiler/CMakeLists.txt b/apps/assets_compiler/CMakeLists.txt
new file mode 100644
index 000000000..a6fc7163f
--- /dev/null
+++ b/apps/assets_compiler/CMakeLists.txt
@@ -0,0 +1,12 @@
+include(${CMAKE_SOURCE_DIR}/cmake/common.cmake)
+
+era_begin(assets_compiler "APP")
+    require_thirdparty_module(assets_compiler EnTT)
+    require_thirdparty_module(assets_compiler yaml-cpp)
+    require_thirdparty_module(assets_compiler rttr_core)
+    require_thirdparty_module(assets_compiler DirectXTex)
+    require_module(assets_compiler base)
+    require_module(assets_compiler core)
+
+    target_include_directories(assets_compiler PUBLIC modules/thirdparty-imgui/imgui)
+era_end(assets_compiler)
\ No newline at end of file
diff --git a/apps/assets_compiler/src/compiler/main.cpp b/apps/assets_compiler/src/compiler/main.cpp
new file mode 100644
index 000000000..e946b3459
--- /dev/null
+++ b/apps/assets_compiler/src/compiler/main.cpp
@@ -0,0 +1,90 @@
+// Copyright (c) 2023-present Eldar Muradov. All rights reserved.
+#include <fstream>
+#include <iostream>
+
+#include <clara/clapa.hpp>
+
+#include <asset/bin.h>
+#include <asset/model_asset.h>
+
+#include <core/log.h>
+#include <core/string.h>
+
+int main(int argc, char** argv)
+{
+	using namespace era_engine;
+	using namespace clara;
+
+	try
+	{
+		fs::path path;
+		bool verbose = false;
+
+		Parser cli;
+		cli += Opt(verbose, "verbose")["-v"]["--verbose"]("Enable verbose logging");
+		cli += Opt(path, "path")["-p"]["--path"]("Path to asset");
+
+		auto result = cli.parse(Args(argc, argv));
+		if (!result)
+		{
+			std::cerr << "Error in command line: " << result.errorMessage() << std::endl;
+		}
+
+		path = get_full_path(path);
+
+		if (!fs::exists(path))
+		{
+			std::cerr << "Could not find file '" << path << "'.\n";
+			return EXIT_FAILURE;
+		}
+
+		std::string extension = path.extension().string();
+
+		fs::path cached_filename = path;
+		cached_filename.replace_extension("." + std::to_string(mesh_flag_default) + ".cache.bin");
+		fs::path cache_filepath = L"asset_cache" / cached_filename;
+
+		if (fs::exists(cache_filepath))
+		{
+			auto last_cache_write_time = fs::last_write_time(cache_filepath);
+			auto last_original_write_time = fs::last_write_time(path);
+
+			if (last_cache_write_time > last_original_write_time)
+			{
+				std::cout << "Asset is already compiled! \n";
+				return EXIT_SUCCESS;
+			}
+		}
+
+		std::cout << "Preprocessing asset '" << path << "' for faster loading next time.\n";
+
+		ModelAsset result_mesh;
+
+		std::transform(extension.begin(), extension.end(), extension.begin(),
+			[](char c) { return std::tolower(c); });
+		if (extension == ".fbx")
+		{
+			result_mesh = loadFBX(path, mesh_flag_default);
+		}
+		else if (extension == ".obj")
+		{
+			result_mesh = loadOBJ(path, mesh_flag_default);
+		}
+
+		fs::create_directories(cache_filepath.parent_path());
+		writeBIN(result_mesh, cache_filepath);
+	}
+	catch (const std::exception& ex)
+	{
+		std::cerr << ex.what() << "\n";
+
+		std::ofstream output("logs/compiler_error_log.txt");
+		output << "Runtime Error>" << ex.what() << std::endl;
+		output.close();
+
+		std::this_thread::sleep_for(std::chrono::duration<float>(5000.0f));
+		return EXIT_FAILURE;
+	}
+
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/apps/editor/CMakeLists.txt b/apps/editor/CMakeLists.txt
index 00158832e..d2ad66fb7 100644
--- a/apps/editor/CMakeLists.txt
+++ b/apps/editor/CMakeLists.txt
@@ -1,6 +1,10 @@
 include(${CMAKE_SOURCE_DIR}/cmake/common.cmake)
 
 era_begin(editor "APP")
+    require_thirdparty_module(editor EnTT)
+    require_thirdparty_module(editor yaml-cpp)
+    require_thirdparty_module(editor rttr_core)
+    require_thirdparty_module(editor DirectXTex)
     require_module(editor base)
     require_module(editor core)
     require_module(editor physics)
diff --git a/apps/editor/src/editor/drag_n_drop_system.cpp b/apps/editor/src/editor/drag_n_drop_system.cpp
new file mode 100644
index 000000000..9085c208e
--- /dev/null
+++ b/apps/editor/src/editor/drag_n_drop_system.cpp
@@ -0,0 +1,77 @@
+#include "editor/drag_n_drop_system.h"
+#include "editor/file_utils.h"
+
+#include <engine/engine.h>
+
+#include <core/editor_icons.h>
+#include <core/imgui.h>
+
+#include <rendering/ecs/renderer_holder_root_component.h>
+
+#include <ecs/update_groups.h>
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include <imgui/imgui_draw.cpp>
+#include <imgui/imgui.cpp>
+#include <imgui/imgui_widgets.cpp>
+#include <imgui/imgui_demo.cpp>
+#include <imgui/imgui_tables.cpp>
+#include <imgui/imgui_internal.h>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<DragNDropSystem>("DragNDropSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("update", &DragNDropSystem::update)(metadata("update_group", update_types::INPUT), metadata("After", std::vector<std::string>{"InputSystem::update"}));
+	}
+
+	DragNDropSystem::DragNDropSystem(World* _world)
+		: System(_world)
+	{
+
+	}
+
+	DragNDropSystem::~DragNDropSystem()
+	{
+	}
+
+	void DragNDropSystem::init()
+	{
+		renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
+	}
+
+	void DragNDropSystem::update(float dt)
+	{
+		//float render_width = static_cast<float>(renderer_holder_rc->width);
+		//float render_height = static_cast<float>(renderer_holder_rc->height);
+
+		//// The drag&drop outline is rendered around the drop target. Since the image fills the frame, the outline is outside the window 
+		//// and thus invisible. So instead this (slightly smaller) Dummy acts as the drop target.
+		//// Important: This is below the input processing, so that we don't override the current element id.
+		//ImGui::SetCursorPos(ImVec2(4.5f, 4.5f));
+		//ImGui::Dummy(ImVec2(render_width - 9.0f, render_height - 9.0f));
+		//
+		//if (ImGui::BeginDragDropTarget())
+		//{
+		//	if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(EDITOR_ICON_MESH))
+		//	{
+		//		EditorFileUtils::handle_file_drop((const char*)payload->Data, world);
+		//	}
+		//	if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(EDITOR_ICON_IMAGE_HDR))
+		//	{
+		//		EditorFileUtils::handle_file_drop((const char*)payload->Data, world);
+		//	}
+		//	ImGui::EndDragDropTarget();
+		//}
+	}
+
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/drag_n_drop_system.h b/apps/editor/src/editor/drag_n_drop_system.h
new file mode 100644
index 000000000..ba3031f05
--- /dev/null
+++ b/apps/editor/src/editor/drag_n_drop_system.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <ecs/system.h>
+
+namespace era_engine
+{
+	class RendererHolderRootComponent;
+
+	class DragNDropSystem final : public System
+	{
+	public:
+		DragNDropSystem(World* _world);
+		~DragNDropSystem();
+
+		void init() override;
+		void update(float dt) override;
+
+		ERA_VIRTUAL_REFLECT(System)
+
+	private:
+		RendererHolderRootComponent* renderer_holder_rc = nullptr;
+	};
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/editor_init_system.cpp b/apps/editor/src/editor/editor_init_system.cpp
new file mode 100644
index 000000000..0fdbd38ab
--- /dev/null
+++ b/apps/editor/src/editor/editor_init_system.cpp
@@ -0,0 +1,68 @@
+#include "editor/editor_init_system.h"
+
+#include <core/ecs/input_reciever_component.h>
+#include <core/ecs/input_sender_component.h>
+#include <core/string.h>
+
+#include <rendering/mesh_shader.h>
+#include <rendering/ecs/renderer_holder_root_component.h>
+
+#include <ecs/update_groups.h>
+#include <ecs/base_components/transform_component.h>
+#include <ecs/rendering/world_renderer.h>
+#include <ecs/rendering/scene_rendering.h>
+#include <core/ecs/camera_holder_component.h>
+#include <ecs/rendering/mesh_component.h>
+
+#include <audio/audio.h>
+
+#include <terrain/terrain.h>
+
+#include <animation/skinning.h>
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+namespace era_engine
+{
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<EditorInitSystem>("GameInitSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("update", &EditorInitSystem::update)(metadata("update_group", update_types::BEGIN));
+	}
+
+	EditorInitSystem::EditorInitSystem(World* _world)
+		: System(_world)
+	{
+	}
+
+	EditorInitSystem::~EditorInitSystem()
+	{
+	}
+
+	void EditorInitSystem::init()
+	{
+		RendererHolderRootComponent* renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
+
+		Entity camera_entity = world->create_entity("CameraEntity");
+		camera_entity.add_component<CameraHolderComponent>()
+					 .add_component<InputRecieverComponent>()
+					 .add_component<InputSenderComponent>();
+
+		CameraHolderComponent& camera_holder_component = camera_entity.get_component<CameraHolderComponent>();
+		camera_holder_component.set_camera_type(CameraHolderComponent::FREE_CAMERA);
+		camera_holder_component.set_render_camera(&renderer_holder_rc->camera);
+
+		camera_entity.get_component<InputSenderComponent>().add_reciever(camera_entity.get_component_if_exists<InputRecieverComponent>());
+	}
+
+	void EditorInitSystem::update(float dt)
+	{
+		
+	}
+
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/editor_init_system.h b/apps/editor/src/editor/editor_init_system.h
new file mode 100644
index 000000000..4290d8a47
--- /dev/null
+++ b/apps/editor/src/editor/editor_init_system.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <ecs/system.h>
+
+namespace era_engine
+{
+
+	class EditorInitSystem final : public System
+	{
+	public:
+		EditorInitSystem(World* _world);
+		~EditorInitSystem();
+
+		void init() override;
+		void update(float dt) override;
+		ERA_VIRTUAL_REFLECT(System)
+	};
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/editor_startup.cpp b/apps/editor/src/editor/editor_startup.cpp
new file mode 100644
index 000000000..28dc8ca4f
--- /dev/null
+++ b/apps/editor/src/editor/editor_startup.cpp
@@ -0,0 +1,44 @@
+#include "editor/editor_startup.h"
+#include "editor/file_utils.h"
+
+#include <engine/engine.h>
+
+#include <base/module_loader.h>
+
+#include <window/dx_window.h>
+
+#include <core/string.h>
+
+#include <editor/transformation_gizmo.h>
+
+#include <ecs/world.h>
+
+namespace era_engine
+{
+
+	void EditorStartup::start(int argc, char** argv)
+	{
+		Engine* engine = Engine::create_instance(argc, argv);
+
+		auto initial_task = [&engine]() {
+			ModuleLoader loader = ModuleLoader(engine, "physics");
+			ASSERT(loader.status());
+		};
+
+		dx_window* window = get_object<dx_window>();
+		window->initialize(TEXT("  Editor - Era Engine - <DX12>"), 1920, 1080);
+		window->setIcon(get_asset_path("/resources/icons/Logo.ico"));
+		window->setCustomWindowStyle();
+		window->maximize();
+
+		World* game_world = get_world_by_name("GameWorld");
+		window->setFileDropCallback([&game_world](const fs::path& s) { EditorFileUtils::handle_file_drop(s, game_world); });
+
+		initializeTransformationGizmos();
+
+		engine->run(initial_task);
+
+		engine->terminate();
+	}
+
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/editor_startup.h b/apps/editor/src/editor/editor_startup.h
new file mode 100644
index 000000000..5efab6121
--- /dev/null
+++ b/apps/editor/src/editor/editor_startup.h
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace era_engine
+{
+
+	class EditorStartup final
+	{
+	public:
+		EditorStartup() = default;
+		~EditorStartup() = default;
+
+		void start(int argc, char** argv);
+	};
+
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/file_utils.cpp b/apps/editor/src/editor/file_utils.cpp
new file mode 100644
index 000000000..99ef67ddc
--- /dev/null
+++ b/apps/editor/src/editor/file_utils.cpp
@@ -0,0 +1,53 @@
+#include "editor/file_utils.h"
+
+#include <asset/model_asset.h>
+
+#include <ecs/world.h>
+#include <ecs/entity.h>
+#include <ecs/base_components/base_components.h>
+#include <ecs/rendering/mesh_component.h>
+#include <ecs/rendering/world_renderer.h>
+
+#include <rendering/ecs/renderer_holder_root_component.h>
+#include <rendering/render_utils.h>
+
+namespace era_engine
+{
+	void EditorFileUtils::handle_file_drop(const fs::path& filename, World* world)
+	{
+		/*fs::path path = filename;
+		fs::path relative = fs::relative(path, fs::current_path());
+		fs::path ext = relative.extension();
+
+		if (is_mesh_extension(ext))
+		{
+			fs::path path = filename;
+			path = path.stem();
+
+			if (auto mesh = loadAnimatedMeshFromFileAsync(relative.string()))
+			{
+				auto& entity = world->create_entity("Veribot")
+					.add_component<animation::AnimationComponent>()
+					.add_component<MeshComponent>(mesh);
+
+				TransformComponent& transform_component = entity.get_component<TransformComponent>();
+				transform_component.type = TransformComponent::DYNAMIC;
+
+				initializeAnimationComponentAsync(entity, mesh);
+				addRaytracingComponentAsync(entity, mesh);
+			}
+			else if (auto mesh = loadMeshFromFileAsync(relative.string()))
+			{
+				auto& entity = world->create_entity("Veribot")
+					.add_component<animation::AnimationComponent>()
+					.add_component<MeshComponent>(mesh);
+
+				addRaytracingComponentAsync(entity, mesh);
+			}
+		}
+		else if (ext == ".hdr")
+		{
+			world->get_root_component<RendererHolderRootComponent>()->environment.setFromTexture(relative);
+		}*/
+	}
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/file_utils.h b/apps/editor/src/editor/file_utils.h
new file mode 100644
index 000000000..70d571353
--- /dev/null
+++ b/apps/editor/src/editor/file_utils.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <filesystem>
+
+namespace era_engine
+{
+	class World;
+
+	class EditorFileUtils
+	{
+	public:
+		static void handle_file_drop(const fs::path& filename, World* world);
+	};
+}
\ No newline at end of file
diff --git a/apps/editor/src/editor/main.cpp b/apps/editor/src/editor/main.cpp
index 1d3692dd5..2307ccb54 100644
--- a/apps/editor/src/editor/main.cpp
+++ b/apps/editor/src/editor/main.cpp
@@ -2,9 +2,7 @@
 #include <fstream>
 #include <iostream>
 
-#include <engine/engine.h>
-
-#include <base/module_loader.h>
+#include "editor/editor_startup.h"
 
 int main(int argc, char** argv)
 {
@@ -12,26 +10,15 @@ int main(int argc, char** argv)
 
 	try
 	{
-		Engine* engine = Engine::create_instance(argc, argv);
-
-		auto initial_task = [&engine]() {
-			ModuleLoader loader = ModuleLoader(engine, "physics");
-			ASSERT(loader.status());
-		};
-
-		if (!engine->run(initial_task))
-		{
-			return EXIT_FAILURE;
-		}
-
-		engine->terminate();
+		EditorStartup startup;
+		startup.start(argc, argv);
 	}
 	catch (const std::exception& ex)
 	{
 		std::cerr << ex.what() << "\n";
 
 		std::ofstream output("logs/error_log.txt");
-		output << "Runtime Error> " << ex.what() << std::endl;
+		output << "Runtime Error>" << ex.what() << std::endl;
 		output.close();
 
 		std::this_thread::sleep_for(std::chrono::duration<float>(5000.0f));
diff --git a/apps/example_game/src/game/game_init_system.cpp b/apps/example_game/src/game/game_init_system.cpp
new file mode 100644
index 000000000..dd30d5192
--- /dev/null
+++ b/apps/example_game/src/game/game_init_system.cpp
@@ -0,0 +1,136 @@
+#include "game/game_init_system.h"
+
+#include <core/ecs/input_reciever_component.h>
+#include <core/ecs/input_sender_component.h>
+#include <core/string.h>
+
+#include <rendering/mesh_shader.h>
+#include <rendering/ecs/renderer_holder_root_component.h>
+
+#include <ecs/update_groups.h>
+#include <ecs/base_components/transform_component.h>
+#include <ecs/rendering/world_renderer.h>
+#include <ecs/rendering/scene_rendering.h>
+#include <core/ecs/camera_holder_component.h>
+#include <ecs/rendering/mesh_component.h>
+
+#include <game/movement/movement_component.h>
+
+#include <audio/audio.h>
+
+#include <terrain/terrain.h>
+
+#include <animation/skinning.h>
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+namespace era_engine
+{
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<GameInitSystem>("GameInitSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("update", &GameInitSystem::update)(metadata("update_group", update_types::BEGIN));
+	}
+
+	GameInitSystem::GameInitSystem(World* _world)
+		: System(_world)
+	{
+	}
+
+	GameInitSystem::~GameInitSystem()
+	{
+	}
+
+	void GameInitSystem::init()
+	{
+		RendererHolderRootComponent* renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
+
+		Entity camera_entity = world->create_entity("CameraEntity");
+		camera_entity.add_component<CameraHolderComponent>()
+					 .add_component<InputSenderComponent>()
+					 .add_component<InputRecieverComponent>()
+					 .add_component<MovementComponent>();
+
+		CameraHolderComponent& camera_holder_component = camera_entity.get_component<CameraHolderComponent>();
+		camera_holder_component.set_camera_type(CameraHolderComponent::ATTACHED_TO_TRS);
+		camera_holder_component.set_render_camera(&renderer_holder_rc->camera);
+
+		camera_entity.get_component<InputSenderComponent>().add_reciever(camera_entity.get_component_if_exists<InputRecieverComponent>());
+
+#if 1
+		auto defaultmat = createPBRMaterialAsync({ "", "" });
+		defaultmat->shader = pbr_material_shader_double_sided;
+
+		mesh_builder builder;
+
+		auto sphereMesh = make_ref<multi_mesh>();
+		builder.pushSphere({ });
+		sphereMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultmat });
+
+		auto boxMesh = make_ref<multi_mesh>();
+		builder.pushBox({ vec3(0.f), vec3(1.f, 1.f, 2.f) });
+		boxMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultmat });
+
+		PbrMaterialDesc defaultPlaneMatDesc;
+		defaultPlaneMatDesc.albedo = get_asset_path("/resources/assets/uv.jpg");
+		defaultPlaneMatDesc.normal = "";
+		defaultPlaneMatDesc.roughness = "";
+		defaultPlaneMatDesc.uv_scale = 15.0f;
+		defaultPlaneMatDesc.metallic_override = 0.35f;
+		defaultPlaneMatDesc.roughness_override = 0.01f;
+
+		auto defaultPlaneMat = createPBRMaterialAsync(defaultPlaneMatDesc);
+
+		auto groundMesh = make_ref<multi_mesh>();
+		builder.pushBox({ vec3(0.f), vec3(30.f, 4.f, 30.f) });
+		groundMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultPlaneMat });
+
+		if (auto mesh = loadAnimatedMeshFromFileAsync(get_asset_path("/resources/assets/veribot/source/VERIBOT_final.fbx")))
+		{
+			auto& en = world->create_entity("Veribot")
+				.add_component<animation::AnimationComponent>()
+				.add_component<animation::SkeletonComponent>()
+				.add_component<MeshComponent>(mesh);
+
+			TransformComponent& transform_component = en.get_component<TransformComponent>();
+			transform_component.type = TransformComponent::DYNAMIC;
+			transform_component.transform.position = vec3(5.0f);
+
+			initializeAnimationComponentAsync(en, mesh);
+			addRaytracingComponentAsync(en, mesh);
+		}
+
+		if (auto mesh = loadMeshFromFileAsync(get_asset_path("/resources/assets/Sponza/sponza.obj")))
+		{
+			auto& sponza = world->create_entity("Sponza")
+				.add_component<MeshComponent>(mesh);
+
+			TransformComponent& transform_component = sponza.get_component<TransformComponent>();
+			transform_component.transform.position = vec3(5.0f, -3.75f, 35.0f);
+			transform_component.transform.scale = vec3(0.01f);
+
+			addRaytracingComponentAsync(sponza, mesh);
+		}
+
+		auto chainMesh = make_ref<multi_mesh>();
+
+		groundMesh->mesh =
+			boxMesh->mesh =
+			sphereMesh->mesh =
+			chainMesh->mesh =
+			builder.createDXMesh();
+
+#endif
+	}
+
+	void GameInitSystem::update(float dt)
+	{
+		
+	}
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/game_init_system.h b/apps/example_game/src/game/game_init_system.h
new file mode 100644
index 000000000..5e0a362f1
--- /dev/null
+++ b/apps/example_game/src/game/game_init_system.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <ecs/system.h>
+
+namespace era_engine
+{
+
+	class GameInitSystem final : public System
+	{
+	public:
+		GameInitSystem(World* _world);
+		~GameInitSystem();
+
+		void init() override;
+		void update(float dt) override;
+		ERA_VIRTUAL_REFLECT(System)
+	};
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/game_startup.cpp b/apps/example_game/src/game/game_startup.cpp
new file mode 100644
index 000000000..bbf5d27f5
--- /dev/null
+++ b/apps/example_game/src/game/game_startup.cpp
@@ -0,0 +1,34 @@
+#include "game/game_startup.h"
+
+#include <engine/engine.h>
+
+#include <base/module_loader.h>
+
+#include <window/dx_window.h>
+
+#include <core/string.h>
+
+namespace era_engine
+{
+
+	void GameStartup::start(int argc, char** argv)
+	{
+		Engine* engine = Engine::create_instance(argc, argv);
+
+		auto initial_task = [&engine]() {
+			ModuleLoader loader = ModuleLoader(engine, "physics");
+			ASSERT(loader.status());
+		};
+
+		dx_window* window = get_object<dx_window>();
+		window->initialize(TEXT("  Example Game"), 1920, 1080);
+		window->setIcon(get_asset_path("/resources/icons/Logo.ico"));
+		window->setCustomWindowStyle();
+		window->maximize();
+
+		engine->run(initial_task);
+
+		engine->terminate();
+	}
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/game_startup.h b/apps/example_game/src/game/game_startup.h
new file mode 100644
index 000000000..01581837e
--- /dev/null
+++ b/apps/example_game/src/game/game_startup.h
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace era_engine
+{
+
+	class GameStartup final
+	{
+	public:
+		GameStartup() = default;
+		~GameStartup() = default;
+
+		void start(int argc, char** argv);
+	};
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/editor/main.cpp b/apps/example_game/src/game/main.cpp
similarity index 54%
rename from apps/example_game/src/editor/main.cpp
rename to apps/example_game/src/game/main.cpp
index aefa065f9..eb7d8b0ef 100644
--- a/apps/example_game/src/editor/main.cpp
+++ b/apps/example_game/src/game/main.cpp
@@ -2,33 +2,16 @@
 #include <fstream>
 #include <iostream>
 
-#include <engine/engine.h>
-
-#include <base/module_loader.h>
+#include "game/game_startup.h"
 
 int main(int argc, char** argv)
 {
 	using namespace era_engine;
 
-#ifndef _DEBUG
-	//::ShowWindow(::GetConsoleWindow(), SW_HIDE);
-#endif
-
 	try
 	{
-		Engine* engine = Engine::create_instance();
-
-		auto initial_task = [&engine]() {
-			ModuleLoader loader = ModuleLoader(engine, "physics");
-			ASSERT(loader.status());
-		};
-
-		if (!engine->run(initial_task))
-		{
-			return EXIT_FAILURE;
-		}
-
-		engine->terminate();
+		GameStartup startup;
+		startup.start(argc, argv);
 	}
 	catch (const std::exception& ex)
 	{
diff --git a/apps/example_game/src/game/movement/movement_component.h b/apps/example_game/src/game/movement/movement_component.h
new file mode 100644
index 000000000..a85c2eded
--- /dev/null
+++ b/apps/example_game/src/game/movement/movement_component.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <core/math.h>
+
+#include <ecs/component.h>
+
+namespace era_engine
+{
+
+	class MovementComponent : public Component
+	{
+	public:
+		MovementComponent() = default;
+		MovementComponent(ref<Entity::EcsData> _data);
+
+		~MovementComponent() override;
+
+		const vec3& get_current_input() const;
+		const vec3& get_desired_input() const;
+		const vec3& get_last_input() const;
+
+		const vec3& get_velocity() const;
+		const vec3& get_last_velocity() const;
+
+		void apply_input(const vec3& input, bool force = false);
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	protected:
+		void apply_desired_input();
+
+	protected:
+		vec3 current_input = vec3::zero;
+		vec3 last_input = vec3::zero;
+		vec3 desired_input = vec3::zero;
+
+		vec3 velocity = vec3::zero;
+		vec3 last_velocity = vec3::zero;
+
+		friend class MovementSystem;
+	};
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/movement/movement_utils.h b/apps/example_game/src/game/movement/movement_utils.h
new file mode 100644
index 000000000..e69de29bb
diff --git a/apps/example_game/src/game/movement/private/movement_component.cpp b/apps/example_game/src/game/movement/private/movement_component.cpp
new file mode 100644
index 000000000..575f05889
--- /dev/null
+++ b/apps/example_game/src/game/movement/private/movement_component.cpp
@@ -0,0 +1,66 @@
+#include "game/movement/movement_component.h"
+
+#include <rttr/registration>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		registration::class_<MovementComponent>("MovementComponent")
+			.constructor<ref<Entity::EcsData>>();
+	}
+
+
+	MovementComponent::MovementComponent(ref<Entity::EcsData> _data)
+		: Component(_data)
+	{
+	}
+
+	MovementComponent::~MovementComponent()
+	{
+	}
+
+	const vec3& MovementComponent::get_current_input() const
+	{
+		return current_input;
+	}
+
+	const vec3& MovementComponent::get_desired_input() const
+	{
+		return desired_input;
+	}
+
+	const vec3& MovementComponent::get_last_input() const
+	{
+		return last_input;
+	}
+
+	const vec3& MovementComponent::get_velocity() const
+	{
+		return velocity;
+	}
+
+	const vec3& MovementComponent::get_last_velocity() const
+	{
+		return last_velocity;
+	}
+
+	void MovementComponent::apply_input(const vec3& input, bool force)
+	{
+		desired_input += input;
+		if (force)
+		{
+			apply_desired_input();
+		}
+	}
+
+	void MovementComponent::apply_desired_input()
+	{
+		last_input = current_input;
+		current_input = desired_input;
+		desired_input = vec3::zero;
+	}
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/movement/private/movement_system.cpp b/apps/example_game/src/game/movement/private/movement_system.cpp
new file mode 100644
index 000000000..1f7d8314f
--- /dev/null
+++ b/apps/example_game/src/game/movement/private/movement_system.cpp
@@ -0,0 +1,74 @@
+#include <game/movement/private/movement_system.h>
+#include <game/movement/movement_component.h>
+		 
+#include <core/ecs/input_reciever_component.h>
+#include <core/ecs/input_sender_component.h>
+#include <core/ecs/camera_holder_component.h>
+
+#include <ecs/update_groups.h>
+#include <ecs/base_components/transform_component.h>
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+namespace era_engine
+{
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<MovementSystem>("MovementSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("update", &MovementSystem::update)(metadata("update_group", update_types::AFTER_PHYSICS))
+			.method("reset_input", &MovementSystem::reset_input)(metadata("update_group", update_types::END));
+	}
+
+	MovementSystem::MovementSystem(World* _world)
+		: System(_world)
+	{
+	}
+
+	MovementSystem::~MovementSystem()
+	{
+	}
+
+	void MovementSystem::init()
+	{
+	}
+
+	void MovementSystem::update(float dt)
+	{
+		const float ROTATION_SENSITIVITY = 4.0f;
+		const float MOVE_SPEED = 4.0f;
+
+		for (auto [handle, transform_component, movement_component, reciever_component] : world->group(components_group<TransformComponent, MovementComponent, InputRecieverComponent>).each())
+		{
+			Entity movable = world->get_entity(handle);
+
+			const UserInput& user_input = reciever_component.get_frame_input();
+			const vec3& input = reciever_component.get_current_input();
+
+			movement_component.apply_input(input);
+
+			movement_component.last_velocity = movement_component.velocity;
+			movement_component.velocity = input;
+
+			vec2 turn_angle = vec2(-user_input.mouse.reldx, -user_input.mouse.reldy) * ROTATION_SENSITIVITY;
+
+			quat& rotation = transform_component.transform.rotation;
+			rotation = quat(vec3(0.f, 1.f, 0.f), turn_angle.x) * rotation;
+			rotation = rotation * quat(vec3(1.f, 0.f, 0.f), turn_angle.y);
+
+			transform_component.transform.position += rotation * movement_component.velocity * dt * MOVE_SPEED;
+		}
+	}
+
+	void MovementSystem::reset_input(float dt)
+	{
+		for (auto [handle, transform_component, movement_component] : world->group(components_group<TransformComponent, MovementComponent>).each())
+		{
+			movement_component.apply_desired_input();
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/movement/private/movement_system.h b/apps/example_game/src/game/movement/private/movement_system.h
new file mode 100644
index 000000000..3e0ef9ba0
--- /dev/null
+++ b/apps/example_game/src/game/movement/private/movement_system.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <ecs/system.h>
+
+namespace era_engine
+{
+	class MovementSystem final : public System
+	{
+	public:
+		MovementSystem(World* _world);
+		~MovementSystem();
+
+		void init() override;
+		void update(float dt) override;
+
+		void reset_input(float dt);
+
+		ERA_VIRTUAL_REFLECT(System)
+	};
+}
\ No newline at end of file
diff --git a/apps/example_game/src/game/movement/private/movement_utils.cpp b/apps/example_game/src/game/movement/private/movement_utils.cpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/cmake/common.cmake b/cmake/common.cmake
index 260007798..419d502ab 100644
--- a/cmake/common.cmake
+++ b/cmake/common.cmake
@@ -26,7 +26,7 @@ function(assign_source_group)
     endforeach()
 endfunction(assign_source_group)
 
-function(default_linkage name)
+function(era_default_linkage name)
     target_compile_definitions(${name} PRIVATE _UNICODE
         UNICODE
         _CRT_SECURE_NO_WARNINGS
@@ -59,13 +59,10 @@ function(declare_module name)
     file(GLOB_RECURSE SOURCES_${name} ${ERA_ENGINE_PATH}/modules/${name}/src/*.cpp)
     file(GLOB_RECURSE HEADERS_${name} ${ERA_ENGINE_PATH}/modules/${name}/src/*.h)
 
-    set(sources_${name} ${SOURCES_${name}})
-    set(headers_${name} ${HEADERS_${name}})
-
     add_library(${name} SHARED ${SOURCES_${name}} ${HEADERS_${name}})
     target_include_directories(${name} PUBLIC ${ERA_ENGINE_PATH}/modules/${name}/src)
 
-    default_linkage(${name})
+    era_default_linkage(${name})
 endfunction()
 
 function(declare_asset_module name)
@@ -82,13 +79,10 @@ function(declare_app name)
     file(GLOB_RECURSE SOURCES_${name} ${ERA_ENGINE_PATH}/apps/${name}/src/*.cpp)
     file(GLOB_RECURSE HEADERS_${name} ${ERA_ENGINE_PATH}/apps/${name}/src/*.h)
 
-    set(sources_${name} ${SOURCES_${name}})
-    set(headers_${name} ${HEADERS_${name}})
-
     add_executable(${name} ${SOURCES_${name}} ${HEADERS_${name}})
     target_include_directories(${name} PUBLIC ${ERA_ENGINE_PATH}/apps/${name}/src)
 
-    default_linkage(${name})
+    era_default_linkage(${name})
 endfunction()
 
 function(era_begin name target_type)
@@ -120,7 +114,7 @@ function(require_module target module)
     add_dependencies(${target} ${module})
 
     get_property(module_dependencies TARGET ${module} PROPERTY DEPENDENCIES)
-    set_property(TARGET ${target} APPEND PROPERTY DEPENDENCIES ${module} ${module_dependencies})
+    set_property(TARGET ${target} APPEND PROPERTY DEPENDENCIES ${module})
 endfunction()
 
 function(require_thirdparty_module target module)
@@ -134,7 +128,7 @@ function(require_thirdparty_module target module)
     add_dependencies(${target} ${module})
 
     get_property(module_dependencies TARGET ${module} PROPERTY DEPENDENCIES)
-    set_property(TARGET ${target} APPEND PROPERTY DEPENDENCIES ${module} ${module_dependencies})
+    set_property(TARGET ${target} APPEND PROPERTY DEPENDENCIES ${module})
 endfunction()
 
 function(era_end name)
diff --git a/cmake/deploy.cmake b/cmake/deploy.cmake
new file mode 100644
index 000000000..0b7a7f441
--- /dev/null
+++ b/cmake/deploy.cmake
@@ -0,0 +1,20 @@
+function(era_add_deploy_target app)
+    set(deploy_target_name deploy_modules_to_${app})
+    add_custom_target(${deploy_target_name} ALL)
+
+    get_property(target_dependencies TARGET ${app} PROPERTY DEPENDENCIES)
+    list(REMOVE_DUPLICATES target_dependencies)
+
+    foreach(dependency ${target_dependencies})
+        get_property(dependency_type TARGET ${dependency} PROPERTY TARGET_TYPE)
+        if(dependency_type STREQUAL "MODULE")
+            add_custom_command(TARGET ${deploy_target_name} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_directory
+                $<TARGET_FILE_DIR:${dependency}>
+                $<TARGET_FILE_DIR:${app}>
+            )
+        endif()
+    endforeach()
+    
+    set_target_properties(${deploy_target_name} PROPERTIES FOLDER deployment)
+endfunction()
\ No newline at end of file
diff --git a/modules/base/src/base/module.h b/modules/base/src/base/module.h
index caf428def..12a0277ed 100644
--- a/modules/base/src/base/module.h
+++ b/modules/base/src/base/module.h
@@ -54,7 +54,8 @@ namespace era_engine
 #define MODULE_REGISTRATION															\
 	{																				\
 		Engine * engine_ptr = static_cast<Engine*>(engine);							\
-		WorldSystemScheduler* scheduler = engine_ptr->get_system_scheduler();		\
+		World* world = get_world_by_name("GameWorld");								\
+		WorldSystemScheduler* scheduler = world->get_system_scheduler();			\
 		rttr::library module_lib(name);												\
 		if (module_lib.load())														\
 		{																			\
diff --git a/modules/base/src/base/system.h b/modules/base/src/base/system.h
index 444540804..f1fbe57c1 100644
--- a/modules/base/src/base/system.h
+++ b/modules/base/src/base/system.h
@@ -10,7 +10,7 @@ namespace era_engine
 
 	enum class UpdateType : uint8_t
 	{
-		NORMAL,
+		NORMAL = 0,
 		FIXED
 	};
 
diff --git a/modules/core/src/animation/animation.cpp b/modules/core/src/animation/animation.cpp
index e15811862..63fe5541a 100644
--- a/modules/core/src/animation/animation.cpp
+++ b/modules/core/src/animation/animation.cpp
@@ -32,207 +32,6 @@ namespace era_engine::animation
 		}
 	}
 
-	void AnimationSkeleton::analyzeJoints(const vec3* positions, const void* others, uint32 otherStride, uint32 numVertices)
-	{
-		for (uint32 jointID = 0; jointID < (uint32)joints.size(); ++jointID)
-		{
-			SkeletonJoint& j = joints[jointID];
-
-			std::string name = j.name;
-			std::transform(name.begin(), name.end(), name.begin(), ::tolower);
-
-			LimbType c = limb_type_none;
-
-			bool left = contains(name, "left") || ends_with(name, ".l") || ends_with(name, "_l");
-
-			if (contains(name, "spine") || contains(name, "hip") || contains(name, "rib") || contains(name, "pelvis") || contains(name, "shoulder") || contains(name, "clavicle")) { c = limb_type_torso; }
-			else if (contains(name, "head") || contains(name, "neck")) { c = limb_type_head; }
-			else if (contains(name, "arm"))
-			{
-				LimbType parentType = (j.parent_id != INVALID_JOINT) ? joints[j.parent_id].limb_type : limb_type_none;
-
-				if (contains(name, "lower") || contains(name, "lo") || contains(name, "fore")) { c = left ? limb_type_lower_arm_left : limb_type_lower_arm_right; }
-				else if (contains(name, "upper") || contains(name, "up")) { c = left ? limb_type_upper_arm_left : limb_type_upper_arm_right; }
-				else if (parentType == limb_type_torso) { c = left ? limb_type_upper_arm_left : limb_type_upper_arm_right; }
-				else { c = left ? limb_type_lower_arm_left : limb_type_lower_arm_right; }
-			}
-			else if (contains(name, "hand") || contains(name, "finger") || contains(name, "thumb") || contains(name, "index") || contains(name, "middle") || contains(name, "ring") || contains(name, "pinky"))
-			{
-				c = left ? limb_type_hand_left : limb_type_hand_right;
-			}
-			else if (contains(name, "leg") || contains(name, "thigh") || contains(name, "shin") || contains(name, "calf"))
-			{
-				LimbType parentType = (j.parent_id != INVALID_JOINT) ? joints[j.parent_id].limb_type : limb_type_none;
-
-				if (contains(name, "lower") || contains(name, "lo") || contains(name, "shin") || contains(name, "calf")) { c = left ? limb_type_lower_leg_left : limb_type_lower_leg_right; }
-				else if (contains(name, "upper") || contains(name, "up") || contains(name, "thigh")) { c = left ? limb_type_upper_leg_left : limb_type_upper_leg_right; }
-				else if (parentType == limb_type_torso) { c = left ? limb_type_upper_leg_left : limb_type_upper_leg_right; }
-				else { c = left ? limb_type_lower_leg_left : limb_type_lower_leg_right; }
-			}
-			else if (contains(name, "foot") || contains(name, "toe") || contains(name, "ball"))
-			{
-				c = left ? limb_type_foot_left : limb_type_foot_right;
-			}
-
-			j.limb_type = c;
-			j.ik = contains(name, "ik");
-
-			if (limbs[c].representative_joint == INVALID_JOINT)
-			{
-				// The highest joint in the hierarchy for this type is chosen as the representative.
-				// Because we order the joints, the first joint we encounter is automatically the highest in the hierarchy.
-				limbs[c].representative_joint = jointID;
-			}
-		}
-
-#if 0
-
-		struct limb_analysis
-		{
-			vec3 vertexMean;
-			uint32 numVertices;
-			mat3 covariance;
-		};
-
-		limb_analysis analysis[limb_type_count] = {};
-
-		for (uint32 i = 0; i < numVertices; ++i)
-		{
-			vec3 p = positions[i];
-			skinning_weights w = *(skinning_weights*)((uint8*)others + i * otherStride);
-			for (uint32 j = 0; j < 4; ++j)
-			{
-				if (w.skinWeights[j] > 150)
-				{
-					const auto& joint = joints[w.skinIndices[j]];
-					limb_type c = joint.limbType;
-					if (c != limb_type_unknown)
-					{
-						limb_analysis& a = analysis[c];
-						a.vertexMean += p;
-						++a.numVertices;
-					}
-				}
-			}
-		}
-
-		for (uint32 i = 0; i < limb_type_count; ++i)
-		{
-			if (analysis[i].numVertices)
-			{
-				analysis[i].vertexMean /= (float)analysis[i].numVertices;
-			}
-		}
-
-
-		for (uint32 i = 0; i < numVertices; ++i)
-		{
-			vec3 p = positions[i];
-			skinning_weights w = *(skinning_weights*)((uint8*)others + i * otherStride);
-			for (uint32 j = 0; j < 4; ++j)
-			{
-				if (w.skinWeights[j] > 150)
-				{
-					const auto& joint = joints[w.skinIndices[j]];
-					limb_type c = joint.limbType;
-					if (c != limb_type_unknown)
-					{
-						limb_analysis& a = analysis[c];
-						vec3 m = a.vertexMean;
-
-						for (uint32 y = 0; y < 3; ++y)
-						{
-							for (uint32 x = 0; x < 3; ++x)
-							{
-								a.covariance.m[3 * y + x] += (m.data[y] - p.data[y]) * (m.data[x] - p.data[x]);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		for (uint32 i = 0; i < limb_type_count; ++i)
-		{
-			if (analysis[i].numVertices)
-			{
-				analysis[i].covariance *= 1.f / (float)analysis[i].numVertices;
-
-				//singular_value_decomposition svd = computeSVD(analysis[i].covariance);
-				//vec3 principalAxis = col(svd.U, 0);
-
-				vec3 eigenValues;
-				mat3 eigenVectors;
-
-				getEigen(analysis[i].covariance, eigenValues, eigenVectors);
-				uint32 maxComponent = (eigenValues.x > eigenValues.y) ? (eigenValues.x > eigenValues.z) ? 0 : 2 : (eigenValues.y > eigenValues.z) ? 1 : 2;
-
-				vec3 principalAxis = col(eigenVectors, maxComponent);
-
-				limbs[i].mean = analysis[i].vertexMean;
-				limbs[i].principalAxis = principalAxis;
-			}
-		}
-
-#else
-
-		for (uint32 i = 0; i < limb_type_count; ++i)
-		{
-			limbs[i].dimensions = { FLT_MAX, -FLT_MAX, -FLT_MAX };
-		}
-
-		for (uint32 i = 0; i < numVertices; ++i)
-		{
-			vec3 p = positions[i];
-			SkinningWeights w = *(SkinningWeights*)((uint8*)others + i * otherStride);
-			for (uint32 j = 0; j < 4; ++j)
-			{
-				if (w.skin_weights[j] > 200)
-				{
-					LimbType type = joints[w.skin_indices[j]].limb_type;
-					if (type != limb_type_none)
-					{
-						if (limbs[type].representative_joint != INVALID_JOINT)
-						{
-							const SkeletonJoint& j = joints[limbs[type].representative_joint];
-							LimbDimensions& d = limbs[type].dimensions;
-
-							p = transform_position(j.inv_bind_transform, p);
-
-							d.minY = min(d.minY, p.y);
-							d.maxY = max(d.maxY, p.y);
-							d.radius = max(d.radius, squared_length(vec2(p.x, p.z)));
-						}
-					}
-				}
-			}
-		}
-
-		for (uint32 i = 0; i < limb_type_count; ++i)
-		{
-			LimbDimensions& d = limbs[i].dimensions;
-
-			d.radius = sqrt(d.radius); // Above, we calculate the squared radius.
-
-			float c = 0.5f * (d.minY + d.maxY);
-
-			const float scaleFactor = 0.8f;
-			d.minY = (d.minY - c) * scaleFactor + c;
-			d.maxY = (d.maxY - c) * scaleFactor + c;
-			d.radius *= scaleFactor;
-
-			d.minY += d.radius;
-			d.maxY -= d.radius;
-			if (d.minY > d.maxY)
-			{
-				d.minY = c - EPSILON;
-				d.maxY = c + EPSILON;
-			}
-		}
-
-#endif
-	}
-
 	static vec3 samplePosition(const AnimationClip& clip, const AnimationJoint& animJoint, float time)
 	{
 		if (time >= clip.length_in_seconds)
@@ -342,11 +141,12 @@ namespace era_engine::animation
 
 	void AnimationSkeleton::sampleAnimation(const AnimationClip& clip, float time, trs* outLocalTransforms, trs* outRootMotion) const
 	{
-		ASSERT(clip.joints.size() == joints.size());
+		ASSERT(skeleton != nullptr);
+		ASSERT(clip.joints.size() == skeleton->joints.size());
 
 		time = clamp(time, 0.f, clip.length_in_seconds);
 
-		uint32 numJoints = (uint32)joints.size();
+		uint32 numJoints = (uint32)skeleton->joints.size();
 		for (uint32 i = 0; i < numJoints; ++i)
 		{
 			const AnimationJoint& animJoint = clip.joints[i];
@@ -410,144 +210,67 @@ namespace era_engine::animation
 		sampleAnimation(clips[index], time, outLocalTransforms, outRootMotion);
 	}
 
-	void AnimationSkeleton::blendLocalTransforms(const trs* localTransforms1, const trs* localTransforms2, float t, trs* outBlendedLocalTransforms) const
+	std::vector<uint32> AnimationSkeleton::getClipsByName(const std::string& name)
 	{
-		t = clamp01(t);
-		for (uint32 jointID = 0; jointID < (uint32)joints.size(); ++jointID)
+		std::vector<uint32> result;
+		for (uint32 i = 0; i < (uint32)clips.size(); ++i)
 		{
-			outBlendedLocalTransforms[jointID] = lerp(localTransforms1[jointID], localTransforms2[jointID], t);
+			if (clips[i].name == name)
+			{
+				result.push_back(i);
+			}
 		}
+		return result;
 	}
 
-	void AnimationSkeleton::getSkinningMatricesFromLocalTransforms(const trs* localTransforms, mat4* outSkinningMatrices, const trs& worldTransform) const
+	static void pretty_print(const Skeleton& skeleton, uint32 parent, uint32 indent)
 	{
-		uint32 numJoints = (uint32)joints.size();
-		trs* globalTransforms = (trs*)alloca(sizeof(trs) * numJoints);
-
-		for (uint32 i = 0; i < numJoints; ++i)
+		for (uint32 i = 0; i < (uint32)skeleton.joints.size(); ++i)
 		{
-			const SkeletonJoint& skelJoint = joints[i];
-			if (skelJoint.parent_id != INVALID_JOINT)
-			{
-				ASSERT(i > skelJoint.parent_id); // Parent already processed.
-				globalTransforms[i] = globalTransforms[skelJoint.parent_id] * localTransforms[i];
-			}
-			else
+			if (skeleton.joints[i].parent_id == parent)
 			{
-				globalTransforms[i] = worldTransform * localTransforms[i];
+				std::cout << std::string(indent, ' ') << skeleton.joints[i].name << '\n';
+				pretty_print(skeleton, i, indent + 1);
 			}
-
-			outSkinningMatrices[i] = trs_to_mat4(globalTransforms[i]) * joints[i].inv_bind_transform;
 		}
 	}
 
-	void AnimationSkeleton::getSkinningMatricesFromLocalTransforms(const trs* localTransforms, trs* outGlobalTransforms, mat4* outSkinningMatrices, const trs& worldTransform) const
+	void AnimationClip::edit()
 	{
-		uint32 numJoints = (uint32)joints.size();
+		ImGui::Checkbox("Bake root rotation into pose", &bake_root_rotation_into_pose);
+		ImGui::Checkbox("Bake xz translation into pose", &bake_root_xz_translation_into_pose);
+		ImGui::Checkbox("Bake y translation into pose", &bake_root_y_translation_into_pose);
+	}
 
-		for (uint32 i = 0; i < numJoints; ++i)
+	trs AnimationClip::get_first_root_transform() const
+	{
+		if (root_motion_joint.is_animated)
 		{
-			const SkeletonJoint& skelJoint = joints[i];
-			if (skelJoint.parent_id != INVALID_JOINT)
+			trs t;
+			t.position = position_keyframes[root_motion_joint.first_position_keyframe];
+			t.rotation = rotation_keyframes[root_motion_joint.first_rotation_keyframe];
+			t.scale = scale_keyframes[root_motion_joint.first_scale_keyframe];
+
+			if (bake_root_rotation_into_pose)
 			{
-				ASSERT(i > skelJoint.parent_id); // Parent already processed
-				outGlobalTransforms[i] = outGlobalTransforms[skelJoint.parent_id] * localTransforms[i];
+				t.rotation = quat::identity;
 			}
-			else
+			if (bake_root_xz_translation_into_pose)
+			{
+				t.position.x = 0.f;
+				t.position.z = 0.f;
+			}
+			if (bake_root_y_translation_into_pose)
 			{
-				outGlobalTransforms[i] = worldTransform * localTransforms[i];
+				t.position.y = 0.f;
 			}
 
-			outSkinningMatrices[i] = trs_to_mat4(outGlobalTransforms[i]) * joints[i].inv_bind_transform;
+			return t;
 		}
+		return trs::identity;
 	}
 
-	void AnimationSkeleton::getSkinningMatricesFromGlobalTransforms(const trs* globalTransforms, mat4* outSkinningMatrices) const
-	{
-		uint32 numJoints = (uint32)joints.size();
-
-		for (uint32 i = 0; i < numJoints; ++i)
-		{
-			outSkinningMatrices[i] = trs_to_mat4(globalTransforms[i]) * joints[i].inv_bind_transform;
-		}
-	}
-
-	void AnimationSkeleton::getSkinningMatricesFromGlobalTransforms(const trs* globalTransforms, mat4* outSkinningMatrices, const trs& worldTransform) const
-	{
-		uint32 numJoints = (uint32)joints.size();
-
-		for (uint32 i = 0; i < numJoints; ++i)
-		{
-			outSkinningMatrices[i] = trs_to_mat4(worldTransform) * trs_to_mat4(globalTransforms[i]) * joints[i].inv_bind_transform;
-		}
-	}
-
-	std::vector<uint32> AnimationSkeleton::getClipsByName(const std::string& name)
-	{
-		std::vector<uint32> result;
-		for (uint32 i = 0; i < (uint32)clips.size(); ++i)
-		{
-			if (clips[i].name == name)
-			{
-				result.push_back(i);
-			}
-		}
-		return result;
-	}
-
-	static void prettyPrint(const AnimationSkeleton& skeleton, uint32 parent, uint32 indent)
-	{
-		for (uint32 i = 0; i < (uint32)skeleton.joints.size(); ++i)
-		{
-			if (skeleton.joints[i].parent_id == parent)
-			{
-				std::cout << std::string(indent, ' ') << skeleton.joints[i].name << '\n';
-				prettyPrint(skeleton, i, indent + 1);
-			}
-		}
-	}
-
-	void AnimationSkeleton::prettyPrintHierarchy() const
-	{
-		prettyPrint(*this, INVALID_JOINT, 0);
-	}
-
-	void AnimationClip::edit()
-	{
-		ImGui::Checkbox("Bake root rotation into pose", &bake_root_rotation_into_pose);
-		ImGui::Checkbox("Bake xz translation into pose", &bake_root_xz_translation_into_pose);
-		ImGui::Checkbox("Bake y translation into pose", &bake_root_y_translation_into_pose);
-	}
-
-	trs AnimationClip::get_first_root_transform() const
-	{
-		if (root_motion_joint.is_animated)
-		{
-			trs t;
-			t.position = position_keyframes[root_motion_joint.first_position_keyframe];
-			t.rotation = rotation_keyframes[root_motion_joint.first_rotation_keyframe];
-			t.scale = scale_keyframes[root_motion_joint.first_scale_keyframe];
-
-			if (bake_root_rotation_into_pose)
-			{
-				t.rotation = quat::identity;
-			}
-			if (bake_root_xz_translation_into_pose)
-			{
-				t.position.x = 0.f;
-				t.position.z = 0.f;
-			}
-			if (bake_root_y_translation_into_pose)
-			{
-				t.position.y = 0.f;
-			}
-
-			return t;
-		}
-		return trs::identity;
-	}
-
-	trs AnimationClip::get_last_root_transform() const
+	trs AnimationClip::get_last_root_transform() const
 	{
 		if (root_motion_joint.is_animated)
 		{
@@ -653,15 +376,15 @@ namespace era_engine::animation
 		relTime += dt / targetLength;
 		relTime = fmodf(relTime, 1.f);
 
-		trs* totalLocalTransforms = (trs*)alloca(sizeof(trs) * skeleton.joints.size() * 2);
+		trs* totalLocalTransforms = (trs*)alloca(sizeof(trs) * skeleton.skeleton->joints.size() * 2);
 		trs* localTransforms1 = totalLocalTransforms;
-		trs* localTransforms2 = totalLocalTransforms + skeleton.joints.size();
+		trs* localTransforms2 = totalLocalTransforms + skeleton.skeleton->joints.size();
 
 		trs rootMotion1, rootMotion2;
 		skeleton.sampleAnimation(*first, first->length_in_seconds * relTime, localTransforms1, &rootMotion1);
 		skeleton.sampleAnimation(*second, second->length_in_seconds * relTime, localTransforms2, &rootMotion2);
 
-		skeleton.blendLocalTransforms(localTransforms1, localTransforms2, blendValue, outLocalTransforms);
+		skeleton.skeleton->blend_local_transforms(localTransforms1, localTransforms2, blendValue, outLocalTransforms);
 
 		trs rootMotion = lerp(rootMotion1, rootMotion2, blendValue);
 
@@ -819,9 +542,11 @@ namespace era_engine::animation
 		using namespace rttr;
 		rttr::registration::class_<AnimationComponent>("AnimationComponent")
 			.constructor<ref<Entity::EcsData>>();
+		rttr::registration::class_<SkeletonComponent>("SkeletonComponent")
+			.constructor<ref<Entity::EcsData>>();
 	}
 
-	animation::AnimationComponent::AnimationComponent(ref<Entity::EcsData> _data)
+	AnimationComponent::AnimationComponent(ref<Entity::EcsData> _data)
 		: Component(_data)
 	{
 	}
@@ -856,7 +581,8 @@ namespace era_engine::animation
 	void AnimationComponent::update(const ref<multi_mesh>& mesh, Allocator& arena, float dt, trs* transform)
 	{
 		const dx_mesh& dxMesh = mesh->mesh;
-		AnimationSkeleton& skeleton = mesh->skeleton;
+		Skeleton& skeleton = mesh->skeleton;
+		AnimationSkeleton& animation_skeleton = mesh->animation_skeleton;
 
 		current_global_transforms = 0;
 
@@ -869,11 +595,11 @@ namespace era_engine::animation
 
 			trs* localTransforms = arena.allocate<trs>((uint32)skeleton.joints.size());
 			trs deltaRootMotion;
-			animation->update(skeleton, dt * time_scale, localTransforms, deltaRootMotion);
+			animation->update(animation_skeleton, dt * time_scale, localTransforms, deltaRootMotion);
 
 			trs* globalTransforms = arena.allocate<trs>((uint32)skeleton.joints.size());
 
-			skeleton.getSkinningMatricesFromLocalTransforms(localTransforms, globalTransforms, skinningMatrices);
+			skeleton.get_skinning_matrices_from_local_transforms(localTransforms, globalTransforms, skinningMatrices);
 
 			if (transform)
 			{
@@ -901,7 +627,8 @@ namespace era_engine::animation
 	void AnimationComponent::draw_current_skeleton(const ref<multi_mesh>& mesh, const trs& transform, ldr_render_pass* render_pass) const
 	{
 		const dx_mesh& dxMesh = mesh->mesh;
-		AnimationSkeleton& skeleton = mesh->skeleton;
+		Skeleton& skeleton = mesh->skeleton;
+		AnimationSkeleton& animation_skeleton = mesh->animation_skeleton;
 
 #if 1
 		uint32 numJoints = (uint32)skeleton.joints.size();
@@ -974,4 +701,291 @@ namespace era_engine::animation
 #endif
 	}
 
+
+	void Skeleton::analyze_joints(const vec3* positions, const void* others, uint32 other_stride, uint32 num_vertices)
+	{
+		for (uint32 jointID = 0; jointID < (uint32)joints.size(); ++jointID)
+		{
+			SkeletonJoint& j = joints[jointID];
+
+			std::string name = j.name;
+			std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+			LimbType c = limb_type_none;
+
+			bool left = contains(name, "left") || ends_with(name, ".l") || ends_with(name, "_l");
+
+			if (contains(name, "spine") || contains(name, "hip") || contains(name, "rib") || contains(name, "pelvis") || contains(name, "shoulder") || contains(name, "clavicle")) { c = limb_type_torso; }
+			else if (contains(name, "head") || contains(name, "neck")) { c = limb_type_head; }
+			else if (contains(name, "arm"))
+			{
+				LimbType parentType = (j.parent_id != INVALID_JOINT) ? joints[j.parent_id].limb_type : limb_type_none;
+
+				if (contains(name, "lower") || contains(name, "lo") || contains(name, "fore")) { c = left ? limb_type_lower_arm_left : limb_type_lower_arm_right; }
+				else if (contains(name, "upper") || contains(name, "up")) { c = left ? limb_type_upper_arm_left : limb_type_upper_arm_right; }
+				else if (parentType == limb_type_torso) { c = left ? limb_type_upper_arm_left : limb_type_upper_arm_right; }
+				else { c = left ? limb_type_lower_arm_left : limb_type_lower_arm_right; }
+			}
+			else if (contains(name, "hand") || contains(name, "finger") || contains(name, "thumb") || contains(name, "index") || contains(name, "middle") || contains(name, "ring") || contains(name, "pinky"))
+			{
+				c = left ? limb_type_hand_left : limb_type_hand_right;
+			}
+			else if (contains(name, "leg") || contains(name, "thigh") || contains(name, "shin") || contains(name, "calf"))
+			{
+				LimbType parentType = (j.parent_id != INVALID_JOINT) ? joints[j.parent_id].limb_type : limb_type_none;
+
+				if (contains(name, "lower") || contains(name, "lo") || contains(name, "shin") || contains(name, "calf")) { c = left ? limb_type_lower_leg_left : limb_type_lower_leg_right; }
+				else if (contains(name, "upper") || contains(name, "up") || contains(name, "thigh")) { c = left ? limb_type_upper_leg_left : limb_type_upper_leg_right; }
+				else if (parentType == limb_type_torso) { c = left ? limb_type_upper_leg_left : limb_type_upper_leg_right; }
+				else { c = left ? limb_type_lower_leg_left : limb_type_lower_leg_right; }
+			}
+			else if (contains(name, "foot") || contains(name, "toe") || contains(name, "ball"))
+			{
+				c = left ? limb_type_foot_left : limb_type_foot_right;
+			}
+
+			j.limb_type = c;
+			j.ik = contains(name, "ik");
+
+			if (limbs[c].representative_joint == INVALID_JOINT)
+			{
+				// The highest joint in the hierarchy for this type is chosen as the representative.
+				// Because we order the joints, the first joint we encounter is automatically the highest in the hierarchy.
+				limbs[c].representative_joint = jointID;
+			}
+		}
+
+#if 0
+
+		struct limb_analysis
+		{
+			vec3 vertexMean;
+			uint32 numVertices;
+			mat3 covariance;
+		};
+
+		limb_analysis analysis[limb_type_count] = {};
+
+		for (uint32 i = 0; i < numVertices; ++i)
+		{
+			vec3 p = positions[i];
+			skinning_weights w = *(skinning_weights*)((uint8*)others + i * otherStride);
+			for (uint32 j = 0; j < 4; ++j)
+			{
+				if (w.skinWeights[j] > 150)
+				{
+					const auto& joint = joints[w.skinIndices[j]];
+					limb_type c = joint.limbType;
+					if (c != limb_type_unknown)
+					{
+						limb_analysis& a = analysis[c];
+						a.vertexMean += p;
+						++a.numVertices;
+					}
+				}
+			}
+		}
+
+		for (uint32 i = 0; i < limb_type_count; ++i)
+		{
+			if (analysis[i].numVertices)
+			{
+				analysis[i].vertexMean /= (float)analysis[i].numVertices;
+			}
+		}
+
+
+		for (uint32 i = 0; i < numVertices; ++i)
+		{
+			vec3 p = positions[i];
+			skinning_weights w = *(skinning_weights*)((uint8*)others + i * otherStride);
+			for (uint32 j = 0; j < 4; ++j)
+			{
+				if (w.skinWeights[j] > 150)
+				{
+					const auto& joint = joints[w.skinIndices[j]];
+					limb_type c = joint.limbType;
+					if (c != limb_type_unknown)
+					{
+						limb_analysis& a = analysis[c];
+						vec3 m = a.vertexMean;
+
+						for (uint32 y = 0; y < 3; ++y)
+						{
+							for (uint32 x = 0; x < 3; ++x)
+							{
+								a.covariance.m[3 * y + x] += (m.data[y] - p.data[y]) * (m.data[x] - p.data[x]);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		for (uint32 i = 0; i < limb_type_count; ++i)
+		{
+			if (analysis[i].numVertices)
+			{
+				analysis[i].covariance *= 1.f / (float)analysis[i].numVertices;
+
+				//singular_value_decomposition svd = computeSVD(analysis[i].covariance);
+				//vec3 principalAxis = col(svd.U, 0);
+
+				vec3 eigenValues;
+				mat3 eigenVectors;
+
+				getEigen(analysis[i].covariance, eigenValues, eigenVectors);
+				uint32 maxComponent = (eigenValues.x > eigenValues.y) ? (eigenValues.x > eigenValues.z) ? 0 : 2 : (eigenValues.y > eigenValues.z) ? 1 : 2;
+
+				vec3 principalAxis = col(eigenVectors, maxComponent);
+
+				limbs[i].mean = analysis[i].vertexMean;
+				limbs[i].principalAxis = principalAxis;
+			}
+		}
+
+#else
+
+		for (uint32 i = 0; i < limb_type_count; ++i)
+		{
+			limbs[i].dimensions = { FLT_MAX, -FLT_MAX, -FLT_MAX };
+		}
+
+		for (uint32 i = 0; i < num_vertices; ++i)
+		{
+			vec3 p = positions[i];
+			SkinningWeights w = *(SkinningWeights*)((uint8*)others + i * other_stride);
+			for (uint32 j = 0; j < 4; ++j)
+			{
+				if (w.skin_weights[j] > 200)
+				{
+					LimbType type = joints[w.skin_indices[j]].limb_type;
+					if (type != limb_type_none)
+					{
+						if (limbs[type].representative_joint != INVALID_JOINT)
+						{
+							const SkeletonJoint& j = joints[limbs[type].representative_joint];
+							LimbDimensions& d = limbs[type].dimensions;
+
+							p = transform_position(j.inv_bind_transform, p);
+
+							d.minY = min(d.minY, p.y);
+							d.maxY = max(d.maxY, p.y);
+							d.radius = max(d.radius, squared_length(vec2(p.x, p.z)));
+						}
+					}
+				}
+			}
+		}
+
+		for (uint32 i = 0; i < limb_type_count; ++i)
+		{
+			LimbDimensions& d = limbs[i].dimensions;
+
+			d.radius = sqrt(d.radius); // Above, we calculate the squared radius.
+
+			float c = 0.5f * (d.minY + d.maxY);
+
+			const float scaleFactor = 0.8f;
+			d.minY = (d.minY - c) * scaleFactor + c;
+			d.maxY = (d.maxY - c) * scaleFactor + c;
+			d.radius *= scaleFactor;
+
+			d.minY += d.radius;
+			d.maxY -= d.radius;
+			if (d.minY > d.maxY)
+			{
+				d.minY = c - EPSILON;
+				d.maxY = c + EPSILON;
+			}
+		}
+
+#endif
+	}
+
+	void Skeleton::blend_local_transforms(const trs* local_transforms1, const trs* local_transforms2, float t, trs* out_blended_local_transforms) const
+	{
+		t = clamp01(t);
+		for (uint32 jointID = 0; jointID < (uint32)joints.size(); ++jointID)
+		{
+			out_blended_local_transforms[jointID] = lerp(local_transforms1[jointID], local_transforms2[jointID], t);
+		}
+	}
+
+	void Skeleton::get_skinning_matrices_from_local_transforms(const trs* local_transforms, mat4* out_skinning_matrices, const trs& world_transform) const
+	{
+		uint32 numJoints = (uint32)joints.size();
+		trs* global_transforms = (trs*)alloca(sizeof(trs) * numJoints);
+
+		for (uint32 i = 0; i < numJoints; ++i)
+		{
+			const SkeletonJoint& skelJoint = joints[i];
+			if (skelJoint.parent_id != INVALID_JOINT)
+			{
+				ASSERT(i > skelJoint.parent_id); // Parent already processed.
+				global_transforms[i] = global_transforms[skelJoint.parent_id] * local_transforms[i];
+			}
+			else
+			{
+				global_transforms[i] = world_transform * local_transforms[i];
+			}
+
+			out_skinning_matrices[i] = trs_to_mat4(global_transforms[i]) * joints[i].inv_bind_transform;
+		}
+	}
+
+	void Skeleton::get_skinning_matrices_from_local_transforms(const trs* local_transforms, trs* out_global_transforms, mat4* out_skinning_matrices, const trs& world_transform) const
+	{
+		uint32 numJoints = (uint32)joints.size();
+
+		for (uint32 i = 0; i < numJoints; ++i)
+		{
+			const SkeletonJoint& skelJoint = joints[i];
+			if (skelJoint.parent_id != INVALID_JOINT)
+			{
+				ASSERT(i > skelJoint.parent_id); // Parent already processed
+				out_global_transforms[i] = out_global_transforms[skelJoint.parent_id] * local_transforms[i];
+			}
+			else
+			{
+				out_global_transforms[i] = world_transform * local_transforms[i];
+			}
+
+			out_skinning_matrices[i] = trs_to_mat4(out_global_transforms[i]) * joints[i].inv_bind_transform;
+		}
+	}
+
+	void Skeleton::get_skinning_matrices_from_global_transforms(const trs* global_transforms, mat4* out_skinning_matrices) const
+	{
+		uint32 numJoints = (uint32)joints.size();
+
+		for (uint32 i = 0; i < numJoints; ++i)
+		{
+			out_skinning_matrices[i] = trs_to_mat4(global_transforms[i]) * joints[i].inv_bind_transform;
+		}
+	}
+
+	void Skeleton::get_skinning_matrices_from_global_transforms(const trs* global_transforms, mat4* out_skinning_matrices, const trs& world_transform) const
+	{
+		uint32 numJoints = (uint32)joints.size();
+
+		for (uint32 i = 0; i < numJoints; ++i)
+		{
+			out_skinning_matrices[i] = trs_to_mat4(world_transform) * trs_to_mat4(global_transforms[i]) * joints[i].inv_bind_transform;
+		}
+	}
+
+	void Skeleton::pretty_print_hierarchy() const
+	{
+		pretty_print(*this, INVALID_JOINT, 0);
+	}
+
+	SkeletonComponent::SkeletonComponent(ref<Entity::EcsData> _data) 
+		: Component(_data) 
+	{
+	}
+
+	SkeletonComponent::~SkeletonComponent()
+	{
+	}
 }
\ No newline at end of file
diff --git a/modules/core/src/animation/animation.h b/modules/core/src/animation/animation.h
index 2e1af93d3..42538f811 100644
--- a/modules/core/src/animation/animation.h
+++ b/modules/core/src/animation/animation.h
@@ -124,29 +124,50 @@ namespace era_engine::animation
 		LimbDimensions dimensions;
 	};
 
-	struct ERA_CORE_API AnimationSkeleton
+	class ERA_CORE_API Skeleton
 	{
-		void analyzeJoints(const vec3* positions, const void* others, uint32 otherStride, uint32 numVertices);
+	public:
+		Skeleton() = default;
 
-		void sampleAnimation(const AnimationClip& clip, float time, trs* outLocalTransforms, trs* outRootMotion = 0) const;
-		void sampleAnimation(uint32 index, float time, trs* outLocalTransforms, trs* outRootMotion = 0) const;
-		void blendLocalTransforms(const trs* localTransforms1, const trs* localTransforms2, float t, trs* outBlendedLocalTransforms) const;
-		void getSkinningMatricesFromLocalTransforms(const trs* localTransforms, mat4* outSkinningMatrices, const trs& worldTransform = trs::identity) const;
-		void getSkinningMatricesFromLocalTransforms(const trs* localTransforms, trs* outGlobalTransforms, mat4* outSkinningMatrices, const trs& worldTransform = trs::identity) const;
-		void getSkinningMatricesFromGlobalTransforms(const trs* globalTransforms, mat4* outSkinningMatrices) const;
-		void getSkinningMatricesFromGlobalTransforms(const trs* globalTransforms, mat4* outSkinningMatrices, const trs& worldTransform) const;
+		void analyze_joints(const vec3* positions, const void* others, uint32 other_stride, uint32 num_vertices);
 
-		std::vector<uint32> getClipsByName(const std::string& name);
+		void blend_local_transforms(const trs* local_transforms1, const trs* local_transforms2, float t, trs* out_blended_local_transforms) const;
+		void get_skinning_matrices_from_local_transforms(const trs* local_transforms, mat4* out_skinning_matrices, const trs& world_transform = trs::identity) const;
+		void get_skinning_matrices_from_local_transforms(const trs* local_transforms, trs* out_global_transforms, mat4* out_skinning_matrices, const trs& world_transform = trs::identity) const;
+		void get_skinning_matrices_from_global_transforms(const trs* global_transforms, mat4* out_skinning_matrices) const;
+		void get_skinning_matrices_from_global_transforms(const trs* global_transforms, mat4* out_skinning_matrices, const trs& world_transform) const;
 
-		void prettyPrintHierarchy() const;
+		void pretty_print_hierarchy() const;
 
+	public:
 		std::vector<SkeletonJoint> joints;
-		std::unordered_map<std::string, uint32> nameToJointID;
+		std::unordered_map<std::string, uint32> name_to_joint_id;
+		SkeletonLimb limbs[limb_type_count];
+	};
+
+	struct ERA_CORE_API AnimationSkeleton
+	{
+		void sampleAnimation(const AnimationClip& clip, float time, trs* outLocalTransforms, trs* outRootMotion = 0) const;
+		void sampleAnimation(uint32 index, float time, trs* outLocalTransforms, trs* outRootMotion = 0) const;
+
+		std::vector<uint32> getClipsByName(const std::string& name);
 
 		std::vector<AnimationClip> clips;
 		std::vector<fs::path> files;
 
-		SkeletonLimb limbs[limb_type_count];
+		Skeleton* skeleton = nullptr;
+	};
+
+	class ERA_CORE_API SkeletonComponent : public Component
+	{
+	public:
+		SkeletonComponent(ref<Entity::EcsData> _data);
+		virtual ~SkeletonComponent();
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	public:
+		Skeleton* skeleton = nullptr;
 	};
 
 	struct ERA_CORE_API AnimationInstance
diff --git a/modules/core/src/animation/animation_system.cpp b/modules/core/src/animation/animation_system.cpp
index ddcf4fecc..0bdf64d27 100644
--- a/modules/core/src/animation/animation_system.cpp
+++ b/modules/core/src/animation/animation_system.cpp
@@ -1,4 +1,7 @@
 #include "animation/animation_system.h"
+#include "animation/animation.h"
+
+#include "rendering/ecs/renderer_holder_root_component.h"
 
 #include "core/cpu_profiling.h"
 #include "core/memory.h"
@@ -6,12 +9,8 @@
 #include "engine/engine.h"
 
 #include "ecs/update_groups.h"
-
-#include "application.h"
-
 #include "ecs/rendering/mesh_component.h"
 #include "ecs/base_components/transform_component.h"
-#include "animation/animation.h"
 
 #include <rttr/policy.h>
 #include <rttr/registration>
@@ -25,12 +24,14 @@ namespace era_engine::animation
 
 		rttr::registration::class_<AnimationSystem>("AnimationSystem")
 			.constructor<World*>()(policy::ctor::as_raw_ptr)
-			.method("update", &AnimationSystem::update)(metadata("update_group", update_types::RENDER));
+			.method("update", &AnimationSystem::update)(metadata("update_group", update_types::BEGIN));
 	}
 
 	AnimationSystem::AnimationSystem(World* _world)
 		: System(_world)
 	{
+		renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
 	}
 
 	AnimationSystem::~AnimationSystem()
@@ -52,7 +53,7 @@ namespace era_engine::animation
 			
 			if (anim.draw_sceleton)
 			{
-				anim.draw_current_skeleton(mesh.mesh, transform.transform, &globalApp.ldrRenderPass);
+				anim.draw_current_skeleton(mesh.mesh, transform.transform, renderer_holder_rc->ldrRenderPass);
 			}
 		}
 		allocator->reset_to_marker(marker);
diff --git a/modules/core/src/animation/animation_system.h b/modules/core/src/animation/animation_system.h
index 75de243ee..2a4248e68 100644
--- a/modules/core/src/animation/animation_system.h
+++ b/modules/core/src/animation/animation_system.h
@@ -5,6 +5,7 @@
 namespace era_engine
 {
 	struct Allocator;
+	class RendererHolderRootComponent;
 }
 
 namespace era_engine::animation
@@ -21,5 +22,6 @@ namespace era_engine::animation
 		ERA_VIRTUAL_REFLECT(System)
 	private:
 		Allocator* allocator = nullptr;
+		RendererHolderRootComponent* renderer_holder_rc = nullptr;
 	};
 }
\ No newline at end of file
diff --git a/modules/core/src/application.cpp b/modules/core/src/application.cpp
deleted file mode 100644
index 2ae3b36e2..000000000
--- a/modules/core/src/application.cpp
+++ /dev/null
@@ -1,858 +0,0 @@
-// Copyright (c) 2023-present Eldar Muradov. All rights reserved.
-
-#include "application.h"
-
-#include "core/random.h"
-#include "core/color.h"
-#include "core/imgui.h"
-#include "core/threading.h"
-#include "core/coroutine.h"
-#include "core/event_queue.h"
-
-#include "geometry/mesh_builder.h"
-
-#include "dx/dx_texture.h"
-#include "dx/dx_context.h"
-#include "dx/dx_profiling.h"
-
-#include "rendering/outline.h"
-#include "rendering/mesh_shader.h"
-#include "rendering/shadow_map.h"
-#include "rendering/debug_visualization.h"
-
-#include "audio/audio.h"
-
-#include "terrain/terrain.h"
-#include "terrain/proc_placement.h"
-#include "terrain/grass.h"
-#include "terrain/water.h"
-#include "terrain/tree.h"
-
-#include "animation/skinning.h"
-
-#include "asset/model_asset.h"
-#include "asset/file_registry.h"
-
-#include "ai/navigation.h"
-#include "ai/navigation_component.h"
-
-//#include "scripting/script.h"
-//#include "scripting/native_scripting_linker.h"
-
-#include "ecs/visitor/visitor.h"
-#include "ecs/world.h"
-#include "ecs/entity.h"
-#include "ecs/base_components/base_components.h"
-#include "ecs/rendering/mesh_component.h"
-#include "ecs/rendering/world_renderer.h"
-#include "ecs/reflection_utils.h"
-#include "ecs/editor/entity_editor_utils.h"
-
-//#include "physics/core/physics.h"
-//#include "physics/aggregate.h"
-//#include "physics/body_component.h"
-//#include "physics/shape_component.h"
-//#include "physics/basic_objects.h"
-
-namespace era_engine
-{
-	static raytracing_object_type defineBlasFromMesh(const ref<multi_mesh>& mesh)
-	{
-		if (dxContext.featureSupport.raytracing())
-		{
-			raytracing_blas_builder blasBuilder;
-			std::vector<ref<pbr_material>> raytracingMaterials;
-
-			for (auto& sm : mesh->submeshes)
-			{
-				blasBuilder.push(mesh->mesh.vertexBuffer, mesh->mesh.indexBuffer, sm.info);
-				raytracingMaterials.push_back(sm.material);
-			}
-
-			ref<raytracing_blas> blas = blasBuilder.finish();
-			raytracing_object_type type = pbr_raytracer::defineObjectType(blas, raytracingMaterials);
-			return type;
-		}
-		else
-		{
-			return {};
-		}
-	}
-
-	void addRaytracingComponentAsync(Entity entity, ref<multi_mesh> mesh)
-	{
-		struct add_ray_tracing_data
-		{
-			Entity entity;
-			ref<multi_mesh> mesh;
-		};
-
-		add_ray_tracing_data data = { entity, mesh };
-
-		low_priority_job_queue.createJob<add_ray_tracing_data>([](add_ray_tracing_data& data, JobHandle)
-			{
-				data.mesh->loadJob.wait_for_completion();
-
-				struct create_component_data
-				{
-					Entity entity;
-					raytracing_object_type blas;
-				};
-
-				create_component_data createData = { data.entity, defineBlasFromMesh(data.mesh) };
-
-				main_thread_job_queue.createJob<create_component_data>([](create_component_data& data, JobHandle)
-					{
-						data.entity.add_component<RaytraceComponent>(data.blas);
-					}, createData).submit_now();
-
-			}, data).submit_now();
-	}
-
-	//struct update_scripting_data
-	//{
-	//	float deltaTime{};
-	//	ref<dotnet::enative_scripting_linker> core;
-	//	ref<World> world;
-	//	const user_input& input;
-	//};
-
-	SpinLock scriptingSync;
-
-	//void updatePhysXCallbacksAndScripting(ref<World> current_world, ref<dotnet::enative_scripting_linker> core, float dt, const user_input& in)
-	//{
-		/*update_scripting_data data = { dt, core, current_world, in };
-
-		highPriorityJobQueue.createJob<update_scripting_data>([](update_scripting_data& data, job_handle)
-			{
-				try
-				{
-					shared_spin_lock lock{ scriptingSync };
-					{
-						const auto& physicsRef = physics::PhysicsHolder::physics_ref;
-
-						{
-							CPU_PROFILE_BLOCK("PhysX collision events step");
-
-							{
-								physics::CollisionHandlingData collData;
-								while (physicsRef->collision_queue.try_dequeue(collData))
-								{
-									data.core->handle_coll(static_cast<int>(collData.id1), static_cast<int>(collData.id2));
-								}
-							}
-
-							{
-								physics::CollisionHandlingData collData;
-								while (physicsRef->collision_exit_queue.try_dequeue(collData))
-								{
-									data.core->handle_exit_coll(static_cast<int>(collData.id1), static_cast<int>(collData.id2));
-								}
-							}
-						}
-					}
-				}
-				catch(std::exception& ex)
-				{
-					LOG_ERROR(ex.what());
-				}
-			}, data).submitNow();
-
-		updateScripting(data);
-
-		{
-			CPU_PROFILE_BLOCK(".NET 8 Input sync step");
-			core->handleInput(reinterpret_cast<uintptr_t>(&in.keyboard[0]));
-		}*/
-
-		//const auto& nav_objects = data.scene.group(component_group<ai::navigation_component, transform_component>);
-
-		//if (nav_objects.size())
-		//{
-		//	struct nav_process_data
-		//	{
-		//		decltype(nav_objects) objects;
-		//	};
-
-		//	nav_process_data nav_data{ nav_objects };
-
-		//	lowPriorityJobQueue.createJob<nav_process_data>([](nav_process_data& data, job_handle)
-		//		{
-		//			CPU_PROFILE_BLOCK("Navigation step");
-		//			for (auto [entityHandle, nav, transform] : data.objects.each())
-		//			{
-		//				nav.processPath();
-		//			}
-		//		}, nav_data).submitNow();
-		//}
-	//}
-
-	//void updateScripting(update_scripting_data& data)
-	//{
-	//	CPU_PROFILE_BLOCK(".NET 8.0 scripting step");
-	//	if (!data.world->size())
-	//	{
-	//		return;
-	//	}
-
-	//	auto group = data.world->group(components_group<ecs::ScriptsComponent, TransformComponent>);
-
-	//	if (group.empty())
-	//	{
-	//		return;
-	//	}
-
-	//	for (auto [entityHandle, script, transform] : group.each())
-	//	{
-	//		const auto& mat = trsToMat4(transform.transform);
-	//		constexpr size_t mat_size = 16;
-	//		float* ptr = new float[mat_size];
-	//		for (size_t i = 0; i < mat_size; i++)
-	//			ptr[i] = mat.m[i];
-	//		data.core->process_trs(reinterpret_cast<uintptr_t>(ptr), (int)entityHandle);
-	//		//delete[] ptr; // CoreRT/CLR clear's it
-	//	}
-	//	data.core->update(data.deltaTime);
-	//}
-
-	static void initializeAnimationComponentAsync(Entity entity, ref<multi_mesh> mesh)
-	{
-		struct add_animation_data
-		{
-			Entity entity;
-			ref<multi_mesh> mesh;
-		};
-
-		add_animation_data data = { entity, mesh };
-
-		main_thread_job_queue.createJob<add_animation_data>([](add_animation_data& data, JobHandle job)
-			{
-				data.mesh->loadJob.wait_for_completion();
-				data.entity.get_component<animation::AnimationComponent>().initialize(data.mesh->skeleton.clips);
-			}, data).submit_now();
-	}
-
-	void application::loadCustomShaders()
-	{
-		if (dxContext.featureSupport.meshShaders())
-		{
-			initializeMeshShader();
-		}
-	}
-
-	static void initTestScene(ref<World> game_world)
-	{
-		Entity entity1 = game_world->create_entity("Entity1");
-		Entity entity2 = game_world->create_entity("Entity2");
-
-		auto defaultmat = createPBRMaterialAsync({ "", "" });
-		defaultmat->shader = pbr_material_shader_double_sided;
-
-		mesh_builder builder;
-
-		auto sphereMesh = make_ref<multi_mesh>();
-		builder.pushSphere({ });
-		sphereMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultmat });
-
-		auto boxMesh = make_ref<multi_mesh>();
-		builder.pushBox({ vec3(0.f), vec3(1.f, 1.f, 2.f) });
-		boxMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultmat });
-
-		PbrMaterialDesc defaultPlaneMatDesc;
-		defaultPlaneMatDesc.albedo = get_asset_path("/resources/assets/uv.jpg");
-		defaultPlaneMatDesc.normal = "";
-		defaultPlaneMatDesc.roughness = "";
-		defaultPlaneMatDesc.uv_scale = 15.0f;
-		defaultPlaneMatDesc.metallic_override = 0.35f;
-		defaultPlaneMatDesc.roughness_override = 0.01f;
-
-		auto defaultPlaneMat = createPBRMaterialAsync(defaultPlaneMatDesc);
-
-		auto groundMesh = make_ref<multi_mesh>();
-		builder.pushBox({ vec3(0.f), vec3(30.f, 4.f, 30.f) });
-		groundMesh->submeshes.push_back({ builder.endSubmesh(), {}, trs::identity, defaultPlaneMat });
-
-		/*{
-			Entity entity3 = game_world->create_entity("Entity3").add_component<MeshComponent>(sphereMesh, false)
-				.add_component<physics::SphereShapeComponent>(1.0f)
-				.add_component<physics::DynamicBodyComponent>();
-			sphereMesh->mesh = builder.createDXMesh();
-		}*/
-
-		if (auto mesh = loadAnimatedMeshFromFileAsync(get_asset_path("/resources/assets/veribot/source/VERIBOT_final.fbx")))
-		{
-			auto& en = game_world->create_entity("Veribot")
-				.add_component<animation::AnimationComponent>()
-				.add_component<MeshComponent>(mesh);
-
-			TransformComponent& transform_component = en.get_component<TransformComponent>();
-			transform_component.type = TransformComponent::DYNAMIC;
-			transform_component.transform.position = vec3(5.0f);
-
-			initializeAnimationComponentAsync(en, mesh);
-			addRaytracingComponentAsync(en, mesh);
-		}
-
-		if (auto mesh = loadMeshFromFileAsync(get_asset_path("/resources/assets/Sponza/sponza.obj")))
-		{
-			auto& sponza = game_world->create_entity("Sponza")
-				.add_component<MeshComponent>(mesh);
-
-			TransformComponent& transform_component = sponza.get_component<TransformComponent>();
-			transform_component.transform.position = vec3(5.0f, -3.75f, 35.0f);
-			transform_component.transform.scale = vec3(0.01f);
-
-			addRaytracingComponentAsync(sponza, mesh);
-		}
-
-		/*Entity plane = game_world->create_entity("Platform")
-			.add_component<TransformComponent>(vec3(10, -9.f, 0.f), quat(vec3(1.f, 0.f, 0.f), deg2rad(0.f)), vec3(5.0f, 1.0f, 5.0f))
-			.add_component<physics::PlaneComponent>(vec3(0.f, -5.0, 0.0f), vec3(0.0f, 1.0f, 0.0f))
-			.add_component<MeshComponent>(groundMesh);
-
-		{
-			TransformComponent& transform_component = plane.get_component<TransformComponent>();
-			transform_component.transform.position = vec3(10.0f, -9.0f, 0.0f);
-			transform_component.transform.scale = vec3(5.0f, 1.0f, 5.0f);
-		}*/
-
-		auto chainMesh = make_ref<multi_mesh>();
-
-		groundMesh->mesh =
-			boxMesh->mesh =
-			sphereMesh->mesh =
-			chainMesh->mesh =
-			builder.createDXMesh();
-
-		//auto& terrain = game_world->create_entity("Terrain")
-		//	.add_component<TerrainComponent>(10u, 64.0f, 50.f, defaultPlaneMat, defaultPlaneMat, defaultPlaneMat)
-		//	.add_component<GrassComponent>();
-		//{
-		//	TransformComponent& transform_component = terrain.get_component<TransformComponent>();
-		//	transform_component.transform.position = vec3(0.0f, -64.0f, 0.0f);
-		//}	
-
-		//auto& water = game_world->create_entity("Water")
-		//	.add_component<WaterComponent>();
-		//{
-		//	TransformComponent& transform_component = water.get_component<TransformComponent>();
-		//	transform_component.transform.position = vec3(-3.920f, -48.689f, -85.580f);
-		//	transform_component.transform.scale = vec3(90.0f);
-		//}
-#if 0
-		if (auto treeMesh = loadTreeMeshFromFileAsync(getAssetPath("/resources/assets/tree/source/tree.fbx")))
-		{
-			auto tree = scene.createEntity("Tree")
-				.addComponent<transform_component>(vec3(0.0, 0.0f, 0.0f), quat::identity, 0.1f)
-				.addComponent<mesh_component>(treeMesh)
-				.addComponent<tree_component>();
-		}
-#endif
-
-#ifndef ERA_RUNTIME
-		{
-
-			//model_asset ass = load3DModelFromFile(getAssetPath("/resources/assets/sphere.fbx"));
-			//auto& px_sphere_entt = scene.createEntity("SpherePX", (entity_handle)60)
-			//	.addComponent<transform_component>(vec3(-10.0f, 5.0f, -3.0f), quat(vec3(0.f, 0.f, 0.f), deg2rad(1.f)), vec3(1.f))
-			//	.addComponent<mesh_component>(sphereMesh)
-				//.addComponent<physics::px_convex_mesh_collider_component>(&(ass.meshes[0]))
-				//.addComponent<physics::px_triangle_mesh_collider_component>(&(ass.meshes[0]))
-				//.addComponent<physics::px_bounding_box_collider_component>(&(ass.meshes[0]))
-			//	.addComponent<physics::px_sphere_collider_component>(1.0f)
-			//	.addComponent<physics::px_dynamic_body_component>();
-			//px_sphere_entt.getComponent<physics::px_dynamic_body_component>().setMass(1000.f);
-			//px_sphere_entt.getComponent<physics::px_dynamic_body_component>().setCCD(true);
-			//px_sphere_entt.getComponent<physics::px_dynamic_body_component>().setFilterMask(1, 2);
-			//sphere = px_sphere_entt.handle;
-
-			//auto px_sphere1 = &scene.createEntity("SpherePX1", (entity_handle)59)
-			//	.addComponent<transform_component>(vec3(5, 155.f, 5), quat(vec3(0.f, 0.f, 0.f), deg2rad(1.f)), vec3(5.f))
-			//	.addComponent<mesh_component>(sphereMesh)
-			//	.addComponent<physics::px_sphere_collider_component>(5.0f)
-			//	.addComponent<physics::px_dynamic_body_component>();
-			//px_sphere1->getComponent<physics::px_dynamic_body_component>().setCCD(true);
-			//px_sphere1->getComponent<physics::px_dynamic_body_component>().setMass(500.0f);
-			//px_sphere1->getComponent<physics::px_dynamic_body_component>().setFilterMask(2, 1 | 3);
-
-			//px_sphere1->getComponent<physics::px_dynamic_body_component>().setFilterMask(3, 1);
-			//if (auto mesh = loadAnimatedMeshFromFileAsync(getAssetPath("/resources/assets/veribot/source/VERIBOT_final.fbx")))
-			//{
-			//	auto& en = scene.createEntity("Veribot", (entity_handle)15)
-			//		.addComponent<transform_component>(vec3(0.f), quat::identity)
-			//		.addComponent<animation_component>()
-			//		.addComponent<dynamic_transform_component>()
-			//		.addComponent<mesh_component>(mesh);
-			//	initializeAnimationComponentAsync(en, mesh);
-			//	addRaytracingComponentAsync(en, mesh);
-			//}
-
-			/*if (auto mesh = loadAnimatedMeshFromFileAsync(getAssetPath("/resources/assets/resident-evil-tyrant/source/UmodelExport.fbx")))
-			{
-				auto& en = scene.createEntity("Ragdoll")
-					.addComponent<transform_component>(vec3(0.0f), quat::identity, vec3(0.1f))
-					.addComponent<animation::animation_component>()
-					.addComponent<dynamic_transform_component>()
-					.addComponent<mesh_component>(mesh)
-					.addComponent<physics::px_ragdoll_component>(vec3(0.0f));
-				initializeAnimationComponentAsync(en, mesh);
-				addRaytracingComponentAsync(en, mesh);
-
-				struct ragdoll_load_data
-				{ 
-					entity_handle handle;
-					escene& scene;
-				} ragdoll_data = {en.handle, scene};
-
-				mainThreadJobQueue.createJob<ragdoll_load_data>([](ragdoll_load_data& data, job_handle handle) 
-					{
-						eentity rag{ data.handle, &data.scene.registry };
-
-						rag.getComponent<physics::px_ragdoll_component>().initRagdoll(make_ref<animation::animation_skeleton>(rag.getComponent<mesh_component>().mesh->skeleton));
-					},
-					ragdoll_data).submitAfter(mesh->loadJob);
-			}*/
-
-
-#if PX_BLAST_ENABLE
-
-			//{
-			//	if (auto mesh = loadMeshFromFileAsync(getAssetPath("/resources/assets/obj/untitled.obj")))
-			//	{
-			//		model_asset ass = load3DModelFromFile(getAssetPath("/resources/assets/obj/untitled.obj"));
-
-			//		auto& px_blast_entt1 = scene.createEntity("BlastPXTest")
-			//			.addComponent<transform_component>(vec3(0.0f, 5.0f, 0.0f), quat::identity, vec3(1.0f))
-			//			.addComponent<mesh_component>(mesh);
-
-			//		physics::fracture fracture;
-			//		auto ref = make_ref<submesh_asset>(ass.meshes[0].submeshes[0]);
-			//		unsigned int seed = 7249U;
-			//		fracture.fractureGameObject(ref, px_blast_entt1, physics::anchor::anchor_none, seed, 15, defaultmat, defaultmat, 20.0f, 1.0f);
-			//		scene.deleteEntity(px_blast_entt1.handle);
-			//	}
-			//}
-
-#endif
-
-			//{
-			//	model_asset ass = load3DModelFromFile(getAssetPath("/resources/assets/box.fbx"));
-			//	auto& px_sphere_entt1 = scene.createEntity("BoxPXTest")
-			//		.addComponent<transform_component>(vec3(0, 0.f, 0.f), quat(vec3(0.f, 0.f, 0.f), deg2rad(1.f)), vec3(1.0f))
-			//		.addComponent<mesh_component>(boxMesh);
-
-			//	physics::fracture fracture;
-			//	auto ref = make_ref<submesh_asset>(ass.meshes[0].submeshes[0]);
-			//	unsigned int seed = 7249U;
-			//	fracture.fractureGameObject(ref, px_sphere_entt1, physics::anchor::anchor_bottom, seed, 50, defaultmat, defaultmat, 0.75f, 0.1f);
-			//	scene.deleteEntity(px_sphere_entt1.handle);
-			//}
-
-			//auto& vehicle = scene.createEntity("Vehicle")
-			//	.addComponent<transform_component>(vec3(2.f, 10.0f, 5.0f), quat::identity, vec3(1.f))
-			//	.addComponent<physics::px_4_wheels_vehicle_component>(vec3(2.f));
-
-			//vehicle.getComponent<physics::px_4_wheels_vehicle_component>().setupVehicle();
-
-			//auto soft_body = &scene.createEntity("SoftBody")
-			//	.addComponent<transform_component>(vec3(0.f), quat::identity, vec3(1.f))
-			//	.addComponent<physics::px_soft_body_component>();
-
-			//px_sphere1->addChild(*px_sphere);
-
-			//{
-			//	for (int i = 0; i < 10; i++)
-			//	{
-			//		for (int j = 0; j < 10; j++)
-			//		{
-			//			for (int k = 0; k < 10; k++)
-			//			{
-			//				auto sphr = &scene.createEntity((std::to_string(i) + std::to_string(j) + std::to_string(k)).c_str())
-			//					.addComponent<transform_component>(vec3(2.0f * i, 5 + 2.0f * j + 5, 2.0f * k), quat(vec3(0.f, 0.f, 0.f), deg2rad(1.f)), vec3(1.f))
-			//					.addComponent<mesh_component>(sphereMesh)
-			//					.addComponent<physics::px_sphere_collider_component>(1.0f)
-			//					.addComponent<physics::px_dynamic_body_component>();
-			//			}
-			//		}
-			//	}
-			//}
-
-			//auto px_cct = &scene.createEntity("CharacterControllerPx")
-			//	.addComponent<transform_component>(vec3(20.f, 5, -5.f), quat(vec3(0.f, 0.f, 0.f), deg2rad(1.f)), vec3(1.f))
-			//	.addComponent<physics::px_box_cct_component>(1.0f, 0.5f, 1.0f);
-
-			//auto& particles = scene.createEntity("ParticlesPX")
-			//	.addComponent<transform_component>(vec3(0.f, 10.0f, 0.0f), quat::identity, vec3(1.f))
-			//	.addComponent<physics::px_particles_component>(vec3(0.f, 10.0f, 0.0f), 10, 10, 10, false);
-
-			//auto& cloth = scene.createEntity("ClothPX")
-			//	.addComponent<transform_component>(vec3(0.f, 15.0f, 0.0f), eulerToQuat(vec3(0.0f, 0.0f, 0.0f)), vec3(1.f))
-			//	.addComponent<physics::px_cloth_component>(100, 100, vec3(0.f, 15.0f, 0.0f));
-		}
-#endif
-#if 0
-		fireParticleSystem.initialize(10000, 50.f, getAssetPath("/resources/assets/particles/fire_explosion.png"), 6, 6, vec3(0, 1, 30));
-		smokeParticleSystem.initialize(10000, 500.f, getAssetPath("/resources/assets/particles/smoke1.tif"), 5, 5, vec3(0, 1, 15));
-		//boidParticleSystem.initialize(10000, 2000.f);
-		debrisParticleSystem.initialize(10000);
-#endif
-	}
-
-	void application::initialize(main_renderer* renderer, editor_panels* editorPanels)
-	{
-		this->renderer = renderer;
-
-		world_scene = make_ref<EditorScene>();
-		world_scene->init();
-
-		if (dxContext.featureSupport.raytracing())
-		{
-			raytracingTLAS.initialize();
-		}
-
-		world_scene->camera.initializeIngame(vec3(0.f, 1.f, 5.f), quat::identity, deg2rad(70.f), 0.2f);
-		world_scene->editor_camera.initializeIngame(vec3(0.f, 1.f, 5.f), quat::identity, deg2rad(70.f), 0.2f);
-		world_scene->environment.setFromTexture(get_asset_path("/resources/assets/sky/sunset_in_the_chalk_quarry_4k.hdr"));
-		world_scene->environment.lightProbeGrid.initialize(vec3(-20.f, -1.f, -20.f), vec3(40.f, 20.f, 40.f), 1.5f);
-
-		ref<World> world = world_scene->get_current_world();
-
-		/*{
-			CPU_PROFILE_BLOCK("Binding for scripting initialization");
-			linker = make_ref<era_engine::dotnet::enative_scripting_linker>(world.get());
-			linker->init();
-		}*/
-
-#ifndef ERA_RUNTIME
-
-		editor.initialize(world_scene, renderer, editorPanels);
-		editor.app = this;
-
-#else
-
-		rt.initialize(&this->scene, renderer);
-
-#endif
-
-		initTestScene(world);
-
-		world_scene->sun.direction = normalize(vec3(-0.6f, -1.f, -0.3f));
-		world_scene->sun.color = vec3(1.f, 0.93f, 0.76f);
-		world_scene->sun.intensity = 11.1f;
-		world_scene->sun.numShadowCascades = 3;
-		world_scene->sun.shadowDimensions = 2048;
-		world_scene->sun.cascadeDistances = vec4(9.f, 25.f, 50.f, 10000.f);
-		world_scene->sun.bias = vec4(0.000588f, 0.000784f, 0.000824f, 0.0035f);
-		world_scene->sun.blendDistances = vec4(5.f, 10.f, 10.f, 10.f);
-		world_scene->sun.stabilize = true;
-
-		for (uint32 i = 0; i < NUM_BUFFERED_FRAMES; ++i)
-		{
-			pointLightBuffer[i] = createUploadBuffer(sizeof(point_light_cb), 512, 0);
-			spotLightBuffer[i] = createUploadBuffer(sizeof(spot_light_cb), 512, 0);
-			decalBuffer[i] = createUploadBuffer(sizeof(pbr_decal_cb), 512, 0);
-
-			spotLightShadowInfoBuffer[i] = createUploadBuffer(sizeof(spot_shadow_info), 512, 0);
-			pointLightShadowInfoBuffer[i] = createUploadBuffer(sizeof(point_shadow_info), 512, 0);
-
-			SET_NAME(pointLightBuffer[i]->resource, "Point lights");
-			SET_NAME(spotLightBuffer[i]->resource, "Spot lights");
-			SET_NAME(decalBuffer[i]->resource, "Decals");
-
-			SET_NAME(spotLightShadowInfoBuffer[i]->resource, "Spot light shadow infos");
-			SET_NAME(pointLightShadowInfoBuffer[i]->resource, "Point light shadow infos");
-		}
-
-		stackArena.initialize();
-	}
-
-#if 0
-	bool editFireParticleSystem(fire_particle_system& particleSystem)
-	{
-		bool result = false;
-		if (ImGui::BeginTree("Fire particles"))
-		{
-			if (ImGui::BeginProperties())
-			{
-				result |= ImGui::PropertySlider("Emit rate", particleSystem.emitRate, 0.f, 1000.f);
-				ImGui::EndProperties();
-			}
-
-			result |= ImGui::Spline("Size over lifetime", ImVec2(200, 200), particleSystem.settings.sizeOverLifetime);
-			ImGui::Separator();
-			result |= ImGui::Spline("Atlas progression over lifetime", ImVec2(200, 200), particleSystem.settings.atlasProgressionOverLifetime);
-			ImGui::Separator();
-			result |= ImGui::Spline("Intensity over lifetime", ImVec2(200, 200), particleSystem.settings.intensityOverLifetime);
-
-			ImGui::EndTree();
-		}
-		return result;
-	}
-
-	bool editBoidParticleSystem(boid_particle_system& particleSystem)
-	{
-		bool result = false;
-		if (ImGui::BeginTree("Boid particles"))
-		{
-			if (ImGui::BeginProperties())
-			{
-				result |= ImGui::PropertySlider("Emit rate", particleSystem.emitRate, 0.f, 5000.f);
-				result |= ImGui::PropertySlider("Emit radius", particleSystem.settings.radius, 5.f, 100.f);
-				ImGui::EndProperties();
-			}
-
-			ImGui::EndTree();
-		}
-		return result;
-	}
-
-#endif
-
-	void application::resetRenderPasses()
-	{
-		opaqueRenderPass.reset();
-		transparentRenderPass.reset();
-		ldrRenderPass.reset();
-		sunShadowRenderPass.reset();
-		computePass.reset();
-
-		for (uint32 i = 0; i < arraysize(spotShadowRenderPasses); ++i)
-		{
-			spotShadowRenderPasses[i].reset();
-		}
-
-		for (uint32 i = 0; i < arraysize(pointShadowRenderPasses); ++i)
-		{
-			pointShadowRenderPasses[i].reset();
-		}
-	}
-
-	void application::submitRendererParams(uint32 numSpotLightShadowPasses, uint32 numPointLightShadowPasses)
-	{
-		{
-			CPU_PROFILE_BLOCK("Sort render passes");
-
-			opaqueRenderPass.sort();
-			transparentRenderPass.sort();
-			ldrRenderPass.sort();
-
-			for (uint32 i = 0; i < sunShadowRenderPass.numCascades; ++i)
-			{
-				sunShadowRenderPass.cascades[i].sort();
-			}
-
-			for (uint32 i = 0; i < numSpotLightShadowPasses; ++i)
-			{
-				spotShadowRenderPasses[i].sort();
-			}
-
-			for (uint32 i = 0; i < numPointLightShadowPasses; ++i)
-			{
-				pointShadowRenderPasses[i].sort();
-			}
-		}
-
-		renderer->submitRenderPass(&opaqueRenderPass);
-		renderer->submitRenderPass(&transparentRenderPass);
-		renderer->submitRenderPass(&ldrRenderPass);
-		renderer->submitComputePass(&computePass);
-
-		renderer->submitShadowRenderPass(&sunShadowRenderPass);
-
-		for (uint32 i = 0; i < numSpotLightShadowPasses; ++i)
-		{
-			renderer->submitShadowRenderPass(&spotShadowRenderPasses[i]);
-		}
-
-		for (uint32 i = 0; i < numPointLightShadowPasses; ++i)
-		{
-			renderer->submitShadowRenderPass(&pointShadowRenderPasses[i]);
-		}
-	}
-
-	static void updateTestScene(float dt, ref<World> world, const UserInput& input)
-	{
-		// Particles
-#if 0
-		computePass.dt = dt;
-		//computePass.updateParticleSystem(&boidParticleSystem);
-		computePass.updateParticleSystem(&fireParticleSystem);
-		computePass.updateParticleSystem(&smokeParticleSystem);
-		computePass.updateParticleSystem(&debrisParticleSystem);
-
-		//boidParticleSystem.render(&transparentRenderPass);
-		fireParticleSystem.render(&transparentRenderPass);
-		smokeParticleSystem.render(&transparentRenderPass);
-		debrisParticleSystem.render(&transparentRenderPass);
-#endif
-	}
-
-	void application::update(const UserInput& input, float dt)
-	{
-		resetRenderPasses();
-
-		stackArena.reset();
-
-#ifndef ERA_RUNTIME
-
-		bool objectDragged = editor.update(input, &ldrRenderPass, dt);
-		editor.render(&ldrRenderPass, dt);
-
-		render_camera& camera = this->world_scene->is_pausable() ? world_scene->editor_camera : world_scene->camera;
-
-#else
-
-		bool objectDragged = false;
-
-		render_camera& camera = world_scene->camera;
-
-		rt.update();
-
-#endif
-
-		directional_light& sun = world_scene->sun;
-		pbr_environment& environment = world_scene->environment;
-
-		environment.update(sun.direction);
-		sun.updateMatrices(camera);
-		setAudioListener(camera.position, camera.rotation, vec3(0.f));
-		environment.lightProbeGrid.visualize(&opaqueRenderPass);
-
-		ref<World> world = world_scene->get_current_world();
-
-		float unscaledDt = dt;
-		dt *= world_scene->get_timestep_scale();
-
-		bool running = world_scene->is_pausable();
-
-#ifndef ERA_RUNTIME
-
-		Entity selectedEntity = editor.selectedEntity;
-
-#else
-
-		Entity selectedEntity = Entity::Null;
-
-#endif
-
-		updateTestScene(dt, world, input);
-
-		{
-			for (auto [entityHandle, transform, terrain] : world->group(components_group<TransformComponent, TerrainComponent>).each())
-			{
-				terrain.update();
-			}
-
-			scene_lighting lighting;
-			lighting.spotLightBuffer = spotLightBuffer[dxContext.bufferedFrameID];
-			lighting.pointLightBuffer = pointLightBuffer[dxContext.bufferedFrameID];
-			lighting.spotLightShadowInfoBuffer = spotLightShadowInfoBuffer[dxContext.bufferedFrameID];
-			lighting.pointLightShadowInfoBuffer = pointLightShadowInfoBuffer[dxContext.bufferedFrameID];
-			lighting.spotShadowRenderPasses = spotShadowRenderPasses;
-			lighting.pointShadowRenderPasses = pointShadowRenderPasses;
-			lighting.maxNumSpotShadowRenderPasses = arraysize(spotShadowRenderPasses);
-			lighting.maxNumPointShadowRenderPasses = arraysize(pointShadowRenderPasses);
-
-			Entity::Handle handle = selectedEntity.is_valid() ? selectedEntity.get_handle() : Entity::NullHandle;
-
-			render_world(camera, world, stackArena, handle, sun, lighting, !renderer->settings.cacheShadowMap,
-				&opaqueRenderPass, &transparentRenderPass, &ldrRenderPass, &sunShadowRenderPass, &computePass, unscaledDt);
-
-			renderer->setSpotLights(spotLightBuffer[dxContext.bufferedFrameID], world->number_of_components_of_type<SpotLightComponent>(), spotLightShadowInfoBuffer[dxContext.bufferedFrameID]);
-			renderer->setPointLights(pointLightBuffer[dxContext.bufferedFrameID], world->number_of_components_of_type<PointLightComponent>(), pointLightShadowInfoBuffer[dxContext.bufferedFrameID]);
-		
-			if (decals.size())
-			{
-				updateUploadBufferData(decalBuffer[dxContext.bufferedFrameID], decals.data(), (uint32)(sizeof(pbr_decal_cb) * decals.size()));
-				renderer->setDecals(decalBuffer[dxContext.bufferedFrameID], (uint32)decals.size(), decalTexture);
-			}
-#ifndef ERA_RUNTIME
-
-			if (selectedEntity != Entity::Null)
-			{
-				TransformComponent& transform = selectedEntity.get_component<TransformComponent>();
-
-				if (PointLightComponent* pl = selectedEntity.get_component_if_exists<PointLightComponent>())
-				{
-					renderWireSphere(transform.transform.position, pl->radius, vec4(pl->color, 1.f), &ldrRenderPass);
-				}
-				else if (SpotLightComponent* sl = selectedEntity.get_component_if_exists<SpotLightComponent>())
-				{
-					renderWireCone(transform.transform.position, transform.transform.rotation * vec3(0.f, 0.f, -1.f),
-						sl->distance, sl->outerAngle * 2.f, vec4(sl->color, 1.f), &ldrRenderPass);
-				}
-				//else if (physics::CapsuleShapeComponent* shape = selectedEntity.get_component_if_exists<physics::CapsuleShapeComponent>())
-				//{
-				//	//renderWireCapsule(transform.transform.position, transform.transform.position + vec3(0, cct->height, 0), cct->radius, vec4(0.107f, 1.0f, 0.0f, 1.0f), &ldrRenderPass);
-				//}
-				//else if (physics::BoxShapeComponent* shape = selectedEntity.get_component_if_exists<physics::BoxShapeComponent>())
-				//{
-				//	//renderWireBox(transform.transform.position, vec3(cct->halfSideExtent, cct->halfHeight * 2, cct->halfSideExtent), transform.transform.rotation, vec4(0.107f, 1.0f, 0.0f, 1.0f), &ldrRenderPass);
-				//}
-			}
-#endif
-			submitRendererParams(lighting.numSpotShadowRenderPasses, lighting.numPointShadowRenderPasses);
-		}
-
-		animation::performSkinning(&computePass);
-
-		if (dxContext.featureSupport.raytracing())
-		{
-			raytracingTLAS.reset();
-
-			for (auto [entityHandle, transform, raytrace] : world->group(components_group<TransformComponent, RaytraceComponent>).each())
-			{
-				auto handle = raytracingTLAS.instantiate(raytrace.type, transform.transform);
-			}
-
-			renderer->setRaytracingScene(&raytracingTLAS);
-		}
-
-		renderer->setEnvironment(environment);
-		renderer->setSun(sun);
-		renderer->setCamera(camera);
-
-#ifndef ERA_RUNTIME
-		editor.visualizePhysics(&ldrRenderPass);
-#endif
-	}
-
-	void application::handleFileDrop(const fs::path& filename)
-	{
-		fs::path path = filename;
-		fs::path relative = fs::relative(path, fs::current_path());
-		fs::path ext = relative.extension();
-
-		if (is_mesh_extension(ext))
-		{
-			fs::path path = filename;
-			path = path.stem();
-
-			ref<World> world = world_scene->get_current_world();
-			if (auto mesh = loadAnimatedMeshFromFileAsync(relative.string()))
-			{
-				auto& entity = world->create_entity("Veribot")
-					.add_component<animation::AnimationComponent>()
-					.add_component<MeshComponent>(mesh);
-
-				TransformComponent& transform_component = entity.get_component<TransformComponent>();
-				transform_component.type = TransformComponent::DYNAMIC;
-
-				initializeAnimationComponentAsync(entity, mesh);
-				addRaytracingComponentAsync(entity, mesh);
-			}
-			else if (auto mesh = loadMeshFromFileAsync(relative.string()))
-			{
-				auto& entity = world->create_entity("Veribot")
-					.add_component<animation::AnimationComponent>()
-					.add_component<MeshComponent>(mesh);
-
-				addRaytracingComponentAsync(entity, mesh);
-			}
-		}
-		else if (ext == ".hdr")
-		{
-			world_scene->environment.setFromTexture(relative);
-		}
-	}
-}
\ No newline at end of file
diff --git a/modules/core/src/application.h b/modules/core/src/application.h
deleted file mode 100644
index db4b84486..000000000
--- a/modules/core/src/application.h
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (c) 2023-present Eldar Muradov. All rights reserved.
-
-#pragma once
-
-#include "core/math.h"
-#include "core/input.h"
-#include "core/camera.h"
-#include "core/camera_controller.h"
-
-#include "geometry/mesh.h"
-
-#include "particles/fire_particle_system.h"
-#include "particles/smoke_particle_system.h"
-#include "particles/boid_particle_system.h"
-#include "particles/debris_particle_system.h"
-
-#include "rendering/raytracing.h"
-#include "rendering/main_renderer.h"
-
-#ifdef ERA_RUNTIME
-#include "core/runtime.h"
-#endif
-
-#include "ecs/world_system_scheduler.h"
-
-#include "editor/asset_editor_panel.h"
-#include "editor/editor.h"
-
-namespace era_engine
-{
-	namespace dotnet
-	{
-		//struct enative_scripting_linker;
-	}
-
-	void addRaytracingComponentAsync(Entity entity, ref<multi_mesh> mesh);
-
-	bool editFireParticleSystem(fire_particle_system& particleSystem);
-	bool editBoidParticleSystem(boid_particle_system& particleSystem);
-
-	//struct update_scripting_data;
-	//void updatePhysXCallbacksAndScripting(ref<World> current_world, ref<dotnet::enative_scripting_linker> core, float dt, const user_input& in);
-	//void updateScripting(update_scripting_data& data);
-
-	struct application
-	{
-		application() {}
-		void loadCustomShaders();
-		void initialize(main_renderer* renderer, editor_panels* editorPanels);
-		void update(const UserInput& input, float dt);
-
-		void handleFileDrop(const fs::path& filename);
-
-		ref<World> getCurrentWorld() const { return world_scene->get_current_world(); }
-		ref<EditorScene> getWorldScene() { return world_scene; }
-
-		main_renderer* getRenderer() const
-		{
-			return renderer;
-		}
-
-#ifndef ERA_RUNTIME
-
-		eeditor* getEditor()
-		{
-			return &editor;
-		}
-
-#endif
-
-		Allocator stackArena;
-
-		ldr_render_pass ldrRenderPass;
-
-	private:
-		void resetRenderPasses();
-		void submitRendererParams(uint32 numSpotLightShadowPasses, uint32 numPointLightShadowPasses);
-
-		raytracing_tlas raytracingTLAS;
-
-		ref<dx_buffer> pointLightBuffer[NUM_BUFFERED_FRAMES];
-		ref<dx_buffer> spotLightBuffer[NUM_BUFFERED_FRAMES];
-		ref<dx_buffer> decalBuffer[NUM_BUFFERED_FRAMES];
-
-		ref<dx_buffer> spotLightShadowInfoBuffer[NUM_BUFFERED_FRAMES];
-		ref<dx_buffer> pointLightShadowInfoBuffer[NUM_BUFFERED_FRAMES];
-
-		std::vector<pbr_decal_cb> decals;
-
-		ref<dx_texture> decalTexture;
-
-		main_renderer* renderer;
-
-		//ref<dotnet::enative_scripting_linker> linker;
-
-		ref<EditorScene> world_scene = nullptr;
-
-#ifndef ERA_RUNTIME
-
-		eeditor editor;
-
-#else
-
-		runtime::runtime rt;
-
-#endif
-
-		fire_particle_system fireParticleSystem;
-		smoke_particle_system smokeParticleSystem;
-		boid_particle_system boidParticleSystem;
-		debris_particle_system debrisParticleSystem;
-
-		opaque_render_pass opaqueRenderPass;
-		transparent_render_pass transparentRenderPass;
-		sun_shadow_render_pass sunShadowRenderPass;
-		spot_shadow_render_pass spotShadowRenderPasses[16];
-		point_shadow_render_pass pointShadowRenderPasses[16];
-		compute_pass computePass;
-
-		friend class eeditor;
-	};
-
-	extern application globalApp;
-}
\ No newline at end of file
diff --git a/modules/core/src/asset/asset.h b/modules/core/src/asset/asset.h
index b2c7a6ec8..05e255c13 100644
--- a/modules/core/src/asset/asset.h
+++ b/modules/core/src/asset/asset.h
@@ -8,7 +8,7 @@
 
 namespace era_engine
 {
-	struct AssetHandle
+	struct ERA_CORE_API AssetHandle
 	{
 		AssetHandle() : value(0) {}
 		AssetHandle(uint64 value) : value(value) {}
diff --git a/modules/core/src/asset/bin.cpp b/modules/core/src/asset/bin.cpp
index 0eb4be803..956382c58 100644
--- a/modules/core/src/asset/bin.cpp
+++ b/modules/core/src/asset/bin.cpp
@@ -1,5 +1,7 @@
 // Copyright (c) 2023-present Eldar Muradov. All rights reserved.
 
+#include "asset/bin.h"
+
 #include "asset/model_asset.h"
 #include "asset/io.h"
 
@@ -359,7 +361,7 @@ namespace era_engine
 		return result;
 	}
 
-	NODISCARD ModelAsset loadBIN(const fs::path& path)
+	ModelAsset loadBIN(const fs::path& path)
 	{
 		PROFILE("Loading BIN");
 
diff --git a/modules/core/src/asset/bin.h b/modules/core/src/asset/bin.h
new file mode 100644
index 000000000..0d62584ee
--- /dev/null
+++ b/modules/core/src/asset/bin.h
@@ -0,0 +1,14 @@
+#pragma once 
+
+#include "core_api.h"
+
+namespace era_engine
+{
+	struct ModelAsset;
+
+	ERA_CORE_API void writeBIN(const ModelAsset& asset, const fs::path& path);
+
+	ERA_CORE_API ModelAsset loadFBX(const fs::path& path, uint32 flags);
+	ERA_CORE_API ModelAsset loadOBJ(const fs::path& path, uint32 flags);
+	ERA_CORE_API ModelAsset loadBIN(const fs::path& path);
+}
\ No newline at end of file
diff --git a/modules/core/src/asset/fbx.cpp b/modules/core/src/asset/fbx.cpp
index f9f38670b..2b4fb2051 100644
--- a/modules/core/src/asset/fbx.cpp
+++ b/modules/core/src/asset/fbx.cpp
@@ -1,5 +1,6 @@
 // Copyright (c) 2023-present Eldar Muradov. All rights reserved.
 
+#include "asset/bin.h"
 #include "asset/deflate.h"
 #include "asset/io.h"
 #include "asset/model_asset.h"
@@ -2004,7 +2005,7 @@ namespace era_engine
 		return 0;
 	}
 
-	NODISCARD ModelAsset loadFBX(const fs::path& path, uint32 flags)
+	ModelAsset loadFBX(const fs::path& path, uint32 flags)
 	{
 		std::string pathStr = path.string();
 		const char* s = pathStr.c_str();
diff --git a/modules/core/src/asset/image.cpp b/modules/core/src/asset/image.cpp
index b1390a185..9f3f5eaff 100644
--- a/modules/core/src/asset/image.cpp
+++ b/modules/core/src/asset/image.cpp
@@ -422,7 +422,7 @@ namespace era_engine
 		return true;
 	}
 
-	bool saveImageToFile(const fs::path& filepath, DirectX::Image image)
+	bool saveImageToFile(const fs::path& filepath, const DirectX::Image& image)
 	{
 		fs::path extension = filepath.extension();
 
diff --git a/modules/core/src/asset/image.h b/modules/core/src/asset/image.h
index ed89edee2..b1ffe0b20 100644
--- a/modules/core/src/asset/image.h
+++ b/modules/core/src/asset/image.h
@@ -48,7 +48,7 @@ namespace era_engine
 	bool loadImageFromFile(const fs::path& filepath, uint32 flags, DirectX::ScratchImage& scratchImage, D3D12_RESOURCE_DESC& textureDesc);
 	bool loadSVGFromFile(const fs::path& filepath, uint32 flags, DirectX::ScratchImage& scratchImage, D3D12_RESOURCE_DESC& textureDesc);
 
-	bool saveImageToFile(const fs::path& filepath, DirectX::Image image);
+	bool saveImageToFile(const fs::path& filepath, const DirectX::Image& image);
 
 	NODISCARD inline constexpr bool isUAVCompatibleFormat(DXGI_FORMAT format)
 	{
diff --git a/modules/core/src/asset/model_asset.cpp b/modules/core/src/asset/model_asset.cpp
index 391ed4203..a50f0cecf 100644
--- a/modules/core/src/asset/model_asset.cpp
+++ b/modules/core/src/asset/model_asset.cpp
@@ -1,5 +1,6 @@
 // Copyright (c) 2023-present Eldar Muradov. All rights reserved.
 
+#include "asset/bin.h"
 #include "asset/model_asset.h"
 #include "core/log.h"
 
@@ -7,12 +8,7 @@
 
 namespace era_engine
 {
-	NODISCARD ModelAsset loadFBX(const fs::path& path, uint32 flags);
-	NODISCARD ModelAsset loadOBJ(const fs::path& path, uint32 flags);
-	NODISCARD ModelAsset loadBIN(const fs::path& path);
-	void writeBIN(const ModelAsset& asset, const fs::path& path);
-
-	NODISCARD ModelAsset load_3d_model_from_file(const fs::path& path, uint32 meshFlags)
+	ModelAsset load_3d_model_from_file(const fs::path& path, uint32 meshFlags)
 	{
 		if (!fs::exists(path))
 		{
@@ -63,14 +59,4 @@ namespace era_engine
 
 		return result;
 	}
-
-	bool is_mesh_extension(const fs::path& extension)
-	{
-		return extension == ".fbx" || extension == ".obj" || extension == ".bin";
-	}
-
-	bool is_mesh_extension(const std::string& extension)
-	{
-		return extension == ".fbx" || extension == ".obj" || extension == ".bin";
-	}
 }
\ No newline at end of file
diff --git a/modules/core/src/asset/model_asset.h b/modules/core/src/asset/model_asset.h
index 591bcc221..e7801479d 100644
--- a/modules/core/src/asset/model_asset.h
+++ b/modules/core/src/asset/model_asset.h
@@ -83,8 +83,15 @@ namespace era_engine
 		mesh_flag_load_colors | mesh_flag_load_skin,
 	};
 
-	NODISCARD ModelAsset load_3d_model_from_file(const fs::path& path, uint32 mesh_flags = mesh_flag_default);
+	ERA_CORE_API ModelAsset load_3d_model_from_file(const fs::path& path, uint32 mesh_flags = mesh_flag_default);
 
-	bool is_mesh_extension(const fs::path& extension);
-	bool is_mesh_extension(const std::string& extension);
+	inline bool is_mesh_extension(const fs::path& extension)
+	{
+		return extension == ".fbx" || extension == ".obj" || extension == ".bin";
+	}
+
+	inline bool is_mesh_extension(const std::string& extension)
+	{
+		return extension == ".fbx" || extension == ".obj" || extension == ".bin";
+	}
 }
\ No newline at end of file
diff --git a/modules/core/src/asset/obj.cpp b/modules/core/src/asset/obj.cpp
index 601d8984b..4192243df 100644
--- a/modules/core/src/asset/obj.cpp
+++ b/modules/core/src/asset/obj.cpp
@@ -1,5 +1,6 @@
 // Copyright (c) 2023-present Eldar Muradov. All rights reserved.
 
+#include "asset/bin.h"
 #include "asset/io.h"
 #include "asset/model_asset.h"
 #include "asset/mesh_postprocessing.h"
@@ -308,7 +309,7 @@ namespace era_engine
 		return result;
 	}
 
-	NODISCARD ModelAsset loadOBJ(const fs::path& path, uint32 flags)
+	ModelAsset loadOBJ(const fs::path& path, uint32 flags)
 	{
 		PROFILE("Loading OBJ");
 
diff --git a/modules/core/src/core/camera.h b/modules/core/src/core/camera.h
index f46607780..a68949846 100644
--- a/modules/core/src/core/camera.h
+++ b/modules/core/src/core/camera.h
@@ -69,6 +69,12 @@ namespace era_engine
 
 	struct ERA_CORE_API render_camera
 	{
+		render_camera() = default;
+		render_camera(const render_camera& other) noexcept = default;
+		render_camera(render_camera&& other) noexcept = default;
+		render_camera& operator=(const render_camera& other) noexcept = default;
+		render_camera& operator=(render_camera&& other) noexcept = default;
+
 		void setPositionAndRotation(vec3 position, quat rotation);
 		void initializeIngame(vec3 position, quat rotation, float verticalFOV, float nearPlane, float farPlane = -1.f);
 		void initializeCalibrated(vec3 position, quat rotation, uint32 width, uint32 height, float fx, float fy, float cx, float cy, float nearPlane, float farPlane = -1.f);
diff --git a/modules/core/src/core/ecs/camera_holder_component.h b/modules/core/src/core/ecs/camera_holder_component.h
new file mode 100644
index 000000000..1ae350b5c
--- /dev/null
+++ b/modules/core/src/core/ecs/camera_holder_component.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "core_api.h"
+
+#include "core/camera.h"
+#include "core/math.h"
+
+#include "ecs/component.h"
+
+namespace era_engine
+{
+
+	class ERA_CORE_API CameraHolderComponent final : public Component
+	{
+	public:
+		enum CameraType : uint8_t
+		{
+			FREE_CAMERA = 0,
+			ATTACHED_TO_TRS
+		};
+
+		CameraHolderComponent() = default;
+		CameraHolderComponent(ref<Entity::EcsData> _data);
+
+		~CameraHolderComponent() override;
+
+		void set_render_camera(render_camera* _camera);
+		render_camera* get_render_camera() const;
+
+		CameraType get_camera_type() const;
+		void set_camera_type(CameraType _type);
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	private:
+		render_camera* camera = nullptr;
+
+		CameraType type = ATTACHED_TO_TRS;
+	};
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/input_reciever_component.h b/modules/core/src/core/ecs/input_reciever_component.h
new file mode 100644
index 000000000..085085577
--- /dev/null
+++ b/modules/core/src/core/ecs/input_reciever_component.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "core_api.h"
+
+#include "core/input.h"
+#include "core/math.h"
+
+#include "ecs/component.h"
+
+namespace era_engine
+{
+
+	class ERA_CORE_API InputRecieverComponent final : public Component
+	{
+	public:
+		InputRecieverComponent() = default;
+		InputRecieverComponent(ref<Entity::EcsData> _data);
+
+		~InputRecieverComponent() override;
+
+		const vec3& get_current_input() const;
+
+		bool is_active() const;
+
+		const UserInput& get_frame_input() const;
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	private:
+		UserInput frame_input{};
+
+		vec3 current_input = vec3::zero;
+
+		bool active = true;
+
+		friend class InputSystem;
+		friend class InputSenderComponent;
+	};
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/input_root_component.h b/modules/core/src/core/ecs/input_root_component.h
deleted file mode 100644
index c843669b4..000000000
--- a/modules/core/src/core/ecs/input_root_component.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "core_api.h"
-
-#include "core/input.h"
-#include "core/math.h"
-
-#include "ecs/component.h"
-
-namespace era_engine
-{
-
-	class ERA_CORE_API InputRootComponent final : public Component
-	{
-	public:
-		InputRootComponent() = default;
-		InputRootComponent(ref<Entity::EcsData> _data);
-
-		~InputRootComponent() override;
-
-		const vec3& get_current_input() const;
-		const vec3& get_desired_input() const;
-		const vec3& get_last_input() const;
-
-		const UserInput& get_frame_input() const;
-
-		ERA_VIRTUAL_REFLECT(Component)
-
-	private:
-		UserInput frame_input;
-
-		vec3 current_input;
-		vec3 last_input;
-		vec3 desired_input;
-
-		friend class InputSystem;
-	};
-
-}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/input_sender_component.h b/modules/core/src/core/ecs/input_sender_component.h
new file mode 100644
index 000000000..a7740521f
--- /dev/null
+++ b/modules/core/src/core/ecs/input_sender_component.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "core_api.h"
+
+#include "core/input.h"
+#include "core/math.h"
+
+#include "ecs/component.h"
+
+namespace era_engine
+{
+	class InputRecieverComponent;
+
+	class ERA_CORE_API InputSenderComponent final : public Component
+	{
+	public:
+		InputSenderComponent() = default;
+		InputSenderComponent(ref<Entity::EcsData> _data);
+
+		~InputSenderComponent() override;
+
+		const vec3& get_current_input() const;
+		const vec3& get_last_input() const;
+
+		const UserInput& get_frame_input() const;
+
+		void add_reciever(InputRecieverComponent* reciever);
+		void remove_reciever(InputRecieverComponent* reciever);
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	private:
+		void notify_input();
+
+	private:
+		UserInput frame_input{};
+
+		vec3 current_input = vec3::zero;
+		vec3 last_input = vec3::zero;
+
+		std::vector<InputRecieverComponent*> recievers;
+
+		friend class InputSystem;
+	};
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/camera_holder_component.cpp b/modules/core/src/core/ecs/private/camera_holder_component.cpp
new file mode 100644
index 000000000..de0e0ca68
--- /dev/null
+++ b/modules/core/src/core/ecs/private/camera_holder_component.cpp
@@ -0,0 +1,47 @@
+#include "core/ecs/camera_holder_component.h"
+
+#include <rttr/registration>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		registration::class_<CameraHolderComponent>("CameraHolderComponent")
+			.constructor<ref<Entity::EcsData>>();
+	}
+
+
+	CameraHolderComponent::CameraHolderComponent(ref<Entity::EcsData> _data)
+		: Component(_data)
+	{
+		type = ATTACHED_TO_TRS;
+	}
+
+	CameraHolderComponent::~CameraHolderComponent()
+	{
+	}
+
+	void CameraHolderComponent::set_render_camera(render_camera* _camera)
+	{
+		camera = _camera;
+	}
+
+	render_camera* CameraHolderComponent::get_render_camera() const
+	{
+		return camera;
+	}
+
+	CameraHolderComponent::CameraType CameraHolderComponent::get_camera_type() const
+	{
+		return type;
+	}
+
+	void CameraHolderComponent::set_camera_type(CameraType _type)
+	{
+		type = _type;
+	}
+
+	
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/camera_system.cpp b/modules/core/src/core/ecs/private/camera_system.cpp
new file mode 100644
index 000000000..7522d5fe9
--- /dev/null
+++ b/modules/core/src/core/ecs/private/camera_system.cpp
@@ -0,0 +1,96 @@
+#include "core/ecs/private/camera_system.h"
+#include "core/log.h"
+#include "core/cpu_profiling.h"
+#include "core/ecs/input_reciever_component.h"
+#include "core/ecs/camera_holder_component.h"
+
+#include "rendering/ecs/renderer_holder_root_component.h"
+
+#include "ecs/base_components/transform_component.h"
+#include "ecs/update_groups.h"
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+#include <imgui/imgui.h>
+
+namespace era_engine
+{
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<CameraSystem>("CameraSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("update", &CameraSystem::update)(metadata("update_group", update_types::BEFORE_RENDER));
+	}
+
+	CameraSystem::CameraSystem(World* _world)
+		: System(_world)
+	{
+		renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
+	}
+
+	CameraSystem::~CameraSystem()
+	{
+	}
+
+	void CameraSystem::init()
+	{
+	}
+
+	void CameraSystem::update(float dt)
+	{
+		for (auto [handle, camera_holder, receiver, transform] : world->group(components_group<CameraHolderComponent, InputRecieverComponent, TransformComponent>).each())
+		{
+			const UserInput& user_input = receiver.get_frame_input();
+			const vec3& input = receiver.get_current_input();
+
+			render_camera* camera = camera_holder.get_render_camera();
+
+			camera->setViewport(renderer_holder_rc->width, renderer_holder_rc->height);
+
+			if (camera_holder.get_camera_type() == CameraHolderComponent::FREE_CAMERA)
+			{
+				if (user_input.mouse.right.down)
+				{
+					const float CAMERA_MOVEMENT_SPEED = 8.0f;
+					const float CAMERA_SENSITIVITY = 4.0f;
+
+					vec2 turn_angle(0.f, 0.f);
+					turn_angle = vec2(-user_input.mouse.reldx, -user_input.mouse.reldy) * CAMERA_SENSITIVITY;
+
+					quat& camera_rotation = camera->rotation;
+					camera_rotation = quat(vec3(0.f, 1.f, 0.f), turn_angle.x) * camera_rotation;
+					camera_rotation = camera_rotation * quat(vec3(1.f, 0.f, 0.f), turn_angle.y);
+
+					camera->position += camera_rotation * input * dt * CAMERA_MOVEMENT_SPEED;
+
+					transform.transform.position = camera->position;
+					transform.transform.rotation = camera->rotation;
+				}
+			}
+			else
+			{
+				camera->position = transform.transform.position;
+				camera->rotation = transform.transform.rotation;
+			}
+
+			camera->updateMatrices();
+		}
+
+		for (auto [handle, camera_holder, transform] : world->group(components_group<CameraHolderComponent, TransformComponent>, components_group<InputRecieverComponent>).each())
+		{
+			render_camera* camera = camera_holder.get_render_camera();
+
+			camera->setViewport(renderer_holder_rc->width, renderer_holder_rc->height);
+
+			camera->position = transform.transform.position;
+			camera->rotation = transform.transform.rotation;
+
+			camera->updateMatrices();
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/camera_system.h b/modules/core/src/core/ecs/private/camera_system.h
new file mode 100644
index 000000000..e8e8a7d0f
--- /dev/null
+++ b/modules/core/src/core/ecs/private/camera_system.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ecs/system.h"
+
+namespace era_engine
+{
+
+	class RendererHolderRootComponent;
+
+	class CameraSystem final : public System
+	{
+	public:
+		CameraSystem(World* _world);
+		~CameraSystem();
+
+		void init() override;
+		void update(float dt) override;
+
+		ERA_VIRTUAL_REFLECT(System)
+
+	private:
+		RendererHolderRootComponent* renderer_holder_rc = nullptr;
+	};
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/input_reciever_component.cpp b/modules/core/src/core/ecs/private/input_reciever_component.cpp
new file mode 100644
index 000000000..7fa654e3c
--- /dev/null
+++ b/modules/core/src/core/ecs/private/input_reciever_component.cpp
@@ -0,0 +1,40 @@
+#include "core/ecs/input_reciever_component.h"
+
+#include <rttr/registration>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		registration::class_<InputRecieverComponent>("InputRecieverComponent")
+			.constructor<ref<Entity::EcsData>>();
+	}
+
+
+	InputRecieverComponent::InputRecieverComponent(ref<Entity::EcsData> _data)
+		: Component(_data)
+	{
+	}
+
+	InputRecieverComponent::~InputRecieverComponent()
+	{
+	}
+
+	const vec3& InputRecieverComponent::get_current_input() const
+	{
+		return current_input;
+	}
+
+	bool era_engine::InputRecieverComponent::is_active() const
+	{
+		return active;
+	}
+
+	const UserInput& InputRecieverComponent::get_frame_input() const
+	{
+		return frame_input;
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/input_root_component.cpp b/modules/core/src/core/ecs/private/input_root_component.cpp
deleted file mode 100644
index 7c7c7d36f..000000000
--- a/modules/core/src/core/ecs/private/input_root_component.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "core/ecs/input_root_component.h"
-
-#include <rttr/registration>
-
-namespace era_engine
-{
-
-	RTTR_REGISTRATION
-	{
-		using namespace rttr;
-		rttr::registration::class_<InputRootComponent>("InputRootComponent")
-			.constructor<ref<Entity::EcsData>>();
-	}
-
-
-	InputRootComponent::InputRootComponent(ref<Entity::EcsData> _data)
-		: Component(_data)
-	{
-	}
-
-	InputRootComponent::~InputRootComponent()
-	{
-	}
-
-	const vec3& InputRootComponent::get_current_input() const
-	{
-		return current_input;
-	}
-
-	const vec3& InputRootComponent::get_desired_input() const
-	{
-		return desired_input;
-	}
-
-	const vec3& InputRootComponent::get_last_input() const
-	{
-		return last_input;
-	}
-
-	const UserInput& era_engine::InputRootComponent::get_frame_input() const
-	{
-		return frame_input;
-	}
-
-}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/input_sender_component.cpp b/modules/core/src/core/ecs/private/input_sender_component.cpp
new file mode 100644
index 000000000..14e3f0b90
--- /dev/null
+++ b/modules/core/src/core/ecs/private/input_sender_component.cpp
@@ -0,0 +1,65 @@
+#include "core/ecs/input_sender_component.h"
+#include "core/ecs/input_reciever_component.h"
+
+#include <rttr/registration>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		registration::class_<InputSenderComponent>("InputSenderComponent")
+			.constructor<ref<Entity::EcsData>>();
+	}
+
+
+	InputSenderComponent::InputSenderComponent(ref<Entity::EcsData> _data)
+		: Component(_data)
+	{
+	}
+
+	InputSenderComponent::~InputSenderComponent()
+	{
+	}
+
+	const vec3& InputSenderComponent::get_current_input() const
+	{
+		return current_input;
+	}
+
+	const vec3& InputSenderComponent::get_last_input() const
+	{
+		return last_input;
+	}
+
+	const UserInput& InputSenderComponent::get_frame_input() const
+	{
+		return frame_input;
+	}
+
+	void InputSenderComponent::add_reciever(InputRecieverComponent* reciever)
+	{
+		recievers.push_back(reciever);
+	}
+
+	void InputSenderComponent::remove_reciever(InputRecieverComponent* reciever)
+	{
+		std::erase(recievers, reciever);
+	}
+
+	void InputSenderComponent::notify_input()
+	{
+		for (InputRecieverComponent* reciever : recievers)
+		{
+			if (!reciever->is_active())
+			{
+				continue;
+			}
+
+			reciever->frame_input = frame_input;
+			reciever->current_input = current_input;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/input_system.cpp b/modules/core/src/core/ecs/private/input_system.cpp
index 1b9e079f0..7ae7707ec 100644
--- a/modules/core/src/core/ecs/private/input_system.cpp
+++ b/modules/core/src/core/ecs/private/input_system.cpp
@@ -1,10 +1,15 @@
 #include "core/ecs/private/input_system.h"
-#include "core/ecs/input_root_component.h"
+#include "core/ecs/input_sender_component.h"
+#include "core/ecs/input_reciever_component.h"
 #include "core/imgui.h"
 #include "core/log.h"
 #include "core/cpu_profiling.h"
 
+#include "rendering/main_renderer.h"
+#include "rendering/ecs/renderer_holder_root_component.h"
+
 #include "ecs/update_groups.h"
+#include "ecs/base_components/transform_component.h"
 
 #define IMGUI_DEFINE_MATH_OPERATORS
 #include <imgui/imgui_internal.h>
@@ -18,17 +23,16 @@ namespace era_engine
 	{
 		using namespace rttr;
 
-		rttr::registration::class_<InputSystem>("InputSystem")
+		registration::class_<InputSystem>("InputSystem")
 			.constructor<World*>()(policy::ctor::as_raw_ptr)
-			.method("update", &InputSystem::update)(metadata("update_group", update_types::INPUT))
-			.method("show_input", &InputSystem::show_input)(metadata("update_group", update_types::END));
+			.method("update", &InputSystem::update)(metadata("update_group", update_types::INPUT));
 	}
 
 	InputSystem::InputSystem(World* _world)
 		: System(_world)
 	{
-		input_rc = world->add_root_component<InputRootComponent>();
-		ASSERT(input_rc != nullptr);
+		renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
 	}
 
 	InputSystem::~InputSystem()
@@ -43,24 +47,55 @@ namespace era_engine
 	{
 		static bool app_focused_last_frame = true;
 
-		CPU_PROFILE_BLOCK("Collect user input");
-
-		UserInput& input = input_rc->frame_input;
-
+		ImGui::BeginWindowHiddenTabBar("Scene Viewport");
 		uint32 render_width = (uint32)ImGui::GetContentRegionAvail().x;
 		uint32 render_height = (uint32)ImGui::GetContentRegionAvail().y;
 
-		ImGuiIO& io = ImGui::GetIO();
-		if (ImGui::IsItemHovered())
+		renderer_holder_rc->width = render_width;
+		renderer_holder_rc->height = render_height;
+
+		main_renderer* renderer = renderer_holder_rc->renderer;
+
+		ImGui::Image(renderer->frameResult, render_width, render_height);
+
+		CPU_PROFILE_BLOCK("Collect user input");
+
+		for (auto [handle, transform, sender] : world->group(components_group<TransformComponent, InputSenderComponent>).each())
 		{
-			ImVec2 relative_mouse = ImGui::GetMousePos() - ImGui::GetItemRectMin();
-			vec2 mouse_mos = { relative_mouse.x, relative_mouse.y };
-			if (app_focused_last_frame)
+			UserInput& input = sender.frame_input;
+			ImGuiIO& io = ImGui::GetIO();
+			if (ImGui::IsItemHovered())
 			{
-				input.mouse.dx = (int32)(mouse_mos.x - input.mouse.x);
-				input.mouse.dy = (int32)(mouse_mos.y - input.mouse.y);
-				input.mouse.reldx = (float)input.mouse.dx / (render_width - 1);
-				input.mouse.reldy = (float)input.mouse.dy / (render_height - 1);
+				ImVec2 relative_mouse = ImGui::GetMousePos() - ImGui::GetItemRectMin();
+				vec2 mouse_mos = { relative_mouse.x, relative_mouse.y };
+				if (app_focused_last_frame)
+				{
+					input.mouse.dx = (int32)(mouse_mos.x - input.mouse.x);
+					input.mouse.dy = (int32)(mouse_mos.y - input.mouse.y);
+					input.mouse.reldx = (float)input.mouse.dx / (render_width - 1);
+					input.mouse.reldy = (float)input.mouse.dy / (render_height - 1);
+				}
+				else
+				{
+					input.mouse.dx = 0;
+					input.mouse.dy = 0;
+					input.mouse.reldx = 0.f;
+					input.mouse.reldy = 0.f;
+				}
+				input.mouse.x = (int32)mouse_mos.x;
+				input.mouse.y = (int32)mouse_mos.y;
+				input.mouse.relX = mouse_mos.x / (render_width - 1);
+				input.mouse.relY = mouse_mos.y / (render_height - 1);
+				input.mouse.left = { ImGui::IsMouseDown(ImGuiMouseButton_Left), ImGui::IsMouseClicked(ImGuiMouseButton_Left), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) };
+				input.mouse.right = { ImGui::IsMouseDown(ImGuiMouseButton_Right), ImGui::IsMouseClicked(ImGuiMouseButton_Right), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Right) };
+				input.mouse.middle = { ImGui::IsMouseDown(ImGuiMouseButton_Middle), ImGui::IsMouseClicked(ImGuiMouseButton_Middle), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Middle) };
+
+				for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
+				{
+					input.keyboard[i] = { ImGui::IsKeyDown(i), ImGui::IsKeyPressed(i, false) };
+				}
+
+				input.over_window = true;
 			}
 			else
 			{
@@ -68,74 +103,49 @@ namespace era_engine
 				input.mouse.dy = 0;
 				input.mouse.reldx = 0.f;
 				input.mouse.reldy = 0.f;
-			}
-			input.mouse.x = (int32)mouse_mos.x;
-			input.mouse.y = (int32)mouse_mos.y;
-			input.mouse.relX = mouse_mos.x / (render_width - 1);
-			input.mouse.relY = mouse_mos.y / (render_height - 1);
-			input.mouse.left = { ImGui::IsMouseDown(ImGuiMouseButton_Left), ImGui::IsMouseClicked(ImGuiMouseButton_Left), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) };
-			input.mouse.right = { ImGui::IsMouseDown(ImGuiMouseButton_Right), ImGui::IsMouseClicked(ImGuiMouseButton_Right), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Right) };
-			input.mouse.middle = { ImGui::IsMouseDown(ImGuiMouseButton_Middle), ImGui::IsMouseClicked(ImGuiMouseButton_Middle), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Middle) };
-
-			for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
-			{
-				input.keyboard[i] = { ImGui::IsKeyDown(i), ImGui::IsKeyPressed(i, false) };
-			}
 
-			input.over_window = true;
-		}
-		else
-		{
-			input.mouse.dx = 0;
-			input.mouse.dy = 0;
-			input.mouse.reldx = 0.f;
-			input.mouse.reldy = 0.f;
-
-			if (input.mouse.left.down && !ImGui::IsMouseDown(ImGuiMouseButton_Left))
-			{
-				input.mouse.left.down = false;
-			}
-			if (input.mouse.right.down && !ImGui::IsMouseDown(ImGuiMouseButton_Right))
-			{
-				input.mouse.right.down = false;
-			}
-			if (input.mouse.middle.down && !ImGui::IsMouseDown(ImGuiMouseButton_Middle))
-			{
-				input.mouse.middle.down = false;
-			}
+				if (input.mouse.left.down && !ImGui::IsMouseDown(ImGuiMouseButton_Left))
+				{
+					input.mouse.left.down = false;
+				}
+				if (input.mouse.right.down && !ImGui::IsMouseDown(ImGuiMouseButton_Right))
+				{
+					input.mouse.right.down = false;
+				}
+				if (input.mouse.middle.down && !ImGui::IsMouseDown(ImGuiMouseButton_Middle))
+				{
+					input.mouse.middle.down = false;
+				}
 
-			input.mouse.left.click_event = input.mouse.left.double_click_event = false;
-			input.mouse.right.click_event = input.mouse.right.double_click_event = false;
-			input.mouse.middle.click_event = input.mouse.middle.double_click_event = false;
+				input.mouse.left.click_event = input.mouse.left.double_click_event = false;
+				input.mouse.right.click_event = input.mouse.right.double_click_event = false;
+				input.mouse.middle.click_event = input.mouse.middle.double_click_event = false;
 
-			for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
-			{
-				if (!ImGui::IsKeyDown(i))
+				for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
 				{
-					input.keyboard[i].down = false;
+					if (!ImGui::IsKeyDown(i))
+					{
+						input.keyboard[i].down = false;
+					}
+					input.keyboard[i].press_event = false;
 				}
-				input.keyboard[i].press_event = false;
+
+				input.over_window = false;
 			}
 
-			input.over_window = false;
-		}
+			vec3 current_input = vec3(
+				(input.keyboard['D'].down ? 1.0f : 0.0f) + (input.keyboard['A'].down ? -1.f : 0.0f),
+				(input.keyboard['E'].down ? 1.0f : 0.0f) + (input.keyboard['Q'].down ? -1.f : 0.0f),
+				(input.keyboard['W'].down ? -1.0f : 0.0f) + (input.keyboard['S'].down ? 1.f : 0.0f)
+			);
 
-		vec3 current_input = vec3(
-			(input.keyboard['D'].down ? 1.0f : 0.0f) + (input.keyboard['A'].down ? -1.f : 0.0f),
-			(input.keyboard['E'].down ? 1.0f : 0.0f) + (input.keyboard['Q'].down ? -1.f : 0.0f),
-			(input.keyboard['W'].down ? -1.0f : 0.0f) + (input.keyboard['S'].down ? 1.f : 0.0f)
-		) * (input.keyboard[key_shift].down ? 3.0f : 1.f) * (input.keyboard[key_ctrl].down ? 0.1f : 1.0f);
+			sender.last_input = sender.current_input;
+			sender.current_input = current_input;
 
-		input_rc->last_input = input_rc->current_input;
-		input_rc->desired_input = current_input;
-		input_rc->current_input = current_input;
+			sender.notify_input();
+		}
 
 		app_focused_last_frame = ImGui::IsMousePosValid();
 	}
 
-	void InputSystem::show_input(float dt)
-	{
-		LOG_MESSAGE("Frame input is: X: %f Y: %f Z: %f", input_rc->current_input.x, input_rc->current_input.y, input_rc->current_input.z);
-	}
-
 }
\ No newline at end of file
diff --git a/modules/core/src/core/ecs/private/input_system.h b/modules/core/src/core/ecs/private/input_system.h
index 0534abe4e..ab7cbf9c6 100644
--- a/modules/core/src/core/ecs/private/input_system.h
+++ b/modules/core/src/core/ecs/private/input_system.h
@@ -4,7 +4,7 @@
 
 namespace era_engine
 {
-	class InputRootComponent;
+	class RendererHolderRootComponent;
 
 	class InputSystem final : public System
 	{
@@ -20,6 +20,6 @@ namespace era_engine
 		ERA_VIRTUAL_REFLECT(System)
 
 	private:
-		InputRootComponent* input_rc = nullptr;
+		RendererHolderRootComponent* renderer_holder_rc = nullptr;
 	};
 }
\ No newline at end of file
diff --git a/modules/core/src/core/fps_limiter.cpp b/modules/core/src/core/fps_limiter.cpp
new file mode 100644
index 000000000..395a27379
--- /dev/null
+++ b/modules/core/src/core/fps_limiter.cpp
@@ -0,0 +1,52 @@
+#include "core/fps_limiter.h"
+
+namespace era_engine
+{
+
+	FpsLimiter::FpsLimiter(int32_t _frame_rate, bool _enabled)
+	{
+		enabled = _enabled;
+		frame_time = 1000.0f / static_cast<float>(_frame_rate);
+	}
+
+	FpsLimiter::~FpsLimiter()
+	{
+	}
+
+	void FpsLimiter::set_enabled(bool _enabled)
+	{
+		enabled = _enabled;
+	}
+
+	bool FpsLimiter::get_enabled() const
+	{
+		return enabled;
+	}
+
+	void FpsLimiter::begin_frame()
+	{
+		frame_start_time = std::chrono::high_resolution_clock::now();
+		frame_started = true;
+	}
+
+	void FpsLimiter::end_frame()
+	{
+		if(frame_started)
+		{
+			auto current_timme = std::chrono::high_resolution_clock::now();
+			std::chrono::duration<float, std::milli> elapsed_seconds = current_timme - frame_start_time;
+			float wait_time = frame_time - elapsed_seconds.count();
+			if (wait_time > 0.0f && enabled)
+			{
+				wait(wait_time);
+			}
+			frame_started = false;
+		}
+	}
+
+	void FpsLimiter::wait(float wait_time)
+	{
+		std::this_thread::sleep_for(std::chrono::duration<float, std::milli>(wait_time));
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/fps_limiter.h b/modules/core/src/core/fps_limiter.h
new file mode 100644
index 000000000..456b5701b
--- /dev/null
+++ b/modules/core/src/core/fps_limiter.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "core_api.h"
+
+#include <chrono>
+
+namespace era_engine
+{
+
+	class ERA_CORE_API FpsLimiter final
+	{
+	public:
+		FpsLimiter(int32_t _frame_rate = 60.0f, bool _enabled = true);
+		~FpsLimiter();
+
+		void set_enabled(bool _enabled);
+		bool get_enabled() const;
+
+		void begin_frame();
+		void end_frame();
+
+	private:
+		void wait(float wait_time);
+
+	private:
+		float frame_time = 0.0f;
+		bool enabled = true;
+		bool frame_started = false;
+		
+		std::chrono::high_resolution_clock::time_point frame_start_time;
+	};
+
+}
\ No newline at end of file
diff --git a/modules/core/src/core/imgui.h b/modules/core/src/core/imgui.h
index d8b3c6005..b58ec0b03 100644
--- a/modules/core/src/core/imgui.h
+++ b/modules/core/src/core/imgui.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include "core_api.h"
+
 #include "core/math.h"
 
 #include "dx/dx_command_list.h"
@@ -60,12 +62,12 @@ namespace ImGui
 {
 	using namespace era_engine;
 
-	bool AnyModifiersDown();
+	ERA_CORE_API bool AnyModifiersDown();
 
-	bool IsItemActiveLastFrame();
+	ERA_CORE_API bool IsItemActiveLastFrame();
 
-	bool BeginWindowHiddenTabBar(const char* name, bool* open = 0, ImGuiWindowFlags flags = 0);
-	bool BeginControlsWindow(const char* name, ImVec2 parentRelativeOffset, ImVec2 parentAbsoluteOffset);
+	ERA_CORE_API bool BeginWindowHiddenTabBar(const char* name, bool* open = 0, ImGuiWindowFlags flags = 0);
+	ERA_CORE_API bool BeginControlsWindow(const char* name, ImVec2 parentRelativeOffset, ImVec2 parentAbsoluteOffset);
 
 	void Image(const ref<dx_texture>& texture, uint32 width = 0, uint32 height = 0, ImVec2 uv0 = ImVec2(0.f, 0.f), ImVec2 uv1 = ImVec2(1.f, 1.f));
 
@@ -73,109 +75,108 @@ namespace ImGui
 
 	bool ImageButton(const ref<dx_texture>& texture, uint32 width, uint32 height, ImVec2 uvTopLeft = ImVec2(0, 0), ImVec2 uvBottomRight = ImVec2(1, 1));
 
-	void Icon(imgui_icon icon, uint32 size);
-	bool IconButton(uint32 id, imgui_icon icon, uint32 size, bool enabled = true);
-	bool IconRadioButton(imgui_icon icon, int* current, int value, uint32 size, bool enabled = true);
+	ERA_CORE_API void Icon(imgui_icon icon, uint32 size);
+	ERA_CORE_API bool IconButton(uint32 id, imgui_icon icon, uint32 size, bool enabled = true);
+	ERA_CORE_API bool IconRadioButton(imgui_icon icon, int* current, int value, uint32 size, bool enabled = true);
 
-	bool Dropdown(const char* label, const char** names, uint32 count, uint32& current);
-	bool Dropdown(const char* label, const char* (*name_func)(uint32, void*), uint32& current, void* data = 0);
+	ERA_CORE_API bool Dropdown(const char* label, const char** names, uint32 count, uint32& current);
+	ERA_CORE_API bool Dropdown(const char* label, const char* (*name_func)(uint32, void*), uint32& current, void* data = 0);
 
-	bool DisableableButton(const char* label, bool enabled);
-	bool DisableableCheckbox(const char* label, bool& v, bool enabled);
+	ERA_CORE_API bool DisableableButton(const char* label, bool enabled);
+	ERA_CORE_API bool DisableableCheckbox(const char* label, bool& v, bool enabled);
 
-	bool SelectableWrapped(const char* label, int width, bool selected = false, ImGuiSelectableFlags flags = 0);
+	ERA_CORE_API bool SelectableWrapped(const char* label, int width, bool selected = false, ImGuiSelectableFlags flags = 0);
 
-	bool BeginTree(const char* label, bool defaultOpen = false);
-	bool BeginTreeColoredText(const char* label, vec3 color, bool defaultOpen = false);
-	void EndTree();
+	ERA_CORE_API bool BeginTree(const char* label, bool defaultOpen = false);
+	ERA_CORE_API bool BeginTreeColoredText(const char* label, vec3 color, bool defaultOpen = false);
+	ERA_CORE_API void EndTree();
 
 	inline void Value(const char* prefix, int64 v) { ImGui::Text("%s: %lld", prefix, v); }
 	inline void Value(const char* prefix, uint64 v) { ImGui::Text("%s: %llu", prefix, v); }
 	inline void Value(const char* prefix, const char* v) { ImGui::Text("%s: %s", prefix, v); }
 
-	void CenteredText(const char* text);
+	ERA_CORE_API void CenteredText(const char* text);
 
-	void PopupOkButton(uint32 width = 120);
+	ERA_CORE_API void PopupOkButton(uint32 width = 120);
 
-	bool AssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset, const char* clearText = 0);
+	ERA_CORE_API bool AssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset, const char* clearText = 0);
 	bool TextureAssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset,
 		const ref<dx_texture>& texture, uint32 width = 0, uint32 height = 0, ImVec2 uv0 = ImVec2(0.f, 0.f), ImVec2 uv1 = ImVec2(1.f, 1.f), const char* clearText = 0);
 
-	bool Drag(const char* label, float& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool Drag(const char* label, vec2& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool Drag(const char* label, vec3& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool Drag(const char* label, vec4& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool Drag(const char* label, int32& f, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%d");
-	bool Drag(const char* label, uint32& f, float speed = 1.f, uint32 min = 0, uint32 max = UINT32_MAX, const char* format = "%u");
-	bool DragRange(const char* label, float& lo, float& hi, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool DragRange(const char* label, int32& lo, int32& hi, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%.3f");
-
-	bool BeginProperties();
-	void EndProperties();
-
-	void PropertyValue(const char* label, const char* format, ...);
-
-	inline void PropertyValue(const char* label, bool v) { ImGui::PropertyValue(label, v ? "True" : "False"); }
-	inline void PropertyValue(const char* label, float v, const char* format = "%.3f") { ImGui::PropertyValue(label, format, v); }
-	inline void PropertyValue(const char* label, int32 v, const char* format = "%d") { ImGui::PropertyValue(label, format, v); }
-	inline void PropertyValue(const char* label, uint32 v, const char* format = "%u") { ImGui::PropertyValue(label, format, v); }
-	inline void PropertyValue(const char* label, int64 v, const char* format = "%lld") { ImGui::PropertyValue(label, format, v); }
-	inline void PropertyValue(const char* label, uint64 v, const char* format = "%llu") { ImGui::PropertyValue(label, format, v); }
-	inline void PropertyValue(const char* label, vec2 v, const char* format = "%.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y); }
-	inline void PropertyValue(const char* label, vec3 v, const char* format = "%.3f, %.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y, v.z); }
-	inline void PropertyValue(const char* label, vec4 v, const char* format = "%.3f, %.3f, %.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y, v.z, v.w); }
-
-	bool PropertyCheckbox(const char* label, bool& v);
-
-	bool PropertySlider(const char* label, float& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
-	bool PropertySlider(const char* label, vec2& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
-	bool PropertySlider(const char* label, vec3& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
-	bool PropertySlider(const char* label, vec4& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
-
-	bool PropertySliderAngle(const char* label, float& fRad, float minValueDeg = -360.f, float maxValueDeg = 360.f, const char* format = "%.0f deg");
-
-	bool PropertySlider(const char* label, int32& v, int minValue, int maxValue, const char* format = "%d");
-	bool PropertySlider(const char* label, uint32& v, uint32 minValue, uint32 maxValue, const char* format = "%u");
-
-	bool PropertyInput(const char* label, float& f, const char* format = "%.3f");
-	bool PropertyInput(const char* label, vec2& f, const char* format = "%.3f");
-	bool PropertyInput(const char* label, vec3& f, const char* format = "%.3f");
-	bool PropertyInput(const char* label, vec4& f, const char* format = "%.3f");
-	bool PropertyInput(const char* label, int32& f, const char* format = "%d");
-	bool PropertyInput(const char* label, uint32& f, const char* format = "%u");
-
-	bool PropertyDrag(const char* label, float& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool PropertyDrag(const char* label, vec2& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool PropertyDrag(const char* label, vec3& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool PropertyDrag(const char* label, vec4& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool PropertyDrag(const char* label, int32& f, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%d");
-	bool PropertyDrag(const char* label, uint32& f, float speed = 1.f, uint32 min = 0, uint32 max = UINT32_MAX, const char* format = "%u");
-	bool PropertyDragRange(const char* label, float& lo, float& hi, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
-	bool PropertyDragRange(const char* label, int32& lo, int32& hi, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%.3f");
-
-	bool PropertyDropdown(const char* label, const char** names, uint32 count, uint32& current);
-	bool PropertyDropdown(const char* label, const char* (*name_func)(uint32, void*), uint32& current, void* data = 0);
-	bool PropertyDropdownPowerOfTwo(const char* label, uint32 from, uint32 to, uint32& current);
-
-	bool PropertyColor(const char* label, vec3& f);
-	bool PropertyColor(const char* label, vec4& f);
-
-	bool PropertyColorWheel(const char* label, vec3& f);
-	bool PropertyColorWheel(const char* label, vec4& f);
-
-	bool PropertyButton(const char* label, const char* buttonText, const char* hoverText = 0, ImVec2 size = ImVec2(0, 0));
-
-	bool PropertyInputText(const char* label, char* buffer, uint32 bufferSize, bool disableInput = false);
-
-	bool PropertyAssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset, const char* clearText = 0);
+	ERA_CORE_API bool Drag(const char* label, float& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool Drag(const char* label, vec2& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool Drag(const char* label, vec3& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool Drag(const char* label, vec4& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool Drag(const char* label, int32& f, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%d");
+	ERA_CORE_API bool Drag(const char* label, uint32& f, float speed = 1.f, uint32 min = 0, uint32 max = UINT32_MAX, const char* format = "%u");
+	ERA_CORE_API bool DragRange(const char* label, float& lo, float& hi, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool DragRange(const char* label, int32& lo, int32& hi, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%.3f");
+
+	ERA_CORE_API bool BeginProperties();
+	ERA_CORE_API void EndProperties();
+
+	ERA_CORE_API void PropertyValue(const char* label, const char* format, ...);
+
+	ERA_CORE_API inline void PropertyValue(const char* label, bool v) { ImGui::PropertyValue(label, v ? "True" : "False"); }
+	ERA_CORE_API inline void PropertyValue(const char* label, float v, const char* format = "%.3f") { ImGui::PropertyValue(label, format, v); }
+	ERA_CORE_API inline void PropertyValue(const char* label, int32 v, const char* format = "%d") { ImGui::PropertyValue(label, format, v); }
+	ERA_CORE_API inline void PropertyValue(const char* label, uint32 v, const char* format = "%u") { ImGui::PropertyValue(label, format, v); }
+	ERA_CORE_API inline void PropertyValue(const char* label, int64 v, const char* format = "%lld") { ImGui::PropertyValue(label, format, v); }
+	ERA_CORE_API inline void PropertyValue(const char* label, uint64 v, const char* format = "%llu") { ImGui::PropertyValue(label, format, v); }
+	ERA_CORE_API inline void PropertyValue(const char* label, vec2 v, const char* format = "%.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y); }
+	ERA_CORE_API inline void PropertyValue(const char* label, vec3 v, const char* format = "%.3f, %.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y, v.z); }
+	ERA_CORE_API inline void PropertyValue(const char* label, vec4 v, const char* format = "%.3f, %.3f, %.3f, %.3f") { ImGui::PropertyValue(label, format, v.x, v.y, v.z, v.w); }
+
+	ERA_CORE_API bool PropertyCheckbox(const char* label, bool& v);
+
+	ERA_CORE_API bool PropertySlider(const char* label, float& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
+	ERA_CORE_API bool PropertySlider(const char* label, vec2& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
+	ERA_CORE_API bool PropertySlider(const char* label, vec3& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
+	ERA_CORE_API bool PropertySlider(const char* label, vec4& f, float minValue = 0.f, float maxValue = 1.f, const char* format = "%.3f", ImGuiSliderFlags flags = ImGuiSliderFlags_None);
+
+	ERA_CORE_API bool PropertySliderAngle(const char* label, float& fRad, float minValueDeg = -360.f, float maxValueDeg = 360.f, const char* format = "%.0f deg");
+
+	ERA_CORE_API bool PropertySlider(const char* label, int32& v, int minValue, int maxValue, const char* format = "%d");
+	ERA_CORE_API bool PropertySlider(const char* label, uint32& v, uint32 minValue, uint32 maxValue, const char* format = "%u");
+
+	ERA_CORE_API bool PropertyInput(const char* label, float& f, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyInput(const char* label, vec2& f, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyInput(const char* label, vec3& f, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyInput(const char* label, vec4& f, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyInput(const char* label, int32& f, const char* format = "%d");
+	ERA_CORE_API bool PropertyInput(const char* label, uint32& f, const char* format = "%u");
+	
+	ERA_CORE_API bool PropertyDrag(const char* label, float& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyDrag(const char* label, vec2& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyDrag(const char* label, vec3& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyDrag(const char* label, vec4& f, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyDrag(const char* label, int32& f, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%d");
+	ERA_CORE_API bool PropertyDrag(const char* label, uint32& f, float speed = 1.f, uint32 min = 0, uint32 max = UINT32_MAX, const char* format = "%u");
+	ERA_CORE_API bool PropertyDragRange(const char* label, float& lo, float& hi, float speed = 1.f, float min = -FLT_MAX, float max = FLT_MAX, const char* format = "%.3f");
+	ERA_CORE_API bool PropertyDragRange(const char* label, int32& lo, int32& hi, float speed = 1.f, int32 min = INT32_MIN, int32 max = INT32_MAX, const char* format = "%.3f");
+	 
+	ERA_CORE_API bool PropertyDropdown(const char* label, const char** names, uint32 count, uint32& current);
+	ERA_CORE_API bool PropertyDropdown(const char* label, const char* (*name_func)(uint32, void*), uint32& current, void* data = 0);
+	ERA_CORE_API bool PropertyDropdownPowerOfTwo(const char* label, uint32 from, uint32 to, uint32& current);
+	ERA_CORE_API bool PropertyColor(const char* label, vec3& f);
+	ERA_CORE_API bool PropertyColor(const char* label, vec4& f);
+
+	ERA_CORE_API bool PropertyColorWheel(const char* label, vec3& f);
+	ERA_CORE_API bool PropertyColorWheel(const char* label, vec4& f);
+
+	ERA_CORE_API bool PropertyButton(const char* label, const char* buttonText, const char* hoverText = 0, ImVec2 size = ImVec2(0, 0));
+
+	ERA_CORE_API bool PropertyInputText(const char* label, char* buffer, uint32 bufferSize, bool disableInput = false);
+
+	ERA_CORE_API bool PropertyAssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset, const char* clearText = 0);
 	bool PropertyTextureAssetHandle(const char* label, const char* type, era_engine::AssetHandle& asset,
 		const ref<dx_texture>& texture, uint32 width = 0, uint32 height = 0, ImVec2 uv0 = ImVec2(0.f, 0.f), ImVec2 uv1 = ImVec2(1.f, 1.f), const char* clearText = 0);
 
-	bool PropertyDragDropStringTarget(const char* label, const char* dragDropID, std::string& value, const char* clearLabel = 0);
+	ERA_CORE_API bool PropertyDragDropStringTarget(const char* label, const char* dragDropID, std::string& value, const char* clearLabel = 0);
 
-	void PropertySeparator();
+	ERA_CORE_API void PropertySeparator();
 
-	bool Spline(const char* label, ImVec2 size, uint32 maxNumPoints, float* x, float* y, uint32 drawResolution = 256);
+	ERA_CORE_API bool Spline(const char* label, ImVec2 size, uint32 maxNumPoints, float* x, float* y, uint32 drawResolution = 256);
 
 	template <uint32 maxNumPoints>
 	bool Spline(const char* label, ImVec2 size, catmull_rom_spline<float, maxNumPoints>& s, uint32 drawResolution = 256)
diff --git a/modules/core/src/core/job_system.cpp b/modules/core/src/core/job_system.cpp
index 27bf93ff7..b3d4149c2 100644
--- a/modules/core/src/core/job_system.cpp
+++ b/modules/core/src/core/job_system.cpp
@@ -160,10 +160,8 @@ namespace era_engine
         SetThreadPriority(handle, THREAD_PRIORITY_HIGHEST);
         CloseHandle(handle);
 
-        uint32 num_hardware_threads = std::thread::hardware_concurrency();
-
-        high_priority_job_queue.initialize(num_hardware_threads, 1, THREAD_PRIORITY_NORMAL, L"High priority worker");
-        low_priority_job_queue.initialize(num_hardware_threads, 5, THREAD_PRIORITY_BELOW_NORMAL, L"Low priority worker");
+        high_priority_job_queue.initialize(4, 1, THREAD_PRIORITY_NORMAL, L"High priority worker");
+        low_priority_job_queue.initialize(4, 5, THREAD_PRIORITY_BELOW_NORMAL, L"Low priority worker");
         main_thread_job_queue.initialize(0, 0, 0, 0);
     }
 
diff --git a/modules/core/src/core/log.h b/modules/core/src/core/log.h
index ef412f80b..655451df0 100644
--- a/modules/core/src/core/log.h
+++ b/modules/core/src/core/log.h
@@ -6,7 +6,7 @@ namespace era_engine
 {
 	extern bool log_window_open;
 
-	enum MessageType
+	enum MessageType : uint8_t
 	{
 		message_type_normal,
 		message_type_warning,
@@ -28,14 +28,16 @@ namespace era_engine
 #define LOG_ERROR(message, ...) log_message(message_type_error, message, __VA_ARGS__)
 #endif
 
+#include "core_api.h"
+
 #include "ecs/system.h"
 
 namespace era_engine
 {
-	void log_message_internal(MessageType type, const char* file, const char* function, uint32 line, const char* format, ...);
-	void log_message(MessageType type, const char* format, ...);
+	ERA_CORE_API void log_message_internal(MessageType type, const char* file, const char* function, uint32 line, const char* format, ...);
+	ERA_CORE_API void log_message(MessageType type, const char* format, ...);
 
-	class LogSystem final : public System
+	class ERA_CORE_API LogSystem final : public System
 	{
 	public:
 		LogSystem(World* _world);
@@ -54,7 +56,4 @@ namespace era_engine
 #define LOG_WARNING(...)
 #define LOG_ERROR(...)
 
-#define initializeMessageLog(...)
-#define updateMessageLog(...)
-
 #endif
\ No newline at end of file
diff --git a/modules/core/src/core/string.h b/modules/core/src/core/string.h
index 7db757285..5cb3b164b 100644
--- a/modules/core/src/core/string.h
+++ b/modules/core/src/core/string.h
@@ -136,6 +136,15 @@ namespace era_engine
 		return  wstring_to_string(Project::path) + path.data();
 #else
 		return wstring_to_string(Project::engine_path) + path.data();
+#endif	
+	}
+
+	inline fs::path get_full_path(const fs::path& path)
+	{
+#ifdef ERA_RUNTIME
+		return  wstring_to_string(Project::path) + path.data();
+#else
+		return fs::path(wstring_to_string(Project::engine_path)) / path;
 #endif	
 	}
 }
diff --git a/modules/core/src/core_module.cpp b/modules/core/src/core_module.cpp
index 7afe41306..eca8c4841 100644
--- a/modules/core/src/core_module.cpp
+++ b/modules/core/src/core_module.cpp
@@ -21,7 +21,10 @@ namespace era_engine
         IModule::initialize(engine);
 
         Engine* engine_ptr = static_cast<Engine*>(engine);
-        WorldSystemScheduler* scheduler = engine_ptr->get_system_scheduler();
+
+        World* world = get_world_by_name("GameWorld");
+        WorldSystemScheduler* scheduler = world->get_system_scheduler();
+
         scheduler->initialize_systems(rttr::type::get_types());
 
         return true;
diff --git a/modules/core/src/dlss/dlss.h b/modules/core/src/dlss/dlss.h
index 4bf648f89..93eeb65f3 100644
--- a/modules/core/src/dlss/dlss.h
+++ b/modules/core/src/dlss/dlss.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#ifdef DEBUG || _DEBUG || ERA_RUNTIME
+#ifdef _DEBUG
 #define ENABLE_DLSS 0
 #else
 #define ENABLE_DLSS 0
diff --git a/modules/core/src/dx/dx_texture.cpp b/modules/core/src/dx/dx_texture.cpp
index d36aad678..94e6f5796 100644
--- a/modules/core/src/dx/dx_texture.cpp
+++ b/modules/core/src/dx/dx_texture.cpp
@@ -236,7 +236,7 @@ namespace era_engine
 	static std::unordered_map<texture_key, weakref<dx_texture>> textureCache;
 	static std::mutex mutex;
 
-	NODISCARD static ref<dx_texture> loadTextureFromFileAndHandle(const fs::path& filename, AssetHandle handle, uint32 flags,
+	static ref<dx_texture> loadTextureFromFileAndHandle(const fs::path& filename, AssetHandle handle, uint32 flags,
 		bool async = false, JobHandle parentJob = {})
 	{
 		if (!fs::exists(filename))
@@ -255,7 +255,7 @@ namespace era_engine
 		return result;
 	}
 
-	NODISCARD ref<dx_texture> loadTextureFromFile(const fs::path& filename, uint32 flags)
+	ref<dx_texture> loadTextureFromFile(const fs::path& filename, uint32 flags)
 	{
 		fs::path path = filename.lexically_normal().make_preferred();
 
@@ -263,13 +263,13 @@ namespace era_engine
 		return loadTextureFromFileAndHandle(path, handle, flags);
 	}
 
-	NODISCARD ref<dx_texture> loadTextureFromHandle(AssetHandle handle, uint32 flags)
+	ref<dx_texture> loadTextureFromHandle(AssetHandle handle, uint32 flags)
 	{
 		fs::path sceneFilename = getPathFromAssetHandle(handle);
 		return loadTextureFromFileAndHandle(sceneFilename, handle, flags);
 	}
 
-	NODISCARD ref<dx_texture> loadTextureFromFileAsync(const fs::path& filename, uint32 flags, JobHandle parentJob)
+	ref<dx_texture> loadTextureFromFileAsync(const fs::path& filename, uint32 flags, JobHandle parentJob)
 	{
 		fs::path path = filename.lexically_normal().make_preferred();
 
@@ -277,55 +277,55 @@ namespace era_engine
 		return loadTextureFromFileAndHandle(path, handle, flags, true, parentJob);
 	}
 
-	NODISCARD ref<dx_texture> loadTextureFromHandleAsync(AssetHandle handle, uint32 flags, JobHandle parentJob)
+	ref<dx_texture> loadTextureFromHandleAsync(AssetHandle handle, uint32 flags, JobHandle parentJob)
 	{
 		fs::path sceneFilename = getPathFromAssetHandle(handle);
 		return loadTextureFromFileAndHandle(sceneFilename, handle, flags, true, parentJob);
 	}
 
-	NODISCARD ref<dx_texture> loadTextureFromMemory(const void* ptr, uint32 size, image_format imageFormat, const fs::path& cacheFilename, uint32 flags)
+	ref<dx_texture> loadTextureFromMemory(const void* ptr, uint32 size, image_format imageFormat, const fs::path& cacheFilename, uint32 flags)
 	{
 		return loadTextureFromMemoryInternal(ptr, size, imageFormat, cacheFilename, flags);
 	}
 
-	NODISCARD ref<dx_texture> loadVolumeTextureFromDirectory(const fs::path& dirname, uint32 flags)
+	ref<dx_texture> loadVolumeTextureFromDirectory(const fs::path& dirname, uint32 flags)
 	{
 		return loadVolumeTextureInternal(dirname, flags);
 	}
 
-	NODISCARD static bool checkFormatSupport(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport, D3D12_FORMAT_SUPPORT1 support)
+	static bool checkFormatSupport(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport, D3D12_FORMAT_SUPPORT1 support)
 	{
 		return (formatSupport.Support1 & support) != 0;
 	}
 
-	NODISCARD static bool checkFormatSupport(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport, D3D12_FORMAT_SUPPORT2 support)
+	static bool checkFormatSupport(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport, D3D12_FORMAT_SUPPORT2 support)
 	{
 		return (formatSupport.Support2 & support) != 0;
 	}
 
-	NODISCARD static bool formatSupportsRTV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
+	static bool formatSupportsRTV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
 	{
 		return checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT1_RENDER_TARGET);
 	}
 
-	NODISCARD static bool formatSupportsDSV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
+	static bool formatSupportsDSV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
 	{
 		return checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL);
 	}
 
-	NODISCARD static bool formatSupportsSRV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
+	static bool formatSupportsSRV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
 	{
 		return checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE);
 	}
 
-	NODISCARD static bool formatSupportsUAV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
+	static bool formatSupportsUAV(D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport)
 	{
 		return checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW) &&
 			checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD) &&
 			checkFormatSupport(formatSupport, D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE);
 	}
 
-	NODISCARD D3D12_RESOURCE_ALLOCATION_INFO getTextureAllocationInfo(uint32 width, uint32 height, DXGI_FORMAT format, bool allocateMips, D3D12_RESOURCE_FLAGS flags)
+	D3D12_RESOURCE_ALLOCATION_INFO getTextureAllocationInfo(uint32 width, uint32 height, DXGI_FORMAT format, bool allocateMips, D3D12_RESOURCE_FLAGS flags)
 	{
 		uint32 numMips = allocateMips ? 0 : 1;
 		auto desc = CD3DX12_RESOURCE_DESC::Tex2D(format, width, height, 1, numMips, 1, 0, flags);
diff --git a/modules/core/src/dx/dx_texture.h b/modules/core/src/dx/dx_texture.h
index f7f6d3e30..97f3b694c 100644
--- a/modules/core/src/dx/dx_texture.h
+++ b/modules/core/src/dx/dx_texture.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include "core_api.h"
 #include "core/math.h"
 #include "core/job_system.h"
 
@@ -146,15 +147,15 @@ namespace era_engine
 	// So if no one else has a reference, the texture gets deleted.
 	// This means you should keep a reference to your textures yourself and not call this every frame.
 
-	NODISCARD ref<dx_texture> loadTextureFromFile(const fs::path& filename, uint32 flags = image_load_flags_default);
-	NODISCARD ref<dx_texture> loadTextureFromHandle(AssetHandle handle, uint32 flags = image_load_flags_default);
-	NODISCARD ref<dx_texture> loadTextureFromFileAsync(const fs::path& filename, uint32 flags = image_load_flags_default, JobHandle parentJob = {});
-	NODISCARD ref<dx_texture> loadTextureFromHandleAsync(AssetHandle handle, uint32 flags = image_load_flags_default, JobHandle parentJob = {});
+	ERA_CORE_API ref<dx_texture> loadTextureFromFile(const fs::path& filename, uint32 flags = image_load_flags_default);
+	ERA_CORE_API ref<dx_texture> loadTextureFromHandle(AssetHandle handle, uint32 flags = image_load_flags_default);
+	ERA_CORE_API ref<dx_texture> loadTextureFromFileAsync(const fs::path& filename, uint32 flags = image_load_flags_default, JobHandle parentJob = {});
+	ERA_CORE_API ref<dx_texture> loadTextureFromHandleAsync(AssetHandle handle, uint32 flags = image_load_flags_default, JobHandle parentJob = {});
 
-	NODISCARD ref<dx_texture> loadTextureFromMemory(const void* ptr, uint32 size, image_format imageFormat, const fs::path& cacheFilename, uint32 flags = image_load_flags_default);
-	NODISCARD ref<dx_texture> loadVolumeTextureFromDirectory(const fs::path& dirname, uint32 flags = image_load_flags_compress | image_load_flags_cache_to_dds | image_load_flags_noncolor);
+	ERA_CORE_API ref<dx_texture> loadTextureFromMemory(const void* ptr, uint32 size, image_format imageFormat, const fs::path& cacheFilename, uint32 flags = image_load_flags_default);
+	ERA_CORE_API ref<dx_texture> loadVolumeTextureFromDirectory(const fs::path& dirname, uint32 flags = image_load_flags_compress | image_load_flags_cache_to_dds | image_load_flags_noncolor);
 
 	void copyTextureToCPUBuffer(const ref<dx_texture>& texture, void* buffer, D3D12_RESOURCE_STATES beforeAndAfterState = D3D12_RESOURCE_STATE_COMMON);
-	void saveTextureToFile(const ref<dx_texture>& texture, const fs::path& path);
+	ERA_CORE_API void saveTextureToFile(const ref<dx_texture>& texture, const fs::path& path);
 	void saveTextureToFile(dx_resource texture, uint32 width, uint32 height, DXGI_FORMAT format, const fs::path& path);
 }
\ No newline at end of file
diff --git a/modules/core/src/ecs/component.cpp b/modules/core/src/ecs/component.cpp
index eff44d73c..9baa0b0ec 100644
--- a/modules/core/src/ecs/component.cpp
+++ b/modules/core/src/ecs/component.cpp
@@ -40,13 +40,19 @@ namespace era_engine
 
 	Component& Component::operator=(const Component& _component)  noexcept
 	{
-		component_data = _component.component_data;
+		if (this != &_component)
+		{
+			component_data = _component.component_data;
+		}
 		return *this;
 	}
 
 	Component& Component::operator=(Component&& _component)  noexcept
 	{
-		component_data = std::move(_component.component_data);
+		if (this != &_component)
+		{
+			component_data = std::move(_component.component_data);
+		}
 		return *this;
 	}
 
diff --git a/modules/core/src/ecs/component.h b/modules/core/src/ecs/component.h
index e0bb1f595..b0fe11aba 100644
--- a/modules/core/src/ecs/component.h
+++ b/modules/core/src/ecs/component.h
@@ -18,7 +18,7 @@ namespace era_engine
 		Component(Component&& _component) noexcept;
 		virtual ~Component();
 
-		virtual void release() override;
+		void release() override;
 
 		Component& operator=(const Component& _component) noexcept;
 		Component& operator=(Component&& _component) noexcept;
diff --git a/modules/core/src/ecs/editor/editor_scene.h b/modules/core/src/ecs/editor/editor_scene.h
index 64ae92ce2..855da2775 100644
--- a/modules/core/src/ecs/editor/editor_scene.h
+++ b/modules/core/src/ecs/editor/editor_scene.h
@@ -23,12 +23,10 @@ namespace era_engine
 
 		EditorScene()
 		{
-			runtime_world = make_ref<World>("GameWorld");
 		}
 
 		static void init()
 		{
-			runtime_world->init();
 		}
 
 		static ref<World> get_current_world()
diff --git a/modules/core/src/ecs/entity.h b/modules/core/src/ecs/entity.h
index 45128137e..03b7e0762 100644
--- a/modules/core/src/ecs/entity.h
+++ b/modules/core/src/ecs/entity.h
@@ -24,8 +24,6 @@ namespace era_engine
 {
 	class World;
 
-	extern std::unordered_map<const char*, World*> worlds;
-
 	class ERA_CORE_API IReleasable
 	{
 	public:
diff --git a/modules/core/src/ecs/rendering/mesh_component.h b/modules/core/src/ecs/rendering/mesh_component.h
index 968083fe0..ea503ccb7 100644
--- a/modules/core/src/ecs/rendering/mesh_component.h
+++ b/modules/core/src/ecs/rendering/mesh_component.h
@@ -1,12 +1,13 @@
 #pragma once
 
+#include "core_api.h"
 #include "ecs/component.h"
 
 #include "geometry/mesh.h"
 
 namespace era_engine
 {
-	class MeshComponent : public Component
+	class ERA_CORE_API MeshComponent : public Component
 	{
 	public:
 		MeshComponent(ref<Entity::EcsData> _data, ref<multi_mesh> _mesh, bool _is_hidden = false);
diff --git a/modules/core/src/ecs/rendering/world_renderer.cpp b/modules/core/src/ecs/rendering/world_renderer.cpp
index 0806b7a7c..7f9334142 100644
--- a/modules/core/src/ecs/rendering/world_renderer.cpp
+++ b/modules/core/src/ecs/rendering/world_renderer.cpp
@@ -319,7 +319,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderStaticObjects(ref<World> world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
+	static void renderStaticObjects(World* world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, shadow_passes& shadow)
 	{
 		CPU_PROFILE_BLOCK("Static objects");
@@ -494,7 +494,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderDynamicObjects(ref<World> world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
+	static void renderDynamicObjects(World* world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, shadow_passes& shadow)
 	{
 		CPU_PROFILE_BLOCK("Dynamic objects");
@@ -513,7 +513,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderAnimatedObjects(ref<World> world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
+	static void renderAnimatedObjects(World* world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, shadow_passes& shadow)
 	{
 		CPU_PROFILE_BLOCK("Animated objects");
@@ -600,7 +600,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderTerrain(const render_camera& camera, ref<World> world, Allocator& arena, Entity::Handle selectedObjectID,
+	static void renderTerrain(const render_camera& camera, World* world, Allocator& arena, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass,
 		compute_pass* computePass, float dt)
 	{
@@ -637,7 +637,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderTrees(ref<World> world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
+	static void renderTrees(World* world, const camera_frustum_planes& frustum, Allocator& arena, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass,
 		float dt)
 	{
@@ -695,7 +695,7 @@ namespace era_engine
 		}
 	}
 
-	static void renderCloth(ref<World> world, Entity::Handle selectedObjectID,
+	static void renderCloth(World* world, Entity::Handle selectedObjectID,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass)
 	{
 		CPU_PROFILE_BLOCK("Cloth");
@@ -783,7 +783,7 @@ namespace era_engine
 		sunShadowRenderPass->copyFromStaticCache = !command.renderStaticGeometry;
 	}
 
-	static void setupSpotShadowPasses(ref<World> world, scene_lighting& lighting, bool invalidateShadowMapCache)
+	static void setupSpotShadowPasses(World* world, scene_lighting& lighting, bool invalidateShadowMapCache)
 	{
 		uint32 numSpotLights = world->number_of_components_of_type<SpotLightComponent>();
 		if (numSpotLights)
@@ -817,7 +817,7 @@ namespace era_engine
 		}
 	}
 
-	static void setupPointShadowPasses(ref<World> world, scene_lighting& lighting, bool invalidateShadowMapCache)
+	static void setupPointShadowPasses(World* world, scene_lighting& lighting, bool invalidateShadowMapCache)
 	{
 		uint32 numPointLights = world->number_of_components_of_type<PointLightComponent>();
 		if (numPointLights)
@@ -854,7 +854,7 @@ namespace era_engine
 		}
 	}
 
-	void render_world(const render_camera& camera, ref<World> world, Allocator& arena, Entity::Handle selectedObjectID, directional_light& sun, scene_lighting& lighting, bool invalidateShadowMapCache, opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass, compute_pass* computePass, float dt)
+	void render_world(const render_camera& camera, World* world, Allocator& arena, Entity::Handle selectedObjectID, directional_light& sun, scene_lighting& lighting, bool invalidateShadowMapCache, opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass, compute_pass* computePass, float dt)
 	{
 		CPU_PROFILE_BLOCK("Submit scene render commands");
 
diff --git a/modules/core/src/ecs/rendering/world_renderer.h b/modules/core/src/ecs/rendering/world_renderer.h
index 792a4b20b..048dac621 100644
--- a/modules/core/src/ecs/rendering/world_renderer.h
+++ b/modules/core/src/ecs/rendering/world_renderer.h
@@ -6,7 +6,7 @@
 
 namespace era_engine
 {
-	void render_world(const render_camera& camera, ref<World> world, Allocator& arena, Entity::Handle selectedObjectID,
+	void render_world(const render_camera& camera, World* world, Allocator& arena, Entity::Handle selectedObjectID,
 		directional_light& sun, scene_lighting& lighting, bool invalidateShadowMapCache,
 		opaque_render_pass* opaqueRenderPass, transparent_render_pass* transparentRenderPass, ldr_render_pass* ldrRenderPass, sun_shadow_render_pass* sunShadowRenderPass,
 		compute_pass* computePass, float dt);
diff --git a/modules/core/src/ecs/task_utils.cpp b/modules/core/src/ecs/task_utils.cpp
new file mode 100644
index 000000000..d277bca2f
--- /dev/null
+++ b/modules/core/src/ecs/task_utils.cpp
@@ -0,0 +1,6 @@
+#include "ecs/task_utils.h"
+
+namespace era_engine
+{
+
+}
\ No newline at end of file
diff --git a/modules/core/src/ecs/task_utils.h b/modules/core/src/ecs/task_utils.h
new file mode 100644
index 000000000..30804368f
--- /dev/null
+++ b/modules/core/src/ecs/task_utils.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "ecs/update_groups.h"
+
+#include "ecs/system.h"
+
+namespace era_engine
+{
+
+}
\ No newline at end of file
diff --git a/modules/core/src/ecs/world.cpp b/modules/core/src/ecs/world.cpp
index 295d76bd6..8c95272fc 100644
--- a/modules/core/src/ecs/world.cpp
+++ b/modules/core/src/ecs/world.cpp
@@ -1,20 +1,27 @@
 #include "ecs/world.h"
 #include "ecs/base_components/base_components.h"
+#include "ecs/world_system_scheduler.h"
 
 #include "core/sync.h"
 #include "core/log.h"
 
 namespace era_engine
 {
-	std::unordered_map<const char*, World*> worlds;
+	std::unordered_map<std::string, World*> worlds;
 
 	World::World(const char* _name)
 	{
-		world_data = make_ref<WorldData>();
+		world_data = new WorldData();
 		world_data->name = _name;
 		world_data->registry.reserve(64000);
+		world_data->scheduler = new WorldSystemScheduler(this);
 
-		worlds.emplace(_name, this);
+		worlds.emplace(std::string(_name), this);
+	}
+
+	World::~World()
+	{
+		destroy();
 	}
 
 	void World::init()
@@ -26,7 +33,7 @@ namespace era_engine
 
 	Entity World::create_entity()
 	{
-		Lock _lock{ world_data->sync};
+		std::lock_guard _lock{ world_data->sync};
 
 		ref<Entity::EcsData> new_data = make_ref<Entity::EcsData>(world_data->registry.create(), this, &world_data->registry);
 		world_data->entity_datas.emplace(new_data->entity_handle, new_data);
@@ -44,7 +51,7 @@ namespace era_engine
 
 	Entity World::create_entity(Entity::Handle _handle)
 	{
-		Lock _lock{ world_data->sync };
+		std::lock_guard _lock{ world_data->sync };
 
 		if (world_data->entity_datas.find(_handle) == world_data->entity_datas.end())
 		{
@@ -81,7 +88,7 @@ namespace era_engine
 			return;
 		}
 
-		Lock _lock{ EntityContainer::sync };
+		std::lock_guard _lock{ EntityContainer::sync };
 
 		if (_destroy_components)
 		{
@@ -89,7 +96,7 @@ namespace era_engine
 			{
 				if (curr.second.contains(_handle))
 				{
-					IReleasable* comp = reinterpret_cast<IReleasable*>(world_data->registry.storage(curr.first)->second.get(_handle));
+					IReleasable* comp = static_cast<IReleasable*>(world_data->registry.storage(curr.first)->second.get(_handle));
 					ASSERT(comp != nullptr);
 					comp->release();
 				}
@@ -134,6 +141,8 @@ namespace era_engine
 		}
 		world_data->registry.clear();
 		world_data->entity_datas.clear();
+
+		delete world_data;
 	}
 
 	size_t World::size() const noexcept
@@ -146,6 +155,11 @@ namespace era_engine
 		return world_data->registry;
 	}
 
+	WorldSystemScheduler* World::get_system_scheduler() const
+	{
+		return world_data->scheduler;
+	}
+
 	void World::add_base_components(Entity& entity)
 	{
 		entity.add_component<TransformComponent>().add_component<ChildComponent>(weakref<Entity::EcsData>(world_data->root_entity.internal_data));
@@ -153,7 +167,12 @@ namespace era_engine
 
 	World* get_world_by_name(const char* _name)
 	{
-		return worlds[_name];
+		return worlds[std::string(_name)];
+	}
+
+	std::unordered_map<std::string, World*>& get_worlds()
+	{
+		return worlds;
 	}
 
 }
\ No newline at end of file
diff --git a/modules/core/src/ecs/world.h b/modules/core/src/ecs/world.h
index 6e6254671..7bbaae6e7 100644
--- a/modules/core/src/ecs/world.h
+++ b/modules/core/src/ecs/world.h
@@ -33,19 +33,28 @@ namespace era_engine
 	template<typename... Type_>
 	inline constexpr ComponentsGroup<Type_...> components_group{};
 
-	class ERA_CORE_API World
+	class WorldSystemScheduler;
+
+	class ERA_CORE_API World final
 	{
 		struct WorldData
 		{
 			std::mutex sync;
+
 			std::unordered_map<Entity::Handle, ref<Entity::EcsData>> entity_datas;
+
 			entt::registry registry;
+
 			Entity root_entity;
+
+			WorldSystemScheduler* scheduler = nullptr;
+
 			const char* name = nullptr;
 		};
 
 	public:
 		World(const char* _name);
+		~World();
 
 		World(const World& _world) = delete;
 		World& operator=(const World* _world) const = delete;
@@ -70,6 +79,8 @@ namespace era_engine
 
 		entt::registry& get_registry();
 
+		WorldSystemScheduler* get_system_scheduler() const;
+
 		template <typename Component_>
 		Entity get_entity_from_component(const Component_& comp)
 		{
@@ -209,11 +220,13 @@ namespace era_engine
 		ERA_REFLECT
 
 	private:
-		ref<WorldData> world_data = nullptr;
+		WorldData* world_data = nullptr;
 
 		friend class Entity;
 		friend class EntityEditorUtils;
 	};
 
-	World* get_world_by_name(const char* _name);
+	ERA_CORE_API World* get_world_by_name(const char* _name);
+
+	ERA_CORE_API std::unordered_map<std::string, World*>& get_worlds();
 }
\ No newline at end of file
diff --git a/modules/core/src/ecs/world_system_scheduler.cpp b/modules/core/src/ecs/world_system_scheduler.cpp
index 989ee5d81..b2b6591f7 100644
--- a/modules/core/src/ecs/world_system_scheduler.cpp
+++ b/modules/core/src/ecs/world_system_scheduler.cpp
@@ -1,6 +1,7 @@
 #include "ecs/world_system_scheduler.h"
 
-#include "core/job_system.h"
+#include "core/cpu_profiling.h"
+#include "core/log.h"
 
 #include "ecs/reflection.h"
 #include "ecs/system.h"
@@ -13,9 +14,9 @@
 namespace era_engine
 {
 
-	struct UpdateParams
+	struct TasksParams
 	{
-		WorldSystemScheduler::Update& update;
+		std::vector<ref<Task>>& updates;
 		float elapsed = 0.0f;
 	};
 
@@ -26,8 +27,9 @@ namespace era_engine
 
 	WorldSystemScheduler::~WorldSystemScheduler()
 	{
-		updates.clear();
+		grouped_ordered_tasks.clear();
 		systems.clear();
+		system_types.clear();
 	}
 
 	void WorldSystemScheduler::initialize_systems(const rttr::array_range<rttr::type>& types)
@@ -37,9 +39,21 @@ namespace era_engine
 
 		for (const type& type_instance : types)
 		{
-			if (base_type.is_base_of(type_instance) && type_instance.get_raw_type() != base_type && type_instance.is_class())
+			rttr::type wrapped_type = type_instance.get_raw_type();
+			if (base_type.is_base_of(type_instance) && wrapped_type != base_type && type_instance.is_class())
 			{
-				for (const method& system_method : type_instance.get_methods())
+				auto iter = system_types.find(wrapped_type);
+				if (iter != system_types.end())
+				{
+					continue;
+				}
+
+				system_types.emplace(wrapped_type);
+
+				System* system = type_instance.create({ world }).get_value<System*>();
+				systems.push_back(system);
+
+				for (method system_method : type_instance.get_methods())
 				{
 					variant meta = system_method.get_metadata("update_group");
 					if (!meta.is_valid())
@@ -47,20 +61,25 @@ namespace era_engine
 						continue;
 					}
 
+					variant after = system_method.get_metadata("After");
+					variant before = system_method.get_metadata("Before");
+
+					std::vector<std::string> dependencies = after.is_valid() ? after.get_value<std::vector<std::string>>() : std::vector<std::string>{};
+					std::vector<std::string> dependent = before.is_valid() ? before.get_value<std::vector<std::string>>() : std::vector<std::string>{};
+
 					UpdateGroup group = meta.get_value<UpdateGroup>();
-					System* system = type_instance.create({ world }).get_value<System*>();
-					if (updates.find(group.name) == updates.end())
-					{
-						updates.emplace(group.name, std::vector<std::pair<System*, rttr::method>>{{ system, system_method }});
-					}
-					else
-					{
-						updates[group.name].tasks.push_back({ system, system_method });
-					}
-					systems.push_back(system);
+
+					ref<Task> task = make_ref<Task>(system, system_method, std::string(group.name), dependencies, dependent);
+
+					add_task(task);
 				}
 			}
 		}
+	}
+
+	void WorldSystemScheduler::initialize_all_systems()
+	{
+		grouped_ordered_tasks = build_task_order();
 
 		for (System* system : systems)
 		{
@@ -70,78 +89,159 @@ namespace era_engine
 
 	void WorldSystemScheduler::input(float elapsed)
 	{
-		run(elapsed, update_types::INPUT);
+		JobHandle handle = run(elapsed, update_types::INPUT, main_thread_job_queue);
+		handle.submit_now();
+		handle.wait_for_completion();
 	}
 
 	void WorldSystemScheduler::begin(float elapsed)
 	{
-		run(elapsed, update_types::BEGIN);
-
+		JobHandle handle = run(elapsed, update_types::BEGIN, main_thread_job_queue);
+		handle.submit_now();
+		handle.wait_for_completion();
 	}
 
 	void WorldSystemScheduler::render_update(float elapsed)
 	{
-		using namespace rttr;
-
-		const auto simulation_task = [](UpdateParams& data, JobHandle job) {
-			for (auto& pair : data.update.tasks)
-			{
-				pair.second.invoke(*pair.first, data.elapsed);
-			}
-		};
-
-		JobHandle before_render_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::BEFORE_RENDER.name], elapsed });
+		JobHandle before_render_handle = run(elapsed, update_types::BEFORE_RENDER, high_priority_job_queue);
 		before_render_handle.submit_now();
 
-		JobHandle render_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::RENDER.name], elapsed });
+		JobHandle render_handle = run(elapsed, update_types::RENDER, high_priority_job_queue);
 		render_handle.submit_after(before_render_handle);
 
-		JobHandle after_render_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::AFTER_RENDER.name], elapsed });
+		JobHandle after_render_handle = run(elapsed, update_types::AFTER_RENDER, high_priority_job_queue);
 		after_render_handle.submit_after(render_handle);
 		after_render_handle.wait_for_completion();
 	}
 
 	void WorldSystemScheduler::physics_update(float elapsed)
 	{
-		using namespace rttr;
-
-		const auto simulation_task = [](UpdateParams& data, JobHandle job) {
-			for (auto& pair : data.update.tasks)
-			{
-				pair.second.invoke(*pair.first, data.elapsed);
-			}
-		};
-
-		JobHandle before_physics_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::BEFORE_PHYSICS.name], elapsed });
+		JobHandle before_physics_handle = run(elapsed, update_types::BEFORE_PHYSICS, main_thread_job_queue);
 		before_physics_handle.submit_now();
 
-		JobHandle physics_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::PHYSICS.name], elapsed });
+		JobHandle physics_handle = run(elapsed, update_types::PHYSICS, main_thread_job_queue);
 		physics_handle.submit_after(before_physics_handle);
 
-		JobHandle after_physics_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[update_types::AFTER_PHYSICS.name], elapsed });
+		JobHandle after_physics_handle = run(elapsed, update_types::AFTER_PHYSICS, main_thread_job_queue);
 		after_physics_handle.submit_after(physics_handle);
 		after_physics_handle.wait_for_completion();
 	}
 
 	void WorldSystemScheduler::end(float elapsed)
 	{
-		run(elapsed, update_types::END);
+		JobHandle handle = run(elapsed, update_types::END, main_thread_job_queue);
+		handle.submit_now();
+		handle.wait_for_completion();
 	}
 
-	void WorldSystemScheduler::run(float elapsed, const UpdateGroup& group)
+	JobHandle WorldSystemScheduler::run(float elapsed, const UpdateGroup& group, JobQueue& queue)
 	{
 		using namespace rttr;
 
-		const auto simulation_task = [](UpdateParams& data, JobHandle job) {
-			for (auto& pair : data.update.tasks)
+		const auto simulation_task = [](TasksParams& data, JobHandle job) {
+			for (auto& task : data.updates)
+			{
+				auto type_name = task->system->get_type().get_name().data();
+				auto method_name = task->method.get_name().data();
+
+				std::stringstream stream{};
+				stream << type_name << ": " << method_name;
+
+				CPU_PROFILE_BLOCK(stream.str().c_str());
+
+				task->method.invoke(*task->system, data.elapsed);
+			}
+		};
+
+		return queue.createJob<TasksParams>(simulation_task, { grouped_ordered_tasks[group.name], elapsed });
+	}
+
+	void WorldSystemScheduler::add_task(ref<Task> task)
+	{
+		std::string task_name = task->system->get_type().get_name() + std::string("::") + task->method.get_name();
+		tasks[task_name] = task;
+
+		if (adj_list.find(task_name) == adj_list.end())
+		{
+			adj_list[task_name] = {};
+		}
+		if (in_degree.find(task_name) == in_degree.end())
+		{
+			in_degree[task_name] = 0;
+		}
+
+		for (const auto& dep : task->dependencies)
+		{
+			adj_list[dep].push_back(task_name);
+			in_degree[task_name]++;
+		}
+
+		for (const auto& dep : task->dependents)
+		{
+			adj_list[task_name].push_back(dep);
+			in_degree[dep]++;
+		}
+	}
+
+	std::unordered_map<std::string, std::vector<ref<Task>>> WorldSystemScheduler::build_task_order()
+	{
+		std::queue<std::string> zero_in_degree;
+		std::vector<ref<Task>> task_order;
+
+		for (const auto& [task_name, degree] : in_degree)
+		{
+			if (degree == 0)
+			{
+				zero_in_degree.push(task_name);
+			}
+		}
+
+		while (!zero_in_degree.empty())
+		{
+			std::string current = zero_in_degree.front();
+
+			task_order.push_back(tasks[current]);
+			zero_in_degree.pop();
+
+			for (const auto& neighbor : adj_list[current])
+			{
+				in_degree[neighbor]--;
+				if (in_degree[neighbor] == 0)
+				{
+					zero_in_degree.push(neighbor);
+				}
+			}
+		}
+
+		if (task_order.size() != tasks.size())
+		{
+			throw std::runtime_error("Cycle in task order graph!");
+		}
+
+		std::unordered_map<std::string, std::vector<ref<Task>>> grouped_tasks;
+		for (const auto& task : task_order)
+		{
+			grouped_tasks[task->group].push_back(task);
+		}
+
+		std::unordered_map<std::string, std::vector<ref<Task>>> ordered_groups;
+		std::unordered_set<std::string> added_groups;
+
+		for (const auto& task : task_order)
+		{
+			if (added_groups.find(task->group) == added_groups.end())
 			{
-				pair.second.invoke(*pair.first, data.elapsed);
+				ordered_groups.emplace(task->group, grouped_tasks[task->group]);
+				added_groups.insert(task->group);
 			}
-			};
+		}
 
-		JobHandle end_handle = high_priority_job_queue.createJob<UpdateParams>(simulation_task, { updates[group.name], elapsed });
-		end_handle.submit_now();
-		end_handle.wait_for_completion();
+		return ordered_groups;
+	}
+
+	Task::Task(System* _system, const rttr::method& _method, const std::string& _group, const std::vector<std::string>& _dependencies, const std::vector<std::string>& _dependents)
+		: system(_system), method(_method), group(_group), dependencies(_dependencies), dependents(_dependents)
+	{
 	}
 
 }
\ No newline at end of file
diff --git a/modules/core/src/ecs/world_system_scheduler.h b/modules/core/src/ecs/world_system_scheduler.h
index acb613716..36a733251 100644
--- a/modules/core/src/ecs/world_system_scheduler.h
+++ b/modules/core/src/ecs/world_system_scheduler.h
@@ -3,24 +3,45 @@
 #include "core_api.h"
 
 #include "ecs/system.h"
+#include "core/job_system.h"
+
+#include <rttr/type>
+#include <string>
 
 namespace era_engine
 {
 	class World;
 
+	struct ERA_CORE_API Task
+	{
+		Task(System* _system,
+			 const rttr::method& _method,
+			 const std::string& _group,
+			 const std::vector<std::string>& _dependencies,
+			 const std::vector<std::string>& _dependents);
+		Task(Task&& _other) noexcept = default;
+		Task(const Task& _other) noexcept = default;
+
+		Task& operator=(const Task& _other) noexcept;
+		Task& operator=(Task&& _other) noexcept;
+
+		System* system = nullptr;
+		rttr::method method;
+		std::string group;
+		std::vector<std::string> dependencies;
+		std::vector<std::string> dependents;
+	};
+
 	class ERA_CORE_API WorldSystemScheduler
 	{
 	public:
-		struct Update
-		{
-			std::vector<std::pair<System*, rttr::method>> tasks;
-		};
-
 		WorldSystemScheduler(World* _world);
 		~WorldSystemScheduler();
 
 		void initialize_systems(const rttr::array_range<rttr::type>& types);
 
+		void initialize_all_systems();
+
 		void input(float elapsed);
 
 		void begin(float elapsed);
@@ -30,12 +51,22 @@ namespace era_engine
 
 		void end(float elapsed);
 
-		void run(float elapsed, const UpdateGroup& group);
+		JobHandle run(float elapsed, const UpdateGroup& group, JobQueue& queue);
+
+	private:
+		std::unordered_map<std::string, std::vector<ref<Task>>> build_task_order();
+
+		void add_task(ref<Task> task);
 
 	private:
 		World* world = nullptr;
 		std::vector<System*> systems;
+		std::set<rttr::type> system_types;
+
+		std::unordered_map<std::string, ref<Task>> tasks;
+		std::unordered_map<std::string, std::vector<std::string>> adj_list;
+		std::unordered_map<std::string, int> in_degree;
 
-		std::unordered_map<std::string, Update> updates;
+		std::unordered_map<std::string, std::vector<ref<Task>>> grouped_ordered_tasks;
 	};
 }
\ No newline at end of file
diff --git a/modules/core/src/editor/asset_editor_panel.cpp b/modules/core/src/editor/asset_editor_panel.cpp
index 23a9c3de9..6a4c72a90 100644
--- a/modules/core/src/editor/asset_editor_panel.cpp
+++ b/modules/core/src/editor/asset_editor_panel.cpp
@@ -201,7 +201,7 @@ namespace era_engine
 			{
 				if (ImGui::BeginChild("AnimationSettings"))
 				{
-					AnimationSkeleton& skeleton = this->mesh->skeleton;
+					Skeleton& skeleton = this->mesh->skeleton;
 					if (skeleton.joints.size() > 0)
 					{
 						if (ImGui::BeginTree("Skeleton"))
diff --git a/modules/core/src/editor/editor.cpp b/modules/core/src/editor/editor.cpp
index 899cabcb8..68cb6b3d7 100644
--- a/modules/core/src/editor/editor.cpp
+++ b/modules/core/src/editor/editor.cpp
@@ -21,8 +21,6 @@
 #include "terrain/grass.h"
 #include "terrain/water.h"
 
-#include "application.h"
-
 #include "imgui/imgui_internal.h"
 
 //#include "scripting/script.h"
diff --git a/modules/core/src/editor/editor.h b/modules/core/src/editor/editor.h
index 2ef9b7315..8c4024594 100644
--- a/modules/core/src/editor/editor.h
+++ b/modules/core/src/editor/editor.h
@@ -20,8 +20,6 @@
 
 namespace era_engine
 {
-	struct application;
-
 	struct eeditor
 	{
 		void initialize(ref<EditorScene> _scene, main_renderer* _renderer, editor_panels* _editorPanels);
@@ -80,8 +78,6 @@ namespace era_engine
 		main_renderer* renderer = nullptr;
 		editor_panels* editorPanels = nullptr;
 
-		application* app = nullptr;
-
 		undo_stack undoStacks[2];
 		undo_buffer undoBuffers[2];
 
@@ -99,7 +95,6 @@ namespace era_engine
 		bool renderPhysicsShapes = false;
 
 		friend struct selection_undo;
-		friend struct application;
 	};
 
 	void editTexture(const char* name, ref<dx_texture>& tex, uint32 loadFlags);
diff --git a/modules/core/src/editor/transformation_gizmo.h b/modules/core/src/editor/transformation_gizmo.h
index 86cf0bfd1..8c230acf9 100644
--- a/modules/core/src/editor/transformation_gizmo.h
+++ b/modules/core/src/editor/transformation_gizmo.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include "core_api.h"
+
 #include "core/math.h"
 #include "core/input.h"
 #include "core/camera.h"
@@ -12,7 +14,7 @@
 
 namespace era_engine
 {
-	struct transformation_gizmo
+	struct ERA_CORE_API transformation_gizmo
 	{
 		bool manipulateTransformation(trs& transform, const render_camera& camera, const UserInput& input, bool allowInput, ldr_render_pass* ldrRenderPass);
 		bool manipulatePosition(vec3& position, const render_camera& camera, const UserInput& input, bool allowInput, ldr_render_pass* ldrRenderPass);
@@ -67,5 +69,5 @@ namespace era_engine
 		vec3 originalScale;
 	};
 
-	void initializeTransformationGizmos();
+	ERA_CORE_API void initializeTransformationGizmos();
 }
\ No newline at end of file
diff --git a/modules/core/src/engine/engine.h b/modules/core/src/engine/engine.h
index d134739ee..68e452c42 100644
--- a/modules/core/src/engine/engine.h
+++ b/modules/core/src/engine/engine.h
@@ -8,7 +8,6 @@
 
 namespace era_engine
 {
-	class WorldSystemScheduler;
 
 	class ERA_CORE_API Engine final
 	{
@@ -44,8 +43,6 @@ namespace era_engine
 			return object.get_value<Object*>();
 		}
 
-		WorldSystemScheduler* get_system_scheduler() const;
-
 	private:
 		bool update();
 
@@ -53,8 +50,6 @@ namespace era_engine
 
 		std::unordered_map<rttr::type, rttr::variant> single_objects;
 
-		WorldSystemScheduler* scheduler = nullptr;
-
 		static Engine* instance_object;
 	};
 
diff --git a/modules/core/src/engine/engine_loop.h b/modules/core/src/engine/engine_loop.h
deleted file mode 100644
index bb3c81b14..000000000
--- a/modules/core/src/engine/engine_loop.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-namespace era_engine
-{
-
-}
\ No newline at end of file
diff --git a/modules/core/src/engine/private/engine.cpp b/modules/core/src/engine/private/engine.cpp
index 191ad8797..0f08fe6a0 100644
--- a/modules/core/src/engine/private/engine.cpp
+++ b/modules/core/src/engine/private/engine.cpp
@@ -21,8 +21,6 @@
 #include "core/editor_icons.h"
 #include "core/log.h"
 
-#include "application.h"
-
 #include "rendering/render_utils.h"
 #include "rendering/main_renderer.h"
 
@@ -34,6 +32,7 @@
 #include <imgui/imgui_internal.h>
 
 #include <fstream>
+#include "editor/transformation_gizmo.h"
 
 namespace era_engine
 {
@@ -82,6 +81,23 @@ namespace era_engine
 		return result;
 	}
 
+	static void draw_debug_menu_bar(float elapsed)
+	{
+		const float fps = 1.0f / elapsed;
+		if (ImGui::BeginMainMenuBar())
+		{
+			if (ImGui::BeginMenu(std::to_string(fps).c_str()))
+			{
+				ImGui::EndMenu();
+			}
+			if (ImGui::BeginMenu(std::to_string(frameID).c_str()))
+			{
+				ImGui::EndMenu();
+			}
+			ImGui::EndMainMenuBar();
+		}
+	}
+
 	static void renderToMainWindow(dx_window& window)
 	{
 		dx_resource backbuffer = window.backBuffers[window.currentBackbufferIndex];
@@ -113,22 +129,25 @@ namespace era_engine
 		fenceValues[window.currentBackbufferIndex] = result;
 	}
 
-	application globalApp;
-
 	Engine* Engine::instance_object = nullptr;
 
+	static bool verbose = false;
+	static bool main_menu = false;
+
 	Engine::Engine(int argc, char** argv)
 	{
 		using namespace clara;
 
 		running = true;
 		instance_object = this;
+
 #ifndef _DEBUG
 		::ShowWindow(::GetConsoleWindow(), SW_HIDE);
 #endif
 
-		bool verbose = false;
-		auto cli = Opt(verbose, "verbose")["-v"]["--verbose"]("verbose logging");
+		Parser cli;
+		cli += Opt(verbose, "verbose")["-v"]["--verbose"]("Enable verbose logging");
+		cli += Opt(main_menu, "main-menu")["-mm"]["--main-menu"]("Enable main menu bar");
 
 		auto result = cli.parse(Args(argc, argv));
 		if (!result)
@@ -140,6 +159,12 @@ namespace era_engine
 		{
 			::ShowWindow(::GetConsoleWindow(), SW_SHOW);
 		}
+
+		const bool dx_inited = dxContext.initialize();
+		ASSERT(dx_inited);
+
+		World* runtime_world = new World("GameWorld");
+		runtime_world->init();
 	}
 
 	Engine::~Engine()
@@ -163,46 +188,13 @@ namespace era_engine
 
 	bool Engine::run(const std::function<void(void)>& initial_task /* = nullptr */)
 	{
-		if (!dxContext.initialize())
-		{
-			return EXIT_FAILURE;
-		}
-
 		initialize_job_system();
 		initializeFileRegistry();
 
-		dx_window window;
-		window.initialize(TEXT("  New Project - Era Engine - 0.1432v1 - <DX12>"), 1920, 1080);
-		window.setIcon(get_asset_path("/resources/icons/Logo.ico"));
-		window.setCustomWindowStyle();
-		window.maximize();
-
-		globalApp.loadCustomShaders();
-
-		window.setFileDropCallback([](const fs::path& s) { globalApp.handleFileDrop(s); });
-
-		initializeTransformationGizmos();
 		initializeRenderUtils();
 
-		initializeImGui(window);
-
-		renderer_spec spec;
-		spec.allowObjectPicking = true;
-		spec.allowAO = true;
-		spec.allowSSS = true;
-		spec.allowSSR = true;
-		spec.allowTAA = true;
-		spec.allowBloom = true;
-		spec.allowDLSS = true;
-
-		main_renderer renderer;
-		renderer.initialize(window.colorDepth, window.clientWidth, window.clientHeight, spec);
-
-		editor_panels editorPanels;
-
-		globalApp.initialize(&renderer, &editorPanels);
-
-		scheduler = new WorldSystemScheduler(globalApp.getCurrentWorld().get());
+		dx_window* window = get_object<dx_window>();
+		initializeImGui(*window);
 
 		file_browser fileBrowser;
 
@@ -215,168 +207,63 @@ namespace era_engine
 			initial_task();
 		}
 
-		UserInput input = {};
-		bool appFocusedLastFrame = true;
+		for (auto& [name, world] : get_worlds())
+		{
+			WorldSystemScheduler* scheduler = world->get_system_scheduler();
+			scheduler->initialize_all_systems();
+		}
+
+		execute_main_thread_jobs();
 
 		float dt;
-		while (newFrame(dt, window))
+		bool status = true;
+		while (status)
 		{
-			ImGui::BeginWindowHiddenTabBar("Scene Viewport");
-			uint32 renderWidth = (uint32)ImGui::GetContentRegionAvail().x;
-			uint32 renderHeight = (uint32)ImGui::GetContentRegionAvail().y;
-			ImGui::Image(renderer.frameResult, renderWidth, renderHeight);
-
-			scheduler->input(dt);
+			status = newFrame(dt, *window);
 
+			auto& worlds = get_worlds();
+			for (auto& [name, world] : worlds)
 			{
-				CPU_PROFILE_BLOCK("Collect user input");
-
-				ImGuiIO& io = ImGui::GetIO();
-				if (ImGui::IsItemHovered() && !editorPanels.meshEditor.isHovered())
-				{
-					ImVec2 relativeMouse = ImGui::GetMousePos() - ImGui::GetItemRectMin();
-					vec2 mousePos = { relativeMouse.x, relativeMouse.y };
-					if (appFocusedLastFrame)
-					{
-						input.mouse.dx = (int32)(mousePos.x - input.mouse.x);
-						input.mouse.dy = (int32)(mousePos.y - input.mouse.y);
-						input.mouse.reldx = (float)input.mouse.dx / (renderWidth - 1);
-						input.mouse.reldy = (float)input.mouse.dy / (renderHeight - 1);
-					}
-					else
-					{
-						input.mouse.dx = 0;
-						input.mouse.dy = 0;
-						input.mouse.reldx = 0.f;
-						input.mouse.reldy = 0.f;
-					}
-					input.mouse.x = (int32)mousePos.x;
-					input.mouse.y = (int32)mousePos.y;
-					input.mouse.relX = mousePos.x / (renderWidth - 1);
-					input.mouse.relY = mousePos.y / (renderHeight - 1);
-					input.mouse.left = { ImGui::IsMouseDown(ImGuiMouseButton_Left), ImGui::IsMouseClicked(ImGuiMouseButton_Left), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) };
-					input.mouse.right = { ImGui::IsMouseDown(ImGuiMouseButton_Right), ImGui::IsMouseClicked(ImGuiMouseButton_Right), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Right) };
-					input.mouse.middle = { ImGui::IsMouseDown(ImGuiMouseButton_Middle), ImGui::IsMouseClicked(ImGuiMouseButton_Middle), ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Middle) };
-
-					for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
-					{
-						input.keyboard[i] = { ImGui::IsKeyDown(i), ImGui::IsKeyPressed(i, false) };
-					}
-
-					input.over_window = true;
-				}
-				else
-				{
-					input.mouse.dx = 0;
-					input.mouse.dy = 0;
-					input.mouse.reldx = 0.f;
-					input.mouse.reldy = 0.f;
-
-					if (input.mouse.left.down && !ImGui::IsMouseDown(ImGuiMouseButton_Left))
-					{
-						input.mouse.left.down = false;
-					}
-					if (input.mouse.right.down && !ImGui::IsMouseDown(ImGuiMouseButton_Right))
-					{
-						input.mouse.right.down = false;
-					}
-					if (input.mouse.middle.down && !ImGui::IsMouseDown(ImGuiMouseButton_Middle))
-					{
-						input.mouse.middle.down = false;
-					}
-
-					input.mouse.left.click_event = input.mouse.left.double_click_event = false;
-					input.mouse.right.click_event = input.mouse.right.double_click_event = false;
-					input.mouse.middle.click_event = input.mouse.middle.double_click_event = false;
-
-					for (uint32 i = 0; i < arraysize(UserInput::keyboard); ++i)
-					{
-						if (!ImGui::IsKeyDown(i))
-						{
-							input.keyboard[i].down = false;
-						}
-						input.keyboard[i].press_event = false;
-					}
-
-					input.over_window = false;
-				}
+				WorldSystemScheduler* scheduler = world->get_system_scheduler();
+				scheduler->input(dt);
 			}
 
-			// The drag&drop outline is rendered around the drop target. Since the image fills the frame, the outline is outside the window 
-			// and thus invisible. So instead this (slightly smaller) Dummy acts as the drop target.
-			// Important: This is below the input processing, so that we don't override the current element id.
-			ImGui::SetCursorPos(ImVec2(4.5f, 4.5f));
-			ImGui::Dummy(ImVec2(renderWidth - 9.f, renderHeight - 9.f));
-
-			if (ImGui::BeginDragDropTarget())
+			for (auto& [name, world] : worlds)
 			{
-				if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(EDITOR_ICON_MESH))
-				{
-					globalApp.handleFileDrop((const char*)payload->Data);
-				}
-				if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(EDITOR_ICON_IMAGE_HDR))
-				{
-					globalApp.handleFileDrop((const char*)payload->Data);
-				}
-				ImGui::EndDragDropTarget();
+				WorldSystemScheduler* scheduler = world->get_system_scheduler();
+				scheduler->begin(dt);
 			}
 
-			appFocusedLastFrame = ImGui::IsMousePosValid();
-
-			if (input.keyboard['V'].press_event && !(input.keyboard[key_ctrl].down || input.keyboard[key_shift].down || input.keyboard[key_alt].down))
-				window.toggleVSync();
-			if (ImGui::IsKeyPressed(key_esc))
+			for (auto& [name, world] : worlds)
 			{
-				break; // Also allowed if not focused on main window.
+				WorldSystemScheduler* scheduler = world->get_system_scheduler();
+				scheduler->physics_update(dt);
 			}
-			if (ImGui::IsKeyPressed(key_enter) && ImGui::IsKeyDown(key_alt))
+
+			for (auto& [name, world] : worlds)
 			{
-				window.toggleFullscreen(); // Also allowed if not focused on main window.
+				WorldSystemScheduler* scheduler = world->get_system_scheduler();
+				scheduler->render_update(dt);
 			}
 
-			scheduler->begin(dt);
-
-			renderer.beginFrame(renderWidth, renderHeight);
-
-			editorPanels.meshEditor.beginFrame();
-
-			scheduler->physics_update(dt);
-			scheduler->render_update(dt);
-			globalApp.update(input, dt);
-
-			scheduler->end(dt);
-
-			execute_main_thread_jobs();
-
-			endFrameCommon();
-			renderer.endFrame(&input);
-
-			editorPanels.meshEditor.endFrame();
-
-			if (ImGui::IsKeyPressed(key_print))
+			if (main_menu)
 			{
-				const fs::path dir = "captures";
-				fs::create_directories(dir);
-
-				fs::path path = dir / (get_time_string() + ".png");
-
-				if (ImGui::IsKeyDown(key_ctrl))
-				{
-					saveTextureToFile(window.backBuffers[window.currentBackbufferIndex], window.clientWidth, window.clientHeight, DXGI_FORMAT_R8G8B8A8_UNORM, path);
-				}
-				else
-				{
-					saveTextureToFile(renderer.frameResult, path);
-				}
+				draw_debug_menu_bar(dt);
+			}
 
-				LOG_MESSAGE("Saved screenshot to '%ws'", path.c_str());
+			for (auto& [name, world] : worlds)
+			{
+				WorldSystemScheduler* scheduler = world->get_system_scheduler();
+				scheduler->end(dt);
 			}
 
+			execute_main_thread_jobs();
+
 			fileBrowser.draw();
 
 			ImGui::End();
 
-			renderToMainWindow(window);
+			renderToMainWindow(*window);
 
 			cpu_profiling_frame_end_marker();
 
@@ -397,11 +284,6 @@ void Engine::terminate()
 	instance_object = nullptr;
 }
 
-WorldSystemScheduler* Engine::get_system_scheduler() const
-{
-	return scheduler;
-}
-
 bool Engine::update()
 {
 	return true;
diff --git a/modules/core/src/engine/private/engine_loop.cpp b/modules/core/src/engine/private/engine_loop.cpp
deleted file mode 100644
index d19ec59a3..000000000
--- a/modules/core/src/engine/private/engine_loop.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "engine/engine_loop.h"
-
-namespace era_engine
-{
-
-}
\ No newline at end of file
diff --git a/modules/core/src/geometry/mesh.cpp b/modules/core/src/geometry/mesh.cpp
index f7fa7cd23..177113371 100644
--- a/modules/core/src/geometry/mesh.cpp
+++ b/modules/core/src/geometry/mesh.cpp
@@ -36,7 +36,7 @@ namespace std
 
 namespace era_engine
 {
-	static void meshLoaderThread(ref<multi_mesh> result, const fs::path& sceneFilename, uint32 flags, mesh_load_callback cb,
+	static void meshLoaderThread(ref<multi_mesh> result, const fs::path& sceneFilename, uint32 flags, const mesh_load_callback& cb,
 		bool async, JobHandle parentJob)
 	{
 		using namespace animation;
@@ -82,7 +82,10 @@ namespace era_engine
 			}
 		}
 
-		AnimationSkeleton& skeleton = result->skeleton;
+		Skeleton& skeleton = result->skeleton;
+
+		AnimationSkeleton& animation_skeleton = result->animation_skeleton;
+		animation_skeleton.skeleton = &result->skeleton;
 
 		// Load skeleton
 		if (!asset.skeletons.empty()/* && flags & mesh_creation_flags_with_skin*/)
@@ -90,8 +93,8 @@ namespace era_engine
 			SkeletonAsset& in = asset.skeletons.front();
 
 			skeleton.joints = std::move(in.joints);
-			skeleton.nameToJointID = std::move(in.name_to_joint_id);
-			skeleton.analyzeJoints(builder.getPositions(), (uint8*)builder.getOthers() + builder.getSkinOffset(), builder.getOthersSize(), builder.getNumVertices());
+			skeleton.name_to_joint_id = std::move(in.name_to_joint_id);
+			skeleton.analyze_joints(builder.getPositions(), (uint8*)builder.getOthers() + builder.getSkinOffset(), builder.getOthersSize(), builder.getNumVertices());
 		}
 
 		// Load animations
@@ -99,7 +102,7 @@ namespace era_engine
 		{
 			AnimationAsset& in = anim;
 
-			AnimationClip& clip = skeleton.clips.emplace_back();
+			AnimationClip& clip = animation_skeleton.clips.emplace_back();
 			clip.name = std::move(in.name);
 			clip.filename = sceneFilename;
 			clip.length_in_seconds = in.duration;
@@ -114,8 +117,8 @@ namespace era_engine
 
 			for (auto& [name, joint] : in.joints)
 			{
-				auto it = skeleton.nameToJointID.find(name);
-				if (it != skeleton.nameToJointID.end())
+				auto it = skeleton.name_to_joint_id.find(name);
+				if (it != skeleton.name_to_joint_id.end())
 				{
 					AnimationJoint& j = clip.joints[it->second];
 					j = joint;
@@ -133,7 +136,7 @@ namespace era_engine
 		result->loadState.store(AssetLoadState::LOADED, std::memory_order_release);
 	}
 
-	static ref<multi_mesh> loadMeshFromFileInternal(const fs::path& sceneFilename, AssetHandle handle, uint32 flags, mesh_load_callback cb,
+	static ref<multi_mesh> loadMeshFromFileInternal(const fs::path& sceneFilename, AssetHandle handle, uint32 flags, const mesh_load_callback& cb,
 		bool async, JobHandle parentJob)
 	{
 		ref<multi_mesh> result = make_ref<multi_mesh>();
@@ -181,16 +184,15 @@ namespace era_engine
 	static std::unordered_map<mesh_key, weakref<multi_mesh>> meshCache;
 	static std::mutex mutex;
 
-	static ref<multi_mesh> loadMeshFromFileAndHandle(const fs::path& filename, AssetHandle handle, uint32 flags, mesh_load_callback cb,
+	static ref<multi_mesh> loadMeshFromFileAndHandle(const fs::path& filename, AssetHandle handle, uint32 flags, const mesh_load_callback& cb,
 		bool async = false, JobHandle parentJob = {})
 	{
 		if (!fs::exists(filename))
-			return 0;
+			return nullptr;
 
 		mesh_key key = { handle, flags };
 
-		mutex.lock();
-
+		std::lock_guard _lock{mutex};
 		ref<multi_mesh> result = { meshCache[key].lock(), {} };
 		if (!result)
 		{
@@ -198,11 +200,10 @@ namespace era_engine
 			meshCache[key] = result;
 		}
 
-		mutex.unlock();
 		return result;
 	}
 
-	NODISCARD ref<multi_mesh> loadMeshFromFile(const fs::path& filename, uint32 flags, mesh_load_callback cb)
+	ref<multi_mesh> loadMeshFromFile(const fs::path& filename, uint32 flags, const mesh_load_callback& cb)
 	{
 		fs::path path = filename.lexically_normal().make_preferred();
 
@@ -210,13 +211,13 @@ namespace era_engine
 		return loadMeshFromFileAndHandle(path, handle, flags, cb);
 	}
 
-	NODISCARD ref<multi_mesh> loadMeshFromHandle(AssetHandle handle, uint32 flags, mesh_load_callback cb)
+	ref<multi_mesh> loadMeshFromHandle(AssetHandle handle, uint32 flags, const mesh_load_callback& cb)
 	{
 		fs::path sceneFilename = getPathFromAssetHandle(handle);
 		return loadMeshFromFileAndHandle(sceneFilename, handle, flags, cb);
 	}
 
-	NODISCARD ref<multi_mesh> loadMeshFromFileAsync(const fs::path& filename, uint32 flags, JobHandle parentJob, mesh_load_callback cb)
+	ref<multi_mesh> loadMeshFromFileAsync(const fs::path& filename, uint32 flags, JobHandle parentJob, const mesh_load_callback& cb)
 	{
 		fs::path path = filename.lexically_normal().make_preferred();
 
@@ -224,7 +225,7 @@ namespace era_engine
 		return loadMeshFromFileAndHandle(path, handle, flags, cb, true, parentJob);
 	}
 
-	NODISCARD ref<multi_mesh> loadMeshFromHandleAsync(AssetHandle handle, uint32 flags, JobHandle parentJob, mesh_load_callback cb)
+	ref<multi_mesh> loadMeshFromHandleAsync(AssetHandle handle, uint32 flags, JobHandle parentJob, const mesh_load_callback& cb)
 	{
 		fs::path sceneFilename = getPathFromAssetHandle(handle);
 		return loadMeshFromFileAndHandle(sceneFilename, handle, flags, cb, true, parentJob);
diff --git a/modules/core/src/geometry/mesh.h b/modules/core/src/geometry/mesh.h
index 44cb8c689..6ed46762e 100644
--- a/modules/core/src/geometry/mesh.h
+++ b/modules/core/src/geometry/mesh.h
@@ -29,7 +29,8 @@ namespace era_engine
 	struct multi_mesh
 	{
 		std::vector<submesh> submeshes;
-		animation::AnimationSkeleton skeleton;
+		animation::Skeleton skeleton;
+		animation::AnimationSkeleton animation_skeleton;
 		dx_mesh mesh;
 		bounding_box aabb = { vec3(0.f), vec3(0.f) };
 
@@ -42,28 +43,28 @@ namespace era_engine
 
 	using mesh_load_callback = std::function<void(mesh_builder& builder, std::vector<submesh>& submeshes, const bounding_box& boundingBox)>;
 
-	NODISCARD ref<multi_mesh> loadMeshFromFile(const fs::path& filename, uint32 flags = mesh_creation_flags_default, mesh_load_callback cb = nullptr);
-	NODISCARD ref<multi_mesh> loadMeshFromHandle(AssetHandle handle, uint32 flags = mesh_creation_flags_default, mesh_load_callback cb = nullptr);
-	NODISCARD ref<multi_mesh> loadMeshFromFileAsync(const fs::path& filename, uint32 flags = mesh_creation_flags_default, JobHandle parentJob = {}, mesh_load_callback cb = nullptr);
-	NODISCARD ref<multi_mesh> loadMeshFromHandleAsync(AssetHandle handle, uint32 flags = mesh_creation_flags_default, JobHandle parentJob = {}, mesh_load_callback cb = nullptr);
+	ERA_CORE_API ref<multi_mesh> loadMeshFromFile(const fs::path& filename, uint32 flags = mesh_creation_flags_default, const mesh_load_callback& cb = nullptr);
+	ERA_CORE_API ref<multi_mesh> loadMeshFromHandle(AssetHandle handle, uint32 flags = mesh_creation_flags_default, const mesh_load_callback& cb = nullptr);
+	ERA_CORE_API ref<multi_mesh> loadMeshFromFileAsync(const fs::path& filename, uint32 flags = mesh_creation_flags_default, JobHandle parentJob = {}, const mesh_load_callback& cb = nullptr);
+	ERA_CORE_API ref<multi_mesh> loadMeshFromHandleAsync(AssetHandle handle, uint32 flags = mesh_creation_flags_default, JobHandle parentJob = {}, const mesh_load_callback& cb = nullptr);
 
 	// Same functions but with different default flags (includes skin).
-	inline NODISCARD ref<multi_mesh> loadAnimatedMeshFromFile(const fs::path& filename, uint32 flags = mesh_creation_flags_animated, mesh_load_callback cb = nullptr)
+	inline ref<multi_mesh> loadAnimatedMeshFromFile(const fs::path& filename, uint32 flags = mesh_creation_flags_animated, const mesh_load_callback& cb = nullptr)
 	{
 		return loadMeshFromFile(filename, flags, cb);
 	}
 
-	inline NODISCARD ref<multi_mesh> loadAnimatedMeshFromHandle(AssetHandle handle, uint32 flags = mesh_creation_flags_animated, mesh_load_callback cb = nullptr)
+	inline ref<multi_mesh> loadAnimatedMeshFromHandle(AssetHandle handle, uint32 flags = mesh_creation_flags_animated, const mesh_load_callback& cb = nullptr)
 	{
 		return loadMeshFromHandle(handle, flags, cb);
 	}
 
-	inline NODISCARD ref<multi_mesh> loadAnimatedMeshFromFileAsync(const fs::path& filename, uint32 flags = mesh_creation_flags_animated, JobHandle parentJob = {}, mesh_load_callback cb = nullptr)
+	inline ref<multi_mesh> loadAnimatedMeshFromFileAsync(const fs::path& filename, uint32 flags = mesh_creation_flags_animated, JobHandle parentJob = {}, const mesh_load_callback& cb = nullptr)
 	{
 		return loadMeshFromFileAsync(filename, flags, parentJob, cb);
 	}
 
-	inline NODISCARD ref<multi_mesh> loadAnimatedMeshFromHandleAsync(AssetHandle handle, uint32 flags = mesh_creation_flags_animated, JobHandle parentJob = {}, mesh_load_callback cb = nullptr)
+	inline ref<multi_mesh> loadAnimatedMeshFromHandleAsync(AssetHandle handle, uint32 flags = mesh_creation_flags_animated, JobHandle parentJob = {}, const mesh_load_callback& cb = nullptr)
 	{
 		return loadMeshFromHandleAsync(handle, flags, parentJob, cb);
 	}
diff --git a/modules/core/src/geometry/mesh_builder.h b/modules/core/src/geometry/mesh_builder.h
index 7f38cf615..2daaa1266 100644
--- a/modules/core/src/geometry/mesh_builder.h
+++ b/modules/core/src/geometry/mesh_builder.h
@@ -14,7 +14,7 @@
 
 namespace era_engine
 {
-	struct submesh_info
+	struct ERA_CORE_API submesh_info
 	{
 		uint32 numIndices;
 		uint32 firstIndex;
@@ -43,21 +43,21 @@ namespace era_engine
 		mesh_index_uint32,
 	};
 
-	struct quad_mesh_desc
+	struct ERA_CORE_API quad_mesh_desc
 	{
 		vec3 center = 0.f;
 		vec2 radius = 1.f;
 		quat rotation = quat::identity;
 	};
 
-	struct box_mesh_desc
+	struct ERA_CORE_API box_mesh_desc
 	{
 		vec3 center = 0.f;
 		vec3 radius = 1.f;
 		quat rotation = quat::identity;
 	};
 
-	struct tesselated_box_mesh_desc
+	struct ERA_CORE_API tesselated_box_mesh_desc
 	{
 		vec3 center = 0.f;
 		vec3 radius = 1.f;
@@ -65,7 +65,7 @@ namespace era_engine
 		quat rotation = quat::identity;
 	};
 
-	struct sphere_mesh_desc
+	struct ERA_CORE_API sphere_mesh_desc
 	{
 		vec3 center = 0.f;
 		float radius = 1.f;
@@ -73,7 +73,7 @@ namespace era_engine
 		uint32 rows = 15;
 	};
 
-	struct icosphere_mesh_desc
+	struct ERA_CORE_API icosphere_mesh_desc
 	{
 		vec3 center = 0.f;
 		float radius = 1.f;
@@ -81,15 +81,15 @@ namespace era_engine
 	};
 
 	// All meshes are standing upright by default.
-	struct capsule_mesh_desc
+	struct ERA_CORE_API capsule_mesh_desc
 	{
 		capsule_mesh_desc() {}
 
-		capsule_mesh_desc(vec3 posA, vec3 posB, float radius)
+		capsule_mesh_desc(vec3 posA, vec3 posB, float _radius)
 		{
 			center = (posA + posB) * 0.5f;
 			height = length(posA - posB);
-			this->radius = radius;
+			radius = _radius;
 			rotation = rotate_from_to(vec3(0.f, 1.f, 0.f), posB - posA);
 		}
 
@@ -101,7 +101,7 @@ namespace era_engine
 		uint32 rows = 15;
 	};
 
-	struct cylinder_mesh_desc
+	struct ERA_CORE_API cylinder_mesh_desc
 	{
 		vec3 center = 0.f;
 		float height = 1.f;
@@ -110,7 +110,7 @@ namespace era_engine
 		uint32 slices = 15;
 	};
 
-	struct hollow_cylinder_mesh_desc
+	struct ERA_CORE_API hollow_cylinder_mesh_desc
 	{
 		vec3 center = 0.f;
 		float height = 1.f;
@@ -120,7 +120,7 @@ namespace era_engine
 		uint32 slices = 15;
 	};
 
-	struct arrow_mesh_desc
+	struct ERA_CORE_API arrow_mesh_desc
 	{
 		vec3 base = 0.f;
 		float shaftLength = 1.f;
@@ -131,7 +131,7 @@ namespace era_engine
 		uint32 slices = 15;
 	};
 
-	struct torus_mesh_desc
+	struct ERA_CORE_API torus_mesh_desc
 	{
 		vec3 center = 0.f;
 		float torusRadius = 1.f;
@@ -141,7 +141,7 @@ namespace era_engine
 		uint32 segments = 15;
 	};
 
-	struct mace_mesh_desc
+	struct ERA_CORE_API mace_mesh_desc
 	{
 		vec3 base = 0.f;
 		float shaftLength = 1.f;
@@ -163,7 +163,7 @@ namespace era_engine
 		return size;
 	}
 
-	struct mesh_builder
+	struct ERA_CORE_API mesh_builder
 	{
 		mesh_builder(uint32 vertexFlags = mesh_creation_flags_default, mesh_index_type indexType = mesh_index_uint16);
 		mesh_builder(const mesh_builder& mesh) = delete;
diff --git a/modules/core/src/particles/boid_particle_system.cpp b/modules/core/src/particles/boid_particle_system.cpp
index e8f55de91..26d3d1a39 100644
--- a/modules/core/src/particles/boid_particle_system.cpp
+++ b/modules/core/src/particles/boid_particle_system.cpp
@@ -62,16 +62,17 @@ namespace era_engine
 		if (cartoonMesh)
 		{
 			const dx_mesh& mesh = cartoonMesh->mesh;
-			animation::AnimationSkeleton& skeleton = cartoonMesh->skeleton;
+			animation::Skeleton& skeleton = cartoonMesh->skeleton;
+			animation::AnimationSkeleton& animation_skeleton = cartoonMesh->animation_skeleton;
 
 			time += dt;
-			time = fmod(time, skeleton.clips[0].length_in_seconds);
+			time = fmod(time, animation_skeleton.clips[0].length_in_seconds);
 
 			auto [skinnedVertexBuffer, skinningMatrices] = era_engine::animation::skinObject(mesh.vertexBuffer, cartoonMesh->submeshes[0].info, (uint32)skeleton.joints.size());
 
 			trs localTransforms[128];
-			skeleton.sampleAnimation(0, time, localTransforms);
-			skeleton.getSkinningMatricesFromLocalTransforms(localTransforms, skinningMatrices);
+			animation_skeleton.sampleAnimation(0, time, localTransforms);
+			skeleton.get_skinning_matrices_from_local_transforms(localTransforms, skinningMatrices);
 
 			this->skinnedVertexBuffer = skinnedVertexBuffer;
 			this->submesh.baseVertex = 0;
diff --git a/modules/core/src/rendering/ecs/private/render_system.cpp b/modules/core/src/rendering/ecs/private/render_system.cpp
new file mode 100644
index 000000000..9667639ad
--- /dev/null
+++ b/modules/core/src/rendering/ecs/private/render_system.cpp
@@ -0,0 +1,247 @@
+#include "rendering/ecs/private/render_system.h"
+#include "rendering/ecs/renderer_holder_root_component.h"
+
+#include "core/imgui.h"
+#include "core/log.h"
+#include "core/string.h"
+#include "core/cpu_profiling.h"
+#include "core/ecs/input_reciever_component.h"
+
+#include "rendering/mesh_shader.h"
+
+#include "ecs/update_groups.h"
+#include "ecs/base_components/transform_component.h"
+#include "ecs/rendering/world_renderer.h"
+#include "ecs/rendering/scene_rendering.h"
+#include "core/ecs/camera_holder_component.h"
+#include "ecs/rendering/mesh_component.h"
+
+#include "audio/audio.h"
+
+#include "terrain/terrain.h"
+
+#include "animation/skinning.h"
+
+#include <rttr/policy.h>
+#include <rttr/registration>
+
+namespace era_engine
+{
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<RenderSystem>("RenderSystem")
+			.constructor<World*>()(policy::ctor::as_raw_ptr)
+			.method("before_render", &RenderSystem::before_render)(metadata("update_group", update_types::BEFORE_RENDER))
+			.method("update", &RenderSystem::update)(metadata("update_group", update_types::RENDER));
+	}
+
+	RenderSystem::RenderSystem(World* _world)
+		: System(_world)
+	{
+		load_custom_shaders();
+
+		renderer_holder_rc = world->add_root_component<RendererHolderRootComponent>();
+		ASSERT(renderer_holder_rc != nullptr);
+
+		if (dxContext.featureSupport.raytracing())
+		{
+			raytracingTLAS.initialize();
+		}
+
+		renderer_holder_rc->camera.initializeIngame(vec3::zero, quat::identity, deg2rad(70.f), 0.2f);
+		renderer_holder_rc->environment.setFromTexture(get_asset_path("/resources/assets/sky/sunset_in_the_chalk_quarry_4k.hdr"));
+		renderer_holder_rc->environment.lightProbeGrid.initialize(vec3(-20.f, -1.f, -20.f), vec3(40.f, 20.f, 40.f), 1.5f);
+
+		renderer_holder_rc->sun.direction = normalize(vec3(-0.6f, -1.f, -0.3f));
+		renderer_holder_rc->sun.color = vec3(1.f, 0.93f, 0.76f);
+		renderer_holder_rc->sun.intensity = 11.1f;
+		renderer_holder_rc->sun.numShadowCascades = 3;
+		renderer_holder_rc->sun.shadowDimensions = 2048;
+		renderer_holder_rc->sun.cascadeDistances = vec4(9.f, 25.f, 50.f, 10000.f);
+		renderer_holder_rc->sun.bias = vec4(0.000588f, 0.000784f, 0.000824f, 0.0035f);
+		renderer_holder_rc->sun.blendDistances = vec4(5.f, 10.f, 10.f, 10.f);
+		renderer_holder_rc->sun.stabilize = true;
+
+		for (uint32 i = 0; i < NUM_BUFFERED_FRAMES; ++i)
+		{
+			pointLightBuffer[i] = createUploadBuffer(sizeof(point_light_cb), 512, 0);
+			spotLightBuffer[i] = createUploadBuffer(sizeof(spot_light_cb), 512, 0);
+			decalBuffer[i] = createUploadBuffer(sizeof(pbr_decal_cb), 512, 0);
+
+			spotLightShadowInfoBuffer[i] = createUploadBuffer(sizeof(spot_shadow_info), 512, 0);
+			pointLightShadowInfoBuffer[i] = createUploadBuffer(sizeof(point_shadow_info), 512, 0);
+
+			SET_NAME(pointLightBuffer[i]->resource, "Point lights");
+			SET_NAME(spotLightBuffer[i]->resource, "Spot lights");
+			SET_NAME(decalBuffer[i]->resource, "Decals");
+
+			SET_NAME(spotLightShadowInfoBuffer[i]->resource, "Spot light shadow infos");
+			SET_NAME(pointLightShadowInfoBuffer[i]->resource, "Point light shadow infos");
+		}
+
+		stackArena.initialize();
+	}
+
+	RenderSystem::~RenderSystem()
+	{
+	}
+
+	void RenderSystem::init()
+	{
+	}
+
+	void RenderSystem::before_render(float dt)
+	{
+		main_renderer* renderer = renderer_holder_rc->renderer;
+
+		renderer->beginFrame(renderer_holder_rc->width, renderer_holder_rc->height);
+	}
+
+	void RenderSystem::update(float dt)
+	{
+		resetRenderPasses();
+
+		stackArena.reset();
+
+		main_renderer* renderer = renderer_holder_rc->renderer;
+
+		directional_light& sun = renderer_holder_rc->sun;
+		pbr_environment& environment = renderer_holder_rc->environment;
+
+		render_camera& camera = renderer_holder_rc->camera;
+
+		environment.update(sun.direction);
+		sun.updateMatrices(camera);
+		setAudioListener(camera.position, camera.rotation, vec3(0.f));
+		environment.lightProbeGrid.visualize(&opaqueRenderPass);
+
+		{
+			for (auto [entityHandle, transform, terrain] : world->group(components_group<TransformComponent, TerrainComponent>).each())
+			{
+				terrain.update();
+			}
+
+			scene_lighting lighting;
+			lighting.spotLightBuffer = spotLightBuffer[dxContext.bufferedFrameID];
+			lighting.pointLightBuffer = pointLightBuffer[dxContext.bufferedFrameID];
+			lighting.spotLightShadowInfoBuffer = spotLightShadowInfoBuffer[dxContext.bufferedFrameID];
+			lighting.pointLightShadowInfoBuffer = pointLightShadowInfoBuffer[dxContext.bufferedFrameID];
+			lighting.spotShadowRenderPasses = spotShadowRenderPasses;
+			lighting.pointShadowRenderPasses = pointShadowRenderPasses;
+			lighting.maxNumSpotShadowRenderPasses = arraysize(spotShadowRenderPasses);
+			lighting.maxNumPointShadowRenderPasses = arraysize(pointShadowRenderPasses);
+
+			render_world(camera, world, stackArena, Entity::NullHandle, sun, lighting, !renderer->settings.cacheShadowMap,
+				&opaqueRenderPass, &transparentRenderPass, renderer_holder_rc->ldrRenderPass, &sunShadowRenderPass, &computePass, dt);
+
+			renderer->setSpotLights(spotLightBuffer[dxContext.bufferedFrameID], world->number_of_components_of_type<SpotLightComponent>(), spotLightShadowInfoBuffer[dxContext.bufferedFrameID]);
+			renderer->setPointLights(pointLightBuffer[dxContext.bufferedFrameID], world->number_of_components_of_type<PointLightComponent>(), pointLightShadowInfoBuffer[dxContext.bufferedFrameID]);
+
+			if (decals.size())
+			{
+				updateUploadBufferData(decalBuffer[dxContext.bufferedFrameID], decals.data(), (uint32)(sizeof(pbr_decal_cb) * decals.size()));
+				renderer->setDecals(decalBuffer[dxContext.bufferedFrameID], (uint32)decals.size(), decalTexture);
+			}
+
+			submitRendererParams(lighting.numSpotShadowRenderPasses, lighting.numPointShadowRenderPasses);
+		}
+
+		animation::performSkinning(&computePass);
+
+		if (dxContext.featureSupport.raytracing())
+		{
+			raytracingTLAS.reset();
+
+			for (auto [entityHandle, transform, raytrace] : world->group(components_group<TransformComponent, RaytraceComponent>).each())
+			{
+				auto handle = raytracingTLAS.instantiate(raytrace.type, transform.transform);
+			}
+
+			renderer->setRaytracingScene(&raytracingTLAS);
+		}
+
+		renderer->setEnvironment(environment);
+		renderer->setSun(sun);
+		renderer->setCamera(camera);
+
+		endFrameCommon();
+
+		UserInput input{};
+		renderer->endFrame(&input);
+	}
+
+	void RenderSystem::load_custom_shaders()
+	{
+		if (dxContext.featureSupport.meshShaders())
+		{
+			initializeMeshShader();
+		}
+	}
+
+	void RenderSystem::resetRenderPasses()
+	{
+		opaqueRenderPass.reset();
+		transparentRenderPass.reset();
+		renderer_holder_rc->ldrRenderPass->reset();
+		sunShadowRenderPass.reset();
+		computePass.reset();
+
+		for (uint32 i = 0; i < arraysize(spotShadowRenderPasses); ++i)
+		{
+			spotShadowRenderPasses[i].reset();
+		}
+
+		for (uint32 i = 0; i < arraysize(pointShadowRenderPasses); ++i)
+		{
+			pointShadowRenderPasses[i].reset();
+		}
+	}
+
+	void RenderSystem::submitRendererParams(uint32 numSpotLightShadowPasses, uint32 numPointLightShadowPasses)
+	{
+		main_renderer* renderer = renderer_holder_rc->renderer;
+
+		{
+			CPU_PROFILE_BLOCK("Sort render passes");
+
+			opaqueRenderPass.sort();
+			transparentRenderPass.sort();
+			renderer_holder_rc->ldrRenderPass->sort();
+
+			for (uint32 i = 0; i < sunShadowRenderPass.numCascades; ++i)
+			{
+				sunShadowRenderPass.cascades[i].sort();
+			}
+
+			for (uint32 i = 0; i < numSpotLightShadowPasses; ++i)
+			{
+				spotShadowRenderPasses[i].sort();
+			}
+
+			for (uint32 i = 0; i < numPointLightShadowPasses; ++i)
+			{
+				pointShadowRenderPasses[i].sort();
+			}
+		}
+
+		renderer->submitRenderPass(&opaqueRenderPass);
+		renderer->submitRenderPass(&transparentRenderPass);
+		renderer->submitRenderPass(renderer_holder_rc->ldrRenderPass);
+		renderer->submitComputePass(&computePass);
+
+		renderer->submitShadowRenderPass(&sunShadowRenderPass);
+
+		for (uint32 i = 0; i < numSpotLightShadowPasses; ++i)
+		{
+			renderer->submitShadowRenderPass(&spotShadowRenderPasses[i]);
+		}
+
+		for (uint32 i = 0; i < numPointLightShadowPasses; ++i)
+		{
+			renderer->submitShadowRenderPass(&pointShadowRenderPasses[i]);
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/rendering/ecs/private/render_system.h b/modules/core/src/rendering/ecs/private/render_system.h
new file mode 100644
index 000000000..6a6b11ec7
--- /dev/null
+++ b/modules/core/src/rendering/ecs/private/render_system.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "ecs/system.h"
+
+#include "core/memory.h"
+
+#include "geometry/mesh.h"
+
+#include "particles/fire_particle_system.h"
+#include "particles/smoke_particle_system.h"
+#include "particles/boid_particle_system.h"
+#include "particles/debris_particle_system.h"
+
+#include "rendering/raytracing.h"
+#include "rendering/main_renderer.h"
+
+namespace era_engine
+{
+	class RendererHolderRootComponent;
+
+	class RenderSystem final : public System
+	{
+	public:
+		RenderSystem(World* _world);
+		~RenderSystem();
+
+		void init() override;
+		void before_render(float dt);
+		void update(float dt) override;
+
+		ERA_VIRTUAL_REFLECT(System)
+
+	private:
+		void load_custom_shaders();
+
+		void resetRenderPasses();
+		void submitRendererParams(uint32 numSpotLightShadowPasses, uint32 numPointLightShadowPasses);
+
+	private:
+		RendererHolderRootComponent* renderer_holder_rc = nullptr;
+
+		Allocator stackArena;
+
+		raytracing_tlas raytracingTLAS;
+
+		ref<dx_buffer> pointLightBuffer[NUM_BUFFERED_FRAMES];
+		ref<dx_buffer> spotLightBuffer[NUM_BUFFERED_FRAMES];
+		ref<dx_buffer> decalBuffer[NUM_BUFFERED_FRAMES];
+
+		ref<dx_buffer> spotLightShadowInfoBuffer[NUM_BUFFERED_FRAMES];
+		ref<dx_buffer> pointLightShadowInfoBuffer[NUM_BUFFERED_FRAMES];
+
+		std::vector<pbr_decal_cb> decals;
+
+		ref<dx_texture> decalTexture;
+
+		fire_particle_system fireParticleSystem;
+		smoke_particle_system smokeParticleSystem;
+		boid_particle_system boidParticleSystem;
+		debris_particle_system debrisParticleSystem;
+
+		opaque_render_pass opaqueRenderPass;
+		transparent_render_pass transparentRenderPass;
+		sun_shadow_render_pass sunShadowRenderPass;
+		spot_shadow_render_pass spotShadowRenderPasses[16];
+		point_shadow_render_pass pointShadowRenderPasses[16];
+		compute_pass computePass;
+	};
+}
\ No newline at end of file
diff --git a/modules/core/src/rendering/ecs/private/renderer_holder_root_component.cpp b/modules/core/src/rendering/ecs/private/renderer_holder_root_component.cpp
new file mode 100644
index 000000000..d73b29ce2
--- /dev/null
+++ b/modules/core/src/rendering/ecs/private/renderer_holder_root_component.cpp
@@ -0,0 +1,79 @@
+#include "rendering/ecs/renderer_holder_root_component.h"
+
+#include "window/dx_window.h"
+
+#include "engine/engine.h"
+
+#include <rttr/registration>
+
+namespace era_engine
+{
+
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+		rttr::registration::class_<RendererHolderRootComponent>("RendererHolderRootComponent")
+			.constructor<ref<Entity::EcsData>>();
+	}
+
+	RendererHolderRootComponent::RendererHolderRootComponent(ref<Entity::EcsData> _data)
+		: Component(_data)
+	{
+		renderer_spec spec;
+		spec.allowObjectPicking = true;
+		spec.allowAO = true;
+		spec.allowSSS = true;
+		spec.allowSSR = true;
+		spec.allowTAA = true;
+		spec.allowBloom = true;
+		spec.allowDLSS = true;
+
+		renderer = new main_renderer();
+
+		dx_window* window = get_object<dx_window>();
+		ASSERT(window != nullptr);
+
+		ldrRenderPass = new ldr_render_pass();
+
+		renderer->initialize(window->colorDepth, window->clientWidth, window->clientHeight, spec);
+	}
+
+	RendererHolderRootComponent& era_engine::RendererHolderRootComponent::operator=(const RendererHolderRootComponent& other) noexcept
+	{
+		if (this != &other)
+		{
+			camera = other.camera;
+			sun = other.sun;
+			ldrRenderPass = other.ldrRenderPass;
+			environment = other.environment;
+		}
+
+		return *this;
+	}
+
+	RendererHolderRootComponent& era_engine::RendererHolderRootComponent::operator=(RendererHolderRootComponent&& other) noexcept
+	{
+		if (this != &other)
+		{
+			camera = std::move(other.camera);
+			sun = std::move(other.sun);
+			ldrRenderPass = std::move(other.ldrRenderPass);
+			environment = std::move(other.environment);
+		}
+
+		return *this;
+	}
+
+	RendererHolderRootComponent::~RendererHolderRootComponent()
+	{
+	}
+
+	void RendererHolderRootComponent::release()
+	{
+		delete ldrRenderPass;
+		delete renderer;
+
+		Component::release();
+	}
+
+}
\ No newline at end of file
diff --git a/modules/core/src/rendering/ecs/renderer_holder_root_component.h b/modules/core/src/rendering/ecs/renderer_holder_root_component.h
new file mode 100644
index 000000000..60cfde22b
--- /dev/null
+++ b/modules/core/src/rendering/ecs/renderer_holder_root_component.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "core_api.h"
+
+#include "rendering/main_renderer.h"
+#include "rendering/light_source.h"
+#include "rendering/pbr.h"
+#include "rendering/pbr_environment.h"
+
+#include "core/camera.h"
+
+#include "ecs/component.h"
+
+namespace era_engine
+{
+	class UserInput;
+
+	class ERA_CORE_API RendererHolderRootComponent final : public Component
+	{
+	public:
+		RendererHolderRootComponent() = default;
+		RendererHolderRootComponent(ref<Entity::EcsData> _data);
+
+		RendererHolderRootComponent(const RendererHolderRootComponent& other) noexcept = default;
+		RendererHolderRootComponent(RendererHolderRootComponent&& other) noexcept = default;
+		RendererHolderRootComponent& operator=(const RendererHolderRootComponent& other) noexcept;
+		RendererHolderRootComponent& operator=(RendererHolderRootComponent&& other) noexcept;
+
+		~RendererHolderRootComponent() override;
+
+		void release() override;
+
+		render_camera camera;
+
+		directional_light sun;
+		pbr_environment environment;
+		ldr_render_pass* ldrRenderPass = nullptr;
+
+		uint32_t width = 1920;
+		uint32_t height = 1080;
+
+		ERA_VIRTUAL_REFLECT(Component)
+
+	private:
+		main_renderer* renderer = nullptr;
+
+		UserInput* active_render_input = nullptr;
+
+		float timestep_scale = 1.0f;
+
+		friend class RenderSystem;
+		friend class InputSystem;
+	};
+
+}
\ No newline at end of file
diff --git a/modules/core/src/rendering/light_source.h b/modules/core/src/rendering/light_source.h
index 14629b380..82dba229f 100644
--- a/modules/core/src/rendering/light_source.h
+++ b/modules/core/src/rendering/light_source.h
@@ -16,6 +16,12 @@ namespace era_engine
 	{
 	public:
 
+		directional_light() = default;
+		directional_light(const directional_light& other) noexcept = default;
+		directional_light(directional_light&& other) noexcept = default;
+		directional_light& operator=(const directional_light& other) noexcept = default;
+		directional_light& operator=(directional_light&& other) noexcept = default;
+
 		void updateMatrices(const render_camera& camera);
 
 		vec4 cascadeDistances;
diff --git a/modules/core/src/rendering/pbr_environment.h b/modules/core/src/rendering/pbr_environment.h
index f49a662c7..b9441b794 100644
--- a/modules/core/src/rendering/pbr_environment.h
+++ b/modules/core/src/rendering/pbr_environment.h
@@ -24,6 +24,12 @@ namespace era_engine
 
 	struct pbr_environment
 	{
+		pbr_environment() = default;
+		pbr_environment(const pbr_environment& other) noexcept = default;
+		pbr_environment(pbr_environment&& other) noexcept = default;
+		pbr_environment& operator=(const pbr_environment& other) noexcept = default;
+		pbr_environment& operator=(pbr_environment&& other) noexcept = default;
+
 		NODISCARD bool isProcedural() const { return sky == 0; }
 
 		void setFromTexture(const fs::path& filename);
diff --git a/modules/core/src/rendering/pbr_material.cpp b/modules/core/src/rendering/pbr_material.cpp
index 2075daa92..de8602ad2 100644
--- a/modules/core/src/rendering/pbr_material.cpp
+++ b/modules/core/src/rendering/pbr_material.cpp
@@ -49,9 +49,9 @@ namespace era_engine
 	static std::unordered_map<PbrMaterialDesc, weakref<pbr_material>> materialCache;
 	static std::mutex mutex;
 
-	NODISCARD ref<pbr_material> createPBRMaterial(const PbrMaterialDesc& desc)
+	ref<pbr_material> createPBRMaterial(const PbrMaterialDesc& desc)
 	{
-		Lock lock{ mutex };
+		std::lock_guard lock{ mutex };
 
 		auto sp = materialCache[desc].lock();
 		if (!sp)
@@ -76,9 +76,9 @@ namespace era_engine
 		return sp;
 	}
 
-	NODISCARD ref<pbr_material> createPBRMaterialAsync(const PbrMaterialDesc& desc, JobHandle parentJob)
+	ref<pbr_material> createPBRMaterialAsync(const PbrMaterialDesc& desc, JobHandle parentJob)
 	{
-		Lock lock{ mutex };
+		std::lock_guard lock{ mutex };
 
 		auto sp = materialCache[desc].lock();
 		if (!sp)
@@ -103,7 +103,7 @@ namespace era_engine
 		return sp;
 	}
 
-	NODISCARD ref<pbr_material> getDefaultPBRMaterial()
+	ref<pbr_material> getDefaultPBRMaterial()
 	{
 		static ref<pbr_material> material = createPBRMaterial({});
 		return material;
diff --git a/modules/core/src/rendering/pbr_material.h b/modules/core/src/rendering/pbr_material.h
index dc83070b0..abb384c10 100644
--- a/modules/core/src/rendering/pbr_material.h
+++ b/modules/core/src/rendering/pbr_material.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include "core_api.h"
 #include "core/math.h"
 #include "core/job_system.h"
 
@@ -36,7 +37,7 @@ namespace era_engine
 		float translucency;
 	};
 
-	NODISCARD ref<pbr_material> createPBRMaterial(const PbrMaterialDesc& desc);
-	NODISCARD ref<pbr_material> createPBRMaterialAsync(const PbrMaterialDesc& desc, JobHandle parentJob = {});
-	NODISCARD ref<pbr_material> getDefaultPBRMaterial();
+	ERA_CORE_API ref<pbr_material> createPBRMaterial(const PbrMaterialDesc& desc);
+	ERA_CORE_API ref<pbr_material> createPBRMaterialAsync(const PbrMaterialDesc& desc, JobHandle parentJob = {});
+	ERA_CORE_API ref<pbr_material> getDefaultPBRMaterial();
 }
\ No newline at end of file
diff --git a/modules/core/src/rendering/render_utils.cpp b/modules/core/src/rendering/render_utils.cpp
index 44614fae2..266453509 100644
--- a/modules/core/src/rendering/render_utils.cpp
+++ b/modules/core/src/rendering/render_utils.cpp
@@ -10,9 +10,11 @@
 #include "rendering/debug_visualization.h"
 #include "rendering/light_probe.h"
 #include "rendering/raytraced_reflections.h"
+#include "rendering/pbr_raytracer.h"
 #include "rendering/shadow_map.h"
 
 #include "core/random.h"
+#include "core/job_system.h"
 
 #include "dx/dx_context.h"
 
@@ -39,7 +41,7 @@ namespace era_engine
 		initializeTexturePreprocessing();
 		initializeDepthPrepassPipelines();
 		initializeOutlinePipelines();
-		era_engine::animation::initializeSkinning();
+		animation::initializeSkinning();
 		initializeShadowPipelines();
 		initializeTerrainPipelines();
 		initializeLightProbePipelines();
@@ -108,4 +110,74 @@ namespace era_engine
 		outCB.jitter = jitter;
 	}
 
+	raytracing_object_type defineBlasFromMesh(const ref<multi_mesh>& mesh)
+	{
+		if (dxContext.featureSupport.raytracing())
+		{
+			raytracing_blas_builder blasBuilder;
+			std::vector<ref<pbr_material>> raytracingMaterials;
+
+			for (auto& sm : mesh->submeshes)
+			{
+				blasBuilder.push(mesh->mesh.vertexBuffer, mesh->mesh.indexBuffer, sm.info);
+				raytracingMaterials.push_back(sm.material);
+			}
+
+			ref<raytracing_blas> blas = blasBuilder.finish();
+			raytracing_object_type type = pbr_raytracer::defineObjectType(blas, raytracingMaterials);
+			return type;
+		}
+		else
+		{
+			return {};
+		}
+	}
+
+	extern "C" void addRaytracingComponentAsync(Entity entity, ref<multi_mesh> mesh)
+	{
+		struct add_ray_tracing_data
+		{
+			Entity entity;
+			ref<multi_mesh> mesh;
+		};
+
+		add_ray_tracing_data data = { entity, mesh };
+
+		low_priority_job_queue.createJob<add_ray_tracing_data>([](add_ray_tracing_data& data, JobHandle)
+			{
+				data.mesh->loadJob.wait_for_completion();
+
+				struct create_component_data
+				{
+					Entity entity;
+					raytracing_object_type blas;
+				};
+
+				create_component_data createData = { data.entity, defineBlasFromMesh(data.mesh) };
+
+				main_thread_job_queue.createJob<create_component_data>([](create_component_data& data, JobHandle)
+					{
+						data.entity.add_component<RaytraceComponent>(data.blas);
+					}, createData).submit_now();
+
+			}, data).submit_now();
+	}
+
+	extern "C" void initializeAnimationComponentAsync(Entity entity, ref<multi_mesh> mesh)
+	{
+		struct add_animation_data
+		{
+			Entity entity;
+			ref<multi_mesh> mesh;
+		};
+
+		add_animation_data data = { entity, mesh };
+
+		main_thread_job_queue.createJob<add_animation_data>([](add_animation_data& data, JobHandle job)
+			{
+				data.mesh->loadJob.wait_for_completion();
+				data.entity.get_component<animation::SkeletonComponent>().skeleton = &data.mesh->skeleton;
+				data.entity.get_component<animation::AnimationComponent>().initialize(data.mesh->animation_skeleton.clips);
+			}, data).submit_now();
+	}
 }
\ No newline at end of file
diff --git a/modules/core/src/rendering/render_utils.h b/modules/core/src/rendering/render_utils.h
index d02b2725b..2d00e6b70 100644
--- a/modules/core/src/rendering/render_utils.h
+++ b/modules/core/src/rendering/render_utils.h
@@ -5,9 +5,13 @@
 
 #include "dx/dx_pipeline.h"
 
+#include "ecs/entity.h"
+
 #include "rendering/light_source.h"
 #include "rendering/render_pass.h"
 
+#include "rendering/raytracing.h"
+
 #include "camera.hlsli"
 
 namespace era_engine
@@ -50,4 +54,9 @@ namespace era_engine
 	{
 		return (colorDepth == color_depth_8) ? DXGI_FORMAT_R8G8B8A8_UNORM : DXGI_FORMAT_R10G10B10A2_UNORM;
 	}
+
+	extern "C" __declspec(dllexport) void addRaytracingComponentAsync(Entity entity, ref<multi_mesh> mesh);
+	raytracing_object_type defineBlasFromMesh(const ref<multi_mesh>& mesh);
+	extern "C" __declspec(dllexport) void initializeAnimationComponentAsync(Entity entity, ref<multi_mesh> mesh);
+
 }
\ No newline at end of file
diff --git a/modules/core/src/window/dx_window.cpp b/modules/core/src/window/dx_window.cpp
index d28c7b87d..6f3586083 100644
--- a/modules/core/src/window/dx_window.cpp
+++ b/modules/core/src/window/dx_window.cpp
@@ -4,8 +4,18 @@
 
 #include "dx/dx_context.h"
 
+#include <rttr/registration>
+
 namespace era_engine
 {
+	RTTR_REGISTRATION
+	{
+		using namespace rttr;
+
+		registration::class_<dx_window>("dx_window")
+			.constructor<>();
+	}
+
 	static bool checkTearingSupport(dx_factory factory)
 	{
 		BOOL allowTearing = FALSE;
diff --git a/modules/core/src/window/dx_window.h b/modules/core/src/window/dx_window.h
index dd015665f..1af8af5a7 100644
--- a/modules/core/src/window/dx_window.h
+++ b/modules/core/src/window/dx_window.h
@@ -11,6 +11,8 @@
 
 #include "rendering/render_utils.h"
 
+#include <rttr/type>
+
 namespace era_engine
 {
 	struct ERA_CORE_API dx_window : win32_window
@@ -40,6 +42,8 @@ namespace era_engine
 
 		color_depth colorDepth;
 
+		RTTR_ENABLE()
+
 	private:
 		void updateRenderTargetViews();
 
diff --git a/modules/physics/CMakeLists.txt b/modules/physics/CMakeLists.txt
index 92edf0148..0fcd0ba49 100644
--- a/modules/physics/CMakeLists.txt
+++ b/modules/physics/CMakeLists.txt
@@ -1,6 +1,11 @@
 include(${CMAKE_SOURCE_DIR}/cmake/common.cmake)
 
 era_begin(physics "MODULE")
+    require_thirdparty_module(physics EnTT)
+    require_thirdparty_module(physics yaml-cpp)
+    require_thirdparty_module(physics rttr_core)
+    require_thirdparty_module(physics DirectXTex)
+    require_module(physics base)
     require_module(physics core)
     require_physx(physics)
     target_compile_definitions(physics PRIVATE ERA_PHYSICS)
diff --git a/modules/physics/src/physics/core/physics.h b/modules/physics/src/physics/core/physics.h
index a52e6f39f..7c0c68fd7 100644
--- a/modules/physics/src/physics/core/physics.h
+++ b/modules/physics/src/physics/core/physics.h
@@ -116,12 +116,12 @@ namespace era_engine::physics
 		physx::RaycastCCDManager* raycast_ccd = nullptr;
 #endif
 
-		PhysicsAllocatorCallback allocator_callback;
+		PhysicsAllocatorCallback* allocator_callback = nullptr;
 		ErrorReporter error_reporter;
 
 		ProfilerCallback profiler_callback;
 
-		FixedStepper stepper;
+		FixedStepper* stepper = nullptr;
 
 		SimulationFilterCallback simulation_filter_callback;
 		ref<SimulationEventCallback> simulation_event_callback = nullptr;
diff --git a/modules/physics/src/physics/core/private/physics.cpp b/modules/physics/src/physics/core/private/physics.cpp
index e4dc75764..d01532656 100644
--- a/modules/physics/src/physics/core/private/physics.cpp
+++ b/modules/physics/src/physics/core/private/physics.cpp
@@ -76,7 +76,8 @@ namespace era_engine::physics
 
 		allocator.initialize(MB(256U));
 
-		foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator_callback, error_reporter);
+		allocator_callback = new PhysicsAllocatorCallback();
+		foundation = PxCreateFoundation(PX_PHYSICS_VERSION, *allocator_callback, error_reporter);
 
 		if (!foundation)
 		{
@@ -97,19 +98,19 @@ namespace era_engine::physics
 		omni_pvd = PxCreateOmniPvd(*foundation);
 		if (!omni_pvd)
 		{
-			printf("Error : could not create PxOmniPvd!");
+			printf("Error: could not create PxOmniPvd!");
 			return;
 		}
 		OmniPvdWriter* omniWriter = omni_pvd->getWriter();
 		if (!omniWriter)
 		{
-			printf("Error : could not get an instance of PxOmniPvdWriter!");
+			printf("Error: could not get an instance of PxOmniPvdWriter!");
 			return;
 		}
 		OmniPvdFileWriteStream* fStream = omni_pvd->getFileWriteStream();
 		if (!fStream)
 		{
-			printf("Error : could not get an instance of PxOmniPvdFileWriteStream!");
+			printf("Error: could not get an instance of PxOmniPvdFileWriteStream!");
 			return;
 		}
 		fStream->setFileName(omni_pvd_path);
@@ -169,6 +170,8 @@ namespace era_engine::physics
 		scene->setVisualizationParameter(PxVisualizationParameter::eCOLLISION_FNORMALS, 1.0f);
 		scene->setVisualizationParameter(PxVisualizationParameter::eSCALE, 1.0f);
 
+		stepper = new FixedStepper();
+
 #if PX_ENABLE_RAYCAST_CCD
 		raycastCCD = new RaycastCCDManager(scene);
 #endif
@@ -234,14 +237,19 @@ namespace era_engine::physics
 			scene->flushSimulation();
 		}
 
-		PX_RELEASE(default_material)
-		PX_RELEASE(scene)
-		PX_RELEASE(dispatcher)
-		PX_RELEASE(pvd)
-		PX_RELEASE(omni_pvd)
-		PX_RELEASE(physics)
-		PX_RELEASE(cuda_context_manager)
-		PX_RELEASE(foundation)
+		{
+			PX_RELEASE(default_material)
+			PX_RELEASE(scene)
+			delete stepper;
+			PX_RELEASE(physics)
+			PX_RELEASE(dispatcher)
+			PX_RELEASE(pvd)
+			PX_RELEASE(omni_pvd)
+			PX_RELEASE(cuda_context_manager)
+			PX_RELEASE(foundation)
+		}
+
+		delete allocator_callback;
 
 #if PX_ENABLE_RAYCAST_CCD
 		delete raycast_ccd;
@@ -282,21 +290,21 @@ namespace era_engine::physics
 
 #else
 
-		stepper.setup(stepSize);
+		stepper->setup(stepSize);
 
-		if (!stepper.advance(scene, stepSize, scratchMemBlock, scratchMemBlockSize))
+		if (!stepper->advance(scene, stepSize, scratchMemBlock, scratchMemBlockSize))
 		{
 			return;
 		}
 
-		stepper.renderDone();
+		stepper->renderDone();
 #endif
 	}
 
 	void Physics::end_simulation(float dt)
 	{
 #if !PX_GPU_BROAD_PHASE
-		stepper.wait(scene);
+		stepper->wait(scene);
 #endif
 #if PX_VEHICLE
 		//vehiclePostStep(dt);
@@ -460,7 +468,7 @@ namespace era_engine::physics
 	void Physics::step_physics(float step_size)
 	{
 		using namespace physx;
-		stepper.setup(step_size);
+		stepper->setup(step_size);
 
 		static constexpr uint64 align = 16U;
 
@@ -468,14 +476,14 @@ namespace era_engine::physics
 
 		static void* scratchMemBlock = allocator.allocate(scratchMemBlockSize, align, true);
 
-		if (!stepper.advance(scene, step_size, scratchMemBlock, scratchMemBlockSize))
+		if (!stepper->advance(scene, step_size, scratchMemBlock, scratchMemBlockSize))
 		{
 			return;
 		}
 
-		stepper.renderDone();
+		stepper->renderDone();
 
-		stepper.wait(scene);
+		stepper->wait(scene);
 
 #if PX_ENABLE_RAYCAST_CCD
 		raycastCCD->doRaycastCCD(true);
diff --git a/resources/common/era_common.h b/resources/common/era_common.h
index f3c7ac072..f76ad1e0d 100644
--- a/resources/common/era_common.h
+++ b/resources/common/era_common.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#define NOMINMAX
+#define NOMINMAX 1
 #define WIN32_LEAN_AND_MEAN
 
 #define LOG_LEVEL_PROFILE 1
diff --git a/tools/assets_compiler/assets_compiler.py b/tools/assets_compiler/assets_compiler.py
index e69de29bb..13a39eae2 100644
--- a/tools/assets_compiler/assets_compiler.py
+++ b/tools/assets_compiler/assets_compiler.py
@@ -0,0 +1,17 @@
+import argparse
+import subprocess
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog='AssetsCompiler')
+    parser.add_argument('-p', '--path')
+    parser.add_argument('-v', '--verbose', action='store_true')
+    parser.add_argument('-c', '--compiler')
+    args = parser.parse_args()
+
+    startline = [f'{args.compiler}', f'--verbose={int(args.verbose)}', '--path', f'{args.path}']
+    proc = subprocess.Popen(startline, stdout=subprocess.PIPE)
+    proc.wait()
+    if proc.returncode == 0:
+        print("Compiled successfuly")
+    else:
+        print("Failed to compile asset!")
diff --git a/tools/python_requirements.txt b/tools/python_requirements.txt
index 7ca3f0c83..81209f02a 100644
--- a/tools/python_requirements.txt
+++ b/tools/python_requirements.txt
@@ -1,2 +1,3 @@
 pytest==8.3.4
-pytest-fixtures==0.1.0
\ No newline at end of file
+pytest-fixtures==0.1.0
+argparse=1.4.0
\ No newline at end of file