diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
deleted file mode 100644
index 0183294..0000000
--- a/.github/workflows/CI.yml
+++ /dev/null
@@ -1,76 +0,0 @@
-name: Continuous Integration
-run-name: Multi platform build for ${{ github.ref }} by ${{ github.actor }}
-on:
-  pull_request:
-  workflow_dispatch:
-
-jobs:
-  Build-and-Test:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ macos-latest, ubuntu-latest, windows-latest ]
-        compiler: [ clang, gcc, cl ]
-        
-        exclude:
-          - os: macos-latest
-            compiler: cl
-          - os: macos-latest
-            compiler: gcc
-          - os: ubuntu-latest
-            compiler: cl
-          - os: windows-latest
-            compiler: clang
-          - os: windows-latest
-            compiler: gcc
-
-        include:
-          - os: macos-latest
-            compiler: clang
-            c_compiler: clang
-            cpp_compiler: clang++
-            
-          - os: ubuntu-latest
-            compiler: clang
-            c_compiler: clang-18
-            cpp_compiler: clang++-18
-            
-          - os: ubuntu-latest
-            compiler: gcc
-            c_compiler: gcc-14
-            cpp_compiler: g++-14
-
-          - os: windows-latest
-            c_compiler: cl
-            cpp_compiler: cl
-          
-        
-    runs-on: ${{ matrix.os }}
-    steps:            
-      - uses: actions/checkout@v4
-
-      - name: Install dependencies
-        if: ${{ matrix.os == 'ubuntu-latest' }}
-        shell: bash 
-        run: |
-          sudo apt update
-          sudo apt install -y xorg-dev
-
-      - name: Configure CMake
-        run: > 
-          cmake -B build -S ${{ github.workspace }}
-          -DCMAKE_BUILD_TYPE=Release
-          -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
-          -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
-          -DGE_BUILD_TESTS=ON
-          -DGE_BUILD_EXAMPLES=ON
-          
-      - name: Build
-        run: cmake --build build --config Release
-
-      - name: Test
-        working-directory: build
-        run: ctest -j 8 --output-on-failure
-        env:
-          GTEST_COLOR: 1
-
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
new file mode 100644
index 0000000..58042fc
--- /dev/null
+++ b/.github/workflows/linux.yml
@@ -0,0 +1,39 @@
+name: Build Linux
+run-name: ${{ github.event.pull_request && format('{0} -> {1} by {2} (PR {3})', github.head_ref, github.base_ref, github.actor, github.event.pull_request.number) || github.event_name == 'workflow_dispatch' && format('{0} by {1} [manual]', github.ref_name, github.actor) || format('{0} by {1}', github.ref_name, github.actor) }}
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build-type: [ Debug, Release ]
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-14 g++-14 xorg-dev
+
+      - name: Generate
+        run: >
+          cmake -S ${{ github.workspace }} -B build
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
+          -DCMAKE_C_COMPILER=gcc-14
+          -DCMAKE_CXX_COMPILER=g++-14
+          -DGE_BUILD_VULKAN=ON
+          -DGE_BUILD_TESTS=ON
+          -DGE_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build build --config ${{ matrix.build-type }} --parallel
+
+      - name: Test
+        run: ctest --test-dir build -C ${{ matrix.build-type }} --output-on-failure
diff --git a/.github/workflows/macos-metal.yml b/.github/workflows/macos-metal.yml
new file mode 100644
index 0000000..75ad9bf
--- /dev/null
+++ b/.github/workflows/macos-metal.yml
@@ -0,0 +1,33 @@
+name: Build macOS - Metal
+run-name: ${{ github.event.pull_request && format('{0} -> {1} by {2} (PR {3})', github.head_ref, github.base_ref, github.actor, github.event.pull_request.number) || github.event_name == 'workflow_dispatch' && format('{0} by {1} [manual]', github.ref_name, github.actor) || format('{0} by {1}', github.ref_name, github.actor) }}
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build-type: [ Debug, Release ]
+
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Generate
+        run: >
+          cmake -S ${{ github.workspace }} -B build
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
+          -DGE_BUILD_METAL=ON
+          -DGE_BUILD_VULKAN=OFF
+          -DGE_BUILD_TESTS=ON
+          -DGE_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build build --config ${{ matrix.build-type }} --parallel
+
+      - name: Test
+        run: ctest --test-dir build -C ${{ matrix.build-type }} --output-on-failure
diff --git a/.github/workflows/macos-vulkan.yml b/.github/workflows/macos-vulkan.yml
new file mode 100644
index 0000000..cfce2db
--- /dev/null
+++ b/.github/workflows/macos-vulkan.yml
@@ -0,0 +1,33 @@
+name: Build macOS - Vulkan
+run-name: ${{ github.event.pull_request && format('{0} -> {1} by {2} (PR {3})', github.head_ref, github.base_ref, github.actor, github.event.pull_request.number) || github.event_name == 'workflow_dispatch' && format('{0} by {1} [manual]', github.ref_name, github.actor) || format('{0} by {1}', github.ref_name, github.actor) }}
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build-type: [ Debug, Release ]
+
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Generate
+        run: >
+          cmake -S ${{ github.workspace }} -B build
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
+          -DGE_BUILD_METAL=OFF
+          -DGE_BUILD_VULKAN=ON
+          -DGE_BUILD_TESTS=ON
+          -DGE_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build build --config ${{ matrix.build-type }} --parallel
+
+      - name: Test
+        run: ctest --test-dir build -C ${{ matrix.build-type }} --output-on-failure
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
new file mode 100644
index 0000000..6f0b579
--- /dev/null
+++ b/.github/workflows/macos.yml
@@ -0,0 +1,33 @@
+name: Build macOS
+run-name: ${{ github.event.pull_request && format('{0} -> {1} by {2} (PR {3})', github.head_ref, github.base_ref, github.actor, github.event.pull_request.number) || github.event_name == 'workflow_dispatch' && format('{0} by {1} [manual]', github.ref_name, github.actor) || format('{0} by {1}', github.ref_name, github.actor) }}
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build-type: [ Debug, Release ]
+
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Generate
+        run: >
+          cmake -S ${{ github.workspace }} -B build
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
+          -DGE_BUILD_METAL=ON
+          -DGE_BUILD_VULKAN=ON
+          -DGE_BUILD_TESTS=ON
+          -DGE_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build build --config ${{ matrix.build-type }} --parallel
+
+      - name: Test
+        run: ctest --test-dir build -C ${{ matrix.build-type }} --output-on-failure
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
new file mode 100644
index 0000000..8a7331f
--- /dev/null
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,32 @@
+name: Build Windows
+run-name: ${{ github.event.pull_request && format('{0} -> {1} by {2} (PR {3})', github.head_ref, github.base_ref, github.actor, github.event.pull_request.number) || github.event_name == 'workflow_dispatch' && format('{0} by {1} [manual]', github.ref_name, github.actor) || format('{0} by {1}', github.ref_name, github.actor) }}
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build-type: [ Debug, Release ]
+
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Generate
+        run: >
+          cmake -S ${{ github.workspace }} -B build
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
+          -DGE_BUILD_VULKAN=ON
+          -DGE_BUILD_TESTS=ON
+          -DGE_BUILD_EXAMPLES=${{ matrix.build-examples }}
+
+      - name: Build
+        run: cmake --build build --config ${{ matrix.build-type }} --parallel
+
+      - name: Test
+        run: ctest --test-dir build -C ${{ matrix.build-type }} --output-on-failure
diff --git a/.gitignore b/.gitignore
index 4eb330f..6d6a193 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ default.profraw
 graph.drawio.svg
 **/.DS_Store
 examples/project1/project1_scriptLib*
+__cmake_systeminformation
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index 4c31544..0000000
--- a/.gitmodules
+++ /dev/null
@@ -1,9 +0,0 @@
-[submodule "dependencies/UtilsCPP"]
-	path = dependencies/UtilsCPP
-	url = https://github.com/Thomas-Chqt/UtilsCPP
-[submodule "dependencies/Math"]
-	path = dependencies/Math
-	url = https://github.com/Thomas-Chqt/Math
-[submodule "dependencies/Graphics"]
-	path = dependencies/Graphics
-	url = https://github.com/Thomas-Chqt/Graphics
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a9e94e..c13d01b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,32 +7,60 @@
 
 cmake_minimum_required(VERSION 3.22)
 
-include(FetchContent)
+include(cmake/FetchDependencies.cmake)
 
-enable_testing()
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 
-set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build using shared libraries" FORCE)
+project(Game-Engine)
 
-option(GE_BUILD_TESTS    "Build test executable" OFF)
-option(GE_BUILD_EXAMPLES "Build example scripts" OFF)
+option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
 
 if (APPLE)
-    option(GE_BUILD_METAL  "Build with metal enable"  ON)
-    option(GE_BUILD_OPENGL "Build with OpenGL enable" ON)
-else()
-    option(GE_BUILD_OPENGL "Build with OpenGL enable" ON)
+    option(GE_BUILD_METAL "Build the metal backend"   ON)
 endif()
+option(GE_BUILD_VULKAN   "Build the vulkan backend"   ON)
+option(GE_BUILD_TESTS    "Build test executable"      OFF)
+option(GE_BUILD_EXAMPLES "Build examples"             OFF)
+option(GE_INSTALL        "Enable the install command" ON)
+
+enable_language(CXX)
+
+fetch_dependencies()
 
-if (NOT GE_BUILD_METAL AND NOT GE_BUILD_OPENGL)
-    message(FATAL_ERROR "One graphic api must be enable")
+add_library(Game-Engine ${GE_LIB_TYPE})
+
+set_target_properties(Game-Engine PROPERTIES
+    CXX_VISIBILITY_PRESET     hidden
+    VISIBILITY_INLINES_HIDDEN YES
+)
+
+target_compile_features(Game-Engine PUBLIC cxx_std_23)
+target_compile_definitions(Game-Engine PRIVATE GE_DLL_EXPORT)
+target_compile_definitions(Game-Engine PUBLIC "GE_SHARED_LIBRARY_EXTENSION=\"${CMAKE_SHARED_LIBRARY_SUFFIX}\"")
+
+if(MSVC)
+    target_compile_options(Game-Engine PRIVATE /W4 /wd4251)
+else()
+    target_compile_options(Game-Engine PRIVATE -Wall -Wextra -Wpedantic)
+    target_compile_options(Game-Engine PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Wno-missing-field-initializers>)
 endif()
 
-project(Game-Engine)
-enable_language(CXX)
+file(GLOB_RECURSE GE_SRC "include/*.hpp" "include/*.inl" "src/*.cpp" "src/*.hpp")
+target_sources(Game-Engine PRIVATE ${GE_SRC} ${GFX_INC})
+
+target_include_directories(Game-Engine
+    PUBLIC  "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}")
+
+# target_precompile_headers(Graphics PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/pch.hpp")
+
+target_link_libraries(Game-Engine PUBLIC Graphics glfw glm::glm imgui stb_image dlLoad assimp::assimp yaml-cpp)
+
+add_subdirectory("shaders")
+
+add_dependencies(Game-Engine flat_color_shader)
+target_compile_definitions(Game-Engine PRIVATE "SHADER_DIR=\"${SHADER_DIR}\"")
 
-add_subdirectory("dependencies")
-add_subdirectory("engine")
 add_subdirectory("editor")
 
 if(GE_BUILD_EXAMPLES)
@@ -40,5 +68,6 @@ if(GE_BUILD_EXAMPLES)
 endif()
 
 if (GE_BUILD_TESTS)
+    enable_testing() # need to be in the top level cmakelists
     add_subdirectory("tests")
-endif()
\ No newline at end of file
+endif()
diff --git a/README.md b/README.md
index b1fe60b..2ba2d8f 100644
--- a/README.md
+++ b/README.md
@@ -1,90 +1,85 @@
-> This project is currently undergoing refactoring (refer to the [refactor branch](https://github.com/Thomas-Chqt/Game-Engine/tree/refactor)) to incorporate the latest version of the graphics library and adopt more modern C++ features.
+# Game-Engine
 
-Game-Engine
-===========
+`Game-Engine` is a small C++23 game engine and editor built as a learning project around rendering, tooling, and runtime architecture. It includes a reusable engine library, a desktop editor, YAML-based project and scene serialization, and hot-reloadable C++ gameplay scripts.
 
-**Game-Engine** is an ongoing project focused on building a simple, low-level game engine. The primary goal is to deepen my understanding of game development by creating a versatile set of tools that can be used to build various types of games and 3D applications.
+![viewport](viewport.png)
 
-Current Features
-----------------
+## Current Features
 
-- **Basic Renderer**: A simple rendering pipeline for drawing objects on the screen.  
-- **Entity Component System (ECS)**: A flexible system for composing game objects with various components.  
-- **Editor**: A built-in editor linked to the engine for editing, saving, and running projects.  
-- **External Scripting**: Projects can include scripts that are loaded at runtime through shared libraries, allowing scripts to be rebuilt and reloaded without closing the editor.  
+- Frame-graph-based renderer
+- Metal backend on macOS and Vulkan backend where enabled
+- Entity Component System
+- Scene hierarchy
+- ImGui-based editor with viewport, scene graph, inspector, project properties, and resource management panels
+- Runtime game mode inside the editor
+- Hot-reloadable gameplay scripts written in C++
+- Reflected script fields exposed to the editor and serialization
+- YAML project, scene, input, and component serialization
+- Input system
+- Mesh importing with `assimp`
+- Texture loading with `stb_image`
+- Automated tests for core engine systems
 
-### Example Project  
+## Example Project
 
-A basic example project is included to demonstrate the engine’s current capabilities. It consists of four entities:  
+The repository includes `examples/project1`, a sample project that demonstrates the current engine and editor workflow. It contains:
 
-1. **Player**: An entity with a mesh component and a script enabling player movement.  
-2. **Camera**: A camera component attached as a child of the player, ensuring it moves along with the player.  
-3. **Chess Set**: A static entity with a mesh component.  
-4. **Light**: A point light component illuminating the scene.  
+- A chess-set scene with imported meshes, textures, lighting, and camera setup
+- A set of inputs and there mappers
+- A Player controller script attached to the player entity
 
-To run the game, use the **Project > Run** menu option.  
+It can be opened from the project root with `./path/to/editor examples/project1/project1.geproj`.
 
 <p float="left">
-  <img src="example1.png" width="49%" />
-  <img src="example2.gif" width="49%" /> 
-</p>  
+  <img src="project1_video.gif" width="49%"></img>
+  <img src="project_properties.png" width="49%"></img>
+</p>
 
-Support
-------
+## Build
 
-| Platform | Supported | Graphics API   |
-|----------|-----------|----------------|
-| Windows  | Yes       | OpenGL         |
-| Linux    | Yes       | OpenGL         |
-| macOS    | Yes       | Metal / OpenGL |
+### Supported Platforms
 
-Building the Project  
---------------------
+| Platform | Metal | Vulkan |
+|----------|-------|--------|
+| macOS    | [![macOS-Metal](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/macos-metal.yml/badge.svg)](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/macos-metal.yml) | [![macOS-Vulkan](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/macos-vulkan.yml/badge.svg)](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/macos-vulkan.yml) |
+| Windows  | N/A | [![Windows](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/windows.yml/badge.svg)](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/windows.yml) |
+| Linux    | N/A | [![Linux](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/linux.yml/badge.svg)](https://github.com/Thomas-Chqt/Game-Engine/actions/workflows/linux.yml) |
 
-The repository must be **cloned** (instead of downloaded as a ZIP) to correctly resolve submodules when configuring the project with CMake. Recursive cloning is not required, as everything is managed through CMake.  
+### Requirements
 
-### Build Instructions  
+- CMake
+- A C++23 compiler (out of the box on macos and windows, require gcc-14 on ubuntu)
+- see [`Graphics`](https://github.com/Thomas-Chqt/Graphics) for backends requirements
+
+### Configure and Build
 
 ```sh
-mkdir build
 cmake -S . -B build
 cmake --build build
-```  
-
-All dependencies are embedded in the project using either **Git submodules** or **CMake's FetchContent**, so it should work out of the box. However, if compilation fails, ensure that your system meets the requirements for each dependency.  
-
-### CMake Options  
-
-| Option              | Default | Description                          |
-|---------------------|---------|--------------------------------------|
-| `GE_BUILD_EXAMPLES` |  `OFF`  | Build example projects               |
-| `GE_BUILD_TESTS`    |  `OFF`  | Build unit tests                     |
-| `GE_BUILD_METAL`    |  `ON`   | Build the Metal backend (macOS only) |
-| `GE_BUILD_OPENGL`   |  `ON`   | Build the OpenGL backend             |
-
-Libraries
----------
-
-This project utilizes a combination of **custom-built** and **open-source** libraries.  
-
-### Custom Libraries  
-
-I’ve developed the following libraries :  
-
-- **[UtilsCPP](https://github.com/Thomas-Chqt/UtilsCPP)** – A utility library with various data structures and algorithms.  
-- **[Math](https://github.com/Thomas-Chqt/Math)** – A math library providing vector and matrix operations for graphics.  
-- **[Graphics](https://github.com/Thomas-Chqt/Graphics)** – An abstraction layer over multiple graphics APIs, enabling cross-platform compatibility with the most native API per platform.  
-
-### Open-Source Libraries  
-
-The engine also integrates several open-source libraries:  
-
-- **[GLFW](https://github.com/glfw/glfw)** – Handles window creation and input events (used internally by **Graphics**).  
-- **[GLAD](https://github.com/Thomas-Chqt/GLAD)** – Loads OpenGL functions for cross-platform rendering (used internally by **Graphics**).  
-- **[assimp](https://github.com/assimp/assimp)** – Imports 3D models and meshes for asset loading.  
-- **[stb_image](https://github.com/Thomas-Chqt/stb_image)** – A lightweight image-loading library for textures.  
-- **[imgui](https://github.com/Thomas-Chqt/imgui)** – A UI framework for building efficient in-engine interfaces.  
-- **[tinyfiledialogs](http://tinyfiledialogs.sourceforge.net)** – Provides a native file picker for all platforms.  
-- **[nlohmann/json](https://github.com/nlohmann/json)** – Parses and writes JSON files.  
-
-Additionally, unit tests are built using **[GoogleTest](https://github.com/google/googletest)**.  
+```
+
+This builds the `Game-Engine` library, the `GE-Editor` application, and the required shader compilation targets.  
+To build the example project, add the `-DGE_BUILD_EXAMPLES=ON` flag
+
+### Useful CMake Options
+
+| Option              | Default       | Description                                                 |
+| ------------------- | ------------- | ----------------------------------------------------------- |
+| `BUILD_SHARED_LIBS` | `OFF`         | Build libraries as shared instead of static where supported |
+| `GE_BUILD_METAL`    | `ON` on macOS | Enable the Metal backend                                    |
+| `GE_BUILD_VULKAN`   | `ON`          | Enable the Vulkan backend                                   |
+| `GE_BUILD_TESTS`    | `OFF`         | Build the test target                                       |
+| `GE_BUILD_EXAMPLES` | `OFF`         | Build the example project script library                    |
+| `GE_INSTALL`        | `ON`          | Enable install rules in dependencies that support them      |
+
+## Libraries Used
+
+- [`Graphics`](https://github.com/Thomas-Chqt/Graphics): rendering abstraction layer and shader toolchain
+- [`GLFW`](https://github.com/glfw/glfw): windowing and input
+- [`GLM`](https://github.com/g-truc/glm): math types and transforms
+- [`imgui`](https://github.com/Thomas-Chqt/imgui): editor UI
+- [`stb_image`](https://github.com/Thomas-Chqt/stb_image): image loading
+- [`assimp`](https://github.com/assimp/assimp): mesh import
+- [`yaml-cpp`](https://github.com/jbeder/yaml-cpp): YAML serialization
+- [`dlLoad`](https://github.com/Thomas-Chqt/dlLoad): dynamic library loading for scripts
+- [`GoogleTest`](https://github.com/google/googletest): unit tests
diff --git a/cmake/FetchDependencies.cmake b/cmake/FetchDependencies.cmake
new file mode 100644
index 0000000..ec8ada8
--- /dev/null
+++ b/cmake/FetchDependencies.cmake
@@ -0,0 +1,178 @@
+# ---------------------------------------------------
+# FetchDependencies.cmake
+#
+# Centralizes FetchContent-based dependencies for the Game-Engine project.
+# Call `fetch_dependencies()` from the root `CMakeLists.txt`.
+# ---------------------------------------------------
+
+include_guard(GLOBAL)
+
+include(FetchContent)
+
+function(fetch_dependencies)
+    set(FETCHCONTENT_QUIET OFF)
+    set(ENV{GIT_LFS_SKIP_SMUDGE} 1)
+
+    # -----------------------------
+    # Graphics
+    # -----------------------------
+    FetchContent_Declare(Graphics
+        GIT_REPOSITORY    https://github.com/Thomas-Chqt/Graphics.git
+        GIT_TAG           c85bcc401cdeaa461458ac1078ca441ad200b65f
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(GFX_BUILD_METAL      ${GE_BUILD_METAL})
+    set(GFX_BUILD_VULKAN     ${GE_BUILD_VULKAN})
+    set(GFX_ENABLE_IMGUI     ON)
+    set(GFX_ENABLE_GLFW      ON)
+    set(GFX_BUILD_EXAMPLES   OFF)
+    set(GFX_BUILD_TESTS      OFF)
+    set(GFX_BUILD_TRACY      OFF)
+    set(GFX_INSTALL          ${GE_INSTALL})
+    FetchContent_MakeAvailable(Graphics)
+    set_target_properties(Graphics PROPERTIES FOLDER "dependencies/Graphics")
+    set_target_properties(gfxsc PROPERTIES FOLDER "dependencies/Graphics")
+
+    # -----------------------------
+    # GLFW
+    # -----------------------------
+    FetchContent_Declare(glfw3
+        GIT_REPOSITORY    https://github.com/glfw/glfw.git
+        GIT_TAG           3.4
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(GLFW_BUILD_TESTS    OFF)
+    set(GLFW_BUILD_DOCS     OFF)
+    set(GLFW_INSTALL        OFF)
+    set(GLFW_BUILD_EXAMPLES OFF)
+    if(NOT GLFW_BUILD_WAYLAND)
+        set(GLFW_BUILD_WAYLAND OFF)
+    endif()
+    if (APPLE)
+        enable_language(OBJC)
+    endif()
+    FetchContent_MakeAvailable(glfw3)
+    if (glfw3_SOURCE_DIR)
+        if (TARGET update_mappings)
+            set_target_properties(glfw PROPERTIES FOLDER "dependencies/GLFW3")
+            set_target_properties(update_mappings PROPERTIES FOLDER "dependencies/GLFW3")
+        else()
+            set_target_properties(glfw PROPERTIES FOLDER "dependencies")
+        endif()
+    endif()
+
+    # -----------------------------
+    # GLM
+    # -----------------------------
+    FetchContent_Declare(glm
+        GIT_REPOSITORY    https://github.com/g-truc/glm.git
+        GIT_TAG           1.0.1
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    FetchContent_MakeAvailable(glm)
+    if (glm_SOURCE_DIR)
+        set_target_properties(glm PROPERTIES FOLDER "dependencies")
+    endif()
+
+    # -----------------------------
+    # ImGui
+    # -----------------------------
+    FetchContent_Declare(imgui
+        GIT_REPOSITORY    https://github.com/Thomas-Chqt/imgui.git
+        GIT_TAG           4d8f55183c2e974916daf6336ee2c4b9c8e72891
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(IM_BUILD_GLFW ON)
+    FetchContent_MakeAvailable(imgui)
+    target_compile_definitions(imgui PRIVATE "GLFW_INCLUDE_NONE")
+    target_link_libraries(imgui PUBLIC glfw)
+    if (imgui_SOURCE_DIR)
+        set_target_properties(imgui PROPERTIES FOLDER "dependencies")
+    endif()
+
+    # -----------------------------
+    # stb_image
+    # -----------------------------
+    FetchContent_Declare(stb_image
+        GIT_REPOSITORY    https://github.com/Thomas-Chqt/stb_image.git
+        GIT_TAG           a09b799a2ba95c14f511493db4ea59811b2fcc97
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    FetchContent_MakeAvailable(stb_image)
+    if (stb_image_SOURCE_DIR)
+        set_target_properties(stb_image PROPERTIES FOLDER "dependencies")
+    endif()
+
+    # -----------------------------
+    # dlLoad
+    # -----------------------------
+    FetchContent_Declare(dlLoad
+        GIT_REPOSITORY    https://github.com/Thomas-Chqt/dlLoad.git
+        GIT_TAG           fd860b8200983b89d3ca58b371f6ec25b9972bd3
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(DL_BUILD_TESTS OFF)
+    set(DL_INSTALL     ${GE_INSTALL})
+    FetchContent_MakeAvailable(dlLoad)
+    set_target_properties(dlLoad PROPERTIES FOLDER "dependencies")
+
+    # -----------------------------
+    # assimp
+    # -----------------------------
+    FetchContent_Declare(assimp
+        GIT_REPOSITORY    https://github.com/assimp/assimp.git
+        GIT_TAG           v5.4.1
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(ASSIMP_BUILD_TESTS                    OFF)
+    set(ASSIMP_INSTALL                        OFF)
+    set(ASSIMP_NO_EXPORT                      ON)
+    set(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT OFF)
+    set(ASSIMP_BUILD_OBJ_IMPORTER             ON)
+    set(ASSIMP_BUILD_FBX_IMPORTER             ON)
+    set(ASSIMP_BUILD_GLTF_IMPORTER            ON)
+    set(CMAKE_POLICY_DEFAULT_CMP0175 OLD)
+    FetchContent_MakeAvailable(assimp)
+    unset(CMAKE_POLICY_DEFAULT_CMP0175)
+    if (assimp_SOURCE_DIR)
+        if(TARGET zlibstatic OR TARGET UpdateAssimpLibsDebugSymbolsAndDLLs)
+            set_target_properties(assimp PROPERTIES FOLDER "dependencies/assimp")
+            if(TARGET zlibstatic)
+                set_target_properties(zlibstatic PROPERTIES FOLDER "dependencies/assimp")
+            endif()
+            if(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs)
+                set_target_properties(UpdateAssimpLibsDebugSymbolsAndDLLs PROPERTIES FOLDER "dependencies/assimp")
+            endif()
+        else()
+            set_target_properties(assimp PROPERTIES FOLDER "dependencies")
+        endif()
+    endif()
+
+    # -----------------------------
+    # yaml-cpp
+    # -----------------------------
+    FetchContent_Declare(yaml-cpp
+        GIT_REPOSITORY    https://github.com/jbeder/yaml-cpp.git
+        GIT_TAG           yaml-cpp-0.9.0
+        GIT_SHALLOW       1
+        GIT_PROGRESS      TRUE
+        FIND_PACKAGE_ARGS
+    )
+    set(YAML_CPP_BUILD_TOOLS OFF)
+    FetchContent_MakeAvailable(yaml-cpp)
+    set_target_properties(yaml-cpp PROPERTIES FOLDER "dependencies")
+endfunction()
diff --git a/cmake/ScriptLibrary.cmake b/cmake/ScriptLibrary.cmake
new file mode 100644
index 0000000..c1bf08b
--- /dev/null
+++ b/cmake/ScriptLibrary.cmake
@@ -0,0 +1,69 @@
+# ---------------------------------------------------
+# ScriptLibrary.cmake
+#
+# Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+# ---------------------------------------------------
+# Script library helper for user project shared libraries.
+
+function(ge_add_script_library target_name)
+    set(export_source "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_ScriptSharedLibraryExports.cpp")
+    file(WRITE "${export_source}"
+        [=[
+        #include "Game-Engine/Script.hpp"
+
+        #if defined(_WIN32)
+            #define GE_SCRIPT_LIBRARY_EXPORT __declspec(dllexport)
+        #else
+            #define GE_SCRIPT_LIBRARY_EXPORT __attribute__((visibility("default")))
+        #endif
+
+        extern "C"
+        {
+
+        GE_SCRIPT_LIBRARY_EXPORT void listScriptNames(const char*** names, size_t* count)
+        {
+            return GE::ScriptRegistry::instance().listScriptNames(names, count);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT void listScriptParameterNames(const char* scriptName, const char*** names, size_t* count)
+        {
+            return GE::ScriptRegistry::instance().listScriptParameterNames(scriptName, names, count);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT const char* getScriptParameterTypeName(const char* scriptName, const char* parameterName)
+        {
+            return GE::ScriptRegistry::instance().getScriptParameterTypeName(scriptName, parameterName);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT void getScriptDefaultParameterValue(const char* scriptName, const char* parameterName, void* data)
+        {
+            return GE::ScriptRegistry::instance().getScriptDefaultParameterValue(scriptName, parameterName, data);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT GE::Script* makeScriptInstance(const char* name)
+        {
+            return GE::ScriptRegistry::instance().makeScriptInstance(name);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT void destroyScriptInstance(GE::Script* instance)
+        {
+            return GE::ScriptRegistry::instance().destroyScriptInstance(instance);
+        }
+
+        GE_SCRIPT_LIBRARY_EXPORT void setScriptParameter(const char* scriptName, const char* parameterName, GE::Script* instance, const void* data)
+        {
+            return GE::ScriptRegistry::instance().setScriptParameter(scriptName, parameterName, instance, data);
+        }
+
+        }
+        ]=]
+    )
+
+    add_library(${target_name} SHARED ${ARGN})
+    target_sources(${target_name} PRIVATE "${export_source}")
+    target_compile_features(${target_name} PRIVATE cxx_std_23)
+
+    if(APPLE)
+        target_link_options(${target_name} PRIVATE "-undefined" "dynamic_lookup")
+    endif()
+endfunction()
diff --git a/dependencies/CMakeLists.txt b/dependencies/CMakeLists.txt
deleted file mode 100644
index 42d8243..0000000
--- a/dependencies/CMakeLists.txt
+++ /dev/null
@@ -1,110 +0,0 @@
-# ---------------------------------------------------
-# CMakeLists.txt
-#
-# Author: Thomas Choquet <thomas.publique@icloud.com>
-# Date: 2024/06/20 16:24:26
-# ---------------------------------------------------
-
-if(NOT TARGET UtilsCPP)
-    find_program(GIT_PATH git REQUIRED)
-    execute_process(COMMAND ${GIT_PATH} submodule update --init UtilsCPP WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    set(UTILSCPP_BUILD_TESTS OFF)
-    set(UTILSCPP_API_EXPORT  ON)
-    add_subdirectory(UtilsCPP)
-endif()
-set_target_properties(UtilsCPP PROPERTIES FOLDER "dependencies")
-
-if(NOT TARGET Math)
-    find_program(GIT_PATH git REQUIRED)
-    execute_process(COMMAND ${GIT_PATH} submodule update --init Math WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    set(MATH_BUILD_TESTS OFF)
-    set(MATH_API_EXPORT  ON)
-    add_subdirectory(Math)
-endif()
-set_target_properties(Math PROPERTIES FOLDER "dependencies")
-
-if(NOT TARGET Graphics)
-    find_program(GIT_PATH git REQUIRED)
-    execute_process(COMMAND ${GIT_PATH} submodule update --init Graphics WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    set(GFX_BUILD_IMGUI    ON)
-    set(GFX_BUILD_EXEMPLES OFF)
-    set(GFX_BUILD_METAL    ${GE_BUILD_METAL})
-    set(GFX_BUILD_OPENGL   ${GE_BUILD_OPENGL})
-    add_subdirectory(Graphics)
-endif()
-set_target_properties(Graphics PROPERTIES FOLDER "dependencies")
-
-FetchContent_Declare(assimp
-    GIT_REPOSITORY https://github.com/assimp/assimp.git
-    GIT_TAG        v5.4.1
-    GIT_SHALLOW    1
-)
-set(ASSIMP_BUILD_TESTS                    OFF)
-set(ASSIMP_INSTALL                        OFF)
-set(ASSIMP_NO_EXPORT                      ON)
-set(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT OFF)
-set(ASSIMP_BUILD_OBJ_IMPORTER             ON)
-set(ASSIMP_BUILD_FBX_IMPORTER             ON)
-set(ASSIMP_BUILD_GLTF_IMPORTER            ON)
-set(CMAKE_POLICY_DEFAULT_CMP0175 OLD)
-FetchContent_MakeAvailable(assimp)
-unset(CMAKE_POLICY_DEFAULT_CMP0175)
-if(TARGET zlibstatic OR TARGET UpdateAssimpLibsDebugSymbolsAndDLLs)
-    set_target_properties(assimp PROPERTIES FOLDER "dependencies/assimp")
-    if(TARGET zlibstatic)
-        set_target_properties(zlibstatic PROPERTIES FOLDER "dependencies/assimp")
-    endif()
-    if(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs)
-        set_target_properties(UpdateAssimpLibsDebugSymbolsAndDLLs PROPERTIES FOLDER "dependencies/assimp")
-    endif()
-else()
-    set_target_properties(assimp PROPERTIES FOLDER "dependencies")
-endif()
-
-
-FetchContent_Declare(json
-    GIT_REPOSITORY https://github.com/nlohmann/json.git
-    GIT_TAG        v3.11.3
-    GIT_SHALLOW    1
-)
-set(JSON_BuildTests OFF)
-set(JSON_Install    OFF)
-FetchContent_MakeAvailable(json)
-
-FetchContent_Declare(tinyfiledialogs
-    GIT_REPOSITORY https://github.com/Thomas-Chqt/tinyfiledialogs.git
-    GIT_TAG        0806552c78bf70658628e0ca4e3b962ca163ac70
-)
-set(TFD_BUILD_EXAMPLES OFF)
-set(TFD_INSTALL        OFF)
-FetchContent_MakeAvailable(tinyfiledialogs)
-set_target_properties(tinyfiledialogs PROPERTIES FOLDER "dependencies")
-
-FetchContent_Declare(stduuid
-    GIT_REPOSITORY https://github.com/mariusbancila/stduuid.git
-    GIT_TAG        v1.2.3
-    GIT_SHALLOW    1
-)
-set(UUID_BUILD_TESTS      OFF)
-set(UUID_SYSTEM_GENERATOR OFF)
-set(UUID_TIME_GENERATOR   OFF)
-set(UUID_USING_CXX20_SPAN ON)
-set(UUID_ENABLE_INSTALL   OFF)
-FetchContent_MakeAvailable(stduuid)
-set_target_properties(stduuid PROPERTIES FOLDER "dependencies")
-
-FetchContent_Declare(stb_image
-    GIT_REPOSITORY https://github.com/Thomas-Chqt/stb_image.git
-    GIT_SHALLOW    1
-)
-FetchContent_MakeAvailable(stb_image)
-set_target_properties(stb_image PROPERTIES FOLDER "dependencies")
-
-FetchContent_Declare(dlLoad
-    GIT_REPOSITORY https://github.com/Thomas-Chqt/dlLoad.git
-    GIT_SHALLOW    1
-)
-set(DL_BUILD_TESTS OFF)
-set(DL_INSTALL     OFF)
-FetchContent_MakeAvailable(dlLoad)
-set_target_properties(dlLoad PROPERTIES FOLDER "dependencies")
\ No newline at end of file
diff --git a/dependencies/Graphics b/dependencies/Graphics
deleted file mode 160000
index fc08a81..0000000
--- a/dependencies/Graphics
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit fc08a8196a5d9669e4459161b4feabd0417adb9d
diff --git a/dependencies/Math b/dependencies/Math
deleted file mode 160000
index af70345..0000000
--- a/dependencies/Math
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit af70345dc20df20ca42276dfc6ec36e1433d8f42
diff --git a/dependencies/UtilsCPP b/dependencies/UtilsCPP
deleted file mode 160000
index 088b32c..0000000
--- a/dependencies/UtilsCPP
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 088b32ca55a5a1e03f3d47b723a2c585370c0482
diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt
index 403154c..360606d 100644
--- a/editor/CMakeLists.txt
+++ b/editor/CMakeLists.txt
@@ -6,21 +6,46 @@
 # ---------------------------------------------------
 
 add_executable(GE-Editor)
-set_target_properties(GE-Editor
-    PROPERTIES CXX_STANDARD 20
-    CXX_STANDARD_REQUIRED   ON
-    ENABLE_EXPORTS          ON
+set_target_properties(GE-Editor PROPERTIES
+    ENABLE_EXPORTS ON
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN YES
 )
 
 file(GLOB_RECURSE GE_EDITOR_SRC "*.cpp" "*.hpp")
 target_sources(GE-Editor PRIVATE ${GE_EDITOR_SRC})
+if(MSVC)
+    target_sources(GE-Editor PRIVATE "ge-editor.def")
+endif()
 
 target_include_directories(GE-Editor PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
-target_compile_definitions(GE-Editor PRIVATE "RESSOURCES_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/ressources\"")
-target_compile_definitions(GE-Editor INTERFACE "UTILSCPP_API_IMPORT" "MATH_API_IMPORT" "GAME_ENGINE_API_IMPORT")
+target_compile_definitions(GE-Editor PRIVATE "RESOURCE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/resources\"")
 
 target_link_libraries(GE-Editor PRIVATE Game-Engine)
 target_include_directories(GE-Editor INTERFACE $<TARGET_PROPERTY:Game-Engine,INTERFACE_INCLUDE_DIRECTORIES>)
 
-target_link_libraries(GE-Editor PRIVATE tinyfiledialogs)
\ No newline at end of file
+if(APPLE)
+    target_link_options(GE-Editor PRIVATE "LINKER:-force_load,$<TARGET_FILE:Game-Engine>")
+elseif(NOT MSVC)
+    target_link_options(GE-Editor PRIVATE "LINKER:--whole-archive,$<TARGET_FILE:Game-Engine>,--no-whole-archive")
+endif()
+
+if(APPLE AND NOT CMAKE_GENERATOR STREQUAL "Xcode")
+    set(CODESIGN_IDENTITY "-" CACHE STRING "Codesigning identity")
+
+    set(GE_EDITOR_ENTITLEMENTS_FILE "${CMAKE_CURRENT_SOURCE_DIR}/ge-editor.entitlements")
+    if(EXISTS "${GE_EDITOR_ENTITLEMENTS_FILE}")
+        add_custom_command(TARGET GE-Editor POST_BUILD
+            COMMAND /bin/sh -c "codesign --sign \"${CODESIGN_IDENTITY}\" --force --entitlements \"${GE_EDITOR_ENTITLEMENTS_FILE}\" \"$<TARGET_FILE:GE-Editor>\" >/dev/null 2>&1"
+            COMMENT "Codesigning GE-Editor (with entitlements) [identity: ${CODESIGN_IDENTITY}]"
+            VERBATIM
+        )
+    else()
+        add_custom_command(TARGET GE-Editor POST_BUILD
+            COMMAND /bin/sh -c "codesign --sign \"${CODESIGN_IDENTITY}\" --force \"$<TARGET_FILE:GE-Editor>\" >/dev/null 2>&1"
+            COMMENT "Codesigning GE-Editor [identity: ${CODESIGN_IDENTITY}]"
+            VERBATIM
+        )
+    endif()
+endif()
diff --git a/editor/Editor.cpp b/editor/Editor.cpp
index 7bfa1ea..a4bfb40 100644
--- a/editor/Editor.cpp
+++ b/editor/Editor.cpp
@@ -8,348 +8,256 @@
  */
 
 #include "Editor.hpp"
-#include "ECS/Components.hpp"
-#include "ECS/ECSView.hpp"
-#include "ECS/Entity.hpp"
-#include "EditorCamera.hpp"
-#include "Graphics/Event.hpp"
-#include "InputManager/RawInput.hpp"
-#include "InputManager/Mapper.hpp"
 #include "Project.hpp"
-#include "Renderer/Renderer.hpp"
-#include "Scene.hpp"
-#include "Script.hpp"
-#include "UI/ContentBrowserPanel.hpp"
-#include "UI/EntityInspectorPanel.hpp"
-#include "UI/FileOpenDialog.hpp"
-#include "UI/FileSaveDialog.hpp"
-#include "UI/MainMenuBar.hpp"
-#include "UI/ProjectPropertiesModal.hpp"
-#include "UI/ViewportPanel.hpp"
-#include "UI/SceneGraphPanel.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/Types.hpp"
-#include "UtilsCPP/UniquePtr.hpp"
-#include <cassert>
+
+#include <Game-Engine/Event.hpp>
+#include <Game-Engine/RawInput.hpp>
+#include <Game-Engine/AssetManager.hpp>
+#include <Game-Engine/ECSView.hpp>
+#include <Game-Engine/Entity.hpp>
+#include <Game-Engine/FrameGraph.hpp>
+#include <Game-Engine/FramePassBuilder.hpp>
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/Script.hpp>
+#include <Game-Engine/Scene.hpp>
+#include <Game-Engine/ICamera.hpp>
+#include <Game-Engine/InputFwd.hpp>
+#include <Game-Engine/InputContext.hpp>
+
+#include <Graphics/Enums.hpp>
+
+#include <format>
+#include <imgui.h>
+
 #include <filesystem>
 #include <fstream>
-#include <nlohmann/json.hpp>
-#include "ViewportFrameBuff.hpp"
-#include "imgui.h"
-#include <stb_image/stb_image.h>
-#include <dlLoad/dlLoad.h>
+#include <memory>
+#include <functional>
+#include <stdexcept>
+#include <utility>
+#include <cassert>
 
-using json = nlohmann::json;
-namespace fs = std::filesystem;
+std::unique_ptr<GE::Application> createApplication(int argc, char* argv[])
+{
+    return std::make_unique<GE_Editor::Editor>(argc, argv);
+}
+
+namespace GE_Editor
+{
 
-namespace GE
+namespace
 {
 
-Editor::Editor() : m_vpFrameBuff(window(), renderer().graphicAPI())
+Project loadProjectFile(const std::filesystem::path& path)
 {
-    ImGui::GetIO().IniFilename = nullptr;
-
-    Mapper<KeyboardButton, Range2DInput>::Descriptor inputMapperDesc;
-
-    ActionInput& quitEditorIpt = m_editorInputContext.newInput<ActionInput>("quit_editor");
-    quitEditorIpt.callback = utils::Func<void()>(*(Application*)this, &Application::terminate);
-    auto quitEditorIptMapper = utils::makeUnique<Mapper<KeyboardButton, ActionInput>>(KeyboardButton::esc, quitEditorIpt);
-    quitEditorIpt.mappers[0] = quitEditorIptMapper.staticCast<IMapper>();
-    quitEditorIpt.mappers[1].clear();
-
-    Range2DInput& editorCamMoveIpt = m_editorInputContext.newInput<Range2DInput>("editor_cam_move");
-    editorCamMoveIpt.callback = utils::Func<void(math::vec2f)>(m_editorCamera, &EditorCamera::move);
-    inputMapperDesc.xPos = KeyboardButton::d;
-    inputMapperDesc.xNeg = KeyboardButton::a;
-    inputMapperDesc.yPos = KeyboardButton::w;
-    inputMapperDesc.yNeg = KeyboardButton::s;
-    auto editorCamMoveIptMapper = utils::makeUnique<Mapper<KeyboardButton, Range2DInput>>(inputMapperDesc, editorCamMoveIpt);
-    editorCamMoveIpt.mappers[0] = editorCamMoveIptMapper.staticCast<IMapper>();
-    editorCamMoveIpt.mappers[1].clear();
-
-    Range2DInput& editorCamRotateIpt = m_editorInputContext.newInput<Range2DInput>("editor_cam_rotate");
-    editorCamRotateIpt.callback = utils::Func<void(math::vec2f)>(m_editorCamera, &EditorCamera::rotate);
-    inputMapperDesc.xPos = KeyboardButton::down;
-    inputMapperDesc.xNeg = KeyboardButton::up;
-    inputMapperDesc.yPos = KeyboardButton::right;
-    inputMapperDesc.yNeg = KeyboardButton::left;
-    auto editorCamRotateIptMapper = utils::makeUnique<Mapper<KeyboardButton, Range2DInput>>(inputMapperDesc, editorCamRotateIpt);
-    editorCamRotateIpt.mappers[0] = editorCamRotateIptMapper.staticCast<IMapper>();
-    editorCamRotateIpt.mappers[1].clear();
-
-    newProject();
+    Project project;
+
+    std::ifstream file(path);
+    if (file.is_open() == false)
+        throw std::runtime_error(std::format("unable to open file : {}", path.string()));
+
+    YAML::Node projectNode = YAML::Load(file);
+
+    if (YAML::convert<Project>::decode(projectNode, project) == false)
+        throw std::runtime_error(std::format("unable to load project file : {}", path.string()));
+
+    return project;
 }
 
-void Editor::onUpdate()
+void makeEditorInputs(GE::InputContext& context)
 {
-    if (m_projectNeedReload)
-    {
-        reloadProject();
-        m_projectNeedReload = false;
-    }
+    GE::Range2DInput editorCameraMoveInput;
+    editorCameraMoveInput.setMapper<GE::KeyboardButton>(GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>::Descriptor{
+        .xPos = GE::KeyboardButton::d, .xNeg = GE::KeyboardButton::a, .yPos = GE::KeyboardButton::w, .yNeg = GE::KeyboardButton::s,
+    });
+    context.addInput("camera_move", editorCameraMoveInput);
+
+    GE::Range2DInput editorCameraRotationInput;
+    editorCameraRotationInput.setMapper<GE::KeyboardButton>(GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>::Descriptor{
+        .xPos = GE::KeyboardButton::up, .xNeg = GE::KeyboardButton::down, .yPos = GE::KeyboardButton::right, .yNeg = GE::KeyboardButton::left,
+    });
+    context.addInput("camera_rotate", editorCameraRotationInput);
+}
 
-    m_vpFrameBuff.onUpdate();
-    processDroppedFiles();
+}
 
-    if (m_game && m_game->isRunning())
-    {
-        ECSView<ScriptComponent>(m_game->activeScene().ecsWorld()).onEach([&](Entity entt, ScriptComponent& scriptComponent){
-            if (scriptComponent.instance)
-                scriptComponent.instance->onUpdate();
-        });
-    }
+Editor::Editor(int argc, char* argv[])
+    : m_projectFilePath(argc == 2 ? std::filesystem::path(argv[1]) : std::filesystem::path())
+    , m_project(m_projectFilePath.empty() ? Project() : loadProjectFile(m_projectFilePath))
+    , m_editedScene{m_project.startScene().first, GE::Scene(&assetManager(), m_project.startScene().second)}
+{
+    makeEditorInputs(m_editorInputContext);
 
-    if (m_game && m_game->isRunning() == false)
-        m_game.clear();
+    m_editorInputContext.setInputCallback<GE::Range2DInput>("camera_move", [editorCamera=&m_editorCamera](const glm::vec2& value) { editorCamera->onMoveInput(value); }) ;
+    m_editorInputContext.setInputCallback<GE::Range2DInput>("camera_rotate", [editorCamera=&m_editorCamera](const glm::vec2& value) { editorCamera->onRotationInput(value); });
 
-    if (!m_game)
-    {
-        assert(m_editedScene != nullptr);
-        renderer().beginScene(m_editorCamera.getRendererCam(), m_vpFrameBuff);
-        {
-            renderer().addRenderables(m_editedScene->ecsWorld(), m_editedScene->assetManager());
-            renderer().addLights(m_editedScene->ecsWorld());
-        }
-        renderer().endScene();
+    pushInputContext(&m_editorInputContext);
+    pushInputContext(&m_imguiInputContext);
 
-        addInputContext(&m_editorInputContext);
-        setDispatchedInputContext(&m_editorInputContext);
-    }
-    else
+    rebuildFrameGraph();
+
+    ImGui::LoadIniSettingsFromMemory(m_project.imguiSettings().c_str());
+
+    if (std::filesystem::exists(m_project.scriptLib()))
+        reloadScriptLib();
+}
+
+void Editor::onUpdate()
+{
+    processDropedFiles();
+
+    if (m_game.has_value())
     {
-        assert(m_game->activeScene().activeCamera());
-        assert(m_game->activeScene().activeCamera().has<TransformComponent>());
-        assert(m_game->activeScene().activeCamera().has<CameraComponent>());
-
-        Renderer::Camera rendererCamera = {
-            m_game->activeScene().activeCamera().worldTransform_noScale().inversed(),
-            m_game->activeScene().activeCamera().get<CameraComponent>().projectionMatrix()
-        };
-        
-        renderer().beginScene(rendererCamera, m_vpFrameBuff);
+        // game update
+        // TODO ? maybe move into game class
+        for (auto [scriptComponent] : m_game->activeScene().ecsWorld() | GE::ECSView<GE::ScriptComponent>())
         {
-            renderer().addRenderables(m_game->activeScene().ecsWorld(), m_editedScene->assetManager());
-            renderer().addLights(m_game->activeScene().ecsWorld());
+            if (scriptComponent.instance)
+                scriptComponent.instance->onUpdate();
         }
-        renderer().endScene();
-
-        addInputContext(&m_editorInputContext);
-        addInputContext(&m_game->inputContext());
-        setDispatchedInputContext(&m_game->inputContext());
     }
-}
 
-void Editor::onImGuiRender()
-{
-    static bool isProjectPropertiesModalPresented = false;
-    static bool isFileOpenDialogPresented = false;
-    static bool isFileSaveDialogPresented = false;
-
-    ImGui::BeginDisabled(isFileOpenDialogPresented || isFileSaveDialogPresented);
-
-    ImGui::DockSpaceOverViewport();
-
-    MainMenuBar()
-        .on_File_New(utils::Func<void()>(*this, &Editor::newProject))
-        .on_File_Open([](){ isFileOpenDialogPresented = true; })
-        .on_File_Save(m_projectSavePath.empty() ? [&](){ (void)(isFileSaveDialogPresented = true); } : utils::Func<void()>(*this, &Editor::saveProject))
-        .on_Project_ReloadScriptLib(!(m_game && m_game->isRunning()) && !m_project.scriptLib().empty() ? utils::Func<void()>(*this, &Editor::reloadScriptLib) : utils::Func<void()>())
-        .on_Project_Properties([](){ isProjectPropertiesModalPresented = true; })
-        .on_Scene_Add_EmptyEntity([&](){ m_editedScene->newEntity("new_empty_entity"); })
-        .on_Project_Run(!(m_game && m_game->isRunning()) ? utils::Func<void()>(*this, &Editor::runGame) : utils::Func<void()>())
-        .on_Project_Stop((m_game && m_game->isRunning()) ? utils::Func<void()>(*this, &Editor::stopGame) : utils::Func<void()>())
-        .render();
-
-    ViewportPanel(*static_cast<const utils::SharedPtr<gfx::FrameBuffer>&>(m_vpFrameBuff)->colorTexture())
-        .onResize(utils::Func<void(utils::uint32, utils::uint32)>(m_vpFrameBuff, &ViewportFrameBuff::resize))
-        .render();
-
-    SceneGraphPanel(m_editedScene, m_selectedEntity)
-        .onEntitySelect([&](const Entity& e){ m_selectedEntity = e; })
-        .render();
-
-    EntityInspectorPanel(m_editedScene, m_selectedEntity)
-        .onEntityDelete([&](){
-            m_selectedEntity.destroy();
-            m_selectedEntity = Entity();
-        })
-        .render();
-
-    ProjectPropertiesModal(isProjectPropertiesModalPresented, m_project, m_projectSavePath)
-        .onOk(utils::Func<void()>(*this, &Editor::reloadScriptLib))
-        .render();
-
-    ContentBrowserPanel(m_project, m_editedScene, m_getScriptNames)
-        .render();
-
-    ImGui::EndDisabled();
-
-    FileOpenDialog("Open project", isFileOpenDialogPresented)
-        .onSelection(utils::Func<void(const fs::path&)>(*this, &Editor::openProject))
-        .render();
-
-    FileSaveDialog(m_project.name() + ".geproj", isFileSaveDialogPresented)
-        .onSelection([&](const fs::path& path){
-            m_projectSavePath = path;
-            saveProject();
-        })
-        .render();
+    renderImgui();
 
     if (ImGui::GetIO().WantSaveIniSettings)
     {
-        m_project.saveIniSettingsToMemory();
+        m_project.setImguiSettings(ImGui::SaveIniSettingsToMemory());
         ImGui::GetIO().WantSaveIniSettings = false;
     }
-
-    if (ImGui::GetIO().WantCaptureKeyboard)
-        setDispatchedInputContext(nullptr);
 }
 
-void Editor::onWindowRequestCloseEvent(gfx::WindowRequestCloseEvent&)
+void Editor::onEvent(GE::Event& event)
 {
-    terminate();
+    if (event.dispatch<GE::WindowRequestCloseEvent>([&](auto&) { terminate(); })) return;
+    if (event.dispatch<GE::WindowResizeEvent>([&](auto&) { rebuildFrameGraph(); })) return;
 }
 
-void Editor::newProject()
+void Editor::loadProject(const std::filesystem::path& path)
 {
-    m_projectSavePath = fs::path();
-    m_projectNeedReload = true;
-}
+    m_projectFilePath = path; // if we allow file loading error (not terminating the program on load error)
+                              // this will need to go after the yaml parsing
+    m_project = loadProjectFile(path);
 
-void Editor::openProject(const fs::path& filePath)
-{
-    assert(fs::is_regular_file(filePath));
-    assert(filePath.is_absolute());
-    
-    m_projectSavePath = filePath;
-    m_projectNeedReload = true;
-}
+    m_editedScene = {
+        m_project.startScene().first,
+        GE::Scene(&assetManager(), m_project.startScene().second)
+    };
 
-void Editor::reloadProject()
-{
-    if (m_projectSavePath.empty())
-        m_project = Project();
-    else
-    {
-        assert(fs::is_regular_file(m_projectSavePath));
-        assert(m_projectSavePath.is_absolute());
-        m_project = json::parse(std::ifstream(m_projectSavePath));
-    }
+    ImGui::LoadIniSettingsFromMemory(m_project.imguiSettings().c_str());
 
-    reloadScriptLib();
+    if (std::filesystem::exists(m_project.scriptLib()))
+        reloadScriptLib();
 
-    m_editedScene = nullptr;
-    editScene(m_project.startScene());
+    m_selectedEntity = {};
+    m_editorCamera = {};
+}
 
-    m_project.loadIniSettingsFromMemory();
+void Editor::saveEditedScene()
+{
+    m_project.setScene(m_editedScene.first, m_editedScene.second.makeDescriptor());
 }
 
 void Editor::saveProject()
 {
-    assert(fs::is_directory(fs::path(m_projectSavePath).remove_filename()));
-    std::ofstream(m_projectSavePath) << json(m_project).dump(4);
+    saveEditedScene();
+    if (m_projectFilePath.has_parent_path())
+        std::filesystem::create_directories(m_projectFilePath.parent_path());
+
+    YAML::Emitter out;
+    out << YAML::convert<Project>::encode(m_project);
+    if (!out.good())
+        throw std::runtime_error("failed to serialize project");
+
+    std::ofstream file(m_projectFilePath);
+    if (!file.is_open())
+        throw std::runtime_error("failed to open project file for writing");
+
+    file << out.c_str();
+    if (!file.good())
+        throw std::runtime_error("failed to write project file");
 }
 
 void Editor::reloadScriptLib()
 {
-    if (m_scriptLibHandle != nullptr)
+    assert(m_game.has_value() == false);
+    assert(std::ranges::all_of(
+        m_editedScene.second.ecsWorld() | GE::ECSView<GE::ScriptComponent>(),
+        [](const auto& e) -> bool { return e.template get<0>().instance == nullptr; }
+    ));
+    assert(std::filesystem::exists(m_project.scriptLib()));
+
+    if (m_project.scriptLib().empty())
     {
-        dlFree(m_scriptLibHandle);
-        m_scriptLibHandle = nullptr;
-        m_getScriptNames = nullptr;
-        m_makeScriptInstance = nullptr;
+        m_scriptLibrary.reset();
+        return;
     }
 
-    if (m_project.scriptLib().empty() == false)
-    {
-        fs::path scriptLibPath = fs::path(m_projectSavePath).remove_filename() / m_project.scriptLib();
-        #ifdef _WIN32
-            scriptLibPath.replace_extension(".dll");
-        #endif
-        assert(scriptLibPath.is_absolute());
-        if (fs::is_regular_file(scriptLibPath) == false)
-            return;
-        m_scriptLibHandle = dlLoad(scriptLibPath.string().c_str());
-        if (m_scriptLibHandle != nullptr)
-        {
-            m_getScriptNames = (GetScriptNamesFn)getSym(m_scriptLibHandle, "getScriptNames");
-            m_makeScriptInstance = (MakeScriptInstanceFn)getSym(m_scriptLibHandle, "makeScriptInstance");
-            if (m_getScriptNames == nullptr || m_makeScriptInstance == nullptr)
-            {
-                dlFree(m_scriptLibHandle);
-                m_scriptLibHandle = nullptr;
-            }
-        }
-    }
+    m_scriptLibrary.emplace(m_project.scriptLib());
 }
 
-void Editor::editScene(Scene* scene)
+void Editor::startGame()
 {
-    if (m_editedScene)
-    {
-        assert(m_editedScene->assetManager().isLoaded());
-        m_editedScene->assetManager().unloadAssets();
-    }
-    
-    m_editedScene = scene;
-    m_editedScene->assetManager().loadAssets(renderer().graphicAPI(), fs::path(m_projectSavePath).remove_filename());
-    
-    m_selectedEntity = Entity();
-    m_editorCamera = EditorCamera();
+    assert(m_game.has_value() == false);
+    saveEditedScene();
+    m_game.emplace(&assetManager(), m_scriptLibrary ? &m_scriptLibrary.value() : nullptr, m_project.makeGameDescriptor());
+    setPrimaryInputContext(m_game->inputContext());
 }
 
-void Editor::runGame()
+void Editor::stopGame()
 {
-    Game::Descriptor gameDescriptor;
-    gameDescriptor.scenes = m_project.scenes();
-    gameDescriptor.inputContext = m_project.inputContext();
-    gameDescriptor.graphicAPI = &renderer().graphicAPI();
-    gameDescriptor.baseDir = m_projectSavePath.remove_filename();
-    gameDescriptor.makeScriptInstance = m_makeScriptInstance;
-
-    m_game = utils::makeUnique<Game>(gameDescriptor);
-    m_game->setActiveScene(m_project.startScene()->name());
+    assert(m_game.has_value());
+    setPrimaryInputContext(m_editorInputContext);
+    m_game.reset();
 }
 
-void Editor::stopGame()
+void Editor::setPrimaryInputContext(GE::InputContext& inputContext)
 {
-    m_game->stop();
+    popInputContext();
+    popInputContext();
+
+    pushInputContext(&inputContext);
+    pushInputContext(&m_imguiInputContext);
 }
 
-Editor::~Editor()
+void Editor::processDropedFiles()
 {
-    if (m_scriptLibHandle != nullptr)
+    while (const std::optional<std::filesystem::path> droppedFile = window().popDroppedFile())
     {
-        dlFree(m_scriptLibHandle);
-        m_scriptLibHandle = nullptr;
+        if (std::filesystem::is_regular_file(*droppedFile) && droppedFile->extension() == ".geproj")
+            loadProject(*droppedFile);
     }
 }
 
-void Editor::processDroppedFiles()
+void Editor::rebuildFrameGraph()
 {
-    fs::path path;
-    while (window().popDroppedFile(path))
-    {
-        if (json::accept(std::ifstream(path)))
-        {
-            json jsn = json::parse(std::ifstream(path));
-            if (jsn.find("scenes") != jsn.end() && jsn.find("imguiSettings") != jsn.end())
-            {
-                openProject(path);
-                continue;
-            }
+    std::function<GE::Scene*()> getScene = [this]() -> GE::Scene* {
+        if (m_game.has_value())
+            return &m_game->activeScene();
+        return &m_editedScene.second;
+    };
+
+    std::function<GE::ICamera*()> getCamera = [this]() -> GE::ICamera*{
+        if (m_game.has_value())
+            return nullptr;
+        return &m_editorCamera;
+    };
+
+    m_frameGraph = GE::FrameGraph(GE::FrameGraph::Descriptor{
+        .backBufferName = "windowBackBuffer",
+        .textures = {
+            { .name = "viewportBackBuffer", .size = m_viewportSize,             .pixelFormat = gfx::PixelFormat::BGRA8Unorm },
+            { .name = "depthBuffer",        .size = m_viewportSize,             .pixelFormat = gfx::PixelFormat::Depth32Float },
+            { .name = "windowBackBuffer",   .size = window().frameBufferSize(), .pixelFormat = gfx::PixelFormat::BGRA8Unorm },
+        },
+        .passes = {
+            GE::FlatGeometryPassBuilder(std::move(getScene), std::move(getCamera))
+                .setColorAttachment("viewportBackBuffer")
+                .setDepthAttachment("depthBuffer"),
+            GE::ImguiPassBuilder()
+                .setColorAttachment("windowBackBuffer")
+                .addSampledTexture("viewportBackBuffer")
         }
-
-        if (stbi_info(path.string().c_str(), nullptr, nullptr, nullptr) == 1)
-            continue;
-
-        if (m_editedScene != nullptr)
-        {
-            m_editedScene->assetManager().registerMesh(path);
-            continue;
-        }
-    }
+    });
 }
 
-}
\ No newline at end of file
+} // namespace GE_Editor
diff --git a/editor/Editor.hpp b/editor/Editor.hpp
index 1f989fe..8203a4c 100644
--- a/editor/Editor.hpp
+++ b/editor/Editor.hpp
@@ -10,81 +10,79 @@
 #ifndef EDITOR_HPP
 #define EDITOR_HPP
 
-#include "Application.hpp"
-#include "ECS/Entity.hpp"
 #include "EditorCamera.hpp"
-#include "Game.hpp"
-#include "InputManager/InputContext.hpp"
+#include "ImGuiInputContext.hpp"
 #include "Project.hpp"
-#include "Scene.hpp"
-#include "ViewportFrameBuff.hpp"
+
+#include <Game-Engine/Application.hpp>
+#include <Game-Engine/FrameGraph.hpp>
+#include <Game-Engine/InputContext.hpp>
+#include <Game-Engine/Input.hpp>
+#include <Game-Engine/ScriptLibrary.hpp>
+#include <Game-Engine/Scene.hpp>
+
+#include <imgui.h>
+
+#include <cstdint>
 #include <filesystem>
-#include "Script.hpp"
-#include "dlLoad/dlLoad.h"
+#include <optional>
+#include <utility>
 
-namespace GE
+namespace GE_Editor
 {
 
-class Editor final : public Application
+class Editor : public GE::Application
 {
 public:
-    Editor();
+    Editor() = delete;
     Editor(const Editor&) = delete;
-    Editor(Editor&&)      = delete;
+    Editor(Editor&&) = delete;
+
+    Editor(int argc, char* argv[]);
 
     void onUpdate() override;
-    void onImGuiRender() override;
-    inline void onWindowResizeEvent(gfx::WindowResizeEvent&) override {}
-    void onWindowRequestCloseEvent(gfx::WindowRequestCloseEvent&) override;
-
-    // * Functions that directly match user action
-    // * Some are also used by other functions
-    void newProject();
-    void openProject(const std::filesystem::path&);
-    void reloadProject();
+    void onEvent(GE::Event& event) override;
+
+    inline const GE::FrameGraph& frameGraph() override { return m_frameGraph; }
+
+    ~Editor() override = default;
+
+private:
+    void loadProject(const std::filesystem::path&);
+    void saveEditedScene();
     void saveProject();
     void reloadScriptLib();
-    void editScene(Scene*);
-    void runGame();
+    void startGame();
     void stopGame();
 
-    ~Editor();
-
-private:
-    // * helper functions
-    void processDroppedFiles();
+    void setPrimaryInputContext(GE::InputContext&);
+    void processDropedFiles();
 
-    // * absolut path of the project file 
-    // * (can be empty if the project hasnt been saved yet)
-    std::filesystem::path m_projectSavePath;
-    bool m_projectNeedReload = false;
+    void rebuildFrameGraph();
+    void renderImgui();
 
-    // * project data (saved to disk)
+    std::filesystem::path m_projectFilePath;
     Project m_project;
+    std::pair<uint32_t, GE::Scene> m_editedScene;
 
-    // * data derived from the project file (created at runtime, not saved)
-    DlHandle m_scriptLibHandle = nullptr;
-    GetScriptNamesFn m_getScriptNames = nullptr;
-    MakeScriptInstanceFn m_makeScriptInstance = nullptr;
-
-    // * editor state
-    // TODO save this data in the project so the last state can be preserved
-    Scene* m_editedScene = nullptr;
-    Entity m_selectedEntity;
+    GE::Entity m_selectedEntity;
     EditorCamera m_editorCamera;
-    InputContext m_editorInputContext;
 
-    // * instance used when the game is running
-    utils::UniquePtr<Game> m_game;
+    GE::InputContext m_editorInputContext;
+    ImGuiInputContext m_imguiInputContext;
+
+    std::optional<GE::Game> m_game;
+
+    std::pair<uint32_t, uint32_t> m_viewportSize = {0, 0};
+    GE::FrameGraph m_frameGraph; // TODO move into render (something like render->setGraph())
 
-    // * UI reladed data
-    ViewportFrameBuff m_vpFrameBuff;
+    std::optional<GE::ScriptLibrary> m_scriptLibrary;
 
 public:
-    Editor& operator = (const Editor&) = delete;
-    Editor& operator = (Editor&&)      = delete;
+    Editor& operator=(const Editor&) = delete;
+    Editor& operator=(Editor&&) = delete;
 };
 
-}
+} // namespace GE
 
-#endif // EDITOR_HPP
\ No newline at end of file
+#endif // EDITOR_HPP
diff --git a/editor/EditorCamera.cpp b/editor/EditorCamera.cpp
index 23b4b1e..dc6721d 100644
--- a/editor/EditorCamera.cpp
+++ b/editor/EditorCamera.cpp
@@ -3,49 +3,60 @@
  * EditorCamera.cpp
  *
  * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 13:57:19
  * ---------------------------------------------------
  */
 
 #include "EditorCamera.hpp"
-#include "Math/Constants.hpp"
-#include "Math/Vector.hpp"
-#include "Renderer/Renderer.hpp"
-#include <cmath>
 
-namespace GE
-{
+#include <Game-Engine/Scene.hpp>
+#include <Game-Engine/Components.hpp>
+
+#include <glm/glm.hpp>
+#include <glm/geometric.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <cassert>
 
-void EditorCamera::rotate(math::vec2f value)
+namespace GE_Editor
 {
-    m_rotation += math::vec3f{ value.x, value.y, 0.0F }.normalized() * 0.05;
-}
 
-void EditorCamera::move(math::vec2f value)
+namespace
 {
-    m_position += math::mat3x3::rotation(m_rotation) * math::vec3f{ value.x, 0, value.y }.normalized() * 0.15;
+
+constexpr float kMoveStepPerFrame = 5.0f / 60.0f;
+constexpr float kRotateStepPerFrame = 1.5f / 60.0f;
+
 }
 
-Renderer::Camera EditorCamera::getRendererCam()
+glm::mat4 EditorCamera::viewProjectionMatrix(float aspectRatio) const
 {
-    Renderer::Camera cam;
+    auto rotationMat = rotationMatrix();
 
-    float zs = 10000.0F / (10000.0F - 0.01F);
-    float ys = 1.0F / std::tan((float)(60 * (PI / 180.0F)) * 0.5F);
-    float xs = ys; // (ys / aspectRatio)
+    glm::vec3 pos = m_position;
+    glm::vec3 dir = rotationMat * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f);
+    glm::vec3 up = rotationMat * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f);
 
-    cam.projectionMatrix = math::mat4x4(xs,  0,  0,           0,
-                                         0, ys,  0,           0,
-                                         0,  0, zs, -0.01F * zs,
-                                         0,  0,  1,           0);
+    return glm::perspective(m_fov, aspectRatio, m_zNear, m_zFar) * glm::lookAt(pos, pos + dir, up);
+}
 
-    cam.viewMatrix = (math::mat4x4::translation(m_position) * math::mat4x4::rotation(m_rotation)).inversed();
-    return cam;
+void EditorCamera::onMoveInput(const glm::vec2& value)
+{
+    m_position += glm::vec3(rotationMatrix() * glm::vec4(glm::vec3{ value.x, 0.0f, -value.y } * kMoveStepPerFrame, 0.0f));
 }
 
+void EditorCamera::onRotationInput(const glm::vec2& value)
+{
+    m_rotation.y -= value.y * kRotateStepPerFrame;
+    m_rotation.x += value.x * kRotateStepPerFrame;
+}
 
-EditorCamera::~EditorCamera()
+glm::mat4 EditorCamera::rotationMatrix() const
 {
+    auto rotationMat = glm::mat4x4(1.0f);
+    rotationMat = glm::rotate(rotationMat, m_rotation.y, glm::vec3(0, 1, 0));
+    rotationMat = glm::rotate(rotationMat, m_rotation.x, glm::vec3(1, 0, 0));
+    rotationMat = glm::rotate(rotationMat, m_rotation.z, glm::vec3(0, 0, 1));
+    return rotationMat;
 }
 
-}
\ No newline at end of file
+}
diff --git a/editor/EditorCamera.hpp b/editor/EditorCamera.hpp
index 0f3f973..b132b41 100644
--- a/editor/EditorCamera.hpp
+++ b/editor/EditorCamera.hpp
@@ -3,42 +3,47 @@
  * EditorCamera.hpp
  *
  * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 13:51:34
  * ---------------------------------------------------
  */
 
 #ifndef EDITORCAMERA_HPP
 #define EDITORCAMERA_HPP
 
-#include "Math/Vector.hpp"
-#include "Renderer/Renderer.hpp"
+#include <Game-Engine/Scene.hpp>
+#include <Game-Engine/ICamera.hpp>
 
-namespace GE
+#include <glm/glm.hpp>
+
+namespace GE_Editor
 {
 
-class EditorCamera
+class EditorCamera : public GE::ICamera
 {
 public:
-    EditorCamera()                    = default;
-    EditorCamera(const EditorCamera&) = default;
-    EditorCamera(EditorCamera&&)      = default;
+    EditorCamera() = default;
+    EditorCamera(const EditorCamera&) = delete;
+    EditorCamera(EditorCamera&&) = default;
 
-    void rotate(math::vec2f);
-    void move(math::vec2f);
+    inline glm::vec3 position() const override { return m_position; }
+    glm::mat4 viewProjectionMatrix(float aspectRatio) const override;
 
-    Renderer::Camera getRendererCam();
-    
-    ~EditorCamera();
+    void onMoveInput(const glm::vec2& value);
+    void onRotationInput(const glm::vec2& value);
 
 private:
-    math::vec3f m_position;
-    math::vec3f m_rotation;
+    glm::mat4 rotationMatrix() const;
+
+    glm::vec3 m_position = { 0.0f, 0.0f, 0.0f };
+    glm::vec3 m_rotation = { 0.0f, 0.0f, 0.0f };
+    float m_fov = glm::radians(60.0f);
+    float m_zFar = 1000.0f;
+    float m_zNear = 0.1f;
 
 public:
-    EditorCamera& operator = (const EditorCamera&) = default;
-    EditorCamera& operator = (EditorCamera&&)      = default;
+    EditorCamera& operator=(const EditorCamera&) = delete;
+    EditorCamera& operator=(EditorCamera&&) = default;
 };
 
-}
+} // namespace GE_Editor
 
-#endif // EDITORCAMERA_HPP
\ No newline at end of file
+#endif
diff --git a/editor/ImGuiInputContext.cpp b/editor/ImGuiInputContext.cpp
new file mode 100644
index 0000000..2d89c15
--- /dev/null
+++ b/editor/ImGuiInputContext.cpp
@@ -0,0 +1,196 @@
+/*
+ * ---------------------------------------------------
+ * ImGuiInputContext.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "ImGuiInputContext.hpp"
+
+#include <Game-Engine/Event.hpp>
+
+#include <imgui.h>
+
+#include <GLFW/glfw3.h>
+
+namespace
+{
+
+ImGuiKey glfwKeyToImGuiKey(int keycode)
+{
+    switch (keycode)
+    {
+        case GLFW_KEY_TAB: return ImGuiKey_Tab;
+        case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
+        case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
+        case GLFW_KEY_UP: return ImGuiKey_UpArrow;
+        case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
+        case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
+        case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
+        case GLFW_KEY_HOME: return ImGuiKey_Home;
+        case GLFW_KEY_END: return ImGuiKey_End;
+        case GLFW_KEY_INSERT: return ImGuiKey_Insert;
+        case GLFW_KEY_DELETE: return ImGuiKey_Delete;
+        case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
+        case GLFW_KEY_SPACE: return ImGuiKey_Space;
+        case GLFW_KEY_ENTER: return ImGuiKey_Enter;
+        case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
+        case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
+        case GLFW_KEY_COMMA: return ImGuiKey_Comma;
+        case GLFW_KEY_MINUS: return ImGuiKey_Minus;
+        case GLFW_KEY_PERIOD: return ImGuiKey_Period;
+        case GLFW_KEY_SLASH: return ImGuiKey_Slash;
+        case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
+        case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
+        case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
+        case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
+        case GLFW_KEY_WORLD_1: return ImGuiKey_Oem102;
+        case GLFW_KEY_WORLD_2: return ImGuiKey_Oem102;
+        case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
+        case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
+        case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
+        case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
+        case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
+        case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
+        case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
+        case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
+        case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
+        case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
+        case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
+        case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
+        case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
+        case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
+        case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
+        case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
+        case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
+        case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
+        case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
+        case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
+        case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
+        case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
+        case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
+        case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
+        case GLFW_KEY_LEFT_SHIFT: return ImGuiKey_LeftShift;
+        case GLFW_KEY_LEFT_CONTROL: return ImGuiKey_LeftCtrl;
+        case GLFW_KEY_LEFT_ALT: return ImGuiKey_LeftAlt;
+        case GLFW_KEY_LEFT_SUPER: return ImGuiKey_LeftSuper;
+        case GLFW_KEY_RIGHT_SHIFT: return ImGuiKey_RightShift;
+        case GLFW_KEY_RIGHT_CONTROL: return ImGuiKey_RightCtrl;
+        case GLFW_KEY_RIGHT_ALT: return ImGuiKey_RightAlt;
+        case GLFW_KEY_RIGHT_SUPER: return ImGuiKey_RightSuper;
+        case GLFW_KEY_MENU: return ImGuiKey_Menu;
+        case GLFW_KEY_0: return ImGuiKey_0;
+        case GLFW_KEY_1: return ImGuiKey_1;
+        case GLFW_KEY_2: return ImGuiKey_2;
+        case GLFW_KEY_3: return ImGuiKey_3;
+        case GLFW_KEY_4: return ImGuiKey_4;
+        case GLFW_KEY_5: return ImGuiKey_5;
+        case GLFW_KEY_6: return ImGuiKey_6;
+        case GLFW_KEY_7: return ImGuiKey_7;
+        case GLFW_KEY_8: return ImGuiKey_8;
+        case GLFW_KEY_9: return ImGuiKey_9;
+        case GLFW_KEY_A: return ImGuiKey_A;
+        case GLFW_KEY_B: return ImGuiKey_B;
+        case GLFW_KEY_C: return ImGuiKey_C;
+        case GLFW_KEY_D: return ImGuiKey_D;
+        case GLFW_KEY_E: return ImGuiKey_E;
+        case GLFW_KEY_F: return ImGuiKey_F;
+        case GLFW_KEY_G: return ImGuiKey_G;
+        case GLFW_KEY_H: return ImGuiKey_H;
+        case GLFW_KEY_I: return ImGuiKey_I;
+        case GLFW_KEY_J: return ImGuiKey_J;
+        case GLFW_KEY_K: return ImGuiKey_K;
+        case GLFW_KEY_L: return ImGuiKey_L;
+        case GLFW_KEY_M: return ImGuiKey_M;
+        case GLFW_KEY_N: return ImGuiKey_N;
+        case GLFW_KEY_O: return ImGuiKey_O;
+        case GLFW_KEY_P: return ImGuiKey_P;
+        case GLFW_KEY_Q: return ImGuiKey_Q;
+        case GLFW_KEY_R: return ImGuiKey_R;
+        case GLFW_KEY_S: return ImGuiKey_S;
+        case GLFW_KEY_T: return ImGuiKey_T;
+        case GLFW_KEY_U: return ImGuiKey_U;
+        case GLFW_KEY_V: return ImGuiKey_V;
+        case GLFW_KEY_W: return ImGuiKey_W;
+        case GLFW_KEY_X: return ImGuiKey_X;
+        case GLFW_KEY_Y: return ImGuiKey_Y;
+        case GLFW_KEY_Z: return ImGuiKey_Z;
+        case GLFW_KEY_F1: return ImGuiKey_F1;
+        case GLFW_KEY_F2: return ImGuiKey_F2;
+        case GLFW_KEY_F3: return ImGuiKey_F3;
+        case GLFW_KEY_F4: return ImGuiKey_F4;
+        case GLFW_KEY_F5: return ImGuiKey_F5;
+        case GLFW_KEY_F6: return ImGuiKey_F6;
+        case GLFW_KEY_F7: return ImGuiKey_F7;
+        case GLFW_KEY_F8: return ImGuiKey_F8;
+        case GLFW_KEY_F9: return ImGuiKey_F9;
+        case GLFW_KEY_F10: return ImGuiKey_F10;
+        case GLFW_KEY_F11: return ImGuiKey_F11;
+        case GLFW_KEY_F12: return ImGuiKey_F12;
+        case GLFW_KEY_F13: return ImGuiKey_F13;
+        case GLFW_KEY_F14: return ImGuiKey_F14;
+        case GLFW_KEY_F15: return ImGuiKey_F15;
+        case GLFW_KEY_F16: return ImGuiKey_F16;
+        case GLFW_KEY_F17: return ImGuiKey_F17;
+        case GLFW_KEY_F18: return ImGuiKey_F18;
+        case GLFW_KEY_F19: return ImGuiKey_F19;
+        case GLFW_KEY_F20: return ImGuiKey_F20;
+        case GLFW_KEY_F21: return ImGuiKey_F21;
+        case GLFW_KEY_F22: return ImGuiKey_F22;
+        case GLFW_KEY_F23: return ImGuiKey_F23;
+        case GLFW_KEY_F24: return ImGuiKey_F24;
+        default: return ImGuiKey_None;
+    }
+}
+
+}
+
+namespace GE_Editor
+{
+
+void ImGuiInputContext::onInputEvent(GE::InputEvent& event)
+{
+    ImGuiIO& io = ImGui::GetIO();
+
+    event.dispatch<GE::KeyDownEvent>([&](GE::KeyDownEvent& keyDownEvent) {
+        if (keyDownEvent.isRepeat())
+            return;
+        io.AddKeyEvent(glfwKeyToImGuiKey(keyDownEvent.keyCode()), true);
+        if (io.WantCaptureKeyboard)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::KeyUpEvent>([&](GE::KeyUpEvent& keyUpEvent) {
+        io.AddKeyEvent(glfwKeyToImGuiKey(keyUpEvent.keyCode()), false);
+        if (io.WantCaptureKeyboard)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::CharEvent>([&](GE::CharEvent& charEvent) {
+        io.AddInputCharacter(charEvent.codePoint());
+        if (io.WantCaptureKeyboard)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::MouseDownEvent>([&](GE::MouseDownEvent& mouseDownEvent) {
+        io.AddMouseButtonEvent(mouseDownEvent.mouseCode(), true);
+        if (io.WantCaptureMouse)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::MouseUpEvent>([&](GE::MouseUpEvent& mouseUpEvent) {
+        io.AddMouseButtonEvent(mouseUpEvent.mouseCode(), false);
+        if (io.WantCaptureMouse)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::MouseMoveEvent>([&](GE::MouseMoveEvent& mouseMoveEvent) {
+        auto [x, y] = mouseMoveEvent.mousePos();
+        io.AddMousePosEvent(static_cast<float>(x), static_cast<float>(y));
+        if (io.WantCaptureMouse)
+            event.markAsProcessed();
+    });
+    event.dispatch<GE::ScrollEvent>([&](GE::ScrollEvent& scrollEvent) {
+        io.AddMouseWheelEvent(static_cast<float>(scrollEvent.offsetX()), static_cast<float>(scrollEvent.offsetY()));
+        if (io.WantCaptureMouse)
+            event.markAsProcessed();
+    });
+}
+
+}
diff --git a/editor/ImGuiInputContext.hpp b/editor/ImGuiInputContext.hpp
new file mode 100644
index 0000000..b91661b
--- /dev/null
+++ b/editor/ImGuiInputContext.hpp
@@ -0,0 +1,25 @@
+/*
+ * ---------------------------------------------------
+ * ImGuiInputContext.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef IMGUIINPUTCONTEXT_HPP
+#define IMGUIINPUTCONTEXT_HPP
+
+#include <Game-Engine/InputContext.hpp>
+
+namespace GE_Editor
+{
+
+class ImGuiInputContext : public GE::InputContext
+{
+public:
+    void onInputEvent(GE::InputEvent& event) override;
+};
+
+}
+
+#endif
diff --git a/editor/Project.cpp b/editor/Project.cpp
index 153b24c..36e93e1 100644
--- a/editor/Project.cpp
+++ b/editor/Project.cpp
@@ -3,123 +3,115 @@
  * Project.cpp
  *
  * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/27 18:41:09
  * ---------------------------------------------------
  */
 
 #include "Project.hpp"
-#include "ECS/Components.hpp"
-#include "Scene.hpp"
-#include <cassert>
-#include <filesystem>
-
-#define DEFAULT_IMGUI_INI                                                                                                 \
-    "[Window][WindowOverViewport_11111111]\nPos=0,19\nSize=1280,701\nCollapsed=0\n\n"                                     \
-    "[Window][Debug##Default]\nPos=60,60\nSize=400,400\nCollapsed=0\n\n"                                                  \
-    "[Window][Entity inspector]\nPos=1015,405\nSize=265,315\nCollapsed=0\nDockId=0x00000004,0\n\n"                        \
-    "[Window][Scene graph]\nPos=1015,19\nSize=265,384\nCollapsed=0\nDockId=0x00000003,0\n\n"                              \
-    "[Window][viewport]\nPos=0,19\nSize=1013,554\nCollapsed=0\nDockId=0x00000007,0\n\n"                                   \
-    "[Window][File explorer]\nPos=0,544\nSize=1013,176\nCollapsed=0\nDockId=0x00000006,0\n\n"                             \
-    "[Window][Project properties]\nPos=435,288\nSize=361,77\nCollapsed=0\n\n"                                             \
-    "[Window][Scenes]\nPos=445,309\nSize=268,102\nCollapsed=0\n\n"                                                        \
-    "[Window][Content browser]\nPos=0,575\nSize=1013,145\nCollapsed=0\nDockId=0x00000008,0\n\n"                           \
-    "[Docking][Data]\n"                                                                                                   \
-    "DockSpace       ID=0x7C6B3D9B Window=0xA87D555D Pos=100,196 Size=1280,701 Split=X Selected=0x0BA3B4F3\n"             \
-    "  DockNode      ID=0x00000001 Parent=0x7C6B3D9B SizeRef=1428,701 Split=Y Selected=0x0BA3B4F3\n"                      \
-    "      DockNode    ID=0x00000005 Parent=0x00000001 SizeRef=1013,523 Split=Y Selected=0x0BA3B4F3\n"                    \
-    "            DockNode  ID=0x00000007 Parent=0x00000005 SizeRef=1013,554 CentralNode=1 Selected=0x0BA3B4F3\n"          \
-    "                  DockNode  ID=0x00000008 Parent=0x00000005 SizeRef=1013,145 Selected=0x3995E0EF\n"                  \
-    "                      DockNode    ID=0x00000006 Parent=0x00000001 SizeRef=1013,176 Selected=0xD2F73F3F\n"            \
-    "                        DockNode      ID=0x00000002 Parent=0x7C6B3D9B SizeRef=265,701 Split=Y Selected=0xF5BE1C77\n" \
-    "                            DockNode    ID=0x00000003 Parent=0x00000002 SizeRef=168,583 Selected=0xF5BE1C77\n"       \
-    "                                DockNode    ID=0x00000004 Parent=0x00000002 SizeRef=168,479 Selected=0xD3D12213\n\n" \
-
-using json = nlohmann::json;
-namespace fs = std::filesystem;
 
-namespace GE
-{
+#include <Game-Engine/AssetManager.hpp>
+#include <Game-Engine/Scene.hpp>
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/ECSWorld.hpp>
+#include <Game-Engine/Mesh.hpp>
+#include <Game-Engine/AssetManagerView.hpp>
 
-Project::Project()
-    : m_name("new_project"),
-      m_imguiSettings(DEFAULT_IMGUI_INI)
-{
-    auto& defautScene = *m_scenes.insert(Scene("default_scene"));
-    
-    auto cube = defautScene.newEntity("cube");
-    cube.emplace<TransformComponent>();
-    cube.emplace<MeshComponent>(BUILT_IN_CUBE_ASSET_ID);
+#include <imgui.h>
 
-    auto light = defautScene.newEntity("light");
-    light.emplace<TransformComponent>().position = math::vec3f{-1.5, 1.5, -1.5};
-    light.emplace<LightComponent>();
-
-    auto camera = defautScene.newEntity("camera");
-    camera.emplace<TransformComponent>().position = math::vec3f{0.0F, 0.0F, -3.0F};
-    camera.emplace<CameraComponent>();
-
-    defautScene.setActiveCamera(camera);
-
-    m_startScene = "default_scene";
+#include <cassert>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace  {
+    constexpr std::string_view DEFAULT_IMGUI_SETTINGS =
+        "[Window][WindowOverViewport_11111111]\n"
+        "Pos=0,19\nSize=1280,701\nCollapsed=0\n\n"
+        "[Window][Debug##Default]\n"
+        "Pos=60,60\nSize=400,400\nCollapsed=0\n\n[Window][viewport]\n"
+        "Pos=0,19\nSize=1004,525\nCollapsed=0\nDockId=0x00000001,0\n\n"
+        "[Window][Scene graph]\n"
+        "Pos=1006,19\nSize=274,273\nCollapsed=0\nDockId=0x00000005,0\n\n"
+        "[Window][Entity inspector]\n"
+        "Pos=1006,294\nSize=274,426\nCollapsed=0\nDockId=0x00000006,0\n\n"
+        "[Window][Scenes]\n"
+        "Pos=0,546\nSize=1004,174\nCollapsed=0\nDockId=0x00000002,0\n\n"
+        "[Window][Project properties]\n"
+        "Pos=435,238\nSize=409,244\nCollapsed=0\n\n"
+        "[Docking][Data]\n"
+        "DockSpace     ID=0x08BD597D Window=0x1BBC0F80 Pos=0,19 Size=1280,701 Split=X\n"
+        "  DockNode    ID=0x00000003 Parent=0x08BD597D SizeRef=1004,701 Split=Y\n"
+        "    DockNode  ID=0x00000001 Parent=0x00000003 SizeRef=1280,525 CentralNode=1 Selected=0xF6034841\n"
+        "    DockNode  ID=0x00000002 Parent=0x00000003 SizeRef=1280,174 Selected=0xC73B27C0\n"
+        "  DockNode    ID=0x00000004 Parent=0x08BD597D SizeRef=274,701 Split=Y Selected=0x848E2614\n"
+        "    DockNode  ID=0x00000005 Parent=0x00000004 SizeRef=142,273 Selected=0x2C1AB1E4\n"
+        "    DockNode  ID=0x00000006 Parent=0x00000004 SizeRef=142,426 Selected=0x848E2614\n"
+        "\n";
 }
 
-void Project::deleteScene(const utils::String& name)
+namespace GE_Editor
 {
-    assert(m_startScene != name);
-    m_scenes.remove(m_scenes.find(name));
-}
 
-Scene* Project::startScene()
+Project::Project()
+    : m_name("Untitled Project")
+    , m_startScene(0)
+    , m_imguiSettings(DEFAULT_IMGUI_SETTINGS)
+    , m_resourceDir("resources")
 {
-    if (m_startScene.isEmpty())
-        return nullptr;
-    auto it = m_scenes.find(m_startScene);
-    assert(it != m_scenes.end());
-    return &*it;
+    auto [it, inserted] = m_scenes.emplace(0, GE::Scene::Descriptor());
+    assert(inserted);
+    GE::Scene::Descriptor& desc = it->second;
+
+    desc.name = "default_scene";
+    desc.activeCamera = 1;
+    desc.registredAssets = {
+        { GE::AssetPath<GE::Mesh>(), GE::BUILT_IN_CUBE_ASSET_ID }
+    };
+    desc.entities = {
+        {
+            0, {
+               GE::NameComponent{"cube"},
+               GE::TransformComponent{},
+               GE::MeshComponent{GE::BUILT_IN_CUBE_ASSET_ID}
+            }
+        },
+        {
+            1, {
+               GE::NameComponent{"camera"},
+               GE::HierarchyComponent{ .firstChild = 2 },
+               GE::TransformComponent{
+                   .position = {  3.0f, 3.0f, 5.0f },
+                   .rotation = { -0.5f, 0.5f, 0.0f },
+                   .scale    = {  1.0f, 1.0f, 1.0f }
+               },
+               GE::CameraComponent{}
+            }
+        },
+        {
+            2, {
+               GE::NameComponent{"light"},
+               GE::HierarchyComponent{ .parent = 1 },
+               GE::TransformComponent{},
+               GE::LightComponent{}
+            }
+        }
+    };
+
+    m_startScene = it->first;
 }
 
-void to_json(json& jsn, const Project& project)
+GE::Game::Descriptor Project::makeGameDescriptor() const
 {
-    jsn["name"] = std::string(project.m_name);
-    jsn["scriptsLib"] = project.m_scriptLib.string();
-
-    jsn["imguiSettings"] = std::string(project.m_imguiSettings);
-
-    json scenesJsn = json::array();
-    for (const auto& scene : project.m_scenes)
-        scenesJsn.emplace_back(scene);
-    jsn["scenes"] = scenesJsn;
-
-    jsn["startScene"] = project.m_startScene;
+    return {
+        .scenes = m_scenes
+                  | std::views::values
+                  | std::views::transform([](const GE::Scene::Descriptor& sceneDescriptor) {
+                        return std::make_pair(sceneDescriptor.name, sceneDescriptor);
+                    })
+                  | std::ranges::to<std::map<std::string, GE::Scene::Descriptor>>(),
+        .activeScene = startScene().second.name,
+        .inputContext = m_inputContext
+    };
 }
 
-void from_json(const json& jsn, Project& project)
-{
-    auto nameIt = jsn.find("name");
-    project.m_name = nameIt != jsn.end() ? utils::String(nameIt->template get<std::string>().c_str()) : utils::String("");
-
-    auto scriptsLibIt = jsn.find("scriptsLib");
-    project.m_scriptLib = scriptsLibIt != jsn.end() ? scriptsLibIt->template get<fs::path>() : fs::path();
-
-    auto imguiSettIt = jsn.find("imguiSettings");
-    if (imguiSettIt != jsn.end())
-        project.m_imguiSettings = utils::String(imguiSettIt->template get<std::string>().c_str());
-    else
-        project.m_imguiSettings = ImGui::SaveIniSettingsToMemory();
-
-    project.m_scenes.clear();
-    auto scenesIt = jsn.find("scenes");
-    if (scenesIt != jsn.end())
-    {
-        for (auto& scene : *scenesIt)
-            project.m_scenes.insert(scene.template get<Scene>());
-    }
-
-    auto startSceneNameIt = jsn.find("startScene");
-    if (startSceneNameIt != jsn.end() && project.m_scenes.contain(utils::String(startSceneNameIt->template get<std::string>().c_str())))  
-        project.m_startScene = utils::String(startSceneNameIt->template get<std::string>().c_str());
-    else
-        project.m_startScene = "";
 }
-
-}
\ No newline at end of file
diff --git a/editor/Project.hpp b/editor/Project.hpp
index 60c0725..efebf3f 100644
--- a/editor/Project.hpp
+++ b/editor/Project.hpp
@@ -3,82 +3,127 @@
  * Project.hpp
  *
  * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/27 18:40:31
  * ---------------------------------------------------
  */
 
 #ifndef PROJECT_HPP
 #define PROJECT_HPP
 
-#include "Scene.hpp"
-#include "UtilsCPP/Set.hpp"
-#include "UtilsCPP/String.hpp"
-#include <utility>
+#include <Game-Engine/Game.hpp>
+#include <Game-Engine/Scene.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
 #include <filesystem>
-#include "InputManager/InputContext.hpp"
+#include <map>
+#include <string>
+#include <utility>
 
-namespace GE
+namespace GE_Editor
 {
 
-/*
- * Mirror of the project file with a convenient set of getters and setters.
- * No complex behavior should be inserted here (like saving) and no other data than the JSON file.
- */
-
 class Project
 {
 public:
-    Project();
-    Project(const Project&) = default;
-    Project(Project&&)      = default;
-    
-    inline const utils::String& name() const { return m_name; }
-    inline void setName(const utils::String& s) { m_name = s; }
-        
-    inline const std::filesystem::path& scriptLib() const { return m_scriptLib; }
-    inline void setScriptLib(const std::filesystem::path& p) { m_scriptLib = p; }
+    Project(); // new project with default scene
+    Project(const Project&) = delete;
+    Project(Project&&) = default;
 
-    inline void loadIniSettingsFromMemory() const { ImGui::LoadIniSettingsFromMemory(m_imguiSettings); }
-    inline void saveIniSettingsToMemory() { m_imguiSettings = ImGui::SaveIniSettingsToMemory(); }
+    inline const std::string& name() const { return m_name; }
+    inline void setName(const std::string& name) { m_name = name; }
 
-    inline const utils::Set<Scene>& scenes() const { return m_scenes; }
-    
-    inline Scene& scene(const utils::String& name) { return *m_scenes.find(name); }
-    inline const Scene& scene(const utils::String& name) const { return const_cast<Project*>(this)->scene(name); }
+    inline const std::map<uint32_t, GE::Scene::Descriptor>& scenes() const { return m_scenes; }
+    inline void setScene(uint32_t id, const GE::Scene::Descriptor& desc) { m_scenes.insert_or_assign(id, desc); }
 
-    inline Scene* addScene(const Scene& s) { return &*m_scenes.insert(s); }
-    inline Scene* addScene(Scene&& s) { return &*m_scenes.insert(std::move(s)); }
+    inline std::pair<uint32_t, GE::Scene::Descriptor> startScene() const { return *m_scenes.find(m_startScene); }
+    inline void setStartScene(uint32_t id) { assert(m_scenes.contains(id)); m_startScene = id; }
 
-    void deleteScene(const utils::String& name);
-    inline void deleteScene(const Scene& s) { deleteScene(s.name()); }
+    inline const std::string& imguiSettings() const { return m_imguiSettings; }
+    inline void setImguiSettings(std::string imguiSettings) { m_imguiSettings = std::move(imguiSettings); }
 
-    Scene* startScene();
-    inline const Scene* startScene() const { return const_cast<Project*>(this)->startScene(); }
+    inline const std::filesystem::path& scriptLib() const { return m_scriptLib; }
+    inline void setScriptLib(std::filesystem::path scriptLib) { m_scriptLib = std::move(scriptLib); }
 
-    inline void setStartScene(const utils::String& name) { m_startScene = name; }
-    inline void setStartScene(const Scene& s) { setStartScene(s.name()); }
+    inline auto& inputContext(this auto&& self) { return self.m_inputContext; }
 
-    inline InputContext& inputContext() { return m_inputContext; }
-    inline const InputContext& inputContext() const { return const_cast<Project*>(this)->inputContext(); }
+    inline std::filesystem::path resourceDir() const { return m_resourceDir; }
+    inline void setResourceDir(std::filesystem::path p) { m_resourceDir = std::move(p); }
 
-    ~Project() = default;
+    GE::Game::Descriptor makeGameDescriptor() const;
 
 private:
-    utils::String m_name;
+    std::string m_name;
+    std::map<uint32_t, GE::Scene::Descriptor> m_scenes;
+    uint32_t m_startScene;
+    std::string m_imguiSettings;
     std::filesystem::path m_scriptLib;
-    utils::String m_imguiSettings;
-    utils::Set<Scene> m_scenes;
-    utils::String m_startScene;
-    InputContext m_inputContext; // TODO add to json 
+    GE::InputContext m_inputContext;
+    std::filesystem::path m_resourceDir;
 
 public:
-    Project& operator = (const Project&) = default;
-    Project& operator = (Project&&)      = default;
+    Project& operator = (const Project&) = delete;
+    Project& operator = (Project&&) = default;
 
-    friend void to_json(nlohmann::json&, const Project&);
-    friend void from_json(const nlohmann::json&, Project&);
+    friend struct YAML::convert<Project>;
+};
+
+}
+
+namespace YAML
+{
+
+template<>
+struct convert<GE_Editor::Project>
+{
+    static Node encode(const GE_Editor::Project& rhs)
+    {
+        Node node;
+        node["name"] = rhs.m_name;
+        node["imguiSettings"] = rhs.m_imguiSettings;
+        node["scriptsLib"] = (rhs.m_scriptLib.extension() == GE_SHARED_LIBRARY_EXTENSION
+                              ? std::filesystem::path(rhs.m_scriptLib).replace_extension()
+                              : rhs.m_scriptLib).string();
+        node["inputContext"] = rhs.m_inputContext;
+        node["resourceDir"] = rhs.m_resourceDir.string();
+        for (const auto& [_, scene] : rhs.m_scenes)
+            node["scenes"].push_back(scene);
+        node["startScene"] = rhs.startScene().second.name;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE_Editor::Project& rhs)
+    {
+        if (!node.IsMap() || !node["name"] || !node["startScene"])
+            return false;
+        if (!node["scenes"] || !node["scenes"].IsSequence() || node["scenes"].size() == 0)
+            return false;
+
+        rhs.m_name = node["name"].as<std::string>();
+        rhs.m_imguiSettings = node["imguiSettings"] ? node["imguiSettings"].as<std::string>() : std::string();
+        rhs.m_scriptLib = node["scriptsLib"] ? std::filesystem::path(node["scriptsLib"].as<std::string>()) : std::filesystem::path();
+        if (!rhs.m_scriptLib.empty() && rhs.m_scriptLib.extension() != GE_SHARED_LIBRARY_EXTENSION)
+            rhs.m_scriptLib.replace_extension(GE_SHARED_LIBRARY_EXTENSION);
+        rhs.m_inputContext = node["inputContext"] ? node["inputContext"].as<GE::InputContext>() : GE::InputContext();
+        rhs.m_resourceDir = node["resourceDir"] ? std::filesystem::path(node["resourceDir"].as<std::string>()) : std::filesystem::path();
+
+        rhs.m_scenes.clear();
+        uint32_t sceneId = 0;
+        for (const Node& sceneNode : node["scenes"])
+            rhs.m_scenes.emplace(sceneId++, sceneNode.as<GE::Scene::Descriptor>());
+
+        const std::string startSceneName = node["startScene"].as<std::string>();
+        auto startScene = std::ranges::find_if(rhs.m_scenes, [&](auto& scene) -> bool {
+            return scene.second.name == startSceneName;
+        });
+        if (startScene == rhs.m_scenes.end())
+            return false;
+        rhs.m_startScene = startScene->first;
+
+        return true;
+    }
 };
 
 }
 
-#endif // PROJECT_HPP
\ No newline at end of file
+#endif // PROJECT_HPP
diff --git a/editor/UI/ContentBrowserPanel.cpp b/editor/UI/ContentBrowserPanel.cpp
deleted file mode 100644
index a2ccc8a..0000000
--- a/editor/UI/ContentBrowserPanel.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * ---------------------------------------------------
- * ContentBrowserPanel.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/06 14:48:45
- * ---------------------------------------------------
- */
-
-#include "UI/ContentBrowserPanel.hpp"
-#include "Script.hpp"
-#include <cstring>
-
-#define ELEMENT_SIZE 60.0F
-
-namespace GE
-{
-
-ContentBrowserPanel::ContentBrowserPanel(Project& project, const Scene* scene, GetScriptNamesFn getScriptNames)
-    : m_project(project), m_scene(scene), m_getScriptNames(getScriptNames)
-{
-}
-
-void ContentBrowserPanel::render()
-{
-    if (ImGui::Begin("Content browser"))
-    {
-        renderScenes();
-        renderAssets();
-        renderScripts();
-    }
-    ImGui::End();
-}
-
-void ContentBrowserPanel::renderElement(const utils::String& name, const char *payloadType, const void* payload, utils::uint64 payloadSize)
-{
-    if (ImGui::BeginChild(name + "childId", ImVec2(ELEMENT_SIZE, ELEMENT_SIZE + ImGui::GetFrameHeightWithSpacing())))
-    {
-        ImGui::Button(name, ImVec2(ELEMENT_SIZE, ELEMENT_SIZE));
-        if (ImGui::BeginDragDropSource())
-        {
-            ImGui::SetDragDropPayload(payloadType, payload, payloadSize);
-            ImGui::Text("%s", (const char*)name);
-            ImGui::EndDragDropSource();
-        }
-        ImGui::Text("%s", (const char*)name);
-    }
-    ImGui::EndChild();
-
-    m_lineWith += ELEMENT_SIZE + 7.5F;
-    if (m_lineWith < ImGui::GetContentRegionAvail().x - ELEMENT_SIZE)
-        ImGui::SameLine();
-    else
-        m_lineWith = 0.0F;
-
-}
-
-void ContentBrowserPanel::renderScenes()
-{
-    for (auto& scene : m_project.scenes())
-        renderElement(scene.name(), "scene_dnd", (void*)(const char*)scene.name(), scene.name().length());
-}
-
-void ContentBrowserPanel::renderAssets()
-{
-    if (m_scene == nullptr)
-        return;
-
-    for (auto& [path, id] : m_scene->assetManager().registeredMeshes())
-        renderElement(path.filename().string().c_str(), "mesh_dnd", &id, sizeof(id));
-}
-
-void ContentBrowserPanel::renderScripts()
-{
-    if (m_getScriptNames == nullptr)
-        return;
-
-    const char** scriptNames;
-    utils::uint64 scriptCount;
-    m_getScriptNames(&scriptNames, &scriptCount);
-
-    for (utils::uint64 i = 0; i < scriptCount; i++)
-        renderElement(scriptNames[i], "script_dnd", scriptNames[i], strlen(scriptNames[i]));
-}
-
-
-}
\ No newline at end of file
diff --git a/editor/UI/ContentBrowserPanel.hpp b/editor/UI/ContentBrowserPanel.hpp
deleted file mode 100644
index 8a1e3f4..0000000
--- a/editor/UI/ContentBrowserPanel.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * ---------------------------------------------------
- * ContentBrowserPanel.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/06 14:16:00
- * ---------------------------------------------------
- */
-
-#ifndef CONTENTBROWSERPANEL_HPP
-#define CONTENTBROWSERPANEL_HPP
-
-#include "Project.hpp"
-#include "Scene.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/Types.hpp"
-#include "Script.hpp"
-
-namespace GE
-{
-
-class ContentBrowserPanel
-{
-public:
-    ContentBrowserPanel()                           = delete;
-    ContentBrowserPanel(const ContentBrowserPanel&) = delete;
-    ContentBrowserPanel(ContentBrowserPanel&&)      = delete;
-    
-    ContentBrowserPanel(Project&, const Scene*, GetScriptNamesFn);
-
-    void render();
-
-    ~ContentBrowserPanel() = default;
-
-private:
-    void renderElement(const utils::String& name, const char *payloadType, const void* payload, utils::uint64 payloadSize);
-
-    void renderScenes();
-    void renderAssets();
-    void renderScripts();
-
-    Project& m_project;
-    const Scene* m_scene;
-    GetScriptNamesFn m_getScriptNames;
-
-    float m_lineWith = 0.0F;
-
-public:
-    ContentBrowserPanel& operator = (const ContentBrowserPanel&) = delete;
-    ContentBrowserPanel& operator = (ContentBrowserPanel&&)      = delete;
-};
-
-}
-
-#endif // CONTENTBROWSERPANEL_HPP
\ No newline at end of file
diff --git a/editor/UI/EditorUI.cpp b/editor/UI/EditorUI.cpp
deleted file mode 100644
index 64e733e..0000000
--- a/editor/UI/EditorUI.cpp
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
- * ---------------------------------------------------
- * EditorUI.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/10 12:54:44
- * ---------------------------------------------------
- */
-
-#if 0
-struct OpenProjectFileDialog
-{
-    bool isPresented = false;
-    std::future<char*> result;
-
-    void present()
-    {
-        isPresented = true;
-        result = std::async(tinyfd_openFileDialog, "Open project", "", 0, nullptr, nullptr, 0);
-    }
-};
-
-struct SaveProjectFileDialog
-{
-    bool isPresented = false;
-    std::future<char*> result;
-
-    void present(const utils::String& projectName)
-    {
-        isPresented = true;
-        result = std::async(tinyfd_saveFileDialog, "Choose destination", projectName + ".geproj", 0, nullptr, nullptr);
-    }
-};
-
-void Editor::onImGuiRender()
-{
-    static bool showProjectProperties = false;
-    static bool showProjectScenes = false;
-    static bool showDemoWindow = false;
-    static bool showMetricsWindow = false;
-
-    static char projectNameBuff[32];
-    static char projectRessourceDirBuff[1024];
-    static char projectScriptsDirBuff[1024];
-    static char projectBuildDirBuff[1024];
-
-    static OpenProjectFileDialog openProjectFileDialog;
-    static SaveProjectFileDialog saveProjectFileDialog;
-
-    ImGui::DockSpaceOverViewport();
-
-    ImGui::BeginDisabled(openProjectFileDialog.isPresented || saveProjectFileDialog.isPresented);
-
-    if (ImGui::BeginMainMenuBar())
-    {
-        if (ImGui::BeginMenu("File"))
-        {
-            ImGui::BeginDisabled();
-            if (ImGui::MenuItem("New"))
-                ;
-            ImGui::EndDisabled();
-
-            if (ImGui::MenuItem("Open"))
-                openProjectFileDialog.present();
-
-            if (ImGui::MenuItem("Save"))
-            {
-                if (m_projectFilePath.empty())
-                    saveProjectFileDialog.present(m_projectName);
-                else
-                    saveProject();
-            }
-
-            ImGui::EndMenu();
-        }
-
-        if (ImGui::BeginMenu("Project"))
-        {
-            if (ImGui::MenuItem("Properties"))
-            {
-                std::strncpy(projectNameBuff,         (const char*)m_projectName,     sizeof(projectNameBuff));
-                std::strncpy(projectRessourceDirBuff, m_projectRessourcesDir.c_str(), sizeof(projectRessourceDirBuff));
-                std::strncpy(projectScriptsDirBuff,   m_projectScriptsDir.c_str(),    sizeof(projectScriptsDirBuff));
-                std::strncpy(projectBuildDirBuff,     m_projectBuildDir.c_str(),      sizeof(projectBuildDirBuff));
-                showProjectProperties = true;
-            }
-            if (ImGui::MenuItem("Scene"))
-                showProjectScenes = true;
-            
-            ImGui::BeginDisabled();
-            if (ImGui::MenuItem("Run"))
-                ;
-
-            if (ImGui::MenuItem("Stop"))
-                ;
-            ImGui::EndDisabled();
-
-            ImGui::EndMenu();
-        }
-
-        ImGui::BeginDisabled(m_editedScene == nullptr);
-        if (ImGui::BeginMenu("Scene"))
-        {
-            if (ImGui::BeginMenu("New"))
-            {
-                if (ImGui::MenuItem("Empty entity"))
-                    m_selectedEntity = m_editedScene->newEntity("new_entity");
-                if (ImGui::MenuItem("Cube"))
-                {
-                    m_selectedEntity = m_editedScene->newEntity("cube");
-                    m_selectedEntity.emplace<TransformComponent>();
-                    m_selectedEntity.emplace<MeshComponent>(BUILT_IN_CUBE_ASSET_ID);
-                }
-                if (ImGui::MenuItem("Light"))
-                {
-                    m_selectedEntity = m_editedScene->newEntity("light");
-                    m_selectedEntity.emplace<TransformComponent>();
-                    m_selectedEntity.emplace<LightComponent>();
-                }
-                ImGui::EndMenu();
-            }
-            ImGui::EndMenu();
-        }
-        ImGui::EndDisabled();
-
-        if (ImGui::BeginMenu("Debug"))
-        {
-            if (ImGui::MenuItem("Show demo window"))
-                showDemoWindow = true;
-            if (ImGui::MenuItem("show metrics window"))
-                showMetricsWindow = true;
-            ImGui::BeginDisabled(m_scriptLibHandle == nullptr || m_editedScene == nullptr);
-            if (ImGui::MenuItem("start edited scene"))
-            {
-                using makeScriptInstanceFunc = GE::Script* (*)(char*);
-
-                m_runningScene = *m_editedScene;
-                ECSView<ScriptComponent>(m_runningScene.ecsWorld()).onEach([&](Entity entt, ScriptComponent& scriptComponent){
-                    auto makeScriptInstance = (makeScriptInstanceFunc)dlsym(m_scriptLibHandle, "makeScriptInstance");
-                    assert(makeScriptInstance);
-                    scriptComponent.instance = utils::SharedPtr<Script>(makeScriptInstance(scriptComponent.name));
-                    scriptComponent.instance->setEntity(entt);
-                });
-                m_isSceneRunning = true;
-            }
-            ImGui::EndDisabled();
-            ImGui::BeginDisabled(m_scriptLibHandle == nullptr || m_editedScene == nullptr || m_isSceneRunning == false);
-            if (ImGui::MenuItem("stop edited scene"))
-            {
-                m_runningScene = Scene();
-                m_isSceneRunning = false;
-            }
-            ImGui::EndDisabled();
-            ImGui::EndMenu();
-        }
-            
-        ImGui::EndMainMenuBar();
-    }
-
-    if (ImGui::Begin("viewport"))
-    {
-        ImVec2 contentRegionAvai = ImGui::GetContentRegionAvail();
-        m_viewportPanelW = contentRegionAvai.x == 0 ? 1 : contentRegionAvai.x;
-        m_viewportPanelH = contentRegionAvai.y == 0 ? 1 : contentRegionAvai.y;
-
-        auto texture = m_viewportFBuff->colorTexture();
-        ImGui::Image(texture->imguiTextureId(), contentRegionAvai, texture->imguiUV0(), texture->imguiUV1());
-    }
-    ImGui::End();
-
-    if (ImGui::Begin("Scene graph"))
-    {
-        if (ImGui::BeginChild("scene_graph_child"))
-        {
-            if (m_editedScene)
-            {
-                utils::Func<void(Entity)> renderRow = [&](Entity entity){
-                    bool node_open = false;
-                    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow        |
-                                                ImGuiTreeNodeFlags_OpenOnDoubleClick |
-                                                ImGuiTreeNodeFlags_SpanAvailWidth    |
-                                                ImGuiTreeNodeFlags_DefaultOpen;
-
-                    if (m_selectedEntity == entity)
-                        flags |= ImGuiTreeNodeFlags_Selected;
-
-                    if (entity.childCount() > 0)
-                        node_open = ImGui::TreeNodeEx(entity.imGuiID(), flags, "%s", (const char*)entity.name());
-                    else
-                    {
-                        flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
-                        ImGui::TreeNodeEx(entity.imGuiID(), flags, "%s", (const char*)entity.name());
-                    }
-
-                    if (ImGui::BeginDragDropSource())
-                    {
-                        ImGui::SetDragDropPayload("dnd_entity", &entity, sizeof(Entity));
-                        ImGui::Text("%s", (char*)entity.name());
-                        ImGui::EndDragDropSource();
-                    }
-
-                    if (ImGui::BeginDragDropTarget())
-                    {
-                        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_entity"))
-                        {
-                            assert(payload->DataSize == sizeof(Entity));
-                            Entity dragEntity = *(Entity*)payload->Data;
-                            assert(&dragEntity.ecsWorld() == &entity.ecsWorld());
-                            if (entity != dragEntity && dragEntity.isParentOf(entity) == false)
-                            {
-                                dragEntity.removeParent();
-                                entity.addChild(dragEntity);
-                            }
-                        }
-                        ImGui::EndDragDropTarget();
-                    }
-
-                    if (ImGui::IsItemClicked())
-                        m_selectedEntity = entity;
-
-                    if (node_open && entity.childCount() > 0)
-                    {
-                        for (Entity curr = entity.firstChild(); curr; curr = curr.nextChild() )
-                            renderRow(curr);
-                        ImGui::TreePop();
-                    }
-                };
-
-                ECSView<NameComponent>(m_editedScene->ecsWorld()).onEach([&](Entity entity, NameComponent&) {
-                    if (entity.hasParent() == false)
-                        renderRow(entity);
-                });
-
-            }
-            else
-            {
-                ImGui::Text("No scene edited");
-            }
-            ImGui::EndChild();
-        }
-        if (ImGui::BeginDragDropTarget())
-        {
-            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_entity"))
-            {
-                assert(payload->DataSize == sizeof(Entity));
-                Entity dragEntity = *(Entity*)payload->Data;
-                dragEntity.removeParent();
-            }
-            ImGui::EndDragDropTarget();
-        }
-    }
-    ImGui::End();
-
-    if (ImGui::Begin("Entity inspector"))
-    {
-        ImGui::PushItemWidth(-80);
-        if (m_editedScene == nullptr)
-            ImGui::Text("No scene edited");
-        else if (m_selectedEntity == false)
-            ImGui::Text("No entity selected");
-        else
-        {
-            NameComponent& nameComponent = m_selectedEntity.get<NameComponent>();
-            char buff[32];
-            std::strncpy(buff, nameComponent.name, sizeof(buff));
-            ImGui::InputText("Name##NameComponent", buff, sizeof(buff));
-            nameComponent.name = utils::String(buff);
-
-            if (m_selectedEntity.has<TransformComponent>())
-            {
-                bool isOpen = ImGui::CollapsingHeader("Transform component", ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-                ImGui::SameLine(0, 30);
-                if (ImGui::Button("remove##TransformComponent"))
-                    m_selectedEntity.remove<TransformComponent>();
-                else if (isOpen)
-                {
-                    TransformComponent& transform = m_selectedEntity.get<TransformComponent>();
-                    ImGui::DragFloat3("position", (float*)&transform.position, 0.01f, -1000.0f, 1000.0f);
-                    ImGui::DragFloat3("rotation", (float*)&transform.rotation, 0.01f,    -2*PI,    2*PI);
-                    ImGui::DragFloat3("scale",    (float*)&transform.scale,    0.01f,     0.0f,   10.0f);
-                }
-            }
-
-            if (m_selectedEntity.has<CameraComponent>())
-            {
-                bool isOpen = ImGui::CollapsingHeader("Camera component", ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-                ImGui::SameLine(0, 30);
-                if (ImGui::Button("remove##CameraComponent"))
-                    m_selectedEntity.remove<CameraComponent>();
-                else if (isOpen)
-                {
-                    CameraComponent& cameraComponent = m_selectedEntity.get<CameraComponent>();
-                    if (m_editedScene->activeCamera() == m_selectedEntity)
-                        ImGui::Text("Active");
-                    else if (ImGui::Button("Make active"))
-                        m_editedScene->setActiveCamera(m_selectedEntity);
-                    ImGui::DragFloat("fov",   &cameraComponent.fov,   0.01f,  -2*PI,     2*PI);
-                    ImGui::DragFloat("zFar",  &cameraComponent.zFar,  0.01f, 0.001f, 10000.0f);
-                    ImGui::DragFloat("zNear", &cameraComponent.zNear, 0.01f, 0.001f, 10000.0f);
-                }
-            }
-
-            if (m_selectedEntity.has<LightComponent>())
-            {
-                bool isOpen = ImGui::CollapsingHeader("Light component", ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-                ImGui::SameLine(0, 30);
-                if (ImGui::Button("remove##LightComponent"))
-                    m_selectedEntity.remove<LightComponent>();
-                else if (isOpen)
-                {
-                    LightComponent& lightComponent = m_selectedEntity.get<LightComponent>();
-                    ImGui::ColorEdit3("color", (float*)&lightComponent.color);
-                    ImGui::DragFloat("intentsity", &lightComponent.intentsity, 0.01, 0.0f, 1.0f);
-                }
-            }
-
-            if (m_selectedEntity.has<MeshComponent>())
-            {
-                bool isOpen = ImGui::CollapsingHeader("Mesh component", ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-                ImGui::SameLine(0, 30);
-                if (ImGui::Button("remove##MeshComponent"))
-                    m_selectedEntity.remove<MeshComponent>();
-                else if (isOpen)
-                {
-                    MeshComponent& meshComponent = m_selectedEntity.get<MeshComponent>();
-                    if (ImGui::BeginCombo("Mesh", meshComponent.assetId.is_nil() ? "" : m_editedScene->assetManager().loadedMeshes()[meshComponent.assetId].name))
-                    {
-                        for (auto& [id, mesh] : m_editedScene->assetManager().loadedMeshes())
-                        {
-                            const bool is_selected = (meshComponent == id);
-                            if (ImGui::Selectable(mesh.name, is_selected))
-                                meshComponent.assetId = id;
-                            if (is_selected)
-                                ImGui::SetItemDefaultFocus();
-                        }
-                        ImGui::EndCombo();
-                    }          
-                    if (ImGui::BeginDragDropTarget())
-                    {
-                        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_file"))
-                        {
-                            fspath path = (char*)payload->Data;
-                            meshComponent.assetId = m_editedScene->assetManager().registerMesh(path);
-                        }
-                        ImGui::EndDragDropTarget();
-                    }     
-                }
-            }
-
-            if (m_selectedEntity.has<ScriptComponent>())
-            {
-                bool isOpen = ImGui::CollapsingHeader("Script component", ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-                ImGui::SameLine(0, 30);
-                if (ImGui::Button("remove##ScriptComponent"))
-                    m_selectedEntity.remove<ScriptComponent>();
-                else if (isOpen)
-                {
-                    ScriptComponent& scriptComponent = m_selectedEntity.get<ScriptComponent>();
-                    ImGui::Text("%s", scriptComponent.name.isEmpty() ? "no script" : (const char*)scriptComponent.name);
-                    if (ImGui::BeginDragDropTarget())
-                    {
-                        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_script"))
-                            scriptComponent.name = (char*)payload->Data;
-                        ImGui::EndDragDropTarget();
-                    }
-                }
-            }
-
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::Spacing();
-
-            if (ImGui::Button("Add component"))
-                ImGui::OpenPopup("ADD_COMP_POPUP");
-            if (ImGui::BeginPopup("ADD_COMP_POPUP"))
-            {
-                if (m_selectedEntity.has<TransformComponent>() == false && ImGui::Selectable("Transform component"))
-                    m_selectedEntity.emplace<TransformComponent>();
-
-                if (m_selectedEntity.has<CameraComponent>() == false && ImGui::Selectable("Camera component"))
-                    m_selectedEntity.emplace<CameraComponent>();
-
-                if (m_selectedEntity.has<LightComponent>() == false && ImGui::Selectable("Light component"))
-                    m_selectedEntity.emplace<LightComponent>();
-                
-                if (m_selectedEntity.has<MeshComponent>() == false && ImGui::Selectable("Mesh component"))
-                    m_selectedEntity.emplace<MeshComponent>();
-
-                if (m_selectedEntity.has<ScriptComponent>() == false && ImGui::Selectable("Script component"))
-                    m_selectedEntity.emplace<ScriptComponent>();
-
-                ImGui::EndPopup();
-            }
-
-            ImGui::SameLine();
-
-            if (ImGui::Button("Delete enitity"))
-            {
-                m_selectedEntity.destroy();
-                m_selectedEntity = Entity();
-            }
-                
-        }
-        ImGui::PopItemWidth();
-    }
-    ImGui::End();
-
-    if (ImGui::Begin("File explorer"))
-    {
-        assert(m_fileExplorerPath.is_absolute());
-        assert(std::filesystem::is_directory(m_fileExplorerPath));
-
-        std::filesystem::path curr;
-        
-        auto pathIt = m_fileExplorerPath.begin();
-        curr /= *pathIt;
-        if (ImGui::Button(pathIt->c_str()))
-            m_fileExplorerPath = curr;
-
-        ++pathIt;
-        for (; pathIt != m_fileExplorerPath.end(); ++pathIt) {
-            if (pathIt->string().length() > 0)
-            {
-                curr /= *pathIt;
-                ImGui::SameLine();
-                if (ImGui::Button(pathIt->c_str()))
-                    m_fileExplorerPath = curr;
-            }
-        }
-
-        if (ImGui::BeginChild("file_explorer_files"))
-        {
-            float lineWith = 0.0F;
-            for (auto const& dir_entry : std::filesystem::directory_iterator(m_fileExplorerPath)) 
-            {
-                if (ImGui::BeginChild(dir_entry.path().filename().c_str(), ImVec2(60, 60 + ImGui::GetFrameHeightWithSpacing())))
-                {
-                    std::string id = dir_entry.path().string();
-                    std::string extension = dir_entry.path().filename().extension();
-                    std::string fileName = dir_entry.path().filename();
-
-                    if (dir_entry.is_directory())
-                    {
-                        ImGui::Button(("dir##" + id).c_str(), ImVec2(60, 60));
-                        if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(0))
-                            m_fileExplorerPath = dir_entry.path();
-                    }
-                    else
-                    {
-                        if (dir_entry.path().has_extension())
-                            ImGui::Button((extension + "##" + id).c_str(), ImVec2(60, 60));    
-                        else
-                            ImGui::Button((fileName + "##" + id).c_str(), ImVec2(60, 60));
-
-                        if (ImGui::BeginDragDropSource())
-                        {
-                            fspath relativePath;
-                            if (m_projectFilePath.empty() || std::filesystem::is_directory(fspath(m_projectFilePath).remove_filename() / m_projectRessourcesDir) == false)
-                                relativePath = dir_entry.path();
-                            else
-                                relativePath = std::filesystem::relative(dir_entry.path(), fspath(m_projectFilePath).remove_filename() / m_projectRessourcesDir);
-                            ImGui::SetDragDropPayload("dnd_file", relativePath.c_str(), strlen(relativePath.c_str()) + 1);
-                            ImGui::Text("%s", relativePath.filename().c_str());
-                            ImGui::EndDragDropSource();
-                        }
-                    }
-
-                    ImGui::Text("%s", dir_entry.path().filename().c_str());
-                }
-                ImGui::EndChild();
-
-                lineWith += 67.5F;
-                if (lineWith < ImGui::GetContentRegionAvail().x - 60.0f)
-                    ImGui::SameLine();
-                else
-                    lineWith = 0.0F;
-            }
-        }
-        ImGui::EndChild();
-    }
-    ImGui::End();
-
-    if (ImGui::Begin("Content explorer"))
-    {
-        if (m_scriptLibHandle != nullptr)
-        {
-            using getScriptNamesFunc = void (*)(char***, unsigned long*);
-            char** scriptNames;
-            utils::uint64 scriptCount;
-            auto getScriptNames = (getScriptNamesFunc)dlsym(m_scriptLibHandle, "getScriptNames");
-            getScriptNames(&scriptNames, &scriptCount);
-
-            float lineWith = 0.0F;
-            for (utils::uint64 i = 0; i < scriptCount; i++)
-            {
-                if (ImGui::BeginChild(scriptNames[i], ImVec2(60, 60 + ImGui::GetFrameHeightWithSpacing())))
-                {
-                    ImGui::Button("script", ImVec2(60, 60));
-                    if (ImGui::BeginDragDropSource())
-                    {
-                        ImGui::SetDragDropPayload("dnd_script", scriptNames[i], strlen(scriptNames[i]));
-                        ImGui::Text("%s", scriptNames[i]);
-                        ImGui::EndDragDropSource();
-                    }
-                    ImGui::Text("%s", scriptNames[i]);
-                }
-                ImGui::EndChild();
-
-                lineWith += 67.5F;
-                if (lineWith < ImGui::GetContentRegionAvail().x - 60.0f)
-                    ImGui::SameLine();
-                else
-                    lineWith = 0.0F;
-            }
-        }
-        else
-            ImGui::Text("lib script lib");
-    }
-    ImGui::End();
-
-    if (showProjectProperties)
-        ImGui::OpenPopup("Project properties");
-    if (ImGui::BeginPopupModal("Project properties", &showProjectProperties, ImGuiWindowFlags_AlwaysAutoResize))
-    {
-        ImGui::InputText("Name##projectName", projectNameBuff, sizeof(projectNameBuff));
-        ImGui::InputText("Ressource directory##projectRessourcesDir", projectRessourceDirBuff, sizeof(projectRessourceDirBuff));
-        ImGui::InputText("Script directory##projectScriptsDir", projectScriptsDirBuff, sizeof(projectScriptsDirBuff));
-        ImGui::InputText("Build directory##projectBuildDir", projectBuildDirBuff, sizeof(projectBuildDirBuff));
-
-        if (ImGui::Button("Cancel"))
-        {
-            showProjectProperties = false;
-            ImGui::CloseCurrentPopup();
-        }
-
-        bool isAllDirValid = true;
-        for (char* dir : { projectRessourceDirBuff, projectScriptsDirBuff })
-        {
-            isAllDirValid &= (fspath(dir).empty() || (
-                    fspath(dir).is_absolute() &&
-                    std::filesystem::is_directory(fspath(dir))
-                ) || (
-                    m_projectFilePath.empty() == false &&
-                    (fspath(m_projectFilePath).remove_filename() / fspath(dir)).is_absolute() &&
-                    std::filesystem::is_directory(fspath(m_projectFilePath).remove_filename() / fspath(dir))
-                )
-            );
-        }
-
-        ImGui::SameLine();
-        ImGui::BeginDisabled(!isAllDirValid);
-        if (ImGui::Button("Ok"))
-        {
-            m_projectName = projectNameBuff;
-            m_projectRessourcesDir = projectRessourceDirBuff;
-            m_projectScriptsDir = projectScriptsDirBuff;
-            m_projectBuildDir = projectBuildDirBuff;
-
-            showProjectProperties = false;
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndDisabled();
-        ImGui::EndPopup();
-    }
-
-    if (showProjectScenes)
-        ImGui::OpenPopup("Scenes");
-    if (ImGui::BeginPopupModal("Scenes", &showProjectScenes, ImGuiWindowFlags_AlwaysAutoResize))
-    {
-        ImGui::Text("Start scene: %s", (char*)utils::String(m_startScene ? m_startScene->name() : "None"));
-
-        if (ImGui::Button("Create new scene"))
-        {
-            utils::String name = "new_scene";
-            if (m_scenes.contain(name))
-            {
-                utils::uint32 i = 1;
-                do {
-                    name = "new_scene" + utils::String::fromUInt(i++);
-                } while (m_scenes.contain(name));
-            }
-            m_scenes.insert(Scene(name));
-        }
-        
-        ImGui::Spacing();
-        
-        const ImGuiTableFlags flags = ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingFixedFit;
-        if (ImGui::BeginTable("table_scrolly", 2, flags, ImVec2(0, ImGui::GetFrameHeightWithSpacing() * (m_scenes.size() > 15 ? 15 : m_scenes.size()))))
-        {
-            ImGui::TableSetupColumn("1", ImGuiTableColumnFlags_WidthFixed, 150.0f);
-            ImGui::TableSetupColumn("2");
-
-            for (auto& scene : m_scenes)
-            {
-                ImGui::TableNextRow();
-
-                ImGui::TableSetColumnIndex(0);
-                ImGui::PushItemWidth(-FLT_MIN);
-
-                char buff[32];
-                std::strncpy(buff, scene.name(), sizeof(buff));
-                ImGui::InputText("##SceneName" + utils::String::fromUInt((utils::uint32)(utils::uint64)&scene), buff, sizeof(buff));
-                scene.setName(utils::String(buff));
-
-                ImGui::TableSetColumnIndex(1);
-                ImGui::PushItemWidth(-FLT_MIN);
-
-                if (ImGui::Button("Edit##" + scene.name()))
-                {
-                    editScene(&scene);
-                    showProjectScenes = false;
-                    ImGui::CloseCurrentPopup();
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("Delete##" + scene.name()) && &scene != m_editedScene)
-                {
-                    m_scenes.remove(m_scenes.find(scene.name()));
-                    break;
-                }
-            }
-
-            ImGui::EndTable();
-        }
-
-        ImGui::EndPopup();
-    }
-
-    if (showDemoWindow)
-        ImGui::ShowDemoWindow(&showDemoWindow);
-
-    if (showMetricsWindow)
-        ImGui::ShowMetricsWindow(&showMetricsWindow);
-
-    ImGui::EndDisabled();
-
-    if (openProjectFileDialog.isPresented && openProjectFileDialog.result.wait_for(std::chrono::nanoseconds(1)) == std::future_status::ready)
-    {
-        if (char* path = openProjectFileDialog.result.get())
-            openProject(path);
-        openProjectFileDialog.isPresented = false;
-    }
-    if (saveProjectFileDialog.isPresented && saveProjectFileDialog.result.wait_for(std::chrono::nanoseconds(1)) == std::future_status::ready)
-    {
-        if (char* path = saveProjectFileDialog.result.get())
-        {
-            m_projectFilePath = path;
-            saveProject();
-        }
-        saveProjectFileDialog.isPresented = false;
-    }
-}
-#endif
\ No newline at end of file
diff --git a/editor/UI/EditorUI.hpp b/editor/UI/EditorUI.hpp
deleted file mode 100644
index dab9362..0000000
--- a/editor/UI/EditorUI.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * ---------------------------------------------------
- * EditorUI.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/28 15:52:54
- * ---------------------------------------------------
- */
-
-#ifndef EDITORUI_HPP
-#define EDITORUI_HPP
-
-#include "UtilsCPP/Types.hpp"
-#include <filesystem>
-
-namespace GE
-{
-
-class Editor;
-
-class EditorUI
-{
-public:
-    EditorUI()                = delete;
-    EditorUI(const EditorUI&) = delete;
-    EditorUI(EditorUI&&)      = delete;
-
-    EditorUI(Editor&);
-
-    utils::uint32 viewportPanelW() const;
-    utils::uint32 viewportPanelH() const;
-
-    void setFileExplorerPath(const std::filesystem::path&);
-
-    void render();
-
-    ~EditorUI() = default;
-
-private:
-    Editor& m_editor;
-
-public:
-    EditorUI& operator = (const EditorUI&) = delete;
-    EditorUI& operator = (EditorUI&&)      = delete;
-};
-
-}
-
-#endif // EDITORUI_HPP
\ No newline at end of file
diff --git a/editor/UI/EntityInspectorPanel.cpp b/editor/UI/EntityInspectorPanel.cpp
deleted file mode 100644
index 4fa4cfc..0000000
--- a/editor/UI/EntityInspectorPanel.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * ---------------------------------------------------
- * EntityInspectorPanel.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/04 15:10:00
- * ---------------------------------------------------
- */
-
-#include "UI/EntityInspectorPanel.hpp"
-#include "AssetManager.hpp"
-#include "ECS/Components.hpp"
-#include "ECS/Entity.hpp"
-#include "Scene.hpp"
-#include "UtilsCPP/String.hpp"
-#include "imgui.h"
-#include <cassert>
-
-namespace GE
-{
-
-template<>
-void EntityInspectorPanel::componentEditWidget<NameComponent>()
-{
-    NameComponent& nameComponent = m_selectedEntity.get<NameComponent>();
-    char buff[32];
-    nameComponent.name.SAFECPY(buff);
-    ImGui::InputText("Name##NameComponent_name", buff, sizeof(buff));
-    nameComponent.name = utils::String(buff);
-}
-
-template<>
-void EntityInspectorPanel::componentEditWidget<TransformComponent>()
-{
-    TransformComponent& transform = m_selectedEntity.get<TransformComponent>();
-    ImGui::DragFloat3("position##TransformComponent_position", (float*)&transform.position, 0.01f, -1000.0f, 1000.0f);
-    ImGui::DragFloat3("rotation##TransformComponent_rotation", (float*)&transform.rotation, 0.01f,    -2*PI,    2*PI);
-    ImGui::DragFloat3("scale##TransformComponent_scale",       (float*)&transform.scale,    0.01f,     0.0f,   10.0f);
-}
-
-template<>
-void EntityInspectorPanel::componentEditWidget<CameraComponent>()
-{
-    assert(m_scene != nullptr);
-
-    CameraComponent& cameraComponent = m_selectedEntity.get<CameraComponent>();
-
-    if (m_scene->activeCamera() == m_selectedEntity)
-        ImGui::Text("Active");
-    else if (ImGui::Button("Make active"))
-        m_scene->setActiveCamera(m_selectedEntity);
-
-    ImGui::DragFloat("fov##CameraComponent_fov",     &cameraComponent.fov,   0.01f,  -2*PI,     2*PI);
-    ImGui::DragFloat("zFar##CameraComponent_zFar",   &cameraComponent.zFar,  0.01f, 0.001f, 10000.0f);
-    ImGui::DragFloat("zNear##CameraComponent_zNear", &cameraComponent.zNear, 0.01f, 0.001f, 10000.0f);
-}
-
-template<>
-void EntityInspectorPanel::componentEditWidget<LightComponent>()
-{
-    LightComponent& lightComponent = m_selectedEntity.get<LightComponent>();
-    ImGui::ColorEdit3("color##LightComponent_color", (float*)&lightComponent.color);
-    ImGui::DragFloat("intentsity##LightComponent_intensity", &lightComponent.intentsity, 0.01, 0.0f, 1.0f);
-}
-
-template<>
-void EntityInspectorPanel::componentEditWidget<MeshComponent>()
-{
-    assert(m_scene != nullptr);
-
-    MeshComponent& meshComponent = m_selectedEntity.get<MeshComponent>();
-
-    if (ImGui::BeginCombo("Mesh##MeshComponent_mesh", meshComponent.assetId.is_nil() ? utils::String("") : m_scene->assetManager().loadedMeshes()[meshComponent.assetId].name))
-    {
-        for (auto& [id, mesh] : m_scene->assetManager().loadedMeshes())
-        {
-            const bool is_selected = (meshComponent == id);
-            if (ImGui::Selectable(mesh.name, is_selected))
-                meshComponent.assetId = id;
-            if (is_selected)
-                ImGui::SetItemDefaultFocus();
-        }
-        ImGui::EndCombo();
-    }          
-    if (ImGui::BeginDragDropTarget())
-    {
-        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("mesh_dnd"))
-            meshComponent.assetId = *(AssetID*)payload->Data;
-        ImGui::EndDragDropTarget();
-    }
-}
-
-template<>
-void EntityInspectorPanel::componentEditWidget<ScriptComponent>()
-{
-    ScriptComponent& scriptComponent = m_selectedEntity.get<ScriptComponent>();
-    ImGui::Text("%s", scriptComponent.name.isEmpty() ? "no script" : (const char*)scriptComponent.name);
-    if (ImGui::BeginDragDropTarget())
-    {
-        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("script_dnd"))
-            scriptComponent.name = utils::String((char*)payload->Data);
-        ImGui::EndDragDropTarget();
-    }
-}
-
-EntityInspectorPanel::EntityInspectorPanel(Scene* scene, const Entity& selectedEntity)
-    : m_scene(scene), m_selectedEntity(selectedEntity)
-{
-}
-
-void EntityInspectorPanel::render()
-{
-    if (ImGui::Begin("Entity inspector"))
-    {
-        ImGui::PushItemWidth(-80);
-        if (m_scene == nullptr)
-            ImGui::Text("No scene edited");
-        else if (m_selectedEntity == false)
-            ImGui::Text("No entity selected");
-        else
-        {
-            componentEditWidget<NameComponent>();
-            if (m_selectedEntity.has<TransformComponent>() && componentEditHeader<TransformComponent>("Transform component"))
-                componentEditWidget<TransformComponent>();
-            if (m_selectedEntity.has<CameraComponent>() && componentEditHeader<CameraComponent>("Camera component"))
-                componentEditWidget<CameraComponent>();
-            if (m_selectedEntity.has<LightComponent>() && componentEditHeader<LightComponent>("Light component"))
-                componentEditWidget<LightComponent>();
-            if (m_selectedEntity.has<MeshComponent>() && componentEditHeader<MeshComponent>("Mesh component"))
-                componentEditWidget<MeshComponent>();
-            if (m_selectedEntity.has<ScriptComponent>() && componentEditHeader<ScriptComponent>("Script component"))
-                componentEditWidget<ScriptComponent>();
-
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::Spacing();
-
-            if (ImGui::Button("Add component"))
-                ImGui::OpenPopup("add_component_popup");
-            addComponentPopUp();
-
-            ImGui::SameLine();
-
-            if (m_onEntityDelete && ImGui::Button("Delete enitity"))
-                m_onEntityDelete();
-        }
-        ImGui::PopItemWidth();
-    }
-    ImGui::End();
-}
-
-template<typename T>
-bool EntityInspectorPanel::componentEditHeader(const char* title)
-{
-    bool isOpen = ImGui::CollapsingHeader(title, ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
-    ImGui::SameLine(0, 30);
-    if (ImGui::Button("remove##" + utils::String(title)))
-        return m_selectedEntity.remove<T>(), false;
-    return isOpen;
-}
-
-void EntityInspectorPanel::addComponentPopUp()
-{
-    if (ImGui::BeginPopup("add_component_popup"))
-    {
-        if (m_selectedEntity.has<TransformComponent>() == false && ImGui::Selectable("Transform component"))
-            m_selectedEntity.emplace<TransformComponent>();
-
-        if (m_selectedEntity.has<CameraComponent>() == false && ImGui::Selectable("Camera component"))
-            m_selectedEntity.emplace<CameraComponent>();
-
-        if (m_selectedEntity.has<LightComponent>() == false && ImGui::Selectable("Light component"))
-            m_selectedEntity.emplace<LightComponent>();
-        
-        if (m_selectedEntity.has<MeshComponent>() == false && ImGui::Selectable("Mesh component"))
-            m_selectedEntity.emplace<MeshComponent>();
-
-        if (m_selectedEntity.has<ScriptComponent>() == false && ImGui::Selectable("Script component"))
-            m_selectedEntity.emplace<ScriptComponent>();
-
-        ImGui::EndPopup();
-    }
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/EntityInspectorPanel.hpp b/editor/UI/EntityInspectorPanel.hpp
deleted file mode 100644
index 679bd3e..0000000
--- a/editor/UI/EntityInspectorPanel.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * ---------------------------------------------------
- * EntityInspectorPanel.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/04 15:03:54
- * ---------------------------------------------------
- */
-
-#ifndef ENTITYINSPECTORPANEL_HPP
-#define ENTITYINSPECTORPANEL_HPP
-
-#include "ECS/Entity.hpp"
-#include "Scene.hpp"
-#include "UtilsCPP/Func.hpp"
-
-namespace GE
-{
-
-class EntityInspectorPanel
-{
-public:
-    EntityInspectorPanel()                            = delete;
-    EntityInspectorPanel(const EntityInspectorPanel&) = delete;
-    EntityInspectorPanel(EntityInspectorPanel&&)      = delete;
-    
-    EntityInspectorPanel(Scene*, const Entity&);
-
-    inline EntityInspectorPanel& onEntityDelete(const utils::Func<void()>& f) { return m_onEntityDelete = f, *this; }
-    inline EntityInspectorPanel& onEntityDelete(utils::Func<void()>&& f) { return m_onEntityDelete = std::move(f), *this; }
-
-    void render();
-
-    ~EntityInspectorPanel() = default;
-
-private:
-    template<typename T> bool componentEditHeader(const char*);
-    template<typename T> void componentEditWidget();
-    void addComponentPopUp();
-
-    Scene* m_scene;
-    Entity m_selectedEntity;
-
-    utils::Func<void()> m_onEntityDelete;
-
-
-public:
-    EntityInspectorPanel& operator = (const EntityInspectorPanel&) = delete;
-    EntityInspectorPanel& operator = (EntityInspectorPanel&&)      = delete;
-};
-
-}
-
-#endif // ENTITYINSPECTORPANEL_HPP
\ No newline at end of file
diff --git a/editor/UI/FileOpenDialog.cpp b/editor/UI/FileOpenDialog.cpp
deleted file mode 100644
index 747ec0e..0000000
--- a/editor/UI/FileOpenDialog.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * ---------------------------------------------------
- * FileOpenDialog.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/04 17:31:58
- * ---------------------------------------------------
- */
-
-#include "UI/FileOpenDialog.hpp"
-#include "TFD/tinyfiledialogs.h"
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-namespace GE
-{
-
-FileOpenDialog::FileOpenDialog(const utils::String& title, bool& isPresented)
-    : m_isPresented(isPresented)
-{
-}
-
-void FileOpenDialog::render()
-{
-    using namespace std::chrono_literals;
-
-    static char title[32];
-
-    if (m_isPresented == false)
-        return;
-    if (s_taskStarted == false)
-    {
-        m_title.safecpy(title, sizeof(title));
-        s_result = std::async(tinyfd_openFileDialog, title, "", 0, nullptr, nullptr, 0);
-        s_taskStarted = true;
-    }
-    if (s_result.wait_for(1ns) == std::future_status::ready)
-    {
-        char* path = s_result.get();
-        if (path)
-        {
-            if (m_onSelection)
-                m_onSelection(fs::path(path));
-        }
-        else if (m_onCancel)
-            m_onCancel();
-
-        m_isPresented = false;
-        s_taskStarted = false;
-    }    
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/FileOpenDialog.hpp b/editor/UI/FileOpenDialog.hpp
deleted file mode 100644
index e61a3b8..0000000
--- a/editor/UI/FileOpenDialog.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * ---------------------------------------------------
- * FileOpenDialog.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/04 17:24:23
- * ---------------------------------------------------
- */
-
-#ifndef FILEOPENDIALOG_HPP
-#define FILEOPENDIALOG_HPP
-
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/String.hpp"
-#include <filesystem>
-#include <future>
-#include <utility>
-
-namespace GE
-{
-
-class FileOpenDialog
-{
-public:
-    FileOpenDialog()                      = delete;
-    FileOpenDialog(const FileOpenDialog&) = delete;
-    FileOpenDialog(FileOpenDialog&&)      = delete;
-    
-    FileOpenDialog(const utils::String& title, bool& isPresented);
-
-    inline FileOpenDialog& onSelection(const utils::Func<void(const std::filesystem::path&)>& f) { return m_onSelection = f, *this; }
-    inline FileOpenDialog& onSelection(utils::Func<void(const std::filesystem::path&)>&& f) { return m_onSelection = std::move(f), *this; }
-
-    inline FileOpenDialog& onCancel(const utils::Func<void()>& f) { return m_onCancel = f, *this; }
-    inline FileOpenDialog& onCancel(utils::Func<void()>&& f) { return m_onCancel = std::move(f), *this; }
-
-    void render();
-
-    ~FileOpenDialog() = default;
-
-private:
-    utils::String m_title;
-    bool& m_isPresented;
-    inline static bool s_taskStarted = false;
-    inline static std::future<char*> s_result;
-    
-    utils::Func<void(const std::filesystem::path&)> m_onSelection;
-    utils::Func<void()> m_onCancel;
-
-public:
-    FileOpenDialog& operator = (const FileOpenDialog&) = delete;
-    FileOpenDialog& operator = (FileOpenDialog&&)      = delete;
-};
-
-}
-
-#endif // FILEOPENDIALOG_HPP
\ No newline at end of file
diff --git a/editor/UI/FileSaveDialog.cpp b/editor/UI/FileSaveDialog.cpp
deleted file mode 100644
index 168d971..0000000
--- a/editor/UI/FileSaveDialog.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * ---------------------------------------------------
- * FileSaveDialog.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/05 11:22:57
- * ---------------------------------------------------
- */
-
-#include "UI/FileSaveDialog.hpp"
-#include "TFD/tinyfiledialogs.h"
-#include <cstring>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-namespace GE
-{
-
-FileSaveDialog::FileSaveDialog(const utils::String& defaultName, bool& isPresented)
-    : m_isPresented(isPresented), m_defaultName(defaultName)
-{
-}
-
-void FileSaveDialog::render()
-{
-    using namespace std::chrono_literals;
-
-    static char defaultFileName[32];
-
-    if (m_isPresented == false)
-        return;
-    if (s_taskStarted == false)
-    {
-        m_defaultName.safecpy(defaultFileName, sizeof(defaultFileName));
-        s_result = std::async(tinyfd_saveFileDialog, "Choose destination", defaultFileName, 0, nullptr, nullptr);
-        s_taskStarted = true;
-    }
-    if (s_result.wait_for(1ns) == std::future_status::ready)
-    {
-        char* path = s_result.get();
-        if (path)
-        {
-            if (m_onSelection)
-                m_onSelection(fs::path(path));
-        }
-        else if (m_onCancel)
-            m_onCancel();
-
-        m_isPresented = false;
-        s_taskStarted = false;
-    }    
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/FileSaveDialog.hpp b/editor/UI/FileSaveDialog.hpp
deleted file mode 100644
index f24cd3a..0000000
--- a/editor/UI/FileSaveDialog.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * ---------------------------------------------------
- * FileSaveDialog.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/05 11:18:07
- * ---------------------------------------------------
- */
-
-#ifndef FILESAVEDIALOG_HPP
-#define FILESAVEDIALOG_HPP
-
-#include "UtilsCPP/String.hpp"
-#include <filesystem>
-#include <future>
-#include <utility>
-
-namespace GE
-{
-
-class FileSaveDialog
-{
-public:
-    FileSaveDialog()                      = delete;
-    FileSaveDialog(const FileSaveDialog&) = delete;
-    FileSaveDialog(FileSaveDialog&&)      = delete;
-    
-    FileSaveDialog(const utils::String& defaultName, bool& isPresented);
-
-    inline FileSaveDialog& onSelection(const utils::Func<void(const std::filesystem::path&)>& f) { return m_onSelection = f, *this; }
-    inline FileSaveDialog& onSelection(utils::Func<void(const std::filesystem::path&)>&& f) { return m_onSelection = std::move(f), *this; }
-
-    inline FileSaveDialog& onCancel(const utils::Func<void()>& f) { return m_onCancel = f, *this; }
-    inline FileSaveDialog& onCancel(utils::Func<void()>&& f) { return m_onCancel = std::move(f), *this; }
-
-    void render();
-
-    ~FileSaveDialog() = default;
-
-private:
-    utils::String m_defaultName;
-    bool& m_isPresented;
-    inline static bool s_taskStarted = false;
-    inline static std::future<char*> s_result;
-    
-    utils::Func<void(const std::filesystem::path&)> m_onSelection;
-    utils::Func<void()> m_onCancel;
-
-public:
-    FileSaveDialog& operator = (const FileSaveDialog&) = delete;
-    FileSaveDialog& operator = (FileSaveDialog&&)      = delete;
-};
-
-}
-
-#endif // FILESAVEDIALOG_HPP
\ No newline at end of file
diff --git a/editor/UI/MainMenuBar.cpp b/editor/UI/MainMenuBar.cpp
deleted file mode 100644
index 919bf72..0000000
--- a/editor/UI/MainMenuBar.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * ---------------------------------------------------
- * MainMenuBar.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/30 16:36:33
- * ---------------------------------------------------
- */
-
-#include "UI/MainMenuBar.hpp"
-#include <imgui.h>
-
-namespace GE
-{
-
-void MainMenuBar::render()
-{
-    if (ImGui::BeginMainMenuBar())
-    {
-        if (ImGui::BeginMenu("File"))
-        {
-            ImGui::BeginDisabled(!m_file.neew);
-            if (ImGui::MenuItem("New"))
-                m_file.neew();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_file.open);
-            if (ImGui::MenuItem("Open"))
-                m_file.open();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_file.save);
-            if (ImGui::MenuItem("Save"))
-                m_file.save();
-            ImGui::EndDisabled();
-
-            ImGui::EndMenu();
-        }
-
-        if (ImGui::BeginMenu("Project"))
-        {
-            ImGui::BeginDisabled(!m_project.properties);
-            if (ImGui::MenuItem("Properties"))
-                m_project.properties();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_project.reloadScriptLib);
-            if (ImGui::MenuItem("Reload script lib"))
-                m_project.reloadScriptLib();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_project.run);
-            if (ImGui::MenuItem("Run"))
-                m_project.run();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_project.stop);
-            if (ImGui::MenuItem("Stop"))
-                m_project.stop();
-            ImGui::EndDisabled();
-
-            ImGui::EndMenu();
-        }
-
-        if (ImGui::BeginMenu("Scene"))
-        {
-            if (ImGui::BeginMenu("New"))
-            {
-                ImGui::BeginDisabled(!m_scene.neew.emptyEntity);
-                if (ImGui::MenuItem("Empty enitity"))
-                    m_scene.neew.emptyEntity();
-                ImGui::EndDisabled();
-                ImGui::EndMenu();
-            }
-            ImGui::EndMenu();
-        }
-
-        if (ImGui::BeginMenu("Debug"))
-        {
-            ImGui::BeginDisabled(!m_debug.showDemoWindow);
-            if (ImGui::MenuItem("Show demo window"))
-                m_debug.showDemoWindow();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_debug.showMetricsWindow);
-            if (ImGui::MenuItem("Show metrics window"))
-                m_debug.showMetricsWindow();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_debug.startEditedScene);
-            if (ImGui::MenuItem("Start edited scene"))
-                m_debug.startEditedScene();
-            ImGui::EndDisabled();
-
-            ImGui::BeginDisabled(!m_debug.stopEditedScene);
-            if (ImGui::MenuItem("Stop edited scene"))
-                m_debug.stopEditedScene();
-            ImGui::EndDisabled();
-
-            ImGui::EndMenu();
-        }
-        ImGui::EndMainMenuBar();
-    }
-}
-
-}
diff --git a/editor/UI/MainMenuBar.hpp b/editor/UI/MainMenuBar.hpp
deleted file mode 100644
index 033cf31..0000000
--- a/editor/UI/MainMenuBar.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * ---------------------------------------------------
- * MainMenuBar.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/28 18:39:45
- * ---------------------------------------------------
- */
-
-#ifndef MAINMENUBAR_HPP
-#define MAINMENUBAR_HPP
-
-#include "UtilsCPP/Func.hpp"
-#include <utility>
-
-namespace GE
-{
-
-class MainMenuBar
-{
-public:
-    MainMenuBar()                   = default;
-    MainMenuBar(const MainMenuBar&) = delete;
-    MainMenuBar(MainMenuBar&&)      = delete;
-    
-    inline MainMenuBar& on_File_New(const utils::Func<void()>& f) { return m_file.neew = f, *this; }
-    inline MainMenuBar& on_File_New(utils::Func<void()>&& f) { return m_file.neew = std::move(f), *this; }
-
-    inline MainMenuBar& on_File_Open(const utils::Func<void()>& f) { return m_file.open = f, *this; }
-    inline MainMenuBar& on_File_Open(utils::Func<void()>&& f) { return m_file.open = std::move(f), *this; }
-
-    inline MainMenuBar& on_File_Save(const utils::Func<void()>& f) { return m_file.save = f, *this; }
-    inline MainMenuBar& on_File_Save(utils::Func<void()>&& f) { return m_file.save = std::move(f), *this; }
-
-    inline MainMenuBar& on_Project_Properties(const utils::Func<void()>& f) { return m_project.properties = f, *this; }
-    inline MainMenuBar& on_Project_Properties(utils::Func<void()>&& f) { return m_project.properties = std::move(f), *this; }
-
-    inline MainMenuBar& on_Project_ReloadScriptLib(const utils::Func<void()>& f) { return m_project.reloadScriptLib = f, *this; }
-    inline MainMenuBar& on_Project_ReloadScriptLib(utils::Func<void()>&& f) { return m_project.reloadScriptLib = std::move(f), *this; }
-
-    inline MainMenuBar& on_Project_Run(const utils::Func<void()>& f) { return m_project.run = f, *this; }
-    inline MainMenuBar& on_Project_Run(utils::Func<void()>&& f) { return m_project.run = std::move(f), *this; }
-
-    inline MainMenuBar& on_Project_Stop(const utils::Func<void()>& f) { return m_project.stop = f, *this; }
-    inline MainMenuBar& on_Project_Stop(utils::Func<void()>&& f) { return m_project.stop = std::move(f), *this; }
-
-    inline MainMenuBar& on_Scene_Add_EmptyEntity(const utils::Func<void()>& f) { return m_scene.neew.emptyEntity = f, *this; }
-    inline MainMenuBar& on_Scene_Add_EmptyEntity(utils::Func<void()>&& f) { return m_scene.neew.emptyEntity = std::move(f), *this; }
-
-    inline MainMenuBar& on_Debug_ShowDemoWindow(const utils::Func<void()>& f) { return m_debug.showDemoWindow = f, *this; }
-    inline MainMenuBar& on_Debug_ShowDemoWindow(utils::Func<void()>&& f) { return m_debug.showDemoWindow = std::move(f), *this; }
-
-    inline MainMenuBar& on_Debug_ShowMetricsWindow(const utils::Func<void()>& f) { return m_debug.showMetricsWindow = f, *this; }
-    inline MainMenuBar& on_Debug_ShowMetricsWindow(utils::Func<void()>&& f) { return m_debug.showMetricsWindow = std::move(f), *this; }
-
-    inline MainMenuBar& on_Debug_StartEditedScene(const utils::Func<void()>& f) { return m_debug.startEditedScene = f, *this; }
-    inline MainMenuBar& on_Debug_StartEditedScene(utils::Func<void()>&& f) { return m_debug.startEditedScene = std::move(f), *this; }
-
-    inline MainMenuBar& on_Debug_StopEditedScene(const utils::Func<void()>& f) { return m_debug.stopEditedScene = f, *this; }
-    inline MainMenuBar& on_Debug_StopEditedScene(utils::Func<void()>&& f) { return m_debug.stopEditedScene = std::move(f), *this; }
-
-    void render();
-
-    ~MainMenuBar() = default;
-
-private:
-    struct
-    {
-        utils::Func<void()> neew;
-        utils::Func<void()> open;
-        utils::Func<void()> save;
-    } m_file;
-
-    struct
-    {
-        utils::Func<void()> properties;
-        utils::Func<void()> reloadScriptLib;
-        utils::Func<void()> run;
-        utils::Func<void()> stop;
-    } m_project;
-
-    struct
-    {
-        struct
-        {
-            utils::Func<void()> emptyEntity;
-        } neew;
-    } m_scene;
-
-    struct
-    {
-        utils::Func<void()> showDemoWindow;
-        utils::Func<void()> showMetricsWindow;
-        utils::Func<void()> startEditedScene;
-        utils::Func<void()> stopEditedScene;
-    } m_debug;
-
-public:
-    MainMenuBar& operator = (const MainMenuBar&) = delete;
-    MainMenuBar& operator = (MainMenuBar&&)      = delete;
-};
-
-}
-
-#endif // MAINMENUBAR_HPP
\ No newline at end of file
diff --git a/editor/UI/ProjectPropertiesModal.cpp b/editor/UI/ProjectPropertiesModal.cpp
deleted file mode 100644
index 228af35..0000000
--- a/editor/UI/ProjectPropertiesModal.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * ---------------------------------------------------
- * ProjectPropertiesModal.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/30 18:14:29
- * ---------------------------------------------------
- */
-
-#include "UI/ProjectPropertiesModal.hpp"
-#include "UI/FileOpenDialog.hpp"
-#include "UtilsCPP/String.hpp"
-#include <cstring>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-
-namespace GE
-{
-
-ProjectPropertiesModal::ProjectPropertiesModal(bool& isPresented, Project& project, const std::filesystem::path& projSavePath)
-    : m_isPresented(isPresented), m_project(project), m_projSavePath(projSavePath)
-{
-}
-
-void ProjectPropertiesModal::render()
-{
-    static bool isScriptLibSelectDialogPresented = false;
-
-    if (m_isPresented)
-    {
-        ImGui::OpenPopup("Project properties");
-        if (s_needBufUpdate)
-        {
-            m_project.name().SAFECPY(s_nameBuff);
-            utils::String(m_project.scriptLib().string().c_str()).SAFECPY(s_scriptsLibBuff);
-            s_needBufUpdate = false;
-        }
-    }
-    if (ImGui::BeginPopupModal("Project properties", &m_isPresented, ImGuiWindowFlags_AlwaysAutoResize))
-    {
-        ImGui::BeginDisabled(isScriptLibSelectDialogPresented);
-            
-        ImGui::InputText("Name##projectName", s_nameBuff, sizeof(s_nameBuff));
-        ImGui::InputText("Script library path##projectScriptsLib", s_scriptsLibBuff, sizeof(s_scriptsLibBuff));
-        ImGui::SameLine();
-        if (ImGui::Button("..."))
-            isScriptLibSelectDialogPresented = true;
-
-        if (ImGui::Button("Cancel"))
-        {
-            closePopup();
-            if (m_onCancel)
-                m_onCancel();
-        }
-
-        ImGui::SameLine();
-        ImGui::BeginDisabled(!isScriptLibValid());
-        if (ImGui::Button("Ok"))
-        {
-            m_project.setName(s_nameBuff);
-            m_project.setScriptLib(fs::path(s_scriptsLibBuff));
-            closePopup();
-            if (m_onOk)
-                m_onOk();
-        }
-        ImGui::EndDisabled();
-        ImGui::EndDisabled();
-
-        ImGui::EndPopup();
-
-        FileOpenDialog("Select script lib", isScriptLibSelectDialogPresented)
-            .onSelection([&](const fs::path& path) {
-                fs::path relativePath = fs::relative(path, fs::path(m_projSavePath).remove_filename());
-                utils::String(relativePath.replace_extension("").string().c_str()).SAFECPY(s_scriptsLibBuff);
-            })
-            .render();
-    }
-}
-
-void ProjectPropertiesModal::closePopup()
-{
-    s_needBufUpdate = true;
-    m_isPresented = false;
-    ImGui::CloseCurrentPopup();
-}
-
-
-bool ProjectPropertiesModal::isScriptLibValid()
-{
-    fs::path path = s_scriptsLibBuff;
-    if (path.empty())
-        return true;
-    #ifdef _WIN32
-        path = fs::path(m_projSavePath).remove_filename() / path.replace_extension(".dll");
-    #else
-        path = fs::path(m_projSavePath).remove_filename() / path;
-    #endif
-    return path.is_absolute() && fs::is_regular_file(path);
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/ProjectPropertiesModal.hpp b/editor/UI/ProjectPropertiesModal.hpp
deleted file mode 100644
index 34c43e6..0000000
--- a/editor/UI/ProjectPropertiesModal.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * ---------------------------------------------------
- * ProjectPropertiesModal.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/30 18:05:37
- * ---------------------------------------------------
- */
-
-#ifndef PROJECTPROPERTIESMODAL_HPP
-#define PROJECTPROPERTIESMODAL_HPP
-
-#include "Project.hpp"
-#include "UtilsCPP/Func.hpp"
-
-namespace GE
-{
-
-class ProjectPropertiesModal
-{
-public:
-    ProjectPropertiesModal()                              = delete;
-    ProjectPropertiesModal(const ProjectPropertiesModal&) = delete;
-    ProjectPropertiesModal(ProjectPropertiesModal&&)      = delete;
-    
-    ProjectPropertiesModal(bool& isPresented, Project&, const std::filesystem::path& projSavePath);
-
-    inline ProjectPropertiesModal& onOk(const utils::Func<void()>& f) { return m_onOk = f, *this; }
-    inline ProjectPropertiesModal& onOk(utils::Func<void()>&& f) { return m_onOk = std::move(f), *this; }
-    
-    inline ProjectPropertiesModal& onCancel(const utils::Func<void()>& f) { return m_onCancel = f, *this; }
-    inline ProjectPropertiesModal& onCancel(utils::Func<void()>&& f) { return m_onCancel = std::move(f), *this; }
-
-    void render();
-
-    ~ProjectPropertiesModal() = default;
-
-private:
-    bool isScriptLibValid();
-    void closePopup();
-
-    bool& m_isPresented;
-    Project& m_project;
-    const std::filesystem::path& m_projSavePath;
-
-    utils::Func<void()> m_onOk;
-    utils::Func<void()> m_onCancel;
-
-    inline static char s_nameBuff[32];
-    inline static char s_scriptsLibBuff[1024];
-    inline static bool s_needBufUpdate = true;
-
-public:
-    ProjectPropertiesModal& operator = (const ProjectPropertiesModal&) = delete;
-    ProjectPropertiesModal& operator = (ProjectPropertiesModal&&)      = delete;
-};
-
-}
-
-#endif // PROJECTPROPERTIESMODAL_HPP
\ No newline at end of file
diff --git a/editor/UI/SceneGraphPanel.cpp b/editor/UI/SceneGraphPanel.cpp
deleted file mode 100644
index 2e6effe..0000000
--- a/editor/UI/SceneGraphPanel.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * ---------------------------------------------------
- * SceneGraphPanel.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/01 16:58:07
- * ---------------------------------------------------
- */
-
-#include "UI/SceneGraphPanel.hpp"
-#include "Scene.hpp"
-#include "ECS/ECSView.hpp"
-#include "ECS/Components.hpp"
-
-namespace GE
-{
-
-SceneGraphPanel::SceneGraphPanel(Scene* scene, const Entity& selectedEntity)
-    : m_scene(scene), m_selectedEntity(selectedEntity)
-{
-}
-
-void SceneGraphPanel::render()
-{
-    if (ImGui::Begin("Scene graph"))
-    {
-        if (ImGui::BeginChild("scene_graph_child"))
-        {
-            if (m_scene)
-            {
-                ECSView<NameComponent>(m_scene->ecsWorld()).onEach([&](Entity entity, NameComponent&) {
-                    if (entity.hasParent() == false)
-                        renderEntityRow(entity);
-                });
-            }
-            else
-            {
-                ImGui::Text("No scene edited");
-            }
-            ImGui::EndChild();
-        }
-        entityDndTarget();
-    }
-    ImGui::End();
-}
-
-void SceneGraphPanel::renderEntityRow(Entity& entity)
-{
-        bool node_open = false;
-        ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_DefaultOpen;
-
-        if (m_selectedEntity == entity)
-            flags |= ImGuiTreeNodeFlags_Selected;
-
-        if (entity.childCount() > 0)
-            node_open = ImGui::TreeNodeEx(entity.imGuiID(), flags, "%s", (const char*)entity.name());
-        else
-        {
-            flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
-            ImGui::TreeNodeEx(entity.imGuiID(), flags, "%s", (const char*)entity.name());
-        }
-
-        if (ImGui::BeginDragDropSource())
-        {
-            ImGui::SetDragDropPayload("dnd_entity", &entity, sizeof(Entity));
-            ImGui::Text("%s", (char*)entity.name());
-            ImGui::EndDragDropSource();
-        }
-
-        entityDndTarget(entity);
-
-        if (ImGui::IsItemClicked() && m_onEntitySelect)
-            m_onEntitySelect(entity);
-
-        if (node_open && entity.childCount() > 0)
-        {
-            for (Entity curr = entity.firstChild(); curr; curr = curr.nextChild() )
-                renderEntityRow(curr);
-            ImGui::TreePop();
-        }
-
-}
-
-void SceneGraphPanel::entityDndTarget(Entity parent)
-{
-    if (ImGui::BeginDragDropTarget())
-    {
-        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_entity"))
-        {
-            assert(payload->DataSize == sizeof(Entity));
-            Entity dragEntity = *(Entity*)payload->Data;
-            dragEntity.removeParent();
-
-            if (parent && parent != dragEntity && dragEntity.isParentOf(parent) == false)
-            {
-                parent.addChild(dragEntity);
-            }
-        }
-        ImGui::EndDragDropTarget();
-    }
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/SceneGraphPanel.hpp b/editor/UI/SceneGraphPanel.hpp
deleted file mode 100644
index 678d023..0000000
--- a/editor/UI/SceneGraphPanel.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * ---------------------------------------------------
- * SceneGraphPanel.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/01 16:45:57
- * ---------------------------------------------------
- */
-
-#ifndef SCENEGRAPHPANEL_HPP
-#define SCENEGRAPHPANEL_HPP
-
-#include "Scene.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "ECS/Entity.hpp"
-#include <utility>
-
-namespace GE
-{
-
-class SceneGraphPanel
-{
-public:
-    SceneGraphPanel()                       = delete;
-    SceneGraphPanel(const SceneGraphPanel&) = delete;
-    SceneGraphPanel(SceneGraphPanel&&)      = delete;
-    
-    SceneGraphPanel(Scene*, const Entity&);
-
-    inline SceneGraphPanel& onEntitySelect(const utils::Func<void(const Entity&)>& f) { return m_onEntitySelect = f, *this; }
-    inline SceneGraphPanel& onEntitySelect(utils::Func<void(const Entity&)>&& f) { return m_onEntitySelect = std::move(f), *this; }
-
-    void render();
-
-    ~SceneGraphPanel() = default;
-
-private:
-    void renderEntityRow(Entity&);
-    void entityDndTarget(Entity parent = Entity());
-
-    Scene* m_scene;
-    Entity m_selectedEntity;
-
-    utils::Func<void(const Entity&)> m_onEntitySelect;
-
-public:
-    SceneGraphPanel& operator = (const SceneGraphPanel&) = delete;
-    SceneGraphPanel& operator = (SceneGraphPanel&&)      = delete;
-};
-
-}
-
-#endif // SCENEGRAPHPANEL_HPP
\ No newline at end of file
diff --git a/editor/UI/ViewportPanel.cpp b/editor/UI/ViewportPanel.cpp
deleted file mode 100644
index d622063..0000000
--- a/editor/UI/ViewportPanel.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * ---------------------------------------------------
- * ViewportPanel.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/01 16:21:18
- * ---------------------------------------------------
- */
-
-#include "UI/ViewportPanel.hpp"
-
-namespace GE
-{
-
-ViewportPanel::ViewportPanel(const gfx::Texture& texture)
-    : m_texture(texture)
-{
-}
-
-void ViewportPanel::render()
-{
-    static utils::uint32 width = 800;
-    static utils::uint32 height = 600;
-
-    if (ImGui::Begin("viewport"))
-    {
-        ImVec2 contentRegionAvai = ImGui::GetContentRegionAvail();
-        utils::uint32 newWidth = contentRegionAvai.x <= 0 ? 1 : contentRegionAvai.x;
-        utils::uint32 newHeight = contentRegionAvai.y <= 0 ? 1 : contentRegionAvai.y;
-
-        ImGui::Image(m_texture.imguiTextureId(), contentRegionAvai, m_texture.imguiUV0(), m_texture.imguiUV1());
-
-        if (newWidth != height || newWidth != width)
-        {
-            width = newWidth;
-            height = newHeight;
-            if (m_onResize)
-                m_onResize(width, height);
-        }
-    }
-    ImGui::End();
-}
-
-}
\ No newline at end of file
diff --git a/editor/UI/ViewportPanel.hpp b/editor/UI/ViewportPanel.hpp
deleted file mode 100644
index db07e55..0000000
--- a/editor/UI/ViewportPanel.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * ---------------------------------------------------
- * ViewportPanel.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/01 16:20:17
- * ---------------------------------------------------
- */
-
-#ifndef VIEWPORTPANEL_HPP
-#define VIEWPORTPANEL_HPP
-
-#include "Graphics/Texture.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <utility>
-
-namespace GE
-{
-
-class ViewportPanel
-{
-public:
-    ViewportPanel()                     = delete;
-    ViewportPanel(const ViewportPanel&) = delete;
-    ViewportPanel(ViewportPanel&&)      = delete;
-    
-    ViewportPanel(const gfx::Texture&);
-
-    inline ViewportPanel& onResize(const utils::Func<void(utils::uint32, utils::uint32)>& f) { return m_onResize = f, *this; }
-    inline ViewportPanel& onResize(utils::Func<void(utils::uint32, utils::uint32)>&& f) { return m_onResize = std::move(f), *this; }
-
-    void render();
-
-    ~ViewportPanel() = default;
-
-private:
-    const gfx::Texture& m_texture;
-    utils::Func<void(utils::uint32, utils::uint32)> m_onResize;
-
-public:
-    ViewportPanel& operator = (const ViewportPanel&) = delete;
-    ViewportPanel& operator = (ViewportPanel&&)      = delete;
-};
-
-}
-
-#endif // VIEWPORTPANEL_HPP
\ No newline at end of file
diff --git a/editor/ViewportFrameBuff.cpp b/editor/ViewportFrameBuff.cpp
deleted file mode 100644
index 879306b..0000000
--- a/editor/ViewportFrameBuff.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * ---------------------------------------------------
- * ViewportFrameBuff.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/07 12:51:51
- * ---------------------------------------------------
- */
-
-#include "ViewportFrameBuff.hpp"
-
-namespace GE
-{
-
-ViewportFrameBuff::ViewportFrameBuff(const gfx::Window& win, const gfx::GraphicAPI& api)
-    : m_window(win), m_graphicAPI(api)
-{
-}
-
-void ViewportFrameBuff::resize(utils::uint32 w, utils::uint32 h)
-{
-    m_width = w;
-    m_height = h;
-}
-
-void ViewportFrameBuff::onUpdate()
-{
-    float xScale, yScale;
-    m_window.getFrameBufferScaleFactor(&xScale, &yScale);
-
-    utils::uint32 newFrameBufferWidth = (utils::uint32)((float)m_width * xScale);
-    utils::uint32 newFrameBufferHeight = (utils::uint32)((float)m_height * yScale);
-
-    if (m_framebuffer && (m_framebuffer->width() == newFrameBufferWidth && m_framebuffer->height() == newFrameBufferHeight))
-        return;
-    
-    gfx::Texture::Descriptor colorTextureDescriptor;
-    colorTextureDescriptor.width = newFrameBufferWidth;
-    colorTextureDescriptor.height = newFrameBufferHeight;
-    colorTextureDescriptor.pixelFormat = gfx::PixelFormat::BGRA;
-    colorTextureDescriptor.usage = gfx::Texture::Usage::ShaderReadAndRenderTarget;
-    
-    gfx::Texture::Descriptor depthTextureDescriptor = gfx::Texture::Descriptor::depthTextureDescriptor(newFrameBufferWidth, newFrameBufferHeight);
-
-    gfx::FrameBuffer::Descriptor fBuffDesc;
-    fBuffDesc.colorTexture = m_graphicAPI.newTexture(colorTextureDescriptor);
-    fBuffDesc.depthTexture = m_graphicAPI.newTexture(depthTextureDescriptor);
-    m_framebuffer = m_graphicAPI.newFrameBuffer(fBuffDesc);
-}
-
-}
\ No newline at end of file
diff --git a/editor/ViewportFrameBuff.hpp b/editor/ViewportFrameBuff.hpp
deleted file mode 100644
index 9798303..0000000
--- a/editor/ViewportFrameBuff.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * ---------------------------------------------------
- * ViewportFrameBuff.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/07 12:48:52
- * ---------------------------------------------------
- */
-
-#ifndef VIEWPORTFRAMEBUFF_HPP
-#define VIEWPORTFRAMEBUFF_HPP
-
-#include "Graphics/FrameBuffer.hpp"
-#include "Graphics/GraphicAPI.hpp"
-#include "Graphics/Window.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "UtilsCPP/Types.hpp"
-
-namespace GE
-{
-
-class ViewportFrameBuff
-{
-public:
-    ViewportFrameBuff()                         = delete;
-    ViewportFrameBuff(const ViewportFrameBuff&) = delete;
-    ViewportFrameBuff(ViewportFrameBuff&&)      = delete;
-
-    ViewportFrameBuff(const gfx::Window&, const gfx::GraphicAPI&);
-    
-    void resize(utils::uint32 w, utils::uint32 h);
-
-    void onUpdate();
-
-    ~ViewportFrameBuff() = default;
-
-private:
-    const gfx::Window& m_window;
-    const gfx::GraphicAPI& m_graphicAPI;
-
-    utils::SharedPtr<gfx::FrameBuffer> m_framebuffer;
-    utils::uint32 m_width = 800;
-    utils::uint32 m_height = 600;
-    
-public:
-    ViewportFrameBuff& operator = (const ViewportFrameBuff&) = delete;
-    ViewportFrameBuff& operator = (ViewportFrameBuff&&)      = delete;
-
-    inline operator const utils::SharedPtr<gfx::FrameBuffer>& () const { return m_framebuffer; }
-    inline operator utils::SharedPtr<gfx::RenderTarget> () const { return m_framebuffer.staticCast<gfx::RenderTarget>(); }
-};
-
-}
-
-#endif // VIEWPORTFRAMEBUFF_HPP
\ No newline at end of file
diff --git a/editor/ge-editor.def b/editor/ge-editor.def
new file mode 100644
index 0000000..d3db5b0
--- /dev/null
+++ b/editor/ge-editor.def
@@ -0,0 +1,3 @@
+EXPORTS
+    glfwGetRequiredInstanceExtensions
+    glfwCreateWindowSurface
diff --git a/editor/ge-editor.entitlements b/editor/ge-editor.entitlements
new file mode 100644
index 0000000..2104a7c
--- /dev/null
+++ b/editor/ge-editor.entitlements
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "www.apple.com">
+<plist version="1.0">
+    <dict>
+        <key>com.apple.security.get-task-allow</key>
+        <true/>
+    </dict>
+</plist>
diff --git a/editor/main.cpp b/editor/main.cpp
deleted file mode 100644
index 7eaae3b..0000000
--- a/editor/main.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * ---------------------------------------------------
- * main.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/30 18:47:00
- * ---------------------------------------------------
- */
-
-#include "Editor.hpp"
-#include "Graphics/Platform.hpp"
-#include "UtilsCPP/UniquePtr.hpp"
-
-int main(int argc, char* argv[])
-{
-    gfx::Platform::init();
-
-    auto editor = utils::makeUnique<GE::Editor>();
-    editor->run();
-    editor.clear();
-
-    gfx::Platform::terminate();
-}
\ No newline at end of file
diff --git a/editor/renderImgui.cpp b/editor/renderImgui.cpp
new file mode 100644
index 0000000..8a66b38
--- /dev/null
+++ b/editor/renderImgui.cpp
@@ -0,0 +1,824 @@
+/*
+ * ---------------------------------------------------
+ * renderImgui.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Editor.hpp"
+
+#include "Game-Engine/ECSView.hpp"
+#include "Game-Engine/Entity.hpp"
+#include "Game-Engine/InputFwd.hpp"
+#include "Game-Engine/RawInput.hpp"
+#include "Game-Engine/Scene.hpp"
+
+#include "imgui.h"
+
+#include <algorithm>
+#include <array>
+#include <concepts>
+#include <cstddef>
+#include <filesystem>
+#include <functional>
+#include <numbers>
+#include <ranges>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+constexpr float TILE_SIZE = 60.0f;
+
+namespace
+{
+
+using MenuItem = std::pair<std::string_view, std::function<void()>>;
+
+template<typename T>
+concept MenuItemRange = std::ranges::range<T> && std::same_as<std::ranges::range_value_t<T>, MenuItem>;
+
+using EditableEntityComponents = GE::TypeList< GE::TransformComponent, GE::CameraComponent, GE::LightComponent, GE::ScriptComponent, GE::MeshComponent >;
+
+template<typename T> struct EditableEntityComponentTraits;
+template<> struct EditableEntityComponentTraits<GE::TransformComponent> { static constexpr const char* label = "Transform component"; };
+template<> struct EditableEntityComponentTraits<GE::CameraComponent>    { static constexpr const char* label = "Camera component";    };
+template<> struct EditableEntityComponentTraits<GE::LightComponent>     { static constexpr const char* label = "Light component";     };
+template<> struct EditableEntityComponentTraits<GE::ScriptComponent>    { static constexpr const char* label = "Script component";    };
+template<> struct EditableEntityComponentTraits<GE::MeshComponent>      { static constexpr const char* label = "Mesh component";      };
+
+constexpr const char* NO_INPUT_MAPPER_LABEL = "None";
+
+template<typename T> struct EditableInputTraits;
+template<> struct EditableInputTraits<GE::ActionInput>  { static constexpr const char* label = "Action"; };
+template<> struct EditableInputTraits<GE::StateInput>   { static constexpr const char* label = "State";  };
+template<> struct EditableInputTraits<GE::RangeInput>   { static constexpr const char* label = "Range";  };
+template<> struct EditableInputTraits<GE::Range2DInput> { static constexpr const char* label = "Range2D"; };
+
+template<typename T> struct EditableRawInputTraits;
+template<> struct EditableRawInputTraits<GE::KeyboardButton> { static constexpr const char* label = "Keyboard button"; };
+
+void keyboardButtonCombo(const char* label, GE::KeyboardButton& button)
+{
+    if (ImGui::BeginCombo(label, GE::keyboardButtonName(button).data()))
+    {
+        for (GE::KeyboardButton candidate : GE::KEYBOARD_BUTTONS)
+        {
+            const bool isSelected = (candidate == button);
+            if (ImGui::Selectable(GE::keyboardButtonName(candidate).data(), isSelected))
+                button = candidate;
+            if (isSelected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+}
+
+template<typename Fn>
+void propertyRow(const char* label, Fn&& fn)
+{
+    ImGui::TableNextRow();
+    ImGui::TableSetColumnIndex(0);
+    ImGui::AlignTextToFramePadding();
+    ImGui::TextUnformatted(label);
+
+    ImGui::TableSetColumnIndex(1);
+    ImGui::SetNextItemWidth(-FLT_MIN);
+    fn();
+}
+
+bool beginPropertyTable(const char* id)
+{
+    if (!ImGui::BeginTable(id, 2, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_BordersInnerV))
+        return false;
+
+    ImGui::TableSetupColumn("Label", ImGuiTableColumnFlags_WidthFixed, 130.0f);
+    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
+    return true;
+}
+
+template<typename Fn>
+bool collapsingHeaderWithActionButton(const char* title, const char* buttonLabel, std::string_view buttonIdSuffix, Fn&& fn)
+{
+    const bool isOpen = ImGui::CollapsingHeader(title, ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_DefaultOpen);
+    const ImGuiStyle& style = ImGui::GetStyle();
+    const float buttonWidth = ImGui::CalcTextSize(buttonLabel).x + style.FramePadding.x * 2.0f;
+    const float buttonX = ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x - buttonWidth;
+    ImGui::SameLine(buttonX);
+
+    std::string buttonId = std::string(buttonLabel) + "##" + std::string(buttonIdSuffix);
+    if (ImGui::SmallButton(buttonId.c_str()))
+    {
+        fn();
+        return false;
+    }
+    return isOpen;
+}
+
+template<typename T>
+void componentEditWidget(GE::Entity&, GE::Scene&)
+{
+    static_assert(false, "not implemented");
+}
+
+template<>
+void componentEditWidget<GE::NameComponent>(GE::Entity& entity, GE::Scene&)
+{
+    GE::NameComponent& nameComponent = entity.get<GE::NameComponent>();
+    char buff[32];
+    std::strncpy(buff, nameComponent.name.c_str(), sizeof(buff));
+    buff[31] = '\0'; // If count is reached before the entire string src was copied, the resulting character array is not null-terminated.
+    ImGui::InputText("Name##NameComponent_name", buff, sizeof(buff));
+    nameComponent.name = std::string(buff);
+}
+
+template<>
+void componentEditWidget<GE::TransformComponent>(GE::Entity& entity, GE::Scene&)
+{
+    GE::TransformComponent& transform = entity.get<GE::TransformComponent>();
+    ImGui::DragFloat3("position##TransformComponent_position", (float*)&transform.position, 0.01f, -1000.0f, 1000.0f);
+    ImGui::DragFloat3("rotation##TransformComponent_rotation", (float*)&transform.rotation, 0.01f, -2*std::numbers::pi_v<float>, 2*std::numbers::pi_v<float>);
+    ImGui::DragFloat3("scale##TransformComponent_scale",       (float*)&transform.scale,    0.01f, 0.0f, 10.0f);
+}
+
+template<>
+void componentEditWidget<GE::CameraComponent>(GE::Entity& entity, GE::Scene&)
+{
+    GE::CameraComponent& cameraComponent = entity.get<GE::CameraComponent>();
+
+    ImGui::DragFloat("fov##CameraComponent_fov",     &cameraComponent.fov,   0.01f,  -2*std::numbers::pi_v<float>, 2*std::numbers::pi_v<float>);
+    ImGui::DragFloat("zFar##CameraComponent_zFar",   &cameraComponent.zFar,  0.01f, 0.001f, 10000.0f);
+    ImGui::DragFloat("zNear##CameraComponent_zNear", &cameraComponent.zNear, 0.01f, 0.001f, 10000.0f);
+}
+
+template<>
+void componentEditWidget<GE::LightComponent>(GE::Entity& entity, GE::Scene&)
+{
+    auto typeToStr = [](const GE::LightComponent::Type& type){
+        switch (type) {
+            case GE::LightComponent::Type::directional: return "directional";
+            case GE::LightComponent::Type::point: return "point";
+        }
+        std::unreachable();
+    };
+
+    GE::LightComponent& lightComponent = entity.get<GE::LightComponent>();
+    if (ImGui::BeginCombo("Type##LightComponent_type", typeToStr(lightComponent.type)))
+    {
+        for (auto& type : {GE::LightComponent::Type::directional, GE::LightComponent::Type::point})
+        {
+            const bool is_selected = (lightComponent.type == type);
+            if (ImGui::Selectable(typeToStr(type), is_selected))
+                lightComponent.type = type;
+            if (is_selected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+    ImGui::ColorEdit3("color##LightComponent_color", (float*)&lightComponent.color);
+    ImGui::DragFloat("intentsity##LightComponent_intensity", &lightComponent.intentsity, 0.01, 0.0f, 1.0f);
+    if (lightComponent.type == GE::LightComponent::Type::point)
+        ImGui::DragFloat("attenuation##LightComponent_attenuation", &lightComponent.attenuation, 0.01, 0.0f, 1.0f);
+}
+
+void scriptComponentEditWidget(GE::Entity& entity, GE::Scene&, const GE::ScriptLibrary& scriptLibrary)
+{
+    GE::ScriptComponent& scriptComponent = entity.get<GE::ScriptComponent>();
+    const char* previewValue = scriptComponent.name.empty() ? "none" : scriptComponent.name.c_str();
+    if (ImGui::BeginCombo("Script##ScriptComponent_name", previewValue))
+    {
+        for (const std::string& scriptName : scriptLibrary.listScriptNames())
+        {
+            const bool isSelected = scriptComponent.name == scriptName;
+            if (ImGui::Selectable(scriptName.c_str(), isSelected))
+            {
+                scriptComponent.name = scriptName;
+                scriptComponent.parameters.clear();
+                for (const std::string& parameterName : scriptLibrary.listScriptParameterNames(scriptName))
+                {
+                    auto [parameterIt, inserted] = scriptComponent.parameters.try_emplace(parameterName, scriptLibrary.getScriptDefaultParameterValue(scriptName, parameterName));
+                    assert(inserted);
+                }
+            }
+            if (isSelected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+
+    for (auto& [name, value] : scriptComponent.parameters)
+    {
+        std::visit([&](auto& typedValue)
+        {
+            using T = std::remove_cvref_t<decltype(typedValue)>;
+            if constexpr (std::is_same_v<T, bool>)
+                ImGui::Checkbox(name.c_str(), &typedValue);
+            else if constexpr (std::is_same_v<T, int64_t>)
+            {
+                int64_t value64 = typedValue;
+                if (ImGui::DragScalar(name.c_str(), ImGuiDataType_S64, &value64))
+                    typedValue = value64;
+            }
+            else if constexpr (std::is_same_v<T, float>)
+                ImGui::DragFloat(name.c_str(), &typedValue, 0.01f);
+            else if constexpr (std::is_same_v<T, glm::vec2>)
+                ImGui::DragFloat2(name.c_str(), &typedValue.x, 0.01f);
+            else if constexpr (std::is_same_v<T, glm::vec3>)
+                ImGui::DragFloat3(name.c_str(), &typedValue.x, 0.01f);
+            else if constexpr (std::is_same_v<T, std::string>)
+            {
+                char buffer[256];
+                std::strncpy(buffer, typedValue.c_str(), sizeof(buffer));
+                buffer[sizeof(buffer) - 1] = '\0';
+                if (ImGui::InputText(name.c_str(), buffer, sizeof(buffer)))
+                    typedValue = buffer;
+            }
+        }, value);
+    }
+}
+
+template<>
+void componentEditWidget<GE::MeshComponent>(GE::Entity& entity, GE::Scene& scene)
+{
+    GE::MeshComponent& meshComponent = entity.get<GE::MeshComponent>();
+
+    std::string currentMeshStem;
+    if (meshComponent.id == GE::BUILT_IN_CUBE_ASSET_ID)
+        currentMeshStem = "built_in_cube";
+    else
+    {
+        const auto& registredAssets = scene.assetManagerView().registredAssets();
+        const auto assetIt = std::ranges::find_if(registredAssets, [&](const auto& asset) { return asset.second == meshComponent.id; });
+        if (assetIt != registredAssets.end())
+            currentMeshStem = std::visit([](auto& path){return path.path.stem().string();}, assetIt->first);
+    }
+
+    if (ImGui::BeginCombo("Type##LightComponent_type", currentMeshStem.c_str()))
+    {
+        if (ImGui::Selectable("built_in_cube", meshComponent.id == GE::BUILT_IN_CUBE_ASSET_ID))
+            meshComponent.id = GE::BUILT_IN_CUBE_ASSET_ID;
+        if (meshComponent.id == GE::BUILT_IN_CUBE_ASSET_ID)
+            ImGui::SetItemDefaultFocus();
+
+        for (auto& [vAssetPath, id] : scene.assetManagerView().registredAssets())
+        {
+            const bool is_selected = (id == meshComponent.id);
+            std::string meshStem = std::visit([](auto& path){ return path.path.stem().string(); }, vAssetPath);
+            if (ImGui::Selectable(meshStem.c_str(), is_selected))
+                meshComponent.id = id;
+            if (is_selected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+
+    if (ImGui::BeginDragDropTarget())
+    {
+        if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("resource_dnd")) {
+            GE::Entity& droped = *(GE::Entity*)payload->Data;
+            std::string_view path = std::string_view((const char*)payload->Data, (size_t)payload->DataSize);
+            GE::AssetID id = scene.assetManagerView().registerAsset<GE::Mesh>(std::filesystem::path(path));
+            meshComponent.id = id;
+        }
+        ImGui::EndDragDropTarget();
+    }
+}
+
+template<typename T>
+void tileGrid(const std::ranges::range auto& items, const std::function<void(const T&)>& fn) requires std::same_as<std::ranges::range_value_t<std::remove_cvref_t<decltype(items)>>, T>
+{
+    for (const auto& item : items)
+    {
+        float posA = ImGui::GetCursorScreenPos().x;
+        fn(item);
+        ImGui::SameLine();
+        float posB = ImGui::GetCursorScreenPos().x;
+        float tileSize = posB - posA;
+        if (tileSize > ImGui::GetContentRegionAvail().x)
+            ImGui::NewLine();
+    }
+}
+
+void menuFromPath(MenuItemRange auto&& items, int offset = 0)
+{
+    auto label = [](std::string_view str, auto&& render)
+    {
+        std::array<char, 128> buffer{};
+        const size_t size = std::min(str.size(), buffer.size() - 1);
+        std::copy_n(str.data(), size, buffer.data());
+        render(buffer.data());
+    };
+
+    for (auto it = items.begin(); it != items.end();)
+    {
+        const std::string_view rest = it->first.substr(offset);
+        const size_t slash = rest.find('/');
+        const std::string_view name = rest.substr(0, slash);
+
+        if (slash == std::string_view::npos)
+        {
+            label(name, [&](const char* cstr) {
+                ImGui::BeginDisabled(!it->second);
+                if (ImGui::MenuItem(cstr) && it->second)
+                    it->second();
+                ImGui::EndDisabled();
+            });
+            ++it;
+            continue;
+        }
+
+        const size_t childOffset = offset + slash + 1;
+        auto childEnd = std::next(it);
+        while (childEnd != items.end() && childEnd->first.size() > childOffset && childEnd->first.substr(offset, slash) == name && childEnd->first[offset + slash] == '/')
+            ++childEnd;
+
+        label(name, [&](const char* cstr) {
+            if (ImGui::BeginMenu(cstr))
+            {
+                menuFromPath(std::ranges::subrange(it, childEnd), childOffset);
+                ImGui::EndMenu();
+            }
+        });
+
+        it = childEnd;
+    }
+}
+
+void sceneGrapRow(GE::Entity& entity, GE::Entity& selectedEntity)
+{
+    bool node_open = false;
+        ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_DefaultOpen;
+
+        if (selectedEntity == entity)
+            flags |= ImGuiTreeNodeFlags_Selected;
+
+        if (entity.children().size() > 0)
+            node_open = ImGui::TreeNodeEx((void*)entity.entityId, flags, "%s", entity.name().c_str());
+        else
+        {
+            flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
+            ImGui::TreeNodeEx((void*)entity.entityId, flags, "%s", entity.name().c_str());
+        }
+
+        if (ImGui::BeginDragDropSource())
+        {
+            ImGui::SetDragDropPayload("dnd_entity", &entity, sizeof(GE::const_Entity));
+            ImGui::Text("%s", entity.name().c_str());
+            ImGui::EndDragDropSource();
+        }
+
+        if (ImGui::BeginDragDropTarget())
+        {
+            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_entity")) {
+                assert(payload->DataSize == sizeof(GE::Entity));
+                GE::Entity& droped = *(GE::Entity*)payload->Data;
+                if (droped.isParentOf(entity) == false) {
+                    if(auto parent = droped.parent())
+                        parent->removeChild(droped);
+                    entity.addChild(droped);
+                }
+            }
+            ImGui::EndDragDropTarget();
+        }
+
+        if (ImGui::IsItemClicked())
+            selectedEntity = entity;
+
+        if (ImGui::BeginPopupContextItem())
+        {
+            menuFromPath(std::to_array<MenuItem>({
+                {"Delete", [&] {
+                    if (selectedEntity == entity)
+                        selectedEntity = GE::Entity{};
+                    entity.destroy();
+                }}
+            }));
+            ImGui::EndPopup();
+            if (entity.world == nullptr || entity.entityId == INVALID_ENTITY_ID)
+                return;
+        }
+
+        if (node_open && entity.children().size() > 0)
+        {
+            for (auto curr = entity.firstChild(); curr; curr = curr->nextChild() )
+                sceneGrapRow(*curr, selectedEntity);
+            ImGui::TreePop();
+        }
+}
+
+}
+
+namespace GE_Editor
+{
+
+void Editor::renderImgui()
+{
+    static bool projectPropertiesOpen = false;
+    static std::filesystem::path resourceBrowserSubDir;
+
+    ImGui::NewFrame();
+
+    ImGui::DockSpaceOverViewport();
+
+    if (ImGui::BeginMainMenuBar())
+    {
+        menuFromPath(std::to_array<MenuItem>({
+            {"file/new",                  {}},
+
+            {"file/open",                 {}},
+
+            {"file/save",                 !m_projectFilePath.empty() ? [this]() { saveProject(); }
+                                                                     : std::function<void()>()},
+
+            {"project/properties",        []() { projectPropertiesOpen = true; }},
+
+            {"project/reload script lib", std::filesystem::exists(m_project.scriptLib()) && !m_game.has_value() ? [this]() { reloadScriptLib(); }
+                                                                                                                : std::function<void()>()},
+
+            {"project/run",               m_game.has_value() ? std::function<void()>()
+                                                             : [this]() { startGame(); }},
+
+            {"project/stop",              m_game.has_value() ? [this]() { stopGame(); }
+                                                             : std::function<void()>()},
+
+        }));
+    }
+    ImGui::EndMainMenuBar();
+
+    if (ImGui::Begin("viewport"))
+    {
+        static std::variant<std::string, uint64_t> textureIdPlaceholder = std::string("viewportBackBuffer");
+
+        ImVec2 contentRegionAvai = ImGui::GetContentRegionAvail();
+        uint32_t newWidth = contentRegionAvai.x <= 0 ? 1 : contentRegionAvai.x;
+        uint32_t newHeight = contentRegionAvai.y <= 0 ? 1 : contentRegionAvai.y;
+
+        ImGui::Image(&textureIdPlaceholder, contentRegionAvai);
+
+        if (newWidth != m_viewportSize.first || newHeight != m_viewportSize.second) {
+            m_viewportSize = {newWidth, newHeight};
+            rebuildFrameGraph();
+        }
+    }
+    ImGui::End();
+
+    if (ImGui::Begin("Scene graph"))
+    {
+        if (ImGui::BeginChild("scene_graph_child"))
+        {
+            for (GE::Entity entity : m_editedScene.second.ecsWorld()
+                                        | GE::ECSView<GE::NameComponent>()
+                                        | std::views::transform([&](auto id){ return GE::Entity{&m_editedScene.second.ecsWorld(), id}; })
+                                        | std::ranges::to<std::vector>())
+            {
+                if (entity.parent().has_value() == false)
+                    sceneGrapRow(entity, m_selectedEntity);
+            }
+            if (ImGui::BeginPopupContextWindow("scene_graph_context", ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+            {
+                menuFromPath(std::to_array<MenuItem>({
+                    {"Add/Cube", [this] {
+                        m_selectedEntity = m_editedScene.second.newEntity("cube");
+                        m_selectedEntity.emplace<GE::TransformComponent>();
+                        m_selectedEntity.emplace<GE::MeshComponent>(GE::BUILT_IN_CUBE_ASSET_ID);
+                    }},
+                    {"Add/Light", [this] {
+                        m_selectedEntity = m_editedScene.second.newEntity("light");
+                        m_selectedEntity.emplace<GE::TransformComponent>();
+                        m_selectedEntity.emplace<GE::LightComponent>();
+                    }},
+                    {"Add/Camera", [this] {
+                        m_selectedEntity = m_editedScene.second.newEntity("camera");
+                        m_selectedEntity.emplace<GE::TransformComponent>();
+                        m_selectedEntity.emplace<GE::CameraComponent>();
+                        if (m_editedScene.second.activeCamera().entityId == INVALID_ENTITY_ID)
+                            m_editedScene.second.setActiveCamera(m_selectedEntity);
+                    }}
+                }));
+                ImGui::EndPopup();
+            }
+            ImGui::EndChild();
+        }
+        if (ImGui::BeginDragDropTarget())
+        {
+            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("dnd_entity")) {
+                assert(payload->DataSize == sizeof(GE::Entity));
+                GE::Entity& droped = *(GE::Entity*)payload->Data;
+                if(auto parent = droped.parent())
+                    parent->removeChild(droped);
+            }
+            ImGui::EndDragDropTarget();
+        }
+    }
+    ImGui::End();
+
+    if (ImGui::Begin("Scenes"))
+    {
+        tileGrid(m_project.scenes() | std::views::values, std::function([](const GE::Scene::Descriptor& scene){
+            ImGui::BeginGroup();
+            {
+                ImGui::Button(scene.name.c_str(), ImVec2(TILE_SIZE, TILE_SIZE));
+                if (ImGui::BeginDragDropSource())
+                {
+                    ImGui::SetDragDropPayload("scene_dnd", scene.name.c_str(), scene.name.size());
+                    ImGui::Text("%s", scene.name.c_str());
+                    ImGui::EndDragDropSource();
+                }
+                ImVec2 textMin = ImGui::GetCursorScreenPos();
+                ImVec2 textSize = {TILE_SIZE, ImGui::GetTextLineHeightWithSpacing()};
+                ImVec4 clipRect(textMin.x, textMin.y, textMin.x + textSize.x, textMin.y + textSize.y);
+                ImGui::GetWindowDrawList()->AddText(ImGui::GetFont(), ImGui::GetFontSize(), textMin, ImGui::GetColorU32(ImGuiCol_Text), scene.name.c_str(), nullptr, 0.0f, &clipRect);
+                ImGui::Dummy(textSize);
+            }
+            ImGui::EndGroup();
+        }));
+    }
+    ImGui::End();
+
+    if (ImGui::Begin("Resources") && std::filesystem::exists(m_project.resourceDir()))
+    {
+        ImGui::BeginDisabled(resourceBrowserSubDir.empty());
+        if (ImGui::Button("<"))
+            resourceBrowserSubDir = resourceBrowserSubDir.parent_path();
+        ImGui::EndDisabled();
+        ImGui::SameLine();
+        const std::string resourcePath = (m_project.resourceDir().filename() / resourceBrowserSubDir).string();
+        ImGui::TextUnformatted(resourcePath.c_str());
+        ImGui::BeginChild("ResourcesChild");
+        tileGrid(std::filesystem::directory_iterator(m_project.resourceDir() / resourceBrowserSubDir), std::function([](const std::filesystem::directory_entry& entry){
+            ImGui::BeginGroup();
+            {
+                const std::string entryPath = entry.path().string();
+                const std::string entryName = entry.path().filename().string();
+                if (entry.is_directory()) {
+                    ImGui::Button(std::format("DIR##{}", entryPath).c_str(), ImVec2(TILE_SIZE, TILE_SIZE));
+                    if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+                        resourceBrowserSubDir /= entry.path().filename();
+                }
+                else {
+                    ImGui::Button(std::format("FILE##{}", entryPath).c_str(), ImVec2(TILE_SIZE, TILE_SIZE));
+                    if (ImGui::BeginDragDropSource())
+                    {
+                        ImGui::SetDragDropPayload("resource_dnd", entryPath.c_str(), entryPath.size() + 1);
+                        ImGui::Text("%s", entryName.c_str());
+                        ImGui::EndDragDropSource();
+                    }
+                }
+                ImVec2 textMin = ImGui::GetCursorScreenPos();
+                ImVec2 textSize = {TILE_SIZE, ImGui::GetTextLineHeightWithSpacing()};
+                ImVec4 clipRect(textMin.x, textMin.y, textMin.x + textSize.x, textMin.y + textSize.y);
+                ImGui::GetWindowDrawList()->AddText(ImGui::GetFont(), ImGui::GetFontSize(), textMin, ImGui::GetColorU32(ImGuiCol_Text), entryName.c_str(), nullptr, 0.0f, &clipRect);
+                ImGui::Dummy(textSize);
+            }
+            ImGui::EndGroup();
+        }));
+        ImGui::EndChild();
+    }
+    ImGui::End();
+
+    if (ImGui::Begin("Entity inspector"))
+    {
+        ImGui::PushItemWidth(-80);
+        if (m_selectedEntity.world == nullptr || m_selectedEntity.entityId == INVALID_ENTITY_ID)
+            ImGui::Text("No entity selected");
+        else
+        {
+            componentEditWidget<GE::NameComponent>(m_selectedEntity, m_editedScene.second);
+            GE::forEachType<EditableEntityComponents>([&]<typename ComponentT>() {
+                if (m_selectedEntity.has<ComponentT>() && collapsingHeaderWithActionButton(EditableEntityComponentTraits<ComponentT>::label, "Remove", EditableEntityComponentTraits<ComponentT>::label, [&] {
+                    m_selectedEntity.remove<ComponentT>();
+                }))
+                {
+                    if constexpr (std::is_same_v<ComponentT, GE::ScriptComponent>)
+                    {
+                        if (m_scriptLibrary.has_value())
+                            scriptComponentEditWidget(m_selectedEntity, m_editedScene.second, *m_scriptLibrary);
+                        else
+                            ImGui::TextDisabled("No script library loaded");
+                    }
+                    else
+                        componentEditWidget<ComponentT>(m_selectedEntity, m_editedScene.second);
+                }
+            });
+
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::Spacing();
+
+            if (ImGui::Button("Add component", ImVec2(-FLT_MIN, 0.0f)))
+                ImGui::OpenPopup("add_component_popup");
+            if (ImGui::BeginPopup("add_component_popup"))
+            {
+                GE::forEachType<EditableEntityComponents>([&]<typename ComponentT>() {
+                    if (m_selectedEntity.has<ComponentT>() == false && ImGui::Selectable(EditableEntityComponentTraits<ComponentT>::label))
+                        m_selectedEntity.emplace<ComponentT>();
+                });
+
+                ImGui::EndPopup();
+            }
+
+        }
+        ImGui::PopItemWidth();
+    }
+    ImGui::End();
+
+    if (projectPropertiesOpen)
+    {
+        ImGuiViewport* viewport = ImGui::GetMainViewport();
+        const ImVec2 windowSize(viewport->Size.x * 0.42f, viewport->Size.y * 0.70f);
+        ImGui::SetNextWindowPos(
+            ImVec2(viewport->Pos.x + viewport->Size.x * 0.5f, viewport->Pos.y + viewport->Size.y * 0.5f),
+            ImGuiCond_Appearing,
+            ImVec2(0.5f, 0.5f)
+        );
+        ImGui::SetNextWindowSize(windowSize, ImGuiCond_Appearing);
+
+        if (ImGui::Begin("Project properties", &projectPropertiesOpen, ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoCollapse))
+        {
+            ImGui::Spacing();
+
+            if (beginPropertyTable("##project_settings"))
+            {
+                propertyRow("Project name", [&] {
+                    char projectName[256];
+                    std::strncpy(projectName, m_project.name().c_str(), sizeof(projectName));
+                    projectName[255] = '\0';
+                    if (ImGui::InputText("##project_name", projectName, sizeof(projectName)))
+                        m_project.setName(projectName);
+                });
+
+                propertyRow("Project file", [&] {
+                    char projectPath[512];
+                    std::strncpy(projectPath, m_projectFilePath.string().c_str(), sizeof(projectPath));
+                    projectPath[511] = '\0';
+                    if (ImGui::InputText("##project_file", projectPath, sizeof(projectPath)))
+                        m_projectFilePath = projectPath;
+                });
+
+                propertyRow("Script library", [&] {
+                    char scriptLibPath[512];
+                    std::strncpy(scriptLibPath, m_project.scriptLib().string().c_str(), sizeof(scriptLibPath));
+                    scriptLibPath[511] = '\0';
+                    if (ImGui::InputText("##script_lib", scriptLibPath, sizeof(scriptLibPath)))
+                        m_project.setScriptLib(scriptLibPath);
+                });
+
+                ImGui::EndTable();
+            }
+
+            ImGui::Spacing();
+            ImGui::SeparatorText("Game inputs");
+
+            auto& inputContext = m_project.inputContext();
+
+            if (ImGui::Button("Add input")) {
+                std::size_t index = inputContext.inputs().size();
+                std::string name;
+                do name = std::format("input_{}", index++);
+                while (inputContext.inputs().contains(name));
+                inputContext.addInput(name, GE::ActionInput{});
+            }
+
+            std::string inputToRemove;
+            std::pair<std::string, std::string> renameRequest;
+
+            const float inputsHeight = std::max(180.0f, ImGui::GetContentRegionAvail().y - ImGui::GetFrameHeightWithSpacing() - 12.0f);
+            ImGui::BeginChild("##project_inputs", ImVec2(0.0f, inputsHeight), true);
+            for (auto& [inputName, vInput] : inputContext.inputs())
+            {
+                ImGui::PushID(inputName.c_str());
+
+                const bool isOpen = collapsingHeaderWithActionButton(inputName.c_str(), "Remove", inputName, [&] {
+                    inputToRemove = inputName;
+                });
+                if (isOpen)
+                {
+                    if (beginPropertyTable("##input_fields"))
+                    {
+                        char nameBuffer[256];
+                        std::strncpy(nameBuffer, inputName.c_str(), sizeof(nameBuffer));
+                        nameBuffer[255] = '\0';
+                        propertyRow("Name", [&] {
+                            if (ImGui::InputText("##name", nameBuffer, sizeof(nameBuffer), ImGuiInputTextFlags_EnterReturnsTrue))
+                                renameRequest = { inputName, nameBuffer };
+                        });
+
+                        const char* currentKindLabel = std::visit([](const auto& input) -> const char*
+                        {
+                            using InputType = std::remove_cvref_t<decltype(input)>;
+                            return EditableInputTraits<InputType>::label;
+                        },
+                        vInput);
+
+                        propertyRow("Kind", [&] {
+                            if (ImGui::BeginCombo("##kind", currentKindLabel))
+                            {
+                                GE::forEachType<GE::InputTypes>([&]<typename InputType>()
+                                {
+                                    const bool isSelected = std::holds_alternative<InputType>(vInput);
+                                    if (ImGui::Selectable(EditableInputTraits<InputType>::label, isSelected))
+                                        vInput = InputType{};
+                                    if (isSelected)
+                                        ImGui::SetItemDefaultFocus();
+                                });
+                                ImGui::EndCombo();
+                            }
+                        });
+
+                        propertyRow("Mapper", [&] {
+                            std::visit([](auto& input) {
+                                const char* currentMapperLabel = NO_INPUT_MAPPER_LABEL;
+                                if (!input.mapper)
+                                    currentMapperLabel = NO_INPUT_MAPPER_LABEL;
+                                std::visit([&](const auto& mapper)
+                                {
+                                    using MapperType = std::remove_cvref_t<decltype(mapper)>;
+                                    using RawInputType = typename MapperType::RawInputType;
+                                    currentMapperLabel = EditableRawInputTraits<RawInputType>::label;
+                                },
+                                *input.mapper);
+
+                                if (ImGui::BeginCombo("##mapper", currentMapperLabel))
+                                {
+                                    const bool noMapperSelected = !input.mapper.has_value();
+
+                                    if (ImGui::Selectable(NO_INPUT_MAPPER_LABEL, !input.mapper.has_value()))
+                                        input.mapper.reset();
+                                    if (!input.mapper.has_value())
+                                        ImGui::SetItemDefaultFocus();
+
+                                    GE::forEachType<GE::RawInputTypes>([&]<typename RawInputType>()
+                                    {
+                                        if constexpr (std::same_as<RawInputType, GE::KeyboardButton>)
+                                        {
+                                            using InputType = std::remove_cvref_t<decltype(input)>;
+                                            using MapperType = typename InputType::template MapperType<RawInputType>;
+                                            const bool isSelected = input.mapper && std::holds_alternative<MapperType>(*input.mapper);
+                                            if (ImGui::Selectable(EditableRawInputTraits<RawInputType>::label, isSelected) && !isSelected)
+                                                input.setMapper(MapperType{});
+                                            if (isSelected)
+                                                ImGui::SetItemDefaultFocus();
+                                        }
+                                    });
+
+                                    ImGui::EndCombo();
+                                }
+                            },
+                            vInput);
+                        });
+
+                        std::visit([&](auto& input)
+                        {
+                            using InputType = std::remove_cvref_t<decltype(input)>;
+                            if (!input.mapper)
+                                return;
+                            auto& mapper = std::get<GE::InputMapper<GE::KeyboardButton, InputType>>(*input.mapper);
+                            if constexpr (std::same_as<InputType, GE::Range2DInput>) {
+                                propertyRow("X+ key",  [&] { keyboardButtonCombo("##x_pos", mapper.xPos); });
+                                propertyRow("X- key",  [&] { keyboardButtonCombo("##x_neg", mapper.xNeg); });
+                                propertyRow("X scale", [&] { ImGui::InputFloat("##x_scale", &mapper.xScale); });
+
+                                propertyRow("Y+ key",  [&] { keyboardButtonCombo("##y_pos", mapper.yPos); });
+                                propertyRow("Y- key",  [&] { keyboardButtonCombo("##y_neg", mapper.yNeg); });
+                                propertyRow("Y scale", [&] { ImGui::InputFloat("##y_scale", &mapper.yScale); });
+
+                                propertyRow("Trigger", [&] { ImGui::InputFloat("##trigger", &mapper.triggerValue); });
+                            }
+                            else if constexpr (std::same_as<InputType, GE::RangeInput>) {
+                                propertyRow("Key",   [&] { keyboardButtonCombo("##key", mapper.button); });
+                                propertyRow("Scale", [&] { ImGui::InputFloat("##scale", &mapper.scale); });
+                            }
+                            else {
+                                propertyRow("Key", [&] { keyboardButtonCombo("##key", mapper.button); });
+                            }
+                        },
+                        vInput);
+                        ImGui::EndTable();
+                    }
+                    ImGui::Spacing();
+                }
+
+                ImGui::PopID();
+
+                if (!inputToRemove.empty())
+                    break;
+            }
+            ImGui::EndChild();
+
+            if (!renameRequest.first.empty())
+                inputContext.renameInput(renameRequest.first, renameRequest.second);
+            if (!inputToRemove.empty())
+                inputContext.removeInput(inputToRemove);
+
+            ImGui::Spacing();
+
+            if (ImGui::Button("Close", ImVec2(90.0f, 0.0f)))
+                projectPropertiesOpen = false;
+        }
+        ImGui::End();
+    }
+
+    ImGui::Render();
+}
+
+}
diff --git a/engine/Application.cpp b/engine/Application.cpp
deleted file mode 100644
index ae4f4ab..0000000
--- a/engine/Application.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * ---------------------------------------------------
- * Application.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/09/02 17:15:13
- * ---------------------------------------------------
- */
-
-#include "Application.hpp"
-#include "Graphics/Event.hpp"
-#include "Graphics/Platform.hpp"
-#include "UtilsCPP/Func.hpp"
-
-namespace GE
-{
-
-Application::Application()
-    : m_window(gfx::Platform::shared().newWindow(1280, 720)),
-      m_renderer(gfx::Platform::shared().newGraphicAPI(m_window))
-{
-    m_renderer.setOnImGuiRender(utils::Func<void()>(*this, &Application::onImGuiRender));
-
-    gfx::Platform::shared().addEventCallBack(utils::Func<void(gfx::Event&)>(*this, &Application::onEvent), this);
-}
-
-void Application::run()
-{
-    m_running = true;
-    while (m_running)
-    {
-        onUpdate();
-
-        m_renderer.render();
-
-        gfx::Platform::shared().pollEvents();
-
-        for (auto& ctx : m_inputContextPool)
-        {
-            if (ctx == m_dispatchedInputContext)
-                ctx->dispatchInputs();
-            else
-                ctx->resetInputs();
-        }
-        m_inputContextPool.clear();
-    }
-}
-
-void Application::onEvent(gfx::Event& event)
-{
-    if (event.dispatch<gfx::InputEvent>([&](gfx::InputEvent& inputEvent) {
-        for (auto& ctx : m_inputContextPool)
-            inputEvent.dispatch(utils::Func<void(gfx::InputEvent&)>(*ctx, &InputContext::onInputEvent));
-    })) return;
-
-    if (event.dispatch(utils::Func<void(gfx::WindowResizeEvent&)>(*this, &Application::onWindowResizeEvent)))
-        return;
-
-    if (event.dispatch(utils::Func<void(gfx::WindowRequestCloseEvent&)>(*this, &Application::onWindowRequestCloseEvent)))
-        return;
-}
-
-Application::~Application()
-{
-    gfx::Platform::shared().clearCallbacks(this);
-}
-
-}
\ No newline at end of file
diff --git a/engine/Application.hpp b/engine/Application.hpp
deleted file mode 100644
index f65b958..0000000
--- a/engine/Application.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * ---------------------------------------------------
- * Application.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/09/02 16:56:11
- * ---------------------------------------------------
- */
-
-#ifndef APPLICATION_HPP
-#define APPLICATION_HPP
-
-#include "Graphics/Event.hpp"
-#include "Graphics/Window.hpp"
-#include "InputManager/InputContext.hpp"
-#include "Renderer/Renderer.hpp"
-#include "UtilsCPP/Set.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-
-namespace GE
-{
-
-class Application
-{
-public:
-    Application();
-    Application(const Application&) = delete;
-    Application(Application&&)      = delete;
-
-    inline gfx::Window& window() { return *m_window; }
-    inline Renderer& renderer() { return m_renderer; }
-
-    void run();
-
-    virtual void onUpdate() = 0;
-    virtual void onImGuiRender() = 0;
-    void onEvent(gfx::Event&);
-    virtual void onWindowResizeEvent(gfx::WindowResizeEvent&) = 0;
-    virtual void onWindowRequestCloseEvent(gfx::WindowRequestCloseEvent&) = 0;
-
-    inline void addInputContext(InputContext* ctx) { m_inputContextPool.insert(ctx); }
-    inline void setDispatchedInputContext(InputContext* ctx) { m_dispatchedInputContext = ctx; }
-
-    inline void terminate() { m_running = false; }
-
-    virtual ~Application();
-
-private:
-    utils::SharedPtr<gfx::Window> m_window;
-    Renderer m_renderer;
-    utils::Set<InputContext*> m_inputContextPool;
-    InputContext* m_dispatchedInputContext = nullptr;
-
-    bool m_running = false;
-
-public:
-    Application& operator = (const Application&) = delete;
-    Application& operator = (Application&&)      = delete;
-};
-
-}
-
-#endif // APPLICATION_HPP
\ No newline at end of file
diff --git a/engine/AssetManager.cpp b/engine/AssetManager.cpp
deleted file mode 100644
index 2a259ee..0000000
--- a/engine/AssetManager.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * ---------------------------------------------------
- * AssetManager.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/13 12:00:28
- * ---------------------------------------------------
- */
-
-#include "AssetManager.hpp"
-#include "Graphics/Buffer.hpp"
-#include "Renderer/Mesh.hpp"
-#include "Math/Matrix.hpp"
-#include "Renderer/Renderer.hpp"
-#include "UtilsCPP/Array.hpp"
-#include "UtilsCPP/RuntimeError.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/Types.hpp"
-#include "assimp/Importer.hpp"
-#include "assimp/postprocess.h"
-#include "assimp/scene.h"
-#include "assimp/types.h"
-#include "uuid.h"
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <filesystem>
-#include <iterator>
-#include <random>
-#include <string>
-
-using json = nlohmann::json;
-namespace fs = std::filesystem;
-
-#define POST_PROCESSING_FLAGS         \
-    aiProcess_JoinIdenticalVertices | \
-    aiProcess_MakeLeftHanded        | \
-    aiProcess_Triangulate           | \
-    aiProcess_GenSmoothNormals      | \
-    aiProcess_FixInfacingNormals    | \
-    aiProcess_FlipUVs               | \
-    aiProcess_FlipWindingOrder      | \
-    aiProcess_CalcTangentSpace
-
-namespace GE
-{
-
-AssetManager::AssetManager()
-{
-}
-
-AssetID AssetManager::registerMesh(const fs::path& path)
-{
-    AssetID newAssetID;
-    if (m_registeredMeshes.contain(path))
-        newAssetID = m_registeredMeshes[path];
-    else
-    {
-        // TODO Check if the file is loadable using assimp
-
-        std::random_device rd;
-        auto seed_data = std::array<int, std::mt19937::state_size> {};
-        std::generate(std::begin(seed_data), std::end(seed_data), std::ref(rd));
-        std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-        std::mt19937 generator(seq);
-        newAssetID = uuids::uuid_random_generator{generator}();
-
-        m_registeredMeshes.insert(path, newAssetID);
-    }
-
-    if (isLoaded())
-        m_loadedMeshes.insert(newAssetID, loadMesh(m_baseDir/path, *m_api));
-
-    return newAssetID;
-}
-
-void AssetManager::loadAssets(gfx::GraphicAPI& api, const fs::path& baseDir)
-{
-    assert(isLoaded() == false);
-
-    assert(baseDir.empty() || fs::is_directory(baseDir) && baseDir.is_absolute());
-
-    m_api = &api;
-    m_baseDir = baseDir;
-
-    for (auto& [path, id] : m_registeredMeshes)
-        m_loadedMeshes.insert(id, loadMesh(m_baseDir/path, *m_api));
-    m_loadedMeshes.insert(BUILT_IN_CUBE_ASSET_ID, loadBuiltInCube());
-}
-
-void AssetManager::unloadAssets()
-{
-    assert(isLoaded());
-
-    m_loadedMeshes.clear();
-
-    m_api = nullptr;
-    m_baseDir.clear();
-}
-
-Mesh AssetManager::loadMesh(const fs::path& filepath, gfx::GraphicAPI& api)
-{
-    assert(filepath.is_absolute());
-    assert(fs::is_regular_file(filepath));
-
-    Assimp::Importer importer;
-
-    const aiScene* scene = importer.ReadFile(filepath.string(), POST_PROCESSING_FLAGS);
-    if (scene == nullptr)
-        throw utils::RuntimeError("fail to load the model using assimp");
-
-    utils::Array<SubMesh> flatSubMeshes;
-
-    for(utils::uint32 meshIndex = 0; meshIndex < scene->mNumMeshes; meshIndex++)
-    {
-        aiMesh* aiMesh = scene->mMeshes[meshIndex];
-
-        gfx::Buffer::Descriptor bufferDescriptor;
-        bufferDescriptor.size = aiMesh->mNumVertices * sizeof(Renderer::Vertex);
-        utils::SharedPtr<gfx::Buffer> vertexBuffer = api.newBuffer(bufferDescriptor);
-        auto* vertices = (Renderer::Vertex*)vertexBuffer->mapContent();
-
-        bufferDescriptor.size = aiMesh->mNumFaces * 3UL * sizeof(utils::uint32);
-        utils::SharedPtr<gfx::Buffer> indexBuffer = api.newBuffer(bufferDescriptor);
-        auto* indices = (utils::uint32*)indexBuffer->mapContent();
-
-        for(utils::uint32 i = 0; i < aiMesh->mNumVertices; i++)
-        {
-            vertices[i].pos = {
-                aiMesh->mVertices[i].x,
-                aiMesh->mVertices[i].y,
-                aiMesh->mVertices[i].z
-            };
-            if (aiMesh->mTextureCoords[0] != nullptr)
-            {
-                vertices[i].uv = {
-                    aiMesh->mTextureCoords[0][i].x,
-                    aiMesh->mTextureCoords[0][i].y
-                };
-            }
-            if (aiMesh->mNormals != nullptr)
-            {
-                vertices[i].normal = {
-                    aiMesh->mNormals[i].x,
-                    aiMesh->mNormals[i].y,
-                    aiMesh->mNormals[i].z
-                };
-            }
-            if (aiMesh->mTangents != nullptr)
-            {
-                vertices[i].tangent = {
-                    aiMesh->mTangents[i].x,
-                    aiMesh->mTangents[i].y,
-                    aiMesh->mTangents[i].z
-                };
-            }
-        }
-
-        for(utils::uint32 i = 0; i < aiMesh->mNumFaces; i++)
-        {
-            indices[i * 3 + 0] = aiMesh->mFaces[i].mIndices[0];
-            indices[i * 3 + 1] = aiMesh->mFaces[i].mIndices[1];
-            indices[i * 3 + 2] = aiMesh->mFaces[i].mIndices[2];
-        }
-
-        vertexBuffer->unMapContent();
-        indexBuffer->unMapContent();
-
-        flatSubMeshes.append(SubMesh{
-            aiMesh->mName.C_Str(),
-            math::mat4x4(1.0F),
-            vertexBuffer,
-            indexBuffer
-        });
-    }
-
-    utils::Array<SubMesh> transformedSubMeshes;
-
-    utils::Func<void(aiNode*, math::mat4x4)> addNode = [&](aiNode* aiNode, math::mat4x4 additionalTransform) {
-
-        math::mat4x4 transform = additionalTransform * math::mat4x4(
-            aiNode->mTransformation.a1, aiNode->mTransformation.a2, aiNode->mTransformation.a3, aiNode->mTransformation.a4,
-            aiNode->mTransformation.b1, aiNode->mTransformation.b2, aiNode->mTransformation.b3, aiNode->mTransformation.b4,
-            aiNode->mTransformation.c1, aiNode->mTransformation.c2, aiNode->mTransformation.c3, aiNode->mTransformation.c4,
-            aiNode->mTransformation.d1, aiNode->mTransformation.d2, aiNode->mTransformation.d3, aiNode->mTransformation.d4
-        );
-
-        for (utils::uint32 i = 0; i < aiNode->mNumMeshes; i++)
-        {
-            SubMesh& flatSubMeshe = flatSubMeshes[aiNode->mMeshes[i]];
-            transformedSubMeshes.append(SubMesh{
-                flatSubMeshe.name,
-                transform,
-                flatSubMeshe.vertexBuffer,
-                flatSubMeshe.indexBuffer
-            });
-        }
-
-        for (utils::uint32 i = 0; i < aiNode->mNumChildren; i++)
-            addNode(aiNode->mChildren[i], transform);
-    };
-
-    for (utils::uint32 i = 0; i < scene->mRootNode->mNumMeshes; i++)
-        transformedSubMeshes.append(flatSubMeshes[scene->mRootNode->mMeshes[i]]);
-
-    for (utils::uint32 i = 0; i < scene->mRootNode->mNumChildren; i++)
-        addNode(scene->mRootNode->mChildren[i], math::mat4x4(1.0F));
-
-    return Mesh{
-        scene->mRootNode->mName.C_Str(),
-        transformedSubMeshes
-    };
-}
-
-Mesh AssetManager::loadBuiltInCube()
-{
-    Renderer::Vertex vertices[] = {
-        { {-1, -1, -1}, {0, 1}, {-1,  0,  0}, { 0,  1,  0} },
-        { {-1,  1, -1}, {1, 1}, {-1,  0,  0}, { 0,  1,  0} },
-        { {-1,  1,  1}, {1, 0}, {-1,  0,  0}, { 0,  1,  0} },
-        { {-1, -1,  1}, {0, 0}, {-1,  0,  0}, { 0,  1,  0} },
-        { {-1, -1,  1}, {0, 1}, { 0,  0,  1}, { 0,  1,  1} },
-        { {-1,  1,  1}, {1, 1}, { 0,  0,  1}, { 0,  1,  1} },
-        { { 1,  1,  1}, {1, 0}, { 0,  0,  1}, { 0,  1,  1} },
-        { { 1, -1,  1}, {0, 0}, { 0,  0,  1}, { 0,  1,  1} },
-        { { 1, -1,  1}, {0, 1}, { 1,  0,  0}, { 0,  1,  0} },
-        { { 1,  1,  1}, {1, 1}, { 1,  0,  0}, { 0,  1,  0} },
-        { { 1,  1, -1}, {1, 0}, { 1,  0,  0}, { 0,  1,  0} },
-        { { 1, -1, -1}, {0, 0}, { 1,  0,  0}, { 0,  1,  0} },
-        { { 1, -1, -1}, {1, 0}, { 0,  0, -1}, { 0, -1, -1} },
-        { { 1,  1, -1}, {0, 0}, { 0,  0, -1}, { 0, -1, -1} },
-        { {-1,  1, -1}, {0, 1}, { 0,  0, -1}, { 0, -1, -1} },
-        { {-1, -1, -1}, {1, 1}, { 0,  0, -1}, { 0, -1, -1} },
-        { {-1, -1,  1}, {0, 1}, { 0, -1,  0}, { 1,  0,  0} },
-        { { 1, -1,  1}, {1, 1}, { 0, -1,  0}, { 1,  0,  0} },
-        { { 1, -1, -1}, {1, 0}, { 0, -1,  0}, { 1,  0,  0} },
-        { {-1, -1, -1}, {0, 0}, { 0, -1,  0}, { 1,  0,  0} },
-        { { 1,  1,  1}, {0, 1}, { 0,  1,  0}, {-1,  0,  0} },
-        { {-1,  1,  1}, {1, 1}, { 0,  1,  0}, {-1,  0,  0} },
-        { {-1,  1, -1}, {1, 0}, { 0,  1,  0}, {-1,  0,  0} },
-        { { 1,  1, -1}, {0, 0}, { 0,  1,  0}, {-1,  0,  0} },    
-    };
-
-    utils::uint32 indices[] = {
-         2,  1,  0,  3,  2,  0,
-         6,  5,  4,  7,  6,  4,
-        10,  9,  8, 11, 10,  8,
-        14, 13, 12, 15, 14, 12,
-        18, 17, 16, 19, 18, 16,
-        22, 21, 20, 23, 22, 20
-    };
-
-    return Mesh {
-        "built_in_cube",
-        utils::Array<SubMesh> {{
-            "built_in_cube_submesh",
-            math::mat4x4(1.0F),
-            m_api->newBuffer(gfx::Buffer::Descriptor(sizeof(Renderer::Vertex) * 24, vertices)),
-            m_api->newBuffer(gfx::Buffer::Descriptor(sizeof(utils::uint32) * 36, indices)),
-        }}
-    };
-}
-
-void to_json(json& jsn, const AssetManager& assetManager)
-{
-    if (assetManager.m_registeredMeshes.isEmpty() == false)
-    {
-        json registeredMeshesJsn;
-        for (auto& [path, id] : assetManager.m_registeredMeshes)
-            registeredMeshesJsn[path.string()] = uuids::to_string(id);
-        jsn["registeredMeshes"] = registeredMeshesJsn;
-    }
-}
-
-void from_json(const json& jsn, AssetManager& assetManager)
-{
-    auto registeredMeshesIt = jsn.find("registeredMeshes");
-    if (registeredMeshesIt != jsn.end())
-    {
-        for (auto& el : registeredMeshesIt->items())
-        {
-            auto id = uuids::uuid::from_string(el.value().get<std::string>());
-            if (id.has_value())
-                assetManager.m_registeredMeshes.insert(fs::path(el.key()), id.value());
-        }
-    }   
-}
-
-}
\ No newline at end of file
diff --git a/engine/AssetManager.hpp b/engine/AssetManager.hpp
deleted file mode 100644
index 58359ee..0000000
--- a/engine/AssetManager.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * ---------------------------------------------------
- * AssetManager.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/13 11:49:48
- * ---------------------------------------------------
- */
-
-#ifndef ASSETMANAGER_HPP
-#define ASSETMANAGER_HPP
-
-#include "Renderer/Mesh.hpp"
-#include "Graphics/GraphicAPI.hpp"
-#include "UtilsCPP/Dictionary.hpp"
-#include "uuid.h"
-#include <filesystem>
-#include <nlohmann/json.hpp>
-
-#define BUILT_IN_CUBE_ASSET_ID uuids::uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()
-
-namespace GE
-{
-
-using AssetID = uuids::uuid;
-
-class AssetManager
-{
-public:
-    AssetManager();
-    AssetManager(const AssetManager&) = default;
-    AssetManager(AssetManager&&)      = default;
-
-    AssetID registerMesh(const std::filesystem::path& relativePath);
-    inline const utils::Dictionary<std::filesystem::path, AssetID>& registeredMeshes() const { return m_registeredMeshes; }
-
-    inline const utils::Dictionary<AssetID, Mesh>& loadedMeshes() const { return m_loadedMeshes; }
-
-    void loadAssets(gfx::GraphicAPI&, const std::filesystem::path& baseDir);
-    void unloadAssets();
-
-    inline bool isLoaded() const { return m_api != nullptr; }
-
-    ~AssetManager() = default;
-
-private:
-    Mesh loadMesh(const std::filesystem::path&, gfx::GraphicAPI&);
-    Mesh loadBuiltInCube();
-
-    gfx::GraphicAPI* m_api = nullptr;
-    std::filesystem::path m_baseDir;
-
-    utils::Dictionary<std::filesystem::path, AssetID> m_registeredMeshes;
-
-    utils::Dictionary<AssetID, Mesh> m_loadedMeshes;
-
-public:
-    AssetManager& operator = (const AssetManager&) = default;
-    AssetManager& operator = (AssetManager&&)      = default;
-
-    friend void to_json(nlohmann::json&, const AssetManager&);
-    friend void from_json(const nlohmann::json&, AssetManager&);
-};
-
-}
-
-#endif // ASSETMANAGER_HPP
\ No newline at end of file
diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
deleted file mode 100644
index 6830cdc..0000000
--- a/engine/CMakeLists.txt
+++ /dev/null
@@ -1,68 +0,0 @@
-# ---------------------------------------------------
-# CMakeLists.txt
-#
-# Author: Thomas Choquet <semoir.dense-0h@icloud.com>
-# Date: 2024/09/10 10:01:04
-# ---------------------------------------------------
-
-include(FetchContent)
-
-add_library(Game-Engine STATIC)
-set_target_properties(Game-Engine PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON)
-
-file(GLOB_RECURSE GAME_ENGINE_SRC "*.cpp" "*.hpp")
-target_sources(Game-Engine PRIVATE ${GAME_ENGINE_SRC})
-
-target_include_directories(Game-Engine PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
-
-if(GE_BUILD_METAL)
-    set(MTL_SHADER_DIR "${CMAKE_SOURCE_DIR}/shaders")
-    set(MTL_SHADER_LIB "${CMAKE_BINARY_DIR}/MTLShaderLib.metallib")
-endif()
-if(GE_BUILD_OPENGL)
-    set(OPENGL_SHADER_DIR "${CMAKE_SOURCE_DIR}/shaders")
-endif()
-
-if(GE_BUILD_METAL)
-    target_compile_definitions(Game-Engine PRIVATE "MTL_SHADER_LIB=\"${MTL_SHADER_LIB}\"")
-endif()
-if(GE_BUILD_OPENGL)
-    target_compile_definitions(Game-Engine PRIVATE "OPENGL_SHADER_DIR=\"${OPENGL_SHADER_DIR}\"")
-endif()
-
-target_compile_definitions(Game-Engine PUBLIC "UTILSCPP_API_EXPORT")
-target_compile_definitions(Game-Engine PUBLIC "MATH_API_EXPORT")
-target_compile_definitions(Game-Engine PUBLIC "GAME_ENGINE_API_EXPORT")
-
-target_link_libraries(Game-Engine PUBLIC  UtilsCPP)
-target_link_libraries(Game-Engine PUBLIC  Math)
-target_link_libraries(Game-Engine PUBLIC  Graphics)
-target_link_libraries(Game-Engine PRIVATE assimp)
-target_link_libraries(Game-Engine PUBLIC  nlohmann_json::nlohmann_json)
-target_link_libraries(Game-Engine PUBLIC  stduuid)
-target_link_libraries(Game-Engine PUBLIC  stb_image)
-target_link_libraries(Game-Engine PUBLIC  dlLoad)
-
-if(GE_BUILD_METAL)
-    add_custom_target(MTLShaderLib DEPENDS ${MTL_SHADER_LIB})
-    
-    file(GLOB MTL_SHADER_LIB_SRCS "${MTL_SHADER_DIR}/*.metal")
-    target_sources(MTLShaderLib PRIVATE ${MTL_SHADER_LIB_SRCS})
-    
-    add_dependencies(Game-Engine MTLShaderLib)
-    
-    if(CMAKE_GENERATOR STREQUAL "Xcode")
-        list(APPEND MTL_SHADER_BUILD_FLAGS "-gline-tables-only" "-frecord-sources")
-    endif()
-    
-    find_program(XCRUN_PATH xcrun REQUIRED)
-    
-    foreach(src IN LISTS MTL_SHADER_LIB_SRCS)
-        string(REPLACE ".metal" ".air" air "${src}")
-        string(REPLACE ${MTL_SHADER_DIR} ${CMAKE_CURRENT_BINARY_DIR} air "${air}")
-        add_custom_command(OUTPUT "${air}" COMMAND ${XCRUN_PATH} -sdk macosx metal ${MTL_SHADER_BUILD_FLAGS} -o "${air}" -c "${src}" DEPENDS "${src}")
-        list(APPEND MTL_SHADER_LIB_AIRS "${air}")
-    endforeach()
-    
-    add_custom_command(OUTPUT ${MTL_SHADER_LIB} COMMAND ${XCRUN_PATH} -sdk macosx metallib ${MTL_SHADER_LINK_FLAGS} -o ${MTL_SHADER_LIB} ${MTL_SHADER_LIB_AIRS} DEPENDS ${MTL_SHADER_LIB_AIRS})
-endif()
\ No newline at end of file
diff --git a/engine/ECS/Archetype.hpp b/engine/ECS/Archetype.hpp
deleted file mode 100644
index f3cb666..0000000
--- a/engine/ECS/Archetype.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * ---------------------------------------------------
- * Archetype.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/16 16:36:28
- * ---------------------------------------------------
- */
-
-#ifndef ECSWORLD_HPP
-    #include "UtilsCPP/Dictionary.hpp"
-    #include "UtilsCPP/Types.hpp"
-
-    using EntityID = utils::uint64;
-    using ComponentID = utils::uint32;
-    using ArchetypeID = utils::Set<ComponentID>;
-
-    using CopyConstructor = utils::Func<void(void* src, void* dst)>;
-    using MoveConstructor = utils::Func<void(void* src, void* dst)>;
-    using Destructor      = utils::Func<void(void* ptr)>;
-
-    template<typename T> ComponentID componentID();
-    template<typename T> utils::uint64 componentSize();
-    template<typename T> const CopyConstructor& componentCopyConstructor();
-    template<typename T> const MoveConstructor& componentMoveConstructor();
-    template<typename T> const Destructor& componentDestructor();
-#endif // ECSWORLD_HPP
-
-class Archetype
-{
-public:
-    Archetype();
-    Archetype(const Archetype&); // copy constructor make no sense inside the same ECSWorld. ment to be used only when copying the ECSWorld
-    Archetype(Archetype&&);
-
-    utils::uint64 size() const { return m_size; }
-
-    // must be use on empty achetype that are not inserted `ECSWorld::m_archetypes`
-    template<typename T>
-    void addRowType()
-    {
-        m_rows.insert(componentID<T>(), Row{
-            operator new (componentSize<T>() * m_capacity),
-            componentSize<T>(),
-            componentCopyConstructor<T>(),
-            componentMoveConstructor<T>(),
-            componentDestructor<T>(),
-        });
-    }
-
-    // must be use on empty achetype that are not inserted `ECSWorld::m_archetypes`
-    template<typename T>
-    void rmvRowType()
-    {
-        {
-            Row& row = m_rows[componentID<T>()];
-            if (row.buffer != nullptr)
-            {
-                for (utils::uint64 i = 0; i < m_size; i++)
-                    row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
-                operator delete (row.buffer);
-            }            
-        }
-        m_rows.remove(componentID<T>());
-    }
-
-    // only duplicate the component infos (no component duplicated)
-    Archetype duplicateRowTypes();
-
-    // only extend the size (and capacity if needed) and return last index
-    utils::uint64 allocateCollum();
-
-    template<typename T>
-    T* getComponentPointer(utils::uint64 idx)
-    {
-        Row& row = m_rows[componentID<T>()];
-        return static_cast<T*>(row.buffer) + idx;
-    }
-
-    template<typename T>
-    const T* getComponentPointer(utils::uint64 idx) const
-    {
-        const Row& row = m_rows[componentID<T>()];
-        return static_cast<T*>(row.buffer) + idx;
-    }
-    
-    EntityID& getEntityID(utils::uint64 idx);
-    const EntityID& getEntityID(utils::uint64 idx) const;
-
-    // destination should be garbage memory
-    // only call the move constructor
-    static void moveComponents(Archetype& arcSrc, utils::uint64 idxSrc, Archetype& arcDst, utils::uint64 idxDst);
-
-    // only call the destructor
-    void destructCollum(utils::uint64 idx);
-
-    // only reduce the size (and capacity if needed)
-    void freeLastCollum();
-
-    ~Archetype();
-
-private:
-    struct Row
-    {
-        void* buffer = nullptr;
-        const utils::uint64 componentSize;
-        const CopyConstructor copyConstructor;
-        const MoveConstructor moveConstructor;
-        const Destructor destructor;
-    };
-
-    utils::Dictionary<ComponentID, Row> m_rows;
-    utils::uint64 m_size;
-    utils::uint64 m_capacity;
-
-    void setCapacity(utils::uint64);
-    inline void extendCapacity() { setCapacity(m_capacity * 2); }
-    inline void reduceCapacity() { setCapacity(m_capacity / 2 > 0 ? m_capacity / 2 : 1); }
-
-public:
-    Archetype& operator = (const Archetype&);
-    Archetype& operator = (Archetype&&);
-};
diff --git a/engine/ECS/Components.cpp b/engine/ECS/Components.cpp
deleted file mode 100644
index b0510cc..0000000
--- a/engine/ECS/Components.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * ---------------------------------------------------
- * Components.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/19 19:05:33
- * ---------------------------------------------------
- */
-
-#include "Components.hpp"
-#include "AssetManager.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "UtilsCPP/String.hpp"
-#include <nlohmann/json.hpp>
-#include <string>
-
-using json = nlohmann::json;
-
-namespace GE
-{
-
-NameComponent::NameComponent(const utils::String& n)
-    : name(n)
-{
-}
-
-void to_json(json& jsn, const NameComponent& comp)
-{
-    jsn["name"] = comp.name;
-}
-
-void from_json(const json& jsn, NameComponent& comp)
-{
-    auto nameIt = jsn.find("name");
-    if (nameIt != jsn.end())
-        comp.name = nameIt->template get<std::string>().c_str();
-}
-
-void to_json(json& jsn, const HierarchyComponent& comp)
-{
-    if (comp.parent != INVALID_ENTITY_ID)
-        jsn["parent"] = comp.parent;
-    if (comp.firstChild != INVALID_ENTITY_ID)
-        jsn["firstChild"] = comp.firstChild;
-    if (comp.nextChild != INVALID_ENTITY_ID)
-        jsn["nextChild"] = comp.nextChild;
-}
-
-void from_json(const json& jsn, HierarchyComponent& comp)
-{
-    auto parentIt = jsn.find("parent");
-    if (parentIt != jsn.end())
-        comp.parent = parentIt->template get<ECSWorld::EntityID>();
-
-    auto firstChildIt = jsn.find("firstChild");
-    if (firstChildIt != jsn.end())
-        comp.firstChild = firstChildIt->template get<ECSWorld::EntityID>();
-
-    auto nextChildIt = jsn.find("nextChild");
-    if (nextChildIt != jsn.end())
-        comp.nextChild = nextChildIt->template get<ECSWorld::EntityID>();
-}
-
-TransformComponent::TransformComponent(const math::vec3f& p, const math::vec3f& r, const math::vec3f& s)
-    : position(p), rotation(r), scale(s)
-{
-}
-
-void to_json(json& jsn, const TransformComponent& comp)
-{
-    jsn = {
-        { "position", {
-            {"x", comp.position.x },
-            {"y", comp.position.y },
-            {"z", comp.position.z }
-        }},
-        { "rotation", {
-            {"x", comp.rotation.x },
-            {"y", comp.rotation.y },
-            {"z", comp.rotation.z }
-        }},
-        { "scale", {
-            {"x", comp.scale.x },
-            {"y", comp.scale.y },
-            {"z", comp.scale.z }
-        }}
-    };
-}
-
-void from_json(const json& jsn, TransformComponent& comp)
-{
-    auto positionIt = jsn.find("position");
-    if (positionIt != jsn.end())
-    {
-        auto xIt = positionIt->find("x");
-        auto yIt = positionIt->find("y");
-        auto zIt = positionIt->find("z");
-        if (xIt != positionIt->end() && yIt != positionIt->end() && zIt != positionIt->end())
-            comp.position = math::vec3f(xIt->template get<float>(), yIt->template get<float>(), zIt->template get<float>());
-    }
-    auto rotationIt = jsn.find("rotation");
-    if (rotationIt != jsn.end())
-    {
-        auto xIt = rotationIt->find("x");
-        auto yIt = rotationIt->find("y");
-        auto zIt = rotationIt->find("z");
-        if (xIt != rotationIt->end() && yIt != rotationIt->end() && zIt != rotationIt->end())
-            comp.rotation = math::vec3f(xIt->template get<float>(), yIt->template get<float>(), zIt->template get<float>());
-    }
-    auto scaleIt = jsn.find("scale");
-    if (scaleIt != jsn.end())
-    {
-        auto xIt = scaleIt->find("x");
-        auto yIt = scaleIt->find("y");
-        auto zIt = scaleIt->find("z");
-        if (xIt != scaleIt->end() && yIt != scaleIt->end() && zIt != scaleIt->end())
-            comp.scale = math::vec3f(xIt->template get<float>(), yIt->template get<float>(), zIt->template get<float>());
-    }
-}
-
-CameraComponent::CameraComponent(float f, float zf, float zn)
-    : fov(f), zFar(zf), zNear(zn)
-{
-}
-
-math::mat4x4 CameraComponent::projectionMatrix()
-{
-    float zs = zFar / (zFar - zNear);
-    float ys = 1.0F / std::tan(fov * 0.5F);
-    float xs = ys; // (ys / aspectRatio)
-
-    return math::mat4x4(xs,  0,  0,           0,
-                         0, ys,  0,           0,
-                         0,  0, zs, -zNear * zs,
-                         0,  0,  1,           0);
-}
-
-void to_json(json& jsn, const CameraComponent& comp)
-{
-    jsn = {
-        { "fov", comp.fov },
-        { "zFar", comp.zFar },
-        { "zNear", comp.zNear }
-    };
-}
-
-void from_json(const json& jsn, CameraComponent& comp)
-{
-    auto fovIt = jsn.find("fov");
-    if (fovIt != jsn.end())
-        comp.fov = fovIt->template get<float>();
-    auto zFarIt = jsn.find("zFar");
-    if (zFarIt != jsn.end())
-        comp.zFar = zFarIt->template get<float>();
-    auto zNearIt = jsn.find("zNear");
-    if (zNearIt != jsn.end())
-        comp.zNear = zNearIt->template get<float>();
-}
-
-LightComponent::LightComponent(Type t, math::rgb c, float i)
-    : type(t), color(c), intentsity(i)
-{
-}
-
-void to_json(json& jsn, const LightComponent& comp)
-{
-    jsn = {
-        { "type", (utils::uint8)comp.type },
-        { "color", {
-            {"r", comp.color.r },
-            {"g", comp.color.g },
-            {"b", comp.color.b }
-        }},
-        { "intentsity", comp.intentsity }
-    };
-}
-
-void from_json(const json& jsn, LightComponent& comp)
-{
-    auto typeIt = jsn.find("type");
-    if (typeIt != jsn.end())
-        comp.type = (LightComponent::Type)(typeIt->template get<utils::uint8>());
-    auto colorIt = jsn.find("color");
-    if (colorIt != jsn.end())
-    {
-        auto rIt = colorIt->find("r");
-        auto gIt = colorIt->find("g");
-        auto bIt = colorIt->find("b");
-        if (rIt != colorIt->end() && gIt != colorIt->end() && bIt != colorIt->end())
-            comp.color = math::vec3f(rIt->template get<float>(), gIt->template get<float>(), bIt->template get<float>());
-    }
-    auto intentsityIt = jsn.find("intentsity");
-    if (intentsityIt != jsn.end())
-        comp.intentsity = intentsityIt->template get<float>();
-}
-
-MeshComponent::MeshComponent(AssetID id)
-    : assetId(id)
-{
-}
-
-void to_json(json& jsn, const MeshComponent& comp)
-{
-    if (comp.assetId.is_nil() == false)
-        jsn["assetId"] = uuids::to_string(comp.assetId);
-}
-
-void from_json(const json& jsn, MeshComponent& comp)
-{
-    auto assetIdIt = jsn.find("assetId");
-    if (assetIdIt != jsn.end())
-        comp.assetId = uuids::uuid::from_string(assetIdIt->template get<std::string>()).value_or(AssetID());
-}
-
-void to_json(nlohmann::json& jsn, const ScriptComponent& comp)
-{
-    jsn["name"] = comp.name;
-}
-
-void from_json(const nlohmann::json& jsn, ScriptComponent& comp)
-{
-    auto nameIt = jsn.find("name");
-    if (nameIt != jsn.end())
-        comp.name = nameIt->template get<std::string>().c_str();
-}
-
-}
\ No newline at end of file
diff --git a/engine/ECS/Components.hpp b/engine/ECS/Components.hpp
deleted file mode 100644
index 5185322..0000000
--- a/engine/ECS/Components.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * ---------------------------------------------------
- * Components.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/18 17:35:21
- * ---------------------------------------------------
- */
-
-#ifndef COMPONENTS_HPP
-#define COMPONENTS_HPP
-
-#include "AssetManager.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "Math/Constants.hpp"
-#include "Math/Matrix.hpp"
-#include "Math/Vector.hpp"
-#include "Script.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <nlohmann/json.hpp>
-
-namespace GE
-{
-
-struct NameComponent
-{
-    utils::String name;
-
-    NameComponent() = default;
-    NameComponent(const utils::String&);
-    inline operator utils::String& () { return name; }
-    friend void to_json(nlohmann::json&, const NameComponent&);
-    friend void from_json(const nlohmann::json&, NameComponent&);
-};
-
-struct HierarchyComponent
-{
-    ECSWorld::EntityID parent = INVALID_ENTITY_ID;
-    ECSWorld::EntityID firstChild = INVALID_ENTITY_ID;
-    ECSWorld::EntityID nextChild = INVALID_ENTITY_ID;
-
-    HierarchyComponent() = default;
-    friend void to_json(nlohmann::json&, const HierarchyComponent&);
-    friend void from_json(const nlohmann::json&, HierarchyComponent&);
-};
-
-struct TransformComponent
-{
-    math::vec3f position = {0.0F, 0.0F, 0.0F};
-    math::vec3f rotation = {0.0F, 0.0F, 0.0F};
-    math::vec3f scale    = {1.0F, 1.0F, 1.0F};
-
-    TransformComponent() = default;
-    TransformComponent(const math::vec3f& position, const math::vec3f& rotation, const math::vec3f& scale);
-    inline math::mat4x4 transform() const { return math::mat4x4::translation(position) * math::mat4x4::rotation(rotation) * math::mat4x4::scale(scale); }
-    inline operator math::mat4x4 () const { return transform(); }
-    friend void to_json(nlohmann::json&, const TransformComponent&);
-    friend void from_json(const nlohmann::json&, TransformComponent&);
-};
-
-struct CameraComponent
-{
-    float fov = (float)(60 * (PI / 180.0F));
-    float zFar = 10000.0F;
-    float zNear = 0.01F;
-
-    CameraComponent() = default;
-    CameraComponent(float fov, float zFar, float zNear);
-    math::mat4x4 projectionMatrix();
-    friend void to_json(nlohmann::json&, const CameraComponent&);
-    friend void from_json(const nlohmann::json&, CameraComponent&);
-};
-
-struct LightComponent
-{
-    enum class Type : utils::uint8 { point = 0 } type = LightComponent::Type::point;
-    math::rgb color = WHITE3;
-    float intentsity = 1.0F;
-
-    LightComponent() = default;
-    LightComponent(Type t, math::rgb c, float i);
-    friend void to_json(nlohmann::json&, const LightComponent&);
-    friend void from_json(const nlohmann::json&, LightComponent&);
-};
-
-struct MeshComponent
-{
-    AssetID assetId;
-
-    MeshComponent() = default;
-    MeshComponent(AssetID id);
-    inline operator const AssetID& () const { return assetId; }
-    inline operator AssetID& () { return assetId; }
-    friend void to_json(nlohmann::json&, const MeshComponent&);
-    friend void from_json(const nlohmann::json&, MeshComponent&);
-};
-
-struct ScriptComponent
-{
-    utils::String name;
-    utils::SharedPtr<Script> instance;
-
-    ScriptComponent() = default;
-    friend void to_json(nlohmann::json&, const ScriptComponent&);
-    friend void from_json(const nlohmann::json&, ScriptComponent&);
-};
-
-}
-
-#endif // COMPONENTS_HPP
\ No newline at end of file
diff --git a/engine/ECS/ECSView.hpp b/engine/ECS/ECSView.hpp
deleted file mode 100644
index f5465db..0000000
--- a/engine/ECS/ECSView.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * ---------------------------------------------------
- * ECSView.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/07/28 18:24:19
- * ---------------------------------------------------
- */
-
-#ifndef ECSVIEW_HPP
-#define ECSVIEW_HPP
-
-#include "ECS/ECSWorld.hpp"
-#include "ECS/Entity.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/Set.hpp"
-#include "UtilsCPP/Types.hpp"
-
-namespace GE
-{
-
-template<typename ... Ts>
-class ECSView
-{
-public:
-    ECSView()               = delete;
-    ECSView(const ECSView&) = delete;
-    ECSView(ECSView&&)      = delete;
-    
-    ECSView(ECSWorld& world) : m_world(world), m_predicate(makePredicate<Ts...>()) {}
-
-    utils::uint32 count() const;
-
-    void onFirst(const utils::Func<void(Entity, Ts& ...)>&);
-    void onEach(const utils::Func<void(Entity, Ts& ...)>&);
-
-    ~ECSView() = default;
-
-private:
-    ECSWorld& m_world;
-    const utils::Set<ECSWorld::ComponentID> m_predicate;
-
-    template<typename T>
-    static utils::Set<ECSWorld::ComponentID> makePredicate()
-    {
-        return utils::Set<ECSWorld::ComponentID>{ ECSWorld::componentID<T>() };
-    }
-
-    template<typename T, typename Y, typename ... Ys>
-    static utils::Set<ECSWorld::ComponentID> makePredicate()
-    {
-        return makePredicate<T>() + makePredicate<Y, Ys...>(); 
-    }
-
-public:
-    ECSView& operator = (const ECSView&) = delete;
-    ECSView& operator = (ECSView&&)      = delete;
-};
-
-template<typename ... Ts>
-utils::uint32 ECSView<Ts...>::count() const
-{
-    utils::uint32 output = 0;
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes) {
-        if (archetypeId.contain(m_predicate))
-            output += archetype.size();
-    }
-    return output;
-}
-
-template<typename ... Ts>
-void ECSView<Ts...>::onFirst(const utils::Func<void(Entity, Ts& ...)>& func)
-{
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes)
-    {
-        if (archetypeId.contain(m_predicate))
-        {
-            for (utils::uint32 idx = 0; idx < archetype.size(); idx++)
-            {
-                func(Entity(m_world, archetype.getEntityID(idx)), *(Ts*)archetype.template getComponentPointer<Ts>(idx) ...);
-                return;
-            }
-        }
-    }
-}
-
-template<typename ... Ts>
-void ECSView<Ts...>::onEach(const utils::Func<void(Entity, Ts& ...)>& func)
-{
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes)
-    {
-        if (archetypeId.contain(m_predicate))
-        {
-            for (utils::uint32 idx = 0; idx < archetype.size(); idx++)
-                func(Entity(m_world, archetype.getEntityID(idx)), *(Ts*)archetype.template getComponentPointer<Ts>(idx) ...);
-        }
-    }
-}
-
-template<typename ... Ts>
-class const_ECSView
-{
-public:
-    const_ECSView()                     = delete;
-    const_ECSView(const const_ECSView&) = delete;
-    const_ECSView(const_ECSView&&)      = delete;
-    
-    const_ECSView(const ECSWorld& world) : m_world(world), m_predicate(makePredicate<Ts...>()) {}
-
-    utils::uint32 count() const;
-
-    void onFirst(const utils::Func<void(const Entity, const Ts& ...)>&);
-    void onEach(const utils::Func<void(const Entity, const Ts& ...)>&);
-
-    ~const_ECSView() = default;
-
-private:
-    const ECSWorld& m_world;
-    const utils::Set<ECSWorld::ComponentID> m_predicate;
-
-    template<typename T>
-    static utils::Set<ECSWorld::ComponentID> makePredicate()
-    {
-        return utils::Set<ECSWorld::ComponentID>{ ECSWorld::componentID<T>() };
-    }
-
-    template<typename T, typename Y, typename ... Ys>
-    static utils::Set<ECSWorld::ComponentID> makePredicate()
-    {
-        return makePredicate<T>() + makePredicate<Y, Ys...>(); 
-    }
-
-public:
-    const_ECSView& operator = (const const_ECSView&) = delete;
-    const_ECSView& operator = (const_ECSView&&)      = delete;
-};
-
-template<typename ... Ts>
-utils::uint32 const_ECSView<Ts...>::count() const
-{
-    utils::uint32 output = 0;
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes) {
-        if (archetypeId.contain(m_predicate))
-            output += archetype.size();
-    }
-    return output;
-}
-
-template<typename ... Ts>
-void const_ECSView<Ts...>::onFirst(const utils::Func<void(const Entity, const Ts& ...)>& func)
-{
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes)
-    {
-        if (archetypeId.contain(m_predicate))
-        {
-            for (utils::uint32 idx = 0; idx < archetype.size(); idx++)
-            {
-                func(Entity(const_cast<ECSWorld&>(m_world), archetype.getEntityID(idx)), *(Ts*)archetype.template getComponentPointer<Ts>(idx) ...);
-                return;
-            }
-        }
-    }
-}
-
-template<typename ... Ts>
-void const_ECSView<Ts...>::onEach(const utils::Func<void(const Entity, const Ts& ...)>& func)
-{
-    for (auto& [archetypeId, archetype] : m_world.m_archetypes)
-    {
-        if (archetypeId.contain(m_predicate))
-        {
-            for (utils::uint32 idx = 0; idx < archetype.size(); idx++)
-                func(Entity(const_cast<ECSWorld&>(m_world), archetype.getEntityID(idx)), *(Ts*)archetype.template getComponentPointer<Ts>(idx) ...);
-        }
-    }
-}
-
-}
-
-#endif // ECSVIEW_HPP
\ No newline at end of file
diff --git a/engine/ECS/ECSWorld.cpp b/engine/ECS/ECSWorld.cpp
deleted file mode 100644
index 2b56642..0000000
--- a/engine/ECS/ECSWorld.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * ---------------------------------------------------
- * ECSWorld.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/07/21 09:35:25
- * ---------------------------------------------------
- */
-
-#include "ECS/ECSWorld.hpp"
-#include "ECS/Components.hpp"
-#include "UtilsCPP/Array.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <cassert>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-namespace GE
-{
-
-ECSWorld::ECSWorld()
-{
-    m_archetypes.insert(ArchetypeID{0}, Archetype());
-}
-
-ECSWorld::EntityID ECSWorld::newEntityID()
-{
-    // new entity has no component so directly inserting in empty archetype (the one with only the entity id)
-    ArchetypeID newEntityArcId = { 0 };
-    Archetype& newEntityArchetype = m_archetypes[newEntityArcId];
-    utils::uint64 newEntityIdx = newEntityArchetype.allocateCollum();
-
-    EntityID newEntityId;
-    if (m_availableEntityIDs.isEmpty())
-    {
-        newEntityId = m_entityDatas.length();
-        m_entityDatas.append(EntityData{newEntityArcId, newEntityIdx});
-    }
-    else
-    {
-        newEntityId = m_availableEntityIDs.pop(m_availableEntityIDs.begin());
-        m_entityDatas[newEntityId] = EntityData{newEntityArcId, newEntityIdx};
-    }
-    newEntityArchetype.getEntityID(newEntityIdx) = newEntityId;
-
-    assert(isValidEntityID(newEntityId));
-    return newEntityId;
-}
-
-void ECSWorld::deleteEntityID(EntityID entityId)
-{
-    assert(isValidEntityID(entityId));
-    Archetype& entityArch = m_archetypes[m_entityDatas[entityId].archetypeId];
-    utils::uint64 entityIdx = m_entityDatas[entityId].idx;
-
-    // last entity of the archetype will be move to the index of the delete entity
-    // so the idx in the entity datas need to be change
-    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
-
-    if (entityIdx != entityArch.size() -1)
-    {
-        entityArch.destructCollum(entityIdx);
-        Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
-    }
-    entityArch.destructCollum(entityArch.size() - 1);
-    entityArch.freeLastCollum();
-
-    m_availableEntityIDs.insert(entityId);
-}
-
-utils::uint32 ECSWorld::componentCount()
-{
-    utils::uint64 count = 0;
-    for (auto& [id, arch] : m_archetypes)
-        count += (id.size() - 1) * arch.size();
-    return count;
-}
-
-ECSWorld::Iterator ECSWorld::begin() const
-{
-    EntityID id = 0;
-    while (m_availableEntityIDs.contain(id))
-        id++;
-    return Iterator(*this, id);
-}
-
-ECSWorld::Iterator ECSWorld::end() const
-{
-    return Iterator(*this, m_entityDatas.length());
-}
-
-ECSWorld::ComponentID ECSWorld::nextComponentID()
-{
-    // start at 1 because 0 is reserved for the entity id
-    static ComponentID id = 1;
-    return id++;
-};
-
-void to_json(nlohmann::json& jsn, const ECSWorld& world)
-{
-    jsn["entities"] = json::array();
-
-    for (auto id : world)
-    {
-        json entityJsn;
-        entityJsn["id"] = id;
-
-        if (world.has<NameComponent>(id))
-            entityJsn["nameComponent"] = world.get<NameComponent>(id);
-
-        if (world.has<HierarchyComponent>(id))
-            entityJsn["hierarchyComponent"] = world.get<HierarchyComponent>(id);
-
-        if (world.has<TransformComponent>(id))
-            entityJsn["transformComponent"] = world.get<TransformComponent>(id);
-
-        if (world.has<CameraComponent>(id))
-            entityJsn["cameraComponent"] = world.get<CameraComponent>(id);
-
-        if (world.has<LightComponent>(id))
-            entityJsn["lightComponent"] = world.get<LightComponent>(id);
-
-        if (world.has<MeshComponent>(id))
-            entityJsn["meshComponent"] = world.get<MeshComponent>(id);
-
-        if (world.has<ScriptComponent>(id))
-            entityJsn["scriptComponent"] = world.get<ScriptComponent>(id);
-
-        jsn["entities"].emplace_back(entityJsn);
-    }
-
-    jsn["availableEntityID"] = json::array();
-
-    for (auto id : world.m_availableEntityIDs)
-        jsn["availableEntityID"].emplace_back(id);
-}
-
-void from_json(const nlohmann::json& jsn, ECSWorld& world)
-{
-    auto entitiesIt = jsn.find("entities");
-    auto availableEntityIDIt = jsn.find("availableEntityID");
-    utils::uint64 entityDatasCount = 0;
-    if (entitiesIt != jsn.end())
-        entityDatasCount += jsn["entities"].size();
-    if (availableEntityIDIt != jsn.end())
-        entityDatasCount += jsn["availableEntityID"].size();
-
-    world.m_entityDatas = utils::Array<ECSWorld::EntityData>(entityDatasCount);
-
-    for (auto& entity : jsn["entities"])
-    {
-        ECSWorld::EntityID entityId = entity["id"].template get<ECSWorld::EntityID>();
-        ECSWorld::ArchetypeID newEntityArcId = { 0 };
-        ECSWorld::Archetype& newEntityArchetype = world.m_archetypes[newEntityArcId];
-        utils::uint64 newEntityIdx = newEntityArchetype.allocateCollum();
-        world.m_entityDatas[entityId] = ECSWorld::EntityData{newEntityArcId, newEntityIdx};
-        newEntityArchetype.getEntityID(newEntityIdx) = entityId;
-        
-        auto nameComponentIt = entity.find("nameComponent");
-        if (nameComponentIt != entity.end())
-            world.emplace<NameComponent>(entityId) = nameComponentIt->template get<NameComponent>();
-
-        auto hierarchyComponentIt = entity.find("hierarchyComponent");
-        if (hierarchyComponentIt != entity.end())
-            world.emplace<HierarchyComponent>(entityId) = hierarchyComponentIt->template get<HierarchyComponent>();
-
-        auto transformComponentIt = entity.find("transformComponent");
-        if (transformComponentIt != entity.end())
-            world.emplace<TransformComponent>(entityId) = transformComponentIt->template get<TransformComponent>();
-
-        auto cameraComponentIt = entity.find("cameraComponent");
-        if (cameraComponentIt != entity.end())
-            world.emplace<CameraComponent>(entityId) = cameraComponentIt->template get<CameraComponent>();
-
-        auto lightComponentIt = entity.find("lightComponent");
-        if (lightComponentIt != entity.end())
-            world.emplace<LightComponent>(entityId) = lightComponentIt->template get<LightComponent>();
-
-        auto meshComponenIt = entity.find("meshComponent");
-        if (meshComponenIt != entity.end())
-            world.emplace<MeshComponent>(entityId) = meshComponenIt->template get<MeshComponent>();
-
-        auto scriptComponentIt = entity.find("scriptComponent");
-        if (scriptComponentIt != entity.end())
-            world.emplace<ScriptComponent>(entityId) = scriptComponentIt->template get<ScriptComponent>();
-    }
-
-    for (auto& id : jsn["availableEntityID"])
-        world.m_availableEntityIDs.insert(id);
-}
-
-}
\ No newline at end of file
diff --git a/engine/ECS/ECSWorld.hpp b/engine/ECS/ECSWorld.hpp
deleted file mode 100644
index df39018..0000000
--- a/engine/ECS/ECSWorld.hpp
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * ---------------------------------------------------
- * ECSWorld.hpp
- *
- * Author: Thomas Choquet <thomas.publique@icloud.com>
- * Date: 2024/07/20 18:41:43
- * ---------------------------------------------------
- */
-
-#ifndef ECSWORLD_HPP
-#define ECSWORLD_HPP
-
-#include "UtilsCPP/Array.hpp"
-#include "UtilsCPP/Dictionary.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/Set.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <cassert>
-#include <climits>
-#include <utility>
-#include <nlohmann/json.hpp>
-
-#define INVALID_ENTITY_ID ULONG_MAX
-
-namespace GE
-{
-
-class ECSWorld
-{
-public:
-    using EntityID = utils::uint64;
-
-    class Iterator;
-
-private:
-    template<typename ... Ts> friend class ECSView;
-    template<typename ... Ts> friend class const_ECSView;
-
-    using ComponentID = utils::uint32;
-    using ArchetypeID = utils::Set<ComponentID>;
-
-    using CopyConstructor = utils::Func<void(void* src, void* dst)>;
-    using MoveConstructor = utils::Func<void(void* src, void* dst)>;
-    using Destructor      = utils::Func<void(void* ptr)>;
-
-public:
-    ECSWorld();
-    ECSWorld(const ECSWorld&) = default;
-    ECSWorld(ECSWorld&&)      = default;
-
-    EntityID newEntityID();
-
-    void deleteEntityID(EntityID);
-
-    inline bool isValidEntityID(EntityID id) const { return id < m_entityDatas.length() && m_availableEntityIDs.contain(id) == false; }
-
-    template<typename T, typename ... Args>
-    T& emplace(EntityID entityId, Args&& ... args);
-
-    template<typename T>
-    void remove(EntityID);
-
-    template<typename T>
-    bool has(EntityID) const;
-
-    template<typename T>
-    T& get(EntityID);
-
-    template<typename T>
-    const T& get(EntityID) const;
-
-    inline utils::uint32 entityCount() { return m_entityDatas.length() - m_availableEntityIDs.size(); }
-    inline utils::uint32 archetypeCount() { return m_archetypes.size(); }
-    utils::uint32 componentCount();
-
-    Iterator begin() const;
-    Iterator end() const;
-
-    ~ECSWorld() = default;
-
-private:
-    #include "ECS/Archetype.hpp"
-
-    struct EntityData
-    {
-        ArchetypeID archetypeId;
-        utils::uint64 idx = 0;
-    };
-
-    static ComponentID nextComponentID();
-    template<typename T> static ComponentID componentID();
-    template<typename T> static utils::uint64 componentSize();
-    template<typename T> static CopyConstructor componentCopyConstructor();
-    template<typename T> static MoveConstructor componentMoveConstructor();
-    template<typename T> static Destructor componentDestructor();
-
-    utils::Array<EntityData> m_entityDatas;
-    utils::Set<EntityID> m_availableEntityIDs;
-    
-    utils::Dictionary<ArchetypeID, Archetype> m_archetypes;
-    
-public:
-    ECSWorld& operator = (const ECSWorld&) = default;
-    ECSWorld& operator = (ECSWorld&&)      = default;
-
-    friend void to_json(nlohmann::json&, const ECSWorld&);
-    friend void from_json(const nlohmann::json&, ECSWorld&);
-
-public:
-    class Iterator
-    {
-    private:
-        friend class ECSWorld;
-
-    public:
-        Iterator()                   = default;
-        Iterator(const Iterator& cp) = default;
-        Iterator(Iterator&& mv)      = default;
-
-        ~Iterator() = default;
-
-    private:
-        Iterator(const ECSWorld& world, EntityID id) : m_world(&world), m_id(id) {}
-
-        const ECSWorld* m_world = nullptr;
-        EntityID m_id = INVALID_ENTITY_ID;
-
-    public:
-        Iterator& operator = (const Iterator& cp) = default;
-        Iterator& operator = (Iterator&& mv)      = default;
-
-        inline EntityID operator * () const { return m_id; }
-
-        inline Iterator& operator ++ ()    { do { ++m_id; } while (m_world->m_availableEntityIDs.contain(m_id)); return *this; }
-        inline Iterator  operator ++ (int) { Iterator temp(*this); ++(*this); return temp; }
-
-        inline Iterator& operator -- ()    { do { --m_id; } while (m_world->m_availableEntityIDs.contain(m_id)); return *this; }
-        inline Iterator  operator -- (int) { Iterator temp(*this); --(*this); return temp; }
-
-        inline bool operator == (const Iterator& rhs) const { return m_world == rhs.m_world && m_id == rhs.m_id; }
-        inline bool operator != (const Iterator& rhs) const { return !(*this == rhs); }
-    };
-};
-
-template<typename T, typename ... Args>
-T& ECSWorld::emplace(EntityID entityId, Args&& ... args)
-{
-    assert(isValidEntityID(entityId));
-    assert(has<T>(entityId) == false);
-    
-    ArchetypeID& entityArchID = m_entityDatas[entityId].archetypeId;
-    Archetype& entityArch = m_archetypes[entityArchID];
-    utils::uint64& entityIdx = m_entityDatas[entityId].idx;
-    
-    ArchetypeID dstArchID = entityArchID + componentID<T>();
-    auto it = m_archetypes.find(dstArchID);
-    if (it == m_archetypes.end())
-    {
-        Archetype newArchetype = entityArch.duplicateRowTypes();
-        newArchetype.addRowType<T>();
-        it = m_archetypes.insert(dstArchID, std::move(newArchetype));
-    }
-    Archetype& dstArchetype = it->val;
-    utils::uint64 dstIdx = dstArchetype.allocateCollum();
-
-    Archetype::moveComponents(entityArch, entityIdx, dstArchetype, dstIdx);
-
-    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
-    
-    entityArch.destructCollum(entityIdx);
-    Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
-    entityArch.destructCollum(entityArch.size() - 1);
-    entityArch.freeLastCollum();
-
-    entityArchID = dstArchID;
-    entityIdx = dstIdx;
-
-    T* componentPtr = m_archetypes[entityArchID].getComponentPointer<T>(entityIdx);
-    new (componentPtr) T(std::forward<Args>(args)...);
-    return *componentPtr;
-}
-
-template<typename T>
-void ECSWorld::remove(EntityID entityId)
-{
-    assert(isValidEntityID(entityId));
-    assert(has<T>(entityId));
-   
-    ArchetypeID& entityArchID = m_entityDatas[entityId].archetypeId;
-    Archetype& entityArch = m_archetypes[entityArchID];
-    utils::uint64& entityIdx = m_entityDatas[entityId].idx;
-
-    ArchetypeID dstArchID = entityArchID - componentID<T>();
-    auto it = m_archetypes.find(dstArchID);
-    if (it == m_archetypes.end())
-    {
-        Archetype newArchetype = entityArch.duplicateRowTypes();
-        newArchetype.rmvRowType<T>();
-        it = m_archetypes.insert(dstArchID, std::move(newArchetype));
-    }
-    Archetype& dstArchetype = it->val;
-    utils::uint64 dstIdx = dstArchetype.allocateCollum();
-
-    Archetype::moveComponents(entityArch, entityIdx, dstArchetype, dstIdx);
-
-    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
-    
-    if (entityIdx != entityArch.size() - 1)
-    {
-        entityArch.destructCollum(entityIdx);
-        Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
-    }
-    entityArch.destructCollum(entityArch.size() - 1);
-    entityArch.freeLastCollum();
-
-    entityArchID = dstArchID;
-    entityIdx = dstIdx;
-}
-
-template<typename T>
-bool ECSWorld::has(EntityID entityId) const
-{
-    assert(isValidEntityID(entityId));
-    return m_entityDatas[entityId].archetypeId.contain(componentID<T>());
-}
-
-template<typename T>
-T& ECSWorld::get(EntityID entityId)
-{
-    assert(isValidEntityID(entityId));
-    assert(has<T>(entityId));
-
-    Archetype& entityArch = m_archetypes[m_entityDatas[entityId].archetypeId];
-    utils::uint64& entityIdx = m_entityDatas[entityId].idx;
-
-    return *entityArch.getComponentPointer<T>(entityIdx);
-}
-
-template<typename T>
-const T& ECSWorld::get(EntityID entityId) const
-{
-    assert(isValidEntityID(entityId));
-    assert(has<T>(entityId));
-
-    const Archetype& entityArch = m_archetypes[m_entityDatas[entityId].archetypeId];
-    const utils::uint64& entityIdx = m_entityDatas[entityId].idx;
-
-    return *entityArch.getComponentPointer<T>(entityIdx);
-}
-
-template<typename T>
-ECSWorld::ComponentID ECSWorld::componentID()
-{
-    static ComponentID id = nextComponentID();
-    return id;
-}
-
-template<typename T>
-utils::uint64 ECSWorld::componentSize()
-{
-    utils::uint64 size = sizeof(T);
-    return size;
-}
-
-template<typename T>
-ECSWorld::CopyConstructor ECSWorld::componentCopyConstructor()
-{
-    auto fn = [](void* src, void* dst) { new (dst) T(*(T*)src); };
-    return fn;
-}
-
-template<typename T>
-ECSWorld::MoveConstructor ECSWorld::componentMoveConstructor()
-{
-    auto fn = [](void* src, void* dst) { new (dst) T(std::move(*(T*)src)); };
-    return fn;
-}
-
-template<typename T>
-ECSWorld::Destructor ECSWorld::componentDestructor()
-{
-    auto fn = [](void* ptr) { ((T*)ptr)->~T(); };
-    return fn;
-}
-
-}
-
-#endif // ECSWORLD_HPP
\ No newline at end of file
diff --git a/engine/ECS/Entity.cpp b/engine/ECS/Entity.cpp
deleted file mode 100644
index 669d740..0000000
--- a/engine/ECS/Entity.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * ---------------------------------------------------
- * Entity.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/07 15:32:06
- * ---------------------------------------------------
- */
-
-#include "ECS/Entity.hpp"
-#include "ECS/Components.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <cassert>
-
-namespace GE
-{
-
-Entity::Entity(ECSWorld& world, ECSWorld::EntityID id)
-    : m_world(&world), m_entityId(id)
-{
-    assert(m_world->isValidEntityID(id));
-}
-
-void Entity::destroy()
-{
-    if (has<HierarchyComponent>())
-    {
-        Entity curr = firstChild();
-        while (curr)
-        {
-            curr.get<HierarchyComponent>().parent = INVALID_ENTITY_ID;
-            curr = curr.nextChild();
-        }
-        if (parent())
-            parent().removeChild(*this);
-    }
-
-    m_world->deleteEntityID(m_entityId);
-    m_world = nullptr;
-    m_entityId = INVALID_ENTITY_ID;
-}
-
-utils::String& Entity::name()
-{
-    return get<NameComponent>();
-}
-
-Entity Entity::parent()
-{
-    ECSWorld::EntityID parentId = get<HierarchyComponent>().parent;
-    if (parentId == INVALID_ENTITY_ID)
-        return Entity();
-    return Entity(*m_world, parentId);
-}
-
-Entity Entity::firstChild()
-{
-    ECSWorld::EntityID firstChildId = get<HierarchyComponent>().firstChild;
-    if (firstChildId == INVALID_ENTITY_ID)
-        return Entity();
-    return Entity(*m_world, firstChildId);
-}
-
-Entity Entity::nextChild()
-{
-    ECSWorld::EntityID nextChildId = get<HierarchyComponent>().nextChild;
-    if (nextChildId == INVALID_ENTITY_ID)
-        return Entity();
-    return Entity(*m_world, nextChildId);
-}
-
-bool Entity::hasParent() const
-{
-    if (has<HierarchyComponent>() && parent())
-        return true;
-    return false;
-}
-
-utils::uint32 Entity::childCount() const
-{
-    utils::uint32 count = 0;
-    if (has<HierarchyComponent>())
-    {
-        Entity curr = firstChild();
-        while (curr)
-        {
-            count++;
-            curr = curr.nextChild();
-        }
-    }
-    return count;
-}
-
-Entity Entity::lastChild()
-{
-    Entity curr = firstChild();
-    while (curr && curr.nextChild())
-        curr = curr.nextChild();
-    return curr;
-}
-
-const Entity Entity::lastChild() const
-{
-    Entity curr = firstChild();
-    while (curr && curr.nextChild())
-        curr = curr.nextChild();
-    return curr;
-}
-
-bool Entity::isParentOf(const Entity& entity) const
-{
-    if (entity.hasParent())
-    {
-        Entity curr = entity.parent();
-        while (curr)
-        {
-            if (curr == *this)
-                return true;
-            curr = curr.nextChild();
-        }
-    }
-    return false;    
-}
-
-void Entity::addChild(Entity child)
-{
-    assert(m_world == &child.ecsWorld());
-    assert(child.isParentOf(*this) == false);
-
-    if (has<HierarchyComponent>() == false)
-        emplace<HierarchyComponent>();
-    if (child.has<HierarchyComponent>() == false)
-        child.emplace<HierarchyComponent>();
-
-    addChild(child, lastChild());
-}
-
-void Entity::addChild(Entity child, Entity after)
-{
-    assert(m_world == &child.ecsWorld());
-    assert(child.hasParent() == false);
-    assert(child.isParentOf(*this) == false);
-
-    if (has<HierarchyComponent>() == false)
-        emplace<HierarchyComponent>();
-    if (child.has<HierarchyComponent>() == false)
-        child.emplace<HierarchyComponent>();
-
-    assert((!after && !firstChild()) || (after && firstChild())); // ensure we not asking to add the child after a certain entity if there is no child
-
-    HierarchyComponent& childComp = child.get<HierarchyComponent>();
-    childComp.parent = m_entityId;
-    if (!after && !firstChild())
-    {
-        childComp.nextChild = INVALID_ENTITY_ID;
-        get<HierarchyComponent>().firstChild = child.entityID();
-    }
-    else
-    {
-        childComp.nextChild = after.nextChild().entityID();
-        after.get<HierarchyComponent>().nextChild = child.entityID();
-    }
-}
-
-void Entity::removeChild(Entity child)
-{
-    assert(m_world == &child.ecsWorld());
-
-    if (firstChild() == child)
-        get<HierarchyComponent>().firstChild = firstChild().nextChild().entityID();
-    else
-    {
-        Entity curr = firstChild();
-        while (curr.nextChild() != child)
-            curr = curr.nextChild();
-        curr.get<HierarchyComponent>().nextChild = curr.nextChild().nextChild().entityID();
-    }
-
-    child.get<HierarchyComponent>().parent = INVALID_ENTITY_ID;
-    child.get<HierarchyComponent>().nextChild = INVALID_ENTITY_ID;
-}
-
-void Entity::removeParent()
-{
-    if (hasParent() == false)
-        return;
-    parent().removeChild(*this);
-}
-
-math::vec3f& Entity::position()
-{
-    return get<TransformComponent>().position;
-}
-
-math::vec3f& Entity::rotation()
-{
-    return get<TransformComponent>().rotation;
-}
-
-math::vec3f& Entity::scale()
-{
-    return get<TransformComponent>().scale;
-}
-
-math::mat4x4 Entity::transform() const
-{
-    return get<TransformComponent>();
-}
-
-math::mat4x4 Entity::transform_noScale() const
-{
-    return math::mat4x4::translation(position()) * math::mat4x4::rotation(rotation());
-}
-
-math::mat4x4 Entity::worldTransform() const
-{
-    if (hasParent() && parent().has<TransformComponent>())
-        return parent().worldTransform() * transform();
-    return transform();
-}
-
-math::mat4x4 Entity::worldTransform_noScale() const
-{
-    if (hasParent() && parent().has<TransformComponent>())
-        return parent().worldTransform_noScale() * transform_noScale();
-    return transform_noScale();
-}
-
-}
\ No newline at end of file
diff --git a/engine/ECS/Entity.hpp b/engine/ECS/Entity.hpp
deleted file mode 100644
index b87352c..0000000
--- a/engine/ECS/Entity.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * ---------------------------------------------------
- * Entity.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/07 14:10:20
- * ---------------------------------------------------
- */
-
-#ifndef ENTITY_HPP
-#define ENTITY_HPP
-
-#include "ECS/ECSWorld.hpp"
-#include "Math/Matrix.hpp"
-#include "Math/Vector.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/Types.hpp"
-#include "Macros.hpp"
-
-namespace GE
-{
-
-class GAME_ENGINE_API Entity
-{
-public:
-    Entity()              = default;
-    Entity(const Entity&) = default;
-    Entity(Entity&&)      = default;
-    
-    Entity(ECSWorld&, ECSWorld::EntityID);
-
-    inline const ECSWorld& ecsWorld() const { return *m_world; }
-    inline ECSWorld::EntityID entityID() const { return m_entityId; }
-    inline void* imGuiID() const { return (void*)(uintptr_t)entityID(); }
-
-    template<typename T, typename ... Args>
-    T& emplace(Args&& ... args)
-    {
-        return m_world->emplace<T>(m_entityId, args...);
-    }
-
-    template<typename T>
-    void remove()
-    {
-        m_world->remove<T>(m_entityId);
-    }
-
-    template<typename T>
-    bool has()
-    {
-        return m_world->has<T>(m_entityId);
-    }
-
-    template<typename T>
-    bool has() const
-    {
-        return m_world->has<T>(m_entityId);
-    }
-
-    template<typename T>
-    T& get()
-    {
-        return m_world->get<T>(m_entityId);
-    }
-
-    template<typename T>
-    const T& get() const
-    {
-        return m_world->get<T>(m_entityId);
-    }
-    
-    void destroy();
-
-    utils::String& name();
-
-    Entity parent();
-    inline const Entity parent() const { return const_cast<Entity*>(this)->parent(); }
-
-    Entity firstChild();
-    inline const Entity firstChild() const { return const_cast<Entity*>(this)->firstChild(); }
-
-    Entity nextChild();
-    inline const Entity nextChild() const { return const_cast<Entity*>(this)->nextChild(); }
-
-    bool hasParent() const;
-    utils::uint32 childCount() const;
-    Entity lastChild();
-    const Entity lastChild() const;
-    bool isParentOf(const Entity&) const; // or grand parent ect
-
-    void addChild(Entity);
-    void addChild(Entity child, Entity after);
-    void removeChild(Entity);
-    void removeParent();
-
-    math::vec3f& position();
-    const math::vec3f& position() const { return const_cast<Entity*>(this)->position(); }
-
-    math::vec3f& rotation();
-    const math::vec3f& rotation() const { return const_cast<Entity*>(this)->rotation(); }
-
-    math::vec3f& scale();
-    const math::vec3f& scale() const { return const_cast<Entity*>(this)->scale(); }
-
-    math::mat4x4 transform() const;
-    math::mat4x4 transform_noScale() const;
-
-    math::mat4x4 worldTransform() const;
-    math::mat4x4 worldTransform_noScale() const;
-
-    ~Entity() = default;
-
-private:
-    ECSWorld* m_world = nullptr;
-    ECSWorld::EntityID m_entityId = INVALID_ENTITY_ID;
-
-public:
-    Entity& operator = (const Entity&) = default;
-    Entity& operator = (Entity&&)      = default;
-
-    inline operator bool () const { return m_world != nullptr && m_world->isValidEntityID(m_entityId); }
-    inline bool operator == (const Entity& rhs) const { return m_world == rhs.m_world && m_entityId == rhs.m_entityId; }
-    inline bool operator != (const Entity& rhs) const { return !(*this == rhs); }
-};
-
-}
-
-#endif // ENTITY_HPP
\ No newline at end of file
diff --git a/engine/Game.cpp b/engine/Game.cpp
deleted file mode 100644
index fee2044..0000000
--- a/engine/Game.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * ---------------------------------------------------
- * Game.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/07 14:45:12
- * ---------------------------------------------------
- */
-
-#include "Game.hpp"
-#include <cassert>
-#include "ECS/ECSView.hpp"
-#include "ECS/Components.hpp"
-#include "InputManager/InputContext.hpp"
-
-namespace GE
-{
-
-Game::Game(const Descriptor& descriptor)
-{
-    m_scenes = descriptor.scenes;
-    m_inputContext = descriptor.inputContext;
-    m_graphicAPI = descriptor.graphicAPI;
-    m_baseDir = descriptor.baseDir;
-    m_makeScriptInstance = descriptor.makeScriptInstance;
-}
-
-Scene& Game::activeScene()
-{
-    assert(m_activeScene != nullptr);
-    assert(m_activeScene->assetManager().isLoaded());
-    return *m_activeScene;
-}
-
-void Game::setActiveScene(const utils::String& name)
-{
-    if (m_activeScene)
-    {
-        assert(m_activeScene->assetManager().isLoaded());
-        if (m_activeScene->name() == name)
-            return;
-        ECSView<ScriptComponent>(m_activeScene->ecsWorld()).onEach([&](Entity, ScriptComponent& scriptComponent) {
-            scriptComponent.instance.clear();
-        });
-        m_activeScene->assetManager().unloadAssets();
-    }
-
-    auto it = m_scenes.find(name);
-    assert(it != m_scenes.end());
-    m_activeScene = &*it;
-
-    if (m_activeScene->assetManager().isLoaded() == false)
-        m_activeScene->assetManager().loadAssets(*m_graphicAPI, m_baseDir);
-
-    if (m_makeScriptInstance != nullptr)
-    {
-        ECSView<ScriptComponent>(m_activeScene->ecsWorld()).onEach([&](Entity entt, ScriptComponent& scriptComponent) {
-            scriptComponent.instance = utils::SharedPtr<Script>(m_makeScriptInstance(scriptComponent.name, entt, *this));
-            assert(scriptComponent.instance);
-        });
-    }
-}
-
-}
\ No newline at end of file
diff --git a/engine/Game.hpp b/engine/Game.hpp
deleted file mode 100644
index 0b6d422..0000000
--- a/engine/Game.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * ---------------------------------------------------
- * Game.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/07 13:16:05
- * ---------------------------------------------------
- */
-
-#ifndef GAME_HPP
-#define GAME_HPP
-
-#include "InputManager/InputContext.hpp"
-#include "Scene.hpp"
-#include "UtilsCPP/Set.hpp"
-#include "UtilsCPP/String.hpp"
-#include "Script.hpp"
-
-namespace GE
-{
-
-class Game
-{
-public:
-    struct Descriptor
-    {
-        utils::Set<Scene> scenes;
-        InputContext inputContext;
-
-        gfx::GraphicAPI* graphicAPI = nullptr;
-        std::filesystem::path baseDir;
-        MakeScriptInstanceFn makeScriptInstance = nullptr;
-    };
-
-public:
-    Game()            = delete;
-    Game(const Game&) = default;
-    Game(Game&&)      = default;
-
-    Game(const Descriptor&);
-
-    inline void stop() { m_isRunning = false; };
-    inline bool isRunning() const { return m_isRunning; }
-
-    Scene& activeScene();
-    inline const Scene& activeScene() const { return const_cast<Game*>(this)->activeScene(); }
-
-    void setActiveScene(const utils::String& name);
-
-    inline InputContext& inputContext() { return m_inputContext; }
-    inline const InputContext& inputContext() const { return m_inputContext; }
-
-    ~Game() = default;
-
-private:
-    bool m_isRunning = true;
-
-    utils::Set<Scene> m_scenes;
-    Scene* m_activeScene = nullptr;
-    InputContext m_inputContext;
-
-    gfx::GraphicAPI* m_graphicAPI = nullptr;
-    std::filesystem::path m_baseDir;
-    MakeScriptInstanceFn m_makeScriptInstance = nullptr;
-
-public:
-    Game& operator = (const Game&) = default;
-    Game& operator = (Game&&)      = default;
-};
-
-}
-
-#endif // GAME_HPP
\ No newline at end of file
diff --git a/engine/InputManager/Input.cpp b/engine/InputManager/Input.cpp
deleted file mode 100644
index 5ca7748..0000000
--- a/engine/InputManager/Input.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * ---------------------------------------------------
- * Input.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 17:29:30
- * ---------------------------------------------------
- */
-
-#include "InputManager/Input.hpp"
-#include "InputManager/Mapper.hpp" // IWYU pragma: keep
-
-namespace GE
-{
-
-Input::Input(utils::String name) : name(name)
-{
-}
-
-Input::~Input()
-{
-}
-
-// ActionInput
-
-utils::UniquePtr<Input> ActionInput::clone() const
-{
-    auto ipt = utils::makeUnique<ActionInput>(name);
-    ipt->triggered = triggered;
-    ipt->mappers[0] = mappers[0]->clone(ipt);
-    ipt->mappers[1] = mappers[1]->clone(ipt);
-    ipt->callback = callback;
-    return ipt.staticCast<Input>();
-}
-
-void ActionInput::dispatch()
-{
-    callback();
-    triggered = false;
-}
-
-void ActionInput::reset()
-{
-    triggered = false;
-}
-
-ActionInput::ActionInput(utils::String name) : Input(name)
-{
-}
-
-// StateInput
-
-utils::UniquePtr<Input> StateInput::clone() const
-{
-    auto ipt = utils::makeUnique<StateInput>(name);
-    ipt->triggered = triggered;
-    ipt->mappers[0] = mappers[0]->clone(ipt);
-    ipt->mappers[1] = mappers[1]->clone(ipt);
-    ipt->callback = callback;
-    return ipt.staticCast<Input>();
-}
-
-void StateInput::dispatch()
-{
-    callback();
-}
-
-void StateInput::reset()
-{
-}
-
-StateInput::StateInput(utils::String name) : Input(name)
-{
-}
-
-// RangeInput
-
-utils::UniquePtr<Input> RangeInput::clone() const
-{
-    auto ipt = utils::makeUnique<RangeInput>(name);
-    ipt->triggered = triggered;
-    ipt->mappers[0] = mappers[0]->clone(ipt);
-    ipt->mappers[1] = mappers[1]->clone(ipt);
-    ipt->callback = callback;
-    ipt->value = value;
-    return ipt.staticCast<Input>();
-}
-
-void RangeInput::dispatch()
-{
-    callback(value);
-}
-
-void RangeInput::reset()
-{
-}
-
-RangeInput::RangeInput(utils::String name) : Input(name)
-{
-}
-
-// Range2DInput
-
-utils::UniquePtr<Input> Range2DInput::clone() const
-{
-    auto ipt = utils::makeUnique<Range2DInput>(name);
-    ipt->triggered = triggered;
-    ipt->mappers[0] = mappers[0]->clone(ipt);
-    ipt->mappers[1] = mappers[1]->clone(ipt);
-    ipt->callback = callback;
-    ipt->value = value;
-    return ipt.staticCast<Input>();
-}
-
-void Range2DInput::dispatch()
-{
-    callback(value);
-}
-
-void Range2DInput::reset()
-{
-}
-
-Range2DInput::Range2DInput(utils::String name) : Input(name)
-{
-}
-
-
-}
\ No newline at end of file
diff --git a/engine/InputManager/Input.hpp b/engine/InputManager/Input.hpp
deleted file mode 100644
index 784abd6..0000000
--- a/engine/InputManager/Input.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * ---------------------------------------------------
- * Input.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 15:45:24
- * ---------------------------------------------------
- */
-
-#ifndef INPUT_HPP
-#define INPUT_HPP
-
-#include "Math/Vector.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/String.hpp"
-#include "UtilsCPP/UniquePtr.hpp"
-#include "Macros.hpp"
-
-namespace GE
-{
-
-class IMapper;
-
-struct GAME_ENGINE_API Input
-{
-    const utils::String name;
-    bool triggered = false;
-    utils::UniquePtr<IMapper> mappers[2];
-
-    virtual utils::UniquePtr<Input> clone() const = 0;
-
-    virtual void dispatch() = 0;
-    virtual void reset() = 0;
-
-    Input(utils::String name);
-    virtual ~Input();
-};
-
-struct GAME_ENGINE_API ActionInput : public Input
-{
-    utils::Func<void()> callback;
-
-    utils::UniquePtr<Input> clone() const override;
-
-    void dispatch() override;
-    void reset() override;
-
-    ActionInput(utils::String name);
-    ~ActionInput() override = default;
-};
-
-struct GAME_ENGINE_API StateInput : public Input
-{
-    utils::Func<void()> callback;
-
-    utils::UniquePtr<Input> clone() const override;
-
-    void dispatch() override;
-    void reset() override;
-
-    StateInput(utils::String name);
-    ~StateInput() override = default;
-};
-
-struct GAME_ENGINE_API RangeInput : public Input
-{
-    utils::Func<void(float)> callback;
-    float value = 0.0F;
-
-    utils::UniquePtr<Input> clone() const override;
-
-    void dispatch() override;
-    void reset() override;
-
-    RangeInput(utils::String name);
-    ~RangeInput() override = default;
-};
-
-struct GAME_ENGINE_API Range2DInput : public Input
-{
-    utils::Func<void(math::vec2f)> callback;
-    math::vec2f value = { 0.0F, 0.0F };
-
-    utils::UniquePtr<Input> clone() const override;
-
-    void dispatch() override;
-    void reset() override;
-
-    Range2DInput(utils::String name);
-    ~Range2DInput() override = default;
-};
-
-}
-
-#endif // INPUT_HPP
\ No newline at end of file
diff --git a/engine/InputManager/InputContext.cpp b/engine/InputManager/InputContext.cpp
deleted file mode 100644
index 232fb16..0000000
--- a/engine/InputManager/InputContext.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * ---------------------------------------------------
- * InputContext.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/25 14:23:10
- * ---------------------------------------------------
- */
-
-#include "InputManager/InputContext.hpp"
-#include "InputManager/Mapper.hpp" // IWYU pragma: keep
-
-namespace GE
-{
-
-InputContext::InputContext(const InputContext& cp)
-{
-    for (auto& [name, ipt] : cp.m_inputs)
-        m_inputs.insert(name, ipt->clone());
-}
-
-void InputContext::onInputEvent(gfx::InputEvent& event)
-{
-    for (auto& [_, input] : m_inputs)
-    {
-        for (utils::uint8 i = 0; i < 2; i++)
-        {
-            if (input->mappers[i] == false)
-                continue;
-            input->mappers[i]->onInputEvent(event);
-        }
-    }
-}
-
-void InputContext::dispatchInputs()
-{
-    for (auto& [_, input] : m_inputs) {
-        if (input->triggered)
-            input->dispatch();
-    }
-}
-
-void InputContext::resetInputs()
-{
-    for (auto& [_, input] : m_inputs) {
-        input->reset();
-    }
-}
-
-InputContext& InputContext::operator = (const InputContext& cp)
-{
-    if (this != &cp)
-    {
-        m_inputs.clear();
-        for (auto& [name, ipt] : cp.m_inputs)
-            m_inputs.insert(name, ipt->clone());
-    }
-    return *this;
-}
-
-}
\ No newline at end of file
diff --git a/engine/InputManager/InputContext.hpp b/engine/InputManager/InputContext.hpp
deleted file mode 100644
index 57217b4..0000000
--- a/engine/InputManager/InputContext.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * ---------------------------------------------------
- * InputContext.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/25 13:27:42
- * ---------------------------------------------------
- */
-
-#ifndef INPUTCONTEXT_HPP
-#define INPUTCONTEXT_HPP
-
-#include "Graphics/Event.hpp"
-#include "UtilsCPP/Dictionary.hpp"
-#include "UtilsCPP/String.hpp"
-#include "InputManager/Input.hpp"
-#include "UtilsCPP/UniquePtr.hpp"
-#include "Macros.hpp"
-
-namespace GE
-{
-
-class GAME_ENGINE_API InputContext
-{
-public:
-    InputContext() = default;
-    InputContext(const InputContext&);
-    InputContext(InputContext&&) = default;
-
-    template<typename T>
-    T& newInput(const utils::String& name);
-
-    template<typename T>
-    inline T& getInput(const utils::String& name) { return *static_cast<T*>((Input*)m_inputs[name]); }
-
-    inline void deleteInput(const utils::String& name) { m_inputs.remove(name); }
-
-    void onInputEvent(gfx::InputEvent&);
-    void dispatchInputs();
-    void resetInputs();
-
-    inline void clear() { m_inputs.clear(); }
-    
-    ~InputContext() = default;
-
-private:
-    utils::Dictionary<utils::String, utils::UniquePtr<Input>> m_inputs;
-
-public:
-    InputContext& operator = (const InputContext&);
-    InputContext& operator = (InputContext&&) = default;
-};
-
-template<typename T>
-T& InputContext::newInput(const utils::String& name)
-{
-    auto it = m_inputs.insert(name, utils::makeUnique<T>(name).template staticCast<Input>());
-    return *static_cast<T*>((Input*)it->val);
-}
-
-}
-
-#endif // INPUTCONTEXT_HPP
\ No newline at end of file
diff --git a/engine/InputManager/Mapper.cpp b/engine/InputManager/Mapper.cpp
deleted file mode 100644
index cb764d1..0000000
--- a/engine/InputManager/Mapper.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * ---------------------------------------------------
- * Mapper.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 15:54:54
- * ---------------------------------------------------
- */
-
-#include "InputManager/Mapper.hpp"
-#include "InputManager/Input.hpp"
-#include "InputManager/RawInput.hpp"
-#include "Graphics/Event.hpp"
-#include "Math/Vector.hpp"
-#include "UtilsCPP/Func.hpp"
-#include <cassert>
-
-namespace GE
-{
-
-// KeyboardButton, ActionInput
-
-Mapper<KeyboardButton, ActionInput>::Mapper(KeyboardButton btn, ActionInput& ipt)
-    : m_button(btn), m_input(ipt)
-{
-}
-
-utils::UniquePtr<IMapper> Mapper<KeyboardButton, ActionInput>::clone(Input* ipt) const
-{
-    ActionInput* actionIpt = dynamic_cast<ActionInput*>(ipt);
-    assert(actionIpt != nullptr);
-    auto output = utils::makeUnique<Mapper<KeyboardButton, ActionInput>>(m_button, *actionIpt);
-    return output.staticCast<IMapper>();
-}
-
-void Mapper<KeyboardButton, ActionInput>::onInputEvent(gfx::InputEvent& event)
-{
-    event.dispatch(utils::Func<void(gfx::KeyDownEvent&)>(*this, &Mapper<KeyboardButton, ActionInput>::onKeyDownEvent));
-}
-
-void Mapper<KeyboardButton, ActionInput>::onKeyDownEvent(gfx::KeyDownEvent& keyDownEvent)
-{
-    if (keyDownEvent.keyCode() == (int)m_button && keyDownEvent.isRepeat() == false)
-    {
-        m_input.triggered = true;
-        keyDownEvent.markAsProcessed();
-    }
-}
-
-// KeyboardButton, StateInput
-
-Mapper<KeyboardButton, StateInput>::Mapper(KeyboardButton btn, StateInput& ipt)
-    : m_button(btn), m_input(ipt)
-{
-}
-
-utils::UniquePtr<IMapper> Mapper<KeyboardButton, StateInput>::clone(Input* ipt) const
-{
-    StateInput* stateIpt = dynamic_cast<StateInput*>(ipt);
-    assert(stateIpt != nullptr);
-    auto output = utils::makeUnique<Mapper<KeyboardButton, StateInput>>(m_button, *stateIpt);
-    return output.staticCast<IMapper>();
-}
-
-void Mapper<KeyboardButton, StateInput>::onInputEvent(gfx::InputEvent& event)
-{
-    if (event.dispatch(utils::Func<void(gfx::KeyDownEvent&)>(*this, &Mapper<KeyboardButton, StateInput>::onKeyDownEvent))) return;
-    if (event.dispatch(utils::Func<void(gfx::KeyUpEvent&)>(*this, &Mapper<KeyboardButton, StateInput>::onKeyUpEvent))) return;
-}
-
-void Mapper<KeyboardButton, StateInput>::onKeyDownEvent(gfx::KeyDownEvent& keyDownEvent)
-{
-    if (keyDownEvent.keyCode() == (int)m_button && keyDownEvent.isRepeat() == false)
-    {
-        m_input.triggered = true;
-        keyDownEvent.markAsProcessed();
-    }
-}
-
-void Mapper<KeyboardButton, StateInput>::onKeyUpEvent(gfx::KeyUpEvent& keyUpEvent)
-{
-    if (keyUpEvent.keyCode() == (int)m_button)
-    {
-        m_input.triggered = false;
-        keyUpEvent.markAsProcessed();
-    }
-}
-
-// KeyboardButton, RangeInput
-
-Mapper<KeyboardButton, RangeInput>::Mapper(const Descriptor& btn, RangeInput& ipt)
-    : m_button(btn.button), m_scale(btn.scale), m_input(ipt)
-{
-}
-
-utils::UniquePtr<IMapper> Mapper<KeyboardButton, RangeInput>::clone(Input* ipt) const
-{
-    RangeInput* rangeIpt = dynamic_cast<RangeInput*>(ipt);
-    assert(rangeIpt != nullptr);
-    Mapper<KeyboardButton, RangeInput>::Descriptor desc;
-    desc.button = m_button;
-    desc.scale = m_scale;
-    auto output = utils::makeUnique<Mapper<KeyboardButton, RangeInput>>(desc, *rangeIpt);
-    return output.staticCast<IMapper>();
-}
-
-void Mapper<KeyboardButton, RangeInput>::onInputEvent(gfx::InputEvent& event)
-{
-    if (event.dispatch(utils::Func<void(gfx::KeyDownEvent&)>(*this, &Mapper<KeyboardButton, RangeInput>::onKeyDownEvent))) return;
-    if (event.dispatch(utils::Func<void(gfx::KeyUpEvent&)>(*this, &Mapper<KeyboardButton, RangeInput>::onKeyUpEvent))) return;
-}
-
-void Mapper<KeyboardButton, RangeInput>::onKeyDownEvent(gfx::KeyDownEvent& keyDownEvent)
-{
-    if (keyDownEvent.keyCode() == (int)m_button && keyDownEvent.isRepeat() == false)
-    {
-        m_input.value = m_scale;
-        m_input.triggered = true;
-        keyDownEvent.markAsProcessed();
-    }
-}
-
-void Mapper<KeyboardButton, RangeInput>::onKeyUpEvent(gfx::KeyUpEvent& keyUpEvent)
-{
-    if (keyUpEvent.keyCode() == (int)m_button)
-    {
-        m_input.triggered = true;
-        keyUpEvent.markAsProcessed();
-    }
-}
-
-// KeyboardButton, Range2DInput
-
-Mapper<KeyboardButton, Range2DInput>::Mapper(const Descriptor& btn, Range2DInput& ipt)
-    : m_xPos(btn.xPos), m_xNeg(btn.xNeg), m_yPos(btn.yPos), m_yNeg(btn.yNeg),
-      m_scale(btn.scale),
-      m_input(ipt)
-{
-}
-
-utils::UniquePtr<IMapper> Mapper<KeyboardButton, Range2DInput>::clone(Input* ipt) const
-{
-    Range2DInput* range2dIpt = dynamic_cast<Range2DInput*>(ipt);
-    assert(range2dIpt != nullptr);
-    Mapper<KeyboardButton, Range2DInput>::Descriptor desc;
-    desc.xPos = m_xPos;
-    desc.xNeg = m_xNeg;
-    desc.yPos = m_yPos;
-    desc.yNeg = m_yNeg;
-    desc.scale = m_scale;
-    auto output = utils::makeUnique<Mapper<KeyboardButton, Range2DInput>>(desc, *range2dIpt);
-    return output.staticCast<IMapper>();
-}
-
-void Mapper<KeyboardButton, Range2DInput>::onInputEvent(gfx::InputEvent& event)
-{
-    if (event.dispatch(utils::Func<void(gfx::KeyDownEvent&)>(*this, &Mapper<KeyboardButton, Range2DInput>::onKeyDownEvent))) return;
-    if (event.dispatch(utils::Func<void(gfx::KeyUpEvent&)>(*this, &Mapper<KeyboardButton, Range2DInput>::onKeyUpEvent))) return;
-}
-
-void Mapper<KeyboardButton, Range2DInput>::onKeyDownEvent(gfx::KeyDownEvent& keyDownEvent)
-{
-    if (keyDownEvent.isRepeat())
-        return;
-
-    if (keyDownEvent.keyCode() == static_cast<int>(m_xPos))
-        m_input.value += math::vec2f{m_scale.x, 0.0F};
-    else if (keyDownEvent.keyCode() == static_cast<int>(m_xNeg))
-        m_input.value -= math::vec2f{m_scale.x, 0.0F};
-    else if (keyDownEvent.keyCode() == static_cast<int>(m_yPos))
-        m_input.value += math::vec2f{0.0F, m_scale.y};
-    else if (keyDownEvent.keyCode() == static_cast<int>(m_yNeg))
-        m_input.value -= math::vec2f{0.0F, m_scale.y};
-    
-    if (keyDownEvent.keyCode() == static_cast<int>(m_xPos) ||
-        keyDownEvent.keyCode() == static_cast<int>(m_xNeg) ||
-        keyDownEvent.keyCode() == static_cast<int>(m_yPos) ||
-        keyDownEvent.keyCode() == static_cast<int>(m_yNeg))
-    {
-        m_input.triggered = m_input.value != math::vec2f{0.0F, 0.0F};
-        keyDownEvent.markAsProcessed();
-    }
-}
-
-void Mapper<KeyboardButton, Range2DInput>::onKeyUpEvent(gfx::KeyUpEvent& keyUpEvent)
-{
-    if (keyUpEvent.keyCode() == static_cast<int>(m_xPos))
-        m_input.value -= math::vec2f{m_scale.x, 0.0F};
-    else if (keyUpEvent.keyCode() == static_cast<int>(m_xNeg))
-        m_input.value += math::vec2f{m_scale.x, 0.0F};
-    else if (keyUpEvent.keyCode() == static_cast<int>(m_yPos))
-        m_input.value -= math::vec2f{0.0F, m_scale.y};
-    else if (keyUpEvent.keyCode() == static_cast<int>(m_yNeg))
-        m_input.value += math::vec2f{0.0F, m_scale.y};
-    
-    if (keyUpEvent.keyCode() == static_cast<int>(m_xPos) ||
-        keyUpEvent.keyCode() == static_cast<int>(m_xNeg) ||
-        keyUpEvent.keyCode() == static_cast<int>(m_yPos) ||
-        keyUpEvent.keyCode() == static_cast<int>(m_yNeg))
-    {
-        m_input.triggered = m_input.value != math::vec2f{0.0F, 0.0F};
-        keyUpEvent.markAsProcessed();
-    }
-}
-
-}
\ No newline at end of file
diff --git a/engine/InputManager/Mapper.hpp b/engine/InputManager/Mapper.hpp
deleted file mode 100644
index 3c0993d..0000000
--- a/engine/InputManager/Mapper.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * ---------------------------------------------------
- * Mapper.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 15:46:20
- * ---------------------------------------------------
- */
-
-#ifndef MAPPER_HPP
-#define MAPPER_HPP
-
-#include "Graphics/Event.hpp"
-#include "InputManager/Input.hpp"
-#include "InputManager/RawInput.hpp"
-#include "Math/Vector.hpp"
-#include "Macros.hpp"
-
-namespace GE
-{
-
-class GAME_ENGINE_API IMapper
-{
-public:
-    virtual utils::UniquePtr<IMapper> clone(Input*) const = 0;
-    virtual void onInputEvent(gfx::InputEvent&) = 0;
-    virtual ~IMapper() = default;
-};
-
-template<typename K, typename I> class Mapper;
-
-template<>
-class GAME_ENGINE_API Mapper<KeyboardButton, ActionInput> : public IMapper
-{
-public:
-    Mapper(KeyboardButton btn, ActionInput& ipt);
-
-    utils::UniquePtr<IMapper> clone(Input*) const override;
-    void onInputEvent(gfx::InputEvent&) override;
-    
-    ~Mapper() override = default;
-
-private:
-    void onKeyDownEvent(gfx::KeyDownEvent&);
-
-    const KeyboardButton m_button;
-    ActionInput& m_input;
-};
-
-template<>
-class GAME_ENGINE_API Mapper<KeyboardButton, StateInput> : public IMapper
-{
-public:
-    Mapper(KeyboardButton btn, StateInput& ipt);
-
-    utils::UniquePtr<IMapper> clone(Input*) const override;
-    void onInputEvent(gfx::InputEvent&) override;
-
-    ~Mapper() override = default;
-
-private:
-    void onKeyDownEvent(gfx::KeyDownEvent&);
-    void onKeyUpEvent(gfx::KeyUpEvent&);
-
-    const KeyboardButton m_button;
-    StateInput& m_input;
-};
-
-template<>
-class GAME_ENGINE_API Mapper<KeyboardButton, RangeInput> : public IMapper
-{
-public:
-    struct Descriptor
-    {
-        KeyboardButton button;
-        float scale = 1.0F;
-    };
-
-public:
-    Mapper(const Descriptor& btn, RangeInput& ipt);
-
-    utils::UniquePtr<IMapper> clone(Input*) const override;
-    void onInputEvent(gfx::InputEvent& event) override;
-
-    ~Mapper() override = default;
-
-private:
-    void onKeyDownEvent(gfx::KeyDownEvent&);
-    void onKeyUpEvent(gfx::KeyUpEvent&);
-
-    const KeyboardButton m_button;
-    const float m_scale;
-    RangeInput& m_input;
-};
-
-template<>
-class GAME_ENGINE_API Mapper<KeyboardButton, Range2DInput> : public IMapper
-{
-public:
-    struct Descriptor
-    {
-        KeyboardButton xPos;
-        KeyboardButton xNeg;
-        KeyboardButton yPos;
-        KeyboardButton yNeg;
-        
-        math::vec2f scale = {1.0F, 1.0F};
-    };
-
-public:
-    Mapper(const Descriptor& btn, Range2DInput& ipt);
-
-    utils::UniquePtr<IMapper> clone(Input*) const override;
-    void onInputEvent(gfx::InputEvent& event) override;
-
-    ~Mapper() override = default;
-
-private:
-    void onKeyDownEvent(gfx::KeyDownEvent&);
-    void onKeyUpEvent(gfx::KeyUpEvent&);
-
-    const KeyboardButton m_xPos;
-    const KeyboardButton m_xNeg;
-    const KeyboardButton m_yPos;
-    const KeyboardButton m_yNeg;
-
-    const math::vec2f m_scale;
-
-    Range2DInput& m_input;
-};
-
-}
-
-#endif // MAPPER_HPP
\ No newline at end of file
diff --git a/engine/InputManager/RawInput.hpp b/engine/InputManager/RawInput.hpp
deleted file mode 100644
index 7a3c339..0000000
--- a/engine/InputManager/RawInput.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * ---------------------------------------------------
- * RawInput.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/24 15:47:29
- * ---------------------------------------------------
- */
-
-#ifndef RAWINPUT_HPP
-#define RAWINPUT_HPP
-
-#include "Graphics/KeyCodes.hpp"
-
-namespace GE
-{
-
-enum class KeyboardButton : int
-{
-    esc        = ESC_KEY,
-    one        = ONE_KEY,
-    two        = TWO_KEY,
-    w          = W_KEY,
-    a          = A_KEY,
-    s          = S_KEY,
-    d          = D_KEY,
-    space      = SPACE_KEY,
-    up         = UP_KEY,
-    left       = LEFT_KEY,
-    down       = DOWN_KEY,
-    right      = RIGHT_KEY,
-    left_shift = LEFT_SHIFT_KEY,
-};
-
-enum class MouseButton : int
-{
-    l = MOUSE_L,
-    r = MOUSE_R
-};
-
-}
-
-#endif // RAWINPUT_HPP
\ No newline at end of file
diff --git a/engine/Macros.hpp b/engine/Macros.hpp
deleted file mode 100644
index cb7ad2c..0000000
--- a/engine/Macros.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * ---------------------------------------------------
- * Macros.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/13 23:12:30
- * ---------------------------------------------------
- */
-
-#ifndef GAME_ENGINE_MACROS_HPP
-#define GAME_ENGINE_MACROS_HPP
-
-#if (defined(__GNUC__) || defined(__clang__)) && defined(GAME_ENGINE_API_EXPORT)
-    #define GAME_ENGINE_API __attribute__((visibility("default")))
-#elif defined(_MSC_VER) && defined(GAME_ENGINE_API_EXPORT)
-    #define GAME_ENGINE_API __declspec(dllexport)
-#elif defined(_MSC_VER) && defined(GAME_ENGINE_API_IMPORT)
-    #define GAME_ENGINE_API __declspec(dllimport)
-#else
-    #define GAME_ENGINE_API
-#endif
-
-#endif // GAME_ENGINE_MACROS_HPP
\ No newline at end of file
diff --git a/engine/Renderer/Mesh.hpp b/engine/Renderer/Mesh.hpp
deleted file mode 100644
index 0fc7c3c..0000000
--- a/engine/Renderer/Mesh.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * ---------------------------------------------------
- * Mesh.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/14 13:06:07
- * ---------------------------------------------------
- */
-
-#ifndef MESH_HPP
-#define MESH_HPP
-
-#include "Graphics/Buffer.hpp"
-#include "Math/Matrix.hpp"
-#include "UtilsCPP/Array.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "UtilsCPP/String.hpp"
-
-namespace GE
-{
-
-
-struct SubMesh
-{
-    const utils::String name;
-    const math::mat4x4 transform = math::mat4x4(1.0F);
-    const utils::SharedPtr<gfx::Buffer> vertexBuffer;
-    const utils::SharedPtr<gfx::Buffer> indexBuffer;
-};
-
-struct Mesh
-{
-    const utils::String name;
-    const utils::Array<SubMesh> subMeshes;
-};
-
-}
-
-#endif // MESH_HPP
\ No newline at end of file
diff --git a/engine/Renderer/Renderer.cpp b/engine/Renderer/Renderer.cpp
deleted file mode 100644
index 5c753f4..0000000
--- a/engine/Renderer/Renderer.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * ---------------------------------------------------
- * Renderer.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/09 15:54:42
- * ---------------------------------------------------
- */
-
-#include "Renderer/Renderer.hpp"
-#include "ECS/Components.hpp"
-#include "ECS/ECSView.hpp"
-#include "Graphics/Enums.hpp"
-#include "Graphics/GraphicAPI.hpp"
-#include "Graphics/GraphicPipeline.hpp"
-#include "Math/Matrix.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "UtilsCPP/Types.hpp"
-#include <cassert>
-
-namespace GE
-{
-
-static utils::SharedPtr<gfx::GraphicPipeline> makeGraphicPipeline(gfx::GraphicAPI& api)
-{
-    gfx::Shader::Descriptor shaderDescriptor;
-
-    shaderDescriptor.type = gfx::ShaderType::vertex;
-    #ifdef GFX_BUILD_METAL
-        shaderDescriptor.mtlShaderLibPath = MTL_SHADER_LIB;
-        shaderDescriptor.mtlFunction = "default_vs";
-    #endif
-    #ifdef GFX_BUILD_OPENGL
-        shaderDescriptor.openglCode = utils::String::contentOfFile(OPENGL_SHADER_DIR"/default.vs");
-    #endif
-
-    utils::SharedPtr<gfx::Shader> vs = api.newShader(shaderDescriptor);
-
-    shaderDescriptor.type = gfx::ShaderType::fragment;
-    #ifdef GFX_BUILD_METAL
-        shaderDescriptor.mtlShaderLibPath = MTL_SHADER_LIB;
-        shaderDescriptor.mtlFunction = "default_fs";
-    #endif
-    #ifdef GFX_BUILD_OPENGL
-        shaderDescriptor.openglCode = utils::String::contentOfFile(OPENGL_SHADER_DIR"/default.fs");
-    #endif
-
-    utils::SharedPtr<gfx::Shader> fs = api.newShader(shaderDescriptor);
-
-    gfx::VertexLayout vertexLayout;
-    vertexLayout.attributes.append({gfx::VertexAttributeFormat::vec3f, offsetof(Renderer::Vertex, pos)});
-    vertexLayout.attributes.append({gfx::VertexAttributeFormat::vec2f, offsetof(Renderer::Vertex, uv)});
-    vertexLayout.attributes.append({gfx::VertexAttributeFormat::vec3f, offsetof(Renderer::Vertex, normal)});
-    vertexLayout.stride = sizeof(Renderer::Vertex);
-
-    gfx::GraphicPipeline::Descriptor gfxPipelineDesc;
-    gfxPipelineDesc.vertexLayout = vertexLayout;
-    gfxPipelineDesc.vertexShader = vs;
-    gfxPipelineDesc.fragmentShader = fs;
-    return api.newGraphicsPipeline(gfxPipelineDesc);
-}
-
-Renderer::Renderer(const utils::SharedPtr<gfx::GraphicAPI>& api)
-    : m_graphicAPI(api)
-{
-    m_graphicAPI->initImgui();
-
-    m_gfxPipeline = makeGraphicPipeline(*m_graphicAPI);
-
-    m_vpMatrix.alloc(*m_graphicAPI);
-    m_lightsBuffer.alloc(*m_graphicAPI);
-}
-
-void Renderer::beginScene(const Renderer::Camera& cam, const utils::SharedPtr<gfx::RenderTarget>& target)
-{
-    m_renderTarget = target;
-
-    math::mat4x4 projectionMatrix = cam.projectionMatrix;
-    projectionMatrix[0][0] /= (float)target->width() / (float)target->height();
-
-    m_vpMatrix.map();
-    m_vpMatrix.content() = projectionMatrix * cam.viewMatrix;
-    m_vpMatrix.unmap();
-
-    m_lightsBuffer.map();
-    m_lightsBuffer.content().pointLightCount = 0;
-
-    m_renderables.clear();
-}
-
-void Renderer::addRenderable(const Renderer::Renderable& renderable)
-{
-    m_renderables.append(renderable);
-}
-
-void Renderer::addRenderables(const ECSWorld& world, const AssetManager& assetManager)
-{
-    const_ECSView<TransformComponent, MeshComponent>(world).onEach([&](const Entity entity, const TransformComponent& transform, const MeshComponent& mesh) {
-        if (mesh.assetId.is_nil() == false)
-        {
-            assert(assetManager.loadedMeshes().contain(mesh.assetId));
-            math::mat4x4 entityWorldTransform = entity.worldTransform();
-            for (auto& subMesh : assetManager.loadedMeshes()[mesh.assetId].subMeshes)
-            {
-                addRenderable(Renderer::Renderable{
-                    subMesh.vertexBuffer, subMesh.indexBuffer,
-                    entityWorldTransform * subMesh.transform,
-                });
-            }
-        }
-    });
-}
-
-void Renderer::addPointLight(const Renderer::PointLight& pointLight)
-{
-    assert(m_lightsBuffer.content().pointLightCount < 32);
-    utils::uint32 idx = m_lightsBuffer.content().pointLightCount++;
-    m_lightsBuffer.content().pointLights[idx] = pointLight;
-}
-
-void Renderer::addLights(const ECSWorld& world)
-{
-    const_ECSView<TransformComponent, LightComponent>(world).onEach([&](const Entity, const TransformComponent& transform, const LightComponent& light) {
-        switch (light.type)
-        {
-        case LightComponent::Type::point:
-            addPointLight({transform.position, light.color, light.intentsity});
-            break;
-        default:
-            UNREACHABLE
-        }
-    });
-}
-
-void Renderer::endScene()
-{
-    m_lightsBuffer.unmap();
-}
-
-void Renderer::render()
-{
-    m_graphicAPI->beginFrame();
-    {
-        m_graphicAPI->setLoadAction(gfx::LoadAction::clear);
-        m_graphicAPI->beginRenderPass(m_renderTarget);
-        {
-            m_graphicAPI->useGraphicsPipeline(m_gfxPipeline);
-
-            m_graphicAPI->setVertexBuffer(m_vpMatrix.buffer(), m_gfxPipeline->getVertexBufferIndex("vpMatrixBuffer"));
-            m_graphicAPI->setFragmentBuffer(m_lightsBuffer.buffer(), m_gfxPipeline->getFragmentBufferIndex("lightsBuffer"));
-
-            for (auto& renderable : m_renderables)
-            {
-                m_graphicAPI->setVertexUniform(renderable.modelMatrix, m_gfxPipeline->getVertexUniformIndex("modelMatrix"));
-                m_graphicAPI->setVertexBuffer(renderable.vertexBuffer, 0);
-                m_graphicAPI->drawIndexedVertices(renderable.indexBuffer);
-            }
-        }
-        m_graphicAPI->endRenderPass();
-
-        if (m_onImGuiRender)
-        {
-            m_graphicAPI->setLoadAction(gfx::LoadAction::load);
-            m_graphicAPI->beginImguiRenderPass();
-            {
-                m_onImGuiRender();
-            }
-            m_graphicAPI->endRenderPass();
-        }
-    }
-    m_graphicAPI->endFrame();
-}
-
-}
\ No newline at end of file
diff --git a/engine/Renderer/Renderer.hpp b/engine/Renderer/Renderer.hpp
deleted file mode 100644
index efe2687..0000000
--- a/engine/Renderer/Renderer.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * ---------------------------------------------------
- * Renderer.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/09 15:49:29
- * ---------------------------------------------------
- */
-
-#ifndef RENDERER_HPP
-#define RENDERER_HPP
-
-#include "Graphics/Buffer.hpp"
-#include "Graphics/GraphicAPI.hpp"
-#include "Graphics/RenderTarget.hpp"
-#include "Math/Matrix.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/SharedPtr.hpp"
-#include "Graphics/BufferInstance.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "AssetManager.hpp"
-
-namespace GE
-{
-
-class Renderer
-{
-public:
-    struct Camera
-    {
-        math::mat4x4 viewMatrix;
-        math::mat4x4 projectionMatrix;
-    };
-
-    struct Renderable
-    {
-        utils::SharedPtr<gfx::Buffer> vertexBuffer;
-        utils::SharedPtr<gfx::Buffer> indexBuffer;
-        math::mat4x4 modelMatrix;
-    };
-
-    struct PointLight
-    {
-        math::vec3f pos;
-        math::rgb color;
-        float intentsity;
-    };
-
-    struct Vertex
-    {
-        math::vec3f pos;
-        math::vec2f uv;
-        math::vec3f normal;
-        math::vec3f tangent;
-    };
-
-public:
-    Renderer()                = delete;
-    Renderer(const Renderer&) = delete;
-    Renderer(Renderer&&)      = delete;
-
-    Renderer(const utils::SharedPtr<gfx::GraphicAPI>&);
-    
-    inline gfx::GraphicAPI& graphicAPI() { return *m_graphicAPI; }
-    
-    inline void setOnImGuiRender(const utils::Func<void(void)>& f) { m_onImGuiRender = f; }
-
-    void beginScene(const Renderer::Camera&, const utils::SharedPtr<gfx::RenderTarget>&);
-
-    void addRenderable(const Renderer::Renderable&);
-    void addRenderables(const ECSWorld&, const AssetManager&);
-
-    void addPointLight(const Renderer::PointLight&);
-    void addLights(const ECSWorld&);
-
-    void endScene();
-
-    void render();
-
-    ~Renderer() = default;
-
-private:
-    struct LightsBuffer
-    {
-        PointLight pointLights[32];
-        utils::uint32 pointLightCount;
-    };
-
-private:
-    utils::SharedPtr<gfx::GraphicAPI> m_graphicAPI;
-    utils::Func<void(void)> m_onImGuiRender;
-    utils::SharedPtr<gfx::GraphicPipeline> m_gfxPipeline; // temporary
-
-    utils::SharedPtr<gfx::RenderTarget> m_renderTarget;
-    gfx::BufferInstance<math::mat4x4> m_vpMatrix;
-    gfx::BufferInstance<LightsBuffer> m_lightsBuffer;
-    utils::Array<Renderable> m_renderables;
-
-public:
-    Renderer& operator = (const Renderer&) = delete;
-    Renderer& operator = (Renderer&&)      = delete;
-};
-
-}
-
-#endif // RENDERER_HPP
\ No newline at end of file
diff --git a/engine/Scene.cpp b/engine/Scene.cpp
deleted file mode 100644
index 1c538d6..0000000
--- a/engine/Scene.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * ---------------------------------------------------
- * Scene.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/09/08 12:10:58
- * ---------------------------------------------------
- */
-
-#include "Scene.hpp"
-#include "AssetManager.hpp"
-#include "ECS/Components.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "ECS/Entity.hpp"
-#include "UtilsCPP/String.hpp"
-#include <cassert>
-#include <string>
-
-using json = nlohmann::json;
-
-namespace GE
-{
-
-Scene::Scene(const utils::String& name)
-    : m_name(name)
-{
-}
-
-Entity Scene::activeCamera()
-{
-    if (m_activeCamera == INVALID_ENTITY_ID)
-        return Entity();
-    return Entity(m_ecsWorld, m_activeCamera);
-}
-
-void Scene::setActiveCamera(const Entity& e)
-{
-    assert(&e.ecsWorld() == &m_ecsWorld);
-    m_activeCamera = e.entityID();
-}
-
-Entity Scene::newEntity(const utils::String& name)
-{
-    Entity newEntity(m_ecsWorld, m_ecsWorld.newEntityID());
-
-    newEntity.emplace<NameComponent>(name);
-
-    return newEntity;
-}
-
-void to_json(json& jsn, const Scene& scene)
-{
-    jsn["name"] = std::string(scene.name());
-    jsn["ecsWorld"] = scene.m_ecsWorld;
-    if (scene.m_activeCamera != INVALID_ENTITY_ID)
-        jsn["activeCamera"] = scene.m_activeCamera;
-    jsn["assetManager"] = scene.m_assetManager;
-}
-
-void from_json(const json& jsn, Scene& scene)
-{
-    auto nameIt = jsn.find("name");        
-    scene.m_name = nameIt == jsn.end() ? utils::String("no_name") : utils::String(nameIt->template get<std::string>().c_str());
-
-    auto ecsWorldIt = jsn.find("ecsWorld");
-    if (ecsWorldIt != jsn.end())
-        scene.m_ecsWorld = ecsWorldIt->template get<ECSWorld>();
-
-    auto activeCameraIt = jsn.find("activeCamera");
-    if (activeCameraIt != jsn.end())
-    {
-        ECSWorld::EntityID activeCameraId = activeCameraIt->template get<ECSWorld::EntityID>();
-        if (scene.ecsWorld().isValidEntityID(activeCameraId) && scene.ecsWorld().has<CameraComponent>(activeCameraId))
-            scene.m_activeCamera = activeCameraId;
-        else
-            scene.m_activeCamera = INVALID_ENTITY_ID;
-    }
-
-    auto assetManagerIt = jsn.find("assetManager");
-    if (assetManagerIt != jsn.end())
-        scene.m_assetManager = assetManagerIt->template get<AssetManager>();
-}
-
-}
\ No newline at end of file
diff --git a/engine/Scene.hpp b/engine/Scene.hpp
deleted file mode 100644
index dc8f589..0000000
--- a/engine/Scene.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * ---------------------------------------------------
- * Scene.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/08/31 16:52:15
- * ---------------------------------------------------
- */
-
-#ifndef SCENE_HPP
-#define SCENE_HPP
-
-#include "AssetManager.hpp"
-#include "ECS/ECSWorld.hpp"
-#include "ECS/Entity.hpp"
-#include "UtilsCPP/String.hpp"
-#include <nlohmann/json.hpp>
-
-namespace GE
-{
-
-class Scene
-{
-public:
-    Scene()             = default;
-    Scene(const Scene&) = default;
-    Scene(Scene&&)      = default;
-
-    Scene(const utils::String& name);
-    
-    inline const utils::String& name() const { return m_name; }
-    inline void setName(const utils::String& s) { m_name = s; }
-
-    inline ECSWorld& ecsWorld() { return m_ecsWorld; }
-    inline const ECSWorld& ecsWorld() const { return const_cast<Scene*>(this)->ecsWorld(); }
-
-    Entity activeCamera();
-    const Entity activeCamera() const { return const_cast<Scene*>(this)->activeCamera(); };
-    
-    void setActiveCamera(const Entity& e);
-
-    inline AssetManager& assetManager() { return m_assetManager; }
-    inline const AssetManager& assetManager() const { return const_cast<Scene*>(this)->assetManager(); }
-
-    Entity newEntity(const utils::String& name);
-    
-    ~Scene() = default;
-
-private:
-    utils::String m_name;
-    ECSWorld m_ecsWorld;
-    ECSWorld::EntityID m_activeCamera = INVALID_ENTITY_ID;
-    AssetManager m_assetManager;
-
-public:
-    Scene& operator = (const Scene&) = default;
-    Scene& operator = (Scene&&)      = default;
-
-    inline bool operator  < (const Scene& rhs) const { return m_name  < rhs.m_name; }
-    inline bool operator == (const Scene& rhs) const { return m_name == rhs.m_name; }
-
-    inline bool operator  < (const utils::String& name) const { return m_name  < m_name; }
-    inline bool operator == (const utils::String& name) const { return m_name == m_name; }
-
-    friend void to_json(nlohmann::json&, const Scene&);
-    friend void from_json(const nlohmann::json&, Scene&);
-};
-
-}
-
-#endif // SCENE_HPP
\ No newline at end of file
diff --git a/engine/Script.hpp b/engine/Script.hpp
deleted file mode 100644
index 7496b73..0000000
--- a/engine/Script.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * ---------------------------------------------------
- * Script.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/24 12:39:19
- * ---------------------------------------------------
- */
-
-#ifndef SCRIPT_HPP
-#define SCRIPT_HPP
-
-#include "ECS/Entity.hpp"
-
-namespace GE
-{
-
-class Game;
-class Script;
-
-using GetScriptNamesFn = void (*)(const char***, unsigned long*); // getScriptNames
-using MakeScriptInstanceFn = Script* (*)(const char*, const Entity&, Game& g); // makeScriptInstance
-
-class Script
-{
-public:
-    Script()              = delete;
-    Script(const Script&) = default;
-    Script(Script&&)      = default;
-
-    inline Script(const Entity& e, Game& g) : m_entity(e), m_game(g) {}
-    
-    virtual void onUpdate() {};
-
-    virtual ~Script() = default;
-
-protected:
-    Entity m_entity;
-    Game& m_game;
-};
-
-}
-
-#endif // SCRIPT_HPP
\ No newline at end of file
diff --git a/example1.png b/example1.png
deleted file mode 100644
index 91f1aeb..0000000
Binary files a/example1.png and /dev/null differ
diff --git a/example2.gif b/example2.gif
deleted file mode 100644
index 13ed9bd..0000000
Binary files a/example2.gif and /dev/null differ
diff --git a/examples/project1/CMakeLists.txt b/examples/project1/CMakeLists.txt
index 118c519..8f5ed22 100644
--- a/examples/project1/CMakeLists.txt
+++ b/examples/project1/CMakeLists.txt
@@ -2,13 +2,16 @@
 # CMakeLists.txt
 #
 # Author: Thomas Choquet <semoir.dense-0h@icloud.com>
-# Date: 2024/11/13 20:48:06
 # ---------------------------------------------------
 
-add_library(project1_scriptLib SHARED)
-set_target_properties(project1_scriptLib PROPERTIES 
-    CXX_STANDARD              20
-    CXX_STANDARD_REQUIRED     ON
+include(../../cmake/ScriptLibrary.cmake)
+
+file(GLOB_RECURSE PROJECT1_SCRIPT_SRCS "${CMAKE_CURRENT_LIST_DIR}/scripts/*.cpp")
+
+ge_add_script_library(project1_scriptLib ${PROJECT1_SCRIPT_SRCS})
+target_link_libraries(project1_scriptLib PRIVATE GE-Editor)
+
+set_target_properties(project1_scriptLib PROPERTIES
     FOLDER                    "examples"
     PREFIX                    ""
     DEBUG_POSTFIX             ""
@@ -16,18 +19,3 @@ set_target_properties(project1_scriptLib PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY  $<1:${CMAKE_CURRENT_LIST_DIR}>
     ARCHIVE_OUTPUT_DIRECTORY  $<1:${CMAKE_CURRENT_LIST_DIR}>
 )
-
-if(NOT WIN32)
-    set_target_properties(project1_scriptLib PROPERTIES SUFFIX "")
-endif()
-
-file(GLOB_RECURSE SRCS "${CMAKE_CURRENT_LIST_DIR}/scripts/*")
-target_sources(project1_scriptLib PRIVATE ${SRCS})
-
-target_compile_definitions(project1_scriptLib PRIVATE "PROJECT1_API_EXPORT" INTERFACE "PROJECT1_API_IMPORT")
-
-if(APPLE)
-    target_link_options(project1_scriptLib PRIVATE "-undefined" "dynamic_lookup")
-endif()
-
-target_link_libraries(project1_scriptLib PRIVATE GE-Editor)
\ No newline at end of file
diff --git a/examples/project1/project1.geproj b/examples/project1/project1.geproj
index 6ed5165..51b1601 100644
--- a/examples/project1/project1.geproj
+++ b/examples/project1/project1.geproj
@@ -1,148 +1,194 @@
-{
-    "imguiSettings": "[Window][WindowOverViewport_11111111]\nPos=0,19\nSize=1280,701\nCollapsed=0\n\n[Window][Debug##Default]\nPos=60,60\nSize=400,400\nCollapsed=0\n\n[Window][Entity inspector]\nPos=958,259\nSize=322,461\nCollapsed=0\nDockId=0x00000004,0\n\n[Window][Scene graph]\nPos=958,19\nSize=322,238\nCollapsed=0\nDockId=0x00000003,0\n\n[Window][viewport]\nPos=0,19\nSize=956,521\nCollapsed=0\nDockId=0x00000009,0\n\n[Window][File explorer]\nPos=0,570\nSize=1039,150\nCollapsed=0\nDockId=0x00000007,0\n\n[Window][Project properties]\nPos=435,288\nSize=361,77\nCollapsed=0\n\n[Window][Scenes]\nPos=445,309\nSize=268,102\nCollapsed=0\n\n[Window][Content browser]\nPos=0,542\nSize=956,178\nCollapsed=0\nDockId=0x0000000A,0\n\n[Window][Content explorer]\nPos=0,570\nSize=1039,150\nCollapsed=0\nDockId=0x00000007,1\n\n[Window][Dear ImGui Demo]\nPos=650,39\nSize=550,680\nCollapsed=0\n\n[Window][Dear ImGui Metrics/Debugger]\nPos=506,457\nSize=493,263\nCollapsed=0\nDockId=0x00000008,0\n\n[Docking][Data]\nDockSpace       ID=0x7C6B3D9B Window=0xA87D555D Pos=200,124 Size=1280,701 Split=X Selected=0x0BA3B4F3\n  DockNode      ID=0x00000001 Parent=0x7C6B3D9B SizeRef=1597,701 Split=Y Selected=0x0BA3B4F3\n    DockNode    ID=0x00000005 Parent=0x00000001 SizeRef=1013,549 Split=Y Selected=0x0BA3B4F3\n      DockNode  ID=0x00000009 Parent=0x00000005 SizeRef=1039,1031 CentralNode=1 Selected=0x0BA3B4F3\n      DockNode  ID=0x0000000A Parent=0x00000005 SizeRef=1039,178 Selected=0x3995E0EF\n    DockNode    ID=0x00000006 Parent=0x00000001 SizeRef=1013,150 Split=X Selected=0xD2F73F3F\n      DockNode  ID=0x00000007 Parent=0x00000006 SizeRef=504,263 Selected=0x41BEEAFB\n      DockNode  ID=0x00000008 Parent=0x00000006 SizeRef=493,263 Selected=0x20E3C5EA\n  DockNode      ID=0x00000002 Parent=0x7C6B3D9B SizeRef=322,701 Split=Y Selected=0xF5BE1C77\n    DockNode    ID=0x00000003 Parent=0x00000002 SizeRef=168,417 Selected=0xF5BE1C77\n    DockNode    ID=0x00000004 Parent=0x00000002 SizeRef=168,806 Selected=0xD3D12213\n\n",
-    "name": "project1",
-    "scenes": [
-        {
-            "activeCamera": 3,
-            "assetManager": {
-                "registeredMeshes": {
-                    "ressources/chess_set/chess_set.gltf": "839880c4-211a-4591-8c20-ec0dc8efad3e",
-                    "ressources/cube.glb": "0a6f2480-dc72-456f-836c-910ebe9a17aa"
-                }
-            },
-            "ecsWorld": {
-                "availableEntityID": [
-                    4,
-                    5
-                ],
-                "entities": [
-                    {
-                        "hierarchyComponent": {
-                            "firstChild": 3
-                        },
-                        "id": 0,
-                        "meshComponent": {
-                            "assetId": "0a6f2480-dc72-456f-836c-910ebe9a17aa"
-                        },
-                        "nameComponent": {
-                            "name": "player"
-                        },
-                        "scriptComponent": {
-                            "name": "PlayerControl"
-                        },
-                        "transformComponent": {
-                            "position": {
-                                "x": 1.5800000429153442,
-                                "y": 0.3100000023841858,
-                                "z": 0.0
-                            },
-                            "rotation": {
-                                "x": 0.0,
-                                "y": 0.0,
-                                "z": 0.0
-                            },
-                            "scale": {
-                                "x": 0.019999999552965164,
-                                "y": 0.20000000298023224,
-                                "z": 0.019999999552965164
-                            }
-                        }
-                    },
-                    {
-                        "hierarchyComponent": null,
-                        "id": 1,
-                        "meshComponent": {
-                            "assetId": "839880c4-211a-4591-8c20-ec0dc8efad3e"
-                        },
-                        "nameComponent": {
-                            "name": "chess_set"
-                        },
-                        "transformComponent": {
-                            "position": {
-                                "x": 0.0,
-                                "y": 0.0,
-                                "z": 0.0
-                            },
-                            "rotation": {
-                                "x": 0.0,
-                                "y": 0.0,
-                                "z": 0.0
-                            },
-                            "scale": {
-                                "x": 5.0,
-                                "y": 5.0,
-                                "z": 5.0
-                            }
-                        }
-                    },
-                    {
-                        "id": 2,
-                        "lightComponent": {
-                            "color": {
-                                "b": 1.0,
-                                "g": 1.0,
-                                "r": 1.0
-                            },
-                            "intentsity": 1.0,
-                            "type": 0
-                        },
-                        "nameComponent": {
-                            "name": "light"
-                        },
-                        "transformComponent": {
-                            "position": {
-                                "x": 0.0,
-                                "y": 1.2599999904632568,
-                                "z": 0.0
-                            },
-                            "rotation": {
-                                "x": 0.0,
-                                "y": 0.0,
-                                "z": 0.0
-                            },
-                            "scale": {
-                                "x": 1.0,
-                                "y": 1.0,
-                                "z": 1.0
-                            }
-                        }
-                    },
-                    {
-                        "cameraComponent": {
-                            "fov": 1.0471975803375244,
-                            "zFar": 10000.0,
-                            "zNear": 0.009999999776482582
-                        },
-                        "hierarchyComponent": {
-                            "parent": 0
-                        },
-                        "id": 3,
-                        "nameComponent": {
-                            "name": "player_camera"
-                        },
-                        "transformComponent": {
-                            "position": {
-                                "x": 0.0,
-                                "y": 0.25,
-                                "z": 0.0
-                            },
-                            "rotation": {
-                                "x": 0.0,
-                                "y": 0.0,
-                                "z": 0.0
-                            },
-                            "scale": {
-                                "x": 1.0,
-                                "y": 0.10000000149011612,
-                                "z": 1.0
-                            }
-                        }
-                    }
-                ]
-            },
-            "name": "scene1"
-        }
-    ],
-    "scriptsLib": "project1_scriptLib",
-    "startScene": "scene1"
-}
\ No newline at end of file
+name: Untitled Project
+imguiSettings: "[Window][WindowOverViewport_11111111]\nPos=0,19\nSize=1710,956\nCollapsed=0\n\n[Window][Debug##Default]\nPos=60,60\nSize=400,400\nCollapsed=0\n\n[Window][viewport]\nPos=0,19\nSize=1371,780\nCollapsed=0\nDockId=0x00000001,0\n\n[Window][Scene graph]\nPos=1373,19\nSize=337,373\nCollapsed=0\nDockId=0x00000005,0\n\n[Window][Entity inspector]\nPos=1373,394\nSize=337,581\nCollapsed=0\nDockId=0x00000006,0\n\n[Window][Scenes]\nPos=0,801\nSize=1371,174\nCollapsed=0\nDockId=0x00000002,0\n\n[Window][Project properties]\nPos=496,146\nSize=718,682\nCollapsed=0\n\n[Window][Ressources]\nPos=0,546\nSize=1004,174\nCollapsed=0\nDockId=0x00000002,1\n\n[Window][Resources]\nPos=0,801\nSize=1371,174\nCollapsed=0\nDockId=0x00000002,1\n\n[Docking][Data]\nDockSpace     ID=0x08BD597D Window=0x1BBC0F80 Pos=0,19 Size=1710,956 Split=X\n  DockNode    ID=0x00000003 Parent=0x08BD597D SizeRef=1371,701 Split=Y\n    DockNode  ID=0x00000001 Parent=0x00000003 SizeRef=1280,525 CentralNode=1 Selected=0xF6034841\n    DockNode  ID=0x00000002 Parent=0x00000003 SizeRef=1280,174 Selected=0x30401527\n  DockNode    ID=0x00000004 Parent=0x08BD597D SizeRef=337,701 Split=Y Selected=0x848E2614\n    DockNode  ID=0x00000005 Parent=0x00000004 SizeRef=142,273 Selected=0x2C1AB1E4\n    DockNode  ID=0x00000006 Parent=0x00000004 SizeRef=142,426 Selected=0x848E2614\n\n"
+scriptsLib: examples/project1/project1_scriptLib
+inputContext:
+  inputs:
+    player_jump:
+      type: Action
+      mapper:
+        type: KeyboardButton
+        data:
+          button: space
+    player_move:
+      type: Range2D
+      mapper:
+        type: KeyboardButton
+        data:
+          xPos: d
+          xNeg: a
+          xScale: 1
+          yPos: w
+          yNeg: s
+          yScale: 1
+          triggerValue: 0.5
+    player_rotate:
+      type: Range2D
+      mapper:
+        type: KeyboardButton
+        data:
+          xPos: up
+          xNeg: down
+          xScale: 1
+          yPos: left
+          yNeg: right
+          yScale: 1
+          triggerValue: 0.5
+resourceDir: examples/project1/resources
+scenes:
+  - name: default_scene
+    activeCamera: 1
+    registredAssets:
+      ? type: Mesh
+        path: examples/project1/resources/chess_set/chess_set.gltf
+      : 1
+    entities:
+      0:
+        - type: NameComponent
+          data:
+            name: chess
+        - type: TransformComponent
+          data:
+            position:
+              - 0
+              - 0
+              - 0
+            rotation:
+              - 0
+              - 0
+              - 0
+            scale:
+              - 10
+              - 10
+              - 10
+        - type: MeshComponent
+          data:
+            id: 1
+      1:
+        - type: NameComponent
+          data:
+            name: camera
+        - type: HierarchyComponent
+          data:
+            parent: 4
+            firstChild: 18446744073709551615
+            nextChild: 18446744073709551615
+        - type: TransformComponent
+          data:
+            position:
+              - 0
+              - 1.41
+              - 1.19
+            rotation:
+              - -0.64
+              - 0
+              - 0
+            scale:
+              - 0.01
+              - 0.01
+              - 0.1
+        - type: CameraComponent
+          data:
+            fov: 1.0471976
+            zFar: 1000
+            zNear: 0.1
+        - type: MeshComponent
+          data:
+            id: 0
+      2:
+        - type: NameComponent
+          data:
+            name: light
+        - type: HierarchyComponent
+          data:
+            parent: 18446744073709551615
+            firstChild: 18446744073709551615
+            nextChild: 18446744073709551615
+        - type: TransformComponent
+          data:
+            position:
+              - 0
+              - 5
+              - 0
+            rotation:
+              - 0
+              - 0
+              - 0
+            scale:
+              - 1
+              - 1
+              - 1
+        - type: LightComponent
+          data:
+            type: point
+            color:
+              - 1
+              - 1
+              - 1
+            intentsity: 1
+            attenuation: 0
+      3:
+        - type: NameComponent
+          data:
+            name: player_mesh
+        - type: HierarchyComponent
+          data:
+            parent: 4
+            firstChild: 18446744073709551615
+            nextChild: 1
+        - type: TransformComponent
+          data:
+            position:
+              - 0
+              - 0
+              - 0
+            rotation:
+              - 0
+              - 0
+              - 0
+            scale:
+              - 0.1
+              - 0.5
+              - 0.1
+        - type: MeshComponent
+          data:
+            id: 0
+      4:
+        - type: NameComponent
+          data:
+            name: player
+        - type: HierarchyComponent
+          data:
+            parent: 18446744073709551615
+            firstChild: 3
+            nextChild: 18446744073709551615
+        - type: TransformComponent
+          data:
+            position:
+              - -3
+              - 0.67
+              - 0
+            rotation:
+              - 0
+              - -1.57
+              - 0
+            scale:
+              - 1
+              - 1
+              - 1
+        - type: ScriptComponent
+          data:
+            name: PlayerController
+            parameters:
+              gravity:
+                type: float
+                data: 0.006
+              jump_speed:
+                type: float
+                data: 0.12
+              move_speed:
+                type: float
+                data: 0.05
+              rotate_speed:
+                type: float
+                data: 0.05
+startScene: default_scene
diff --git a/examples/project1/ressources/chess_set/chess_set.bin b/examples/project1/resources/chess_set/chess_set.bin
similarity index 100%
rename from examples/project1/ressources/chess_set/chess_set.bin
rename to examples/project1/resources/chess_set/chess_set.bin
diff --git a/examples/project1/ressources/chess_set/chess_set.gltf b/examples/project1/resources/chess_set/chess_set.gltf
similarity index 100%
rename from examples/project1/ressources/chess_set/chess_set.gltf
rename to examples/project1/resources/chess_set/chess_set.gltf
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_board_arm_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_board_arm_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_board_arm_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_board_arm_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_board_diff_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_board_diff_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_board_diff_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_board_diff_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_board_nor_gl_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_board_nor_gl_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_board_nor_gl_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_board_nor_gl_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_black_arm_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_black_arm_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_black_arm_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_black_arm_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_black_diff_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_black_diff_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_black_diff_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_black_diff_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_black_nor_gl_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_black_nor_gl_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_black_nor_gl_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_black_nor_gl_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_white_arm_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_white_arm_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_white_arm_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_white_arm_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_white_diff_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_white_diff_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_white_diff_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_white_diff_1k.jpg
diff --git a/examples/project1/ressources/chess_set/textures/chess_set_pieces_white_nor_gl_1k.jpg b/examples/project1/resources/chess_set/textures/chess_set_pieces_white_nor_gl_1k.jpg
similarity index 100%
rename from examples/project1/ressources/chess_set/textures/chess_set_pieces_white_nor_gl_1k.jpg
rename to examples/project1/resources/chess_set/textures/chess_set_pieces_white_nor_gl_1k.jpg
diff --git a/examples/project1/ressources/cube.glb b/examples/project1/resources/cube.glb
similarity index 100%
rename from examples/project1/ressources/cube.glb
rename to examples/project1/resources/cube.glb
diff --git a/examples/project1/scripts/PlayerControl.cpp b/examples/project1/scripts/PlayerControl.cpp
deleted file mode 100644
index 8a71423..0000000
--- a/examples/project1/scripts/PlayerControl.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * ---------------------------------------------------
- * PlayerControl.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/08 16:22:51
- * ---------------------------------------------------
- */
-
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/UniquePtr.hpp"
-#include "ECS/Entity.hpp"
-#include "InputManager/Input.hpp"
-#include "InputManager/Mapper.hpp"
-#include "InputManager/RawInput.hpp"
-#include "Script.hpp"
-#include "ScriptLib.hpp"
-#include "Game.hpp"
-
-class PlayerControl : public GE::Script
-{
-public:
-    using GE::Script::Script;
-
-    PlayerControl(const GE::Entity& e, GE::Game& g) : GE::Script(e, g)
-    {
-        m_camera = m_entity.firstChild();
-
-        GE::ActionInput& gameStopInput = m_game.inputContext().newInput<GE::ActionInput>("game_stop");
-        gameStopInput.callback = utils::Func<void()>(m_game, &GE::Game::stop);
-        auto gameStopInputMapper = utils::makeUnique<GE::Mapper<GE::KeyboardButton, GE::ActionInput>>(GE::KeyboardButton::esc, gameStopInput);
-        gameStopInput.mappers[0] = gameStopInputMapper.staticCast<GE::IMapper>();
-
-        GE::Mapper<GE::KeyboardButton, GE::Range2DInput>::Descriptor inputMapperDesc;
-
-        GE::Range2DInput& playerMoveIpt = m_game.inputContext().newInput<GE::Range2DInput>("player_move");
-        playerMoveIpt.callback = utils::Func<void(math::vec2f)>(*this, &PlayerControl::move);
-        inputMapperDesc.xPos = GE::KeyboardButton::d;
-        inputMapperDesc.xNeg = GE::KeyboardButton::a;
-        inputMapperDesc.yPos = GE::KeyboardButton::w;
-        inputMapperDesc.yNeg = GE::KeyboardButton::s;
-        auto playerMoveIptMapper = utils::makeUnique<GE::Mapper<GE::KeyboardButton, GE::Range2DInput>>(inputMapperDesc, playerMoveIpt);
-        playerMoveIpt.mappers[0] = playerMoveIptMapper.staticCast<GE::IMapper>();
-        playerMoveIpt.mappers[1].clear();
-
-        GE::Range2DInput& playerRotateIpt = m_game.inputContext().newInput<GE::Range2DInput>("player_rotate");
-        playerRotateIpt.callback = utils::Func<void(math::vec2f)>(*this, &PlayerControl::rotate);
-        inputMapperDesc.xPos = GE::KeyboardButton::down;
-        inputMapperDesc.xNeg = GE::KeyboardButton::up;
-        inputMapperDesc.yPos = GE::KeyboardButton::right;
-        inputMapperDesc.yNeg = GE::KeyboardButton::left;
-        auto playerRotateIptMapper = utils::makeUnique<GE::Mapper<GE::KeyboardButton, GE::Range2DInput>>(inputMapperDesc, playerRotateIpt);
-        playerRotateIpt.mappers[0] = playerRotateIptMapper.staticCast<GE::IMapper>();
-        playerRotateIpt.mappers[1].clear();
-    }
-
-    void onUpdate() override
-    {
-    }
-
-    void move(math::vec2f value)
-    {
-        m_entity.position() += math::mat3x3::rotation(m_entity.rotation()) * math::vec3f{ value.x, 0, value.y }.normalized() * 0.05;
-    }
-
-    void rotate(math::vec2f value)
-    {
-        m_entity.rotation() += math::vec3f{ 0.0F,    value.y, 0.0F }.normalized() * 0.025;
-        m_camera.rotation() += math::vec3f{ value.x, 0.0F,    0.0F }.normalized() * 0.025;
-    }
-
-private:
-    GE::Entity m_camera;
-};
-
-REGISTER_SCRIPT(PlayerControl);
\ No newline at end of file
diff --git a/examples/project1/scripts/PlayerController.cpp b/examples/project1/scripts/PlayerController.cpp
new file mode 100644
index 0000000..f54dd3e
--- /dev/null
+++ b/examples/project1/scripts/PlayerController.cpp
@@ -0,0 +1,93 @@
+/*
+ * ---------------------------------------------------
+ * PlayerController.cpp
+ * ---------------------------------------------------
+ */
+
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/Entity.hpp>
+#include <Game-Engine/Game.hpp>
+#include <Game-Engine/Script.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+
+class PlayerController final : public GE::Script
+{
+    GE_SCRIPT(PlayerController, "PlayerController");
+
+    GE_SCRIPT_PARAM(float, move_speed, 0.05f);
+    GE_SCRIPT_PARAM(float, rotate_speed, 0.05f);
+    GE_SCRIPT_PARAM(float, jump_height, 0.12f);
+    GE_SCRIPT_PARAM(float, gravity, 0.006f);
+
+    void setup(GE::Entity& entity, GE::Game& game) override
+    {
+        m_entity = entity;
+        m_groundHeight = entity.get<GE::TransformComponent>().position.y;
+        m_grounded = true;
+
+        auto children = entity.children();
+        auto it = std::ranges::find_if(children, [](const GE::Entity& child) -> bool { return child.name() == "camera"; });
+        assert(it != children.end());
+
+        game.inputContext().setInputCallback<GE::Range2DInput>(
+            "player_move",
+            [this, entity](const glm::vec2& value) mutable
+            {
+                auto& transform = entity.get<GE::TransformComponent>();
+                const auto forward = glm::vec3(-std::sin(transform.rotation.y), 0.0f, -std::cos(transform.rotation.y));
+                const auto right = glm::vec3(std::cos(transform.rotation.y), 0.0f, -std::sin(transform.rotation.y));
+                transform.position += (right * value.x + forward * value.y) * move_speed;
+            }
+        );
+
+        game.inputContext().setInputCallback<GE::Range2DInput>(
+            "player_rotate",
+            [this, entity, camera=*it](const glm::vec2& value) mutable
+            {
+                auto& entityTransform = entity.get<GE::TransformComponent>();
+                auto& cameraTransform = camera.get<GE::TransformComponent>();
+
+                entityTransform.rotation.y += value.y * rotate_speed;
+                cameraTransform.rotation.x = std::clamp(cameraTransform.rotation.x + value.x * rotate_speed, glm::radians(-89.0f), glm::radians(89.0f));
+            }
+        );
+
+        game.inputContext().setInputCallback<GE::ActionInput>(
+            "player_jump",
+            [this]()
+            {
+                if (!m_grounded)
+                    return;
+
+                m_verticalVelocity = jump_height;
+                m_grounded = false;
+            }
+        );
+    }
+
+    void onUpdate() override
+    {
+        if (m_grounded)
+            return;
+
+        auto& transform = m_entity.get<GE::TransformComponent>();
+        transform.position.y += m_verticalVelocity;
+        m_verticalVelocity -= gravity;
+
+        if (transform.position.y <= m_groundHeight)
+        {
+            transform.position.y = m_groundHeight;
+            m_verticalVelocity = 0.0f;
+            m_grounded = true;
+        }
+    }
+
+private:
+    GE::Entity m_entity;
+    float m_groundHeight = 0.0f;
+    float m_verticalVelocity = 0.0f;
+    bool m_grounded = true;
+};
diff --git a/examples/project1/scripts/Rotating.cpp b/examples/project1/scripts/Rotating.cpp
index 4275790..5323ba3 100644
--- a/examples/project1/scripts/Rotating.cpp
+++ b/examples/project1/scripts/Rotating.cpp
@@ -1,24 +1,31 @@
 /*
  * ---------------------------------------------------
  * Rotating.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/24 12:13:30
  * ---------------------------------------------------
  */
 
-#include "Script.hpp"
-#include "ScriptLib.hpp"
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/Entity.hpp>
+#include <Game-Engine/Game.hpp>
+#include <Game-Engine/Script.hpp>
 
-class Rotating : public GE::Script
+class Rotating final : public GE::Script
 {
-public:
-    using GE::Script::Script;
+    GE_SCRIPT(Rotating, "Rotating");
+    GE_SCRIPT_PARAM(float, speed, 0.02f);
+
+    void setup(GE::Entity& entity, GE::Game& game) override
+    {
+        (void)game;
+        m_entity = entity;
+    }
 
     void onUpdate() override
     {
-        m_entity.rotation() += { 0.0, 0.02, 0.0 };
+        auto& transform = m_entity.get<GE::TransformComponent>();
+        transform.rotation.y += speed;
     }
-};
 
-REGISTER_SCRIPT(Rotating);
\ No newline at end of file
+private:
+    GE::Entity m_entity;
+};
diff --git a/examples/project1/scripts/Scaling.cpp b/examples/project1/scripts/Scaling.cpp
index 0bc1b34..fea9839 100644
--- a/examples/project1/scripts/Scaling.cpp
+++ b/examples/project1/scripts/Scaling.cpp
@@ -1,32 +1,38 @@
 /*
  * ---------------------------------------------------
  * Scaling.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/11/06 17:20:14
  * ---------------------------------------------------
  */
 
-#include "Math/Vector.hpp"
-#include "Script.hpp"
-#include "ScriptLib.hpp"
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/Entity.hpp>
+#include <Game-Engine/Game.hpp>
+#include <Game-Engine/Script.hpp>
 
-class Scaling : public GE::Script
+class Scaling final : public GE::Script
 {
-public:
-    using GE::Script::Script;
-    
+    GE_SCRIPT(Scaling, "Scaling");
+    GE_SCRIPT_PARAM(float, speed, 0.02f);
+    GE_SCRIPT_PARAM(bool, increasing, true);
+
+    void setup(GE::Entity& entity, GE::Game& game) override
+    {
+        (void)game;
+        m_entity = entity;
+    }
+
     void onUpdate() override
     {
-        m_entity.scale() += m_increasing ? math::vec3f{0.02, 0.02, 0.02} : math::vec3f{-0.02, -0.02, -0.02};
-        if (m_entity.scale().x >= 5)
-            m_increasing = false;
-        if (m_entity.scale().y <= 1)
-            m_increasing = true;
+        auto& transform = m_entity.get<GE::TransformComponent>();
+        const float delta = increasing ? speed : -speed;
+        transform.scale += glm::vec3(delta);
+
+        if (transform.scale.x >= 5.0f)
+            increasing = false;
+        if (transform.scale.x <= 1.0f)
+            increasing = true;
     }
 
 private:
-    bool m_increasing = true;
+    GE::Entity m_entity;
 };
-
-REGISTER_SCRIPT(Scaling);
\ No newline at end of file
diff --git a/examples/project1/scripts/ScriptLib.cpp b/examples/project1/scripts/ScriptLib.cpp
deleted file mode 100644
index 55a4b80..0000000
--- a/examples/project1/scripts/ScriptLib.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * ---------------------------------------------------
- * ScriptLib.cpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/24 21:09:33
- * ---------------------------------------------------
- */
-
-#include "ScriptLib.hpp"
-#include "ECS/Entity.hpp"
-#include "Script.hpp"
-#include "UtilsCPP/Array.hpp"
-
-extern "C" 
-{
-
-PROJECT1_API void getScriptNames(const char*** names, unsigned long* count)
-{
-    static utils::Array<const char*> nameArray;
-    nameArray.clear();
-    nameArray.setCapacity(ScriptRegistry::getRegistery().size() + 1);
-    for (const auto& [name, _] : ScriptRegistry::getRegistery())
-        nameArray.append((const char*)name);
-    nameArray.append(nullptr);
-    *names = &nameArray[0];
-    *count = ScriptRegistry::getRegistery().size();
-}
-
-PROJECT1_API GE::Script* makeScriptInstance(const char* name, const GE::Entity& e, GE::Game& g)
-{
-    return ScriptRegistry::getRegistery()[name](e, g);
-}
-
-}
\ No newline at end of file
diff --git a/examples/project1/scripts/ScriptLib.hpp b/examples/project1/scripts/ScriptLib.hpp
deleted file mode 100644
index a4dbb39..0000000
--- a/examples/project1/scripts/ScriptLib.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * ---------------------------------------------------
- * ScriptLib.hpp
- *
- * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
- * Date: 2024/10/24 15:51:57
- * ---------------------------------------------------
- */
-
-#ifndef SCRIPTLIB_HPP
-#define SCRIPTLIB_HPP
-
-#include "ECS/Entity.hpp"
-#include "Script.hpp"
-#include "UtilsCPP/Dictionary.hpp"
-#include "UtilsCPP/Func.hpp"
-#include "UtilsCPP/String.hpp"
-
-#if (defined(__GNUC__) || defined(__clang__)) && defined(PROJECT1_API_EXPORT)
-    #define PROJECT1_API __attribute__((visibility("default")))
-#elif defined(_MSC_VER) && defined(PROJECT1_API_EXPORT)
-    #define PROJECT1_API __declspec(dllexport)
-#elif defined(_MSC_VER) && defined(PROJECT1_API_IMPORT)
-    #define PROJECT1_API __declspec(dllimport)
-#else
-    #define PROJECT1_API
-#endif
-
-
-struct ScriptRegistry
-{
-    static utils::Dictionary<utils::String, utils::Func<GE::Script*(const GE::Entity&, GE::Game&)>>& getRegistery()
-    {
-        static utils::Dictionary<utils::String, utils::Func<GE::Script*(const GE::Entity&, GE::Game&)>> registery;
-        return registery;
-    }
-};
-
-#define REGISTER_SCRIPT(name)                                                  \
-    class ScriptRegistry_##name : public ScriptRegistry                        \
-    {                                                                          \
-    public:                                                                    \
-        ScriptRegistry_##name()                                                \
-        {                                                                      \
-            getRegistery().insert(#name, [](const GE::Entity& e, GE::Game& g){ \
-                return new name(e, g);                                         \
-            });                                                                \
-        }                                                                      \
-        static ScriptRegistry_##name s_instance;                               \
-    };                                                                         \
-    ScriptRegistry_##name  ScriptRegistry_##name::s_instance
-
-#endif // SCRIPTLIB_HPP
\ No newline at end of file
diff --git a/include/Game-Engine/Application.hpp b/include/Game-Engine/Application.hpp
new file mode 100644
index 0000000..0eb4c3e
--- /dev/null
+++ b/include/Game-Engine/Application.hpp
@@ -0,0 +1,72 @@
+/*
+ * ---------------------------------------------------
+ * Application.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/09/02 16:56:11
+ * ---------------------------------------------------
+ */
+
+#ifndef APPLICATION_HPP
+#define APPLICATION_HPP
+
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/Event.hpp"
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/FrameGraph.hpp"
+#include "Game-Engine/InputContext.hpp"
+#include "Game-Engine/Window.hpp"
+#include "Game-Engine/Renderer.hpp"
+
+#include <Graphics/Instance.hpp>
+#include <Graphics/Device.hpp>
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+namespace GE
+{
+
+class GE_API Application
+{
+public:
+    Application();
+    Application(const Application&) = delete;
+    Application(Application&&)      = delete;
+
+    inline Window& window() { return *m_window; }
+    inline AssetManager& assetManager() { return *m_assetManager; }
+
+    void run();
+    inline void terminate() { m_running = false; }
+    void pushInputContext(InputContext*);
+    void popInputContext();
+
+    virtual void onUpdate() = 0;
+    virtual void onEvent(Event&) = 0;
+
+    virtual const FrameGraph& frameGraph() = 0;
+
+    virtual ~Application() = default;
+
+private:
+    std::unique_ptr<void, std::function<void(void*)>> m_glfwGuard;
+    std::unique_ptr<gfx::Instance> m_instance = nullptr;
+    std::unique_ptr<Window> m_window = nullptr;
+    std::unique_ptr<gfx::Device> m_device = nullptr;
+    std::unique_ptr<void, std::function<void(void*)>> m_imguiGuard;
+    std::unique_ptr<Renderer> m_renderer = nullptr;
+    std::unique_ptr<AssetManager> m_assetManager = nullptr;
+
+    bool m_running = false;
+    std::vector<InputContext*> m_inputContextStack;
+
+public:
+    Application& operator = (const Application&) = delete;
+    Application& operator = (Application&&)      = delete;
+};
+
+}
+
+#endif // APPLICATION_HPP
diff --git a/include/Game-Engine/Archetype.inl b/include/Game-Engine/Archetype.inl
new file mode 100644
index 0000000..84ef871
--- /dev/null
+++ b/include/Game-Engine/Archetype.inl
@@ -0,0 +1,64 @@
+/*
+ * ---------------------------------------------------
+ * Archetype.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+class Archetype
+{
+public:
+    class Iterator;
+    using iterator = Iterator;
+
+    Archetype();
+    Archetype(const Archetype&); // copy constructor make no sense inside the same ECSWorld. ment to be used only when copying the ECSWorld
+    Archetype(Archetype&&);
+
+    uint64_t size() const { return m_size; }
+
+    inline Iterator begin() const { return Iterator(this, 0); }
+    inline std::default_sentinel_t end() const { return std::default_sentinel; }
+
+    template<typename T> void addRowType(); // must be use on empty achetype that are not inserted `ECSWorld::m_archetypes`
+    template<typename T> void rmvRowType(); // must be use on empty achetype that are not inserted `ECSWorld::m_archetypes`
+
+    Archetype duplicateRowTypes(); // only duplicate the component infos (no component duplicated)
+    uint64_t allocateCollum(); // only extend the size (and capacity if needed) and return last index
+
+    template<Component T> auto* getComponentPointer(this auto&& self, uint64_t idx);
+    auto getEntityID(this auto&& self, uint64_t idx)
+        -> std::conditional_t<std::is_const_v<std::remove_reference_t<decltype(self)>>, const EntityID&, EntityID&>;
+
+    static void moveComponents(Archetype& arcSrc, uint64_t idxSrc, Archetype& arcDst, uint64_t idxDst); // only call the move constructor. destination should be garbage memory
+    void destructCollum(uint64_t idx); // only call the destructor
+    void freeLastCollum(); // only reduce the size (and capacity if needed)
+
+    ~Archetype();
+
+private:
+    struct Row
+    {
+        void* buffer = nullptr;
+        const uint64_t componentSize;
+        const CopyConstructor copyConstructor;
+        const MoveConstructor moveConstructor;
+        const Destructor destructor;
+    };
+
+    std::map<ComponentID, Row> m_rows;
+    uint64_t m_size;
+    uint64_t m_capacity;
+
+    void setCapacity(uint64_t);
+    inline void extendCapacity() { setCapacity(m_capacity * 2); }
+    inline void reduceCapacity() { setCapacity(m_capacity / 2 > 0 ? m_capacity / 2 : 1); }
+
+public:
+    Archetype& operator=(const Archetype&);
+    Archetype& operator=(Archetype&&);
+
+public:
+    #include "Game-Engine/ArchetypeIterator.inl"
+};
diff --git a/include/Game-Engine/ArchetypeIterator.inl b/include/Game-Engine/ArchetypeIterator.inl
new file mode 100644
index 0000000..9ed056f
--- /dev/null
+++ b/include/Game-Engine/ArchetypeIterator.inl
@@ -0,0 +1,44 @@
+/*
+ * ---------------------------------------------------
+ * ArchetypeIterator.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+class Iterator
+{
+public:
+    friend class Archetype;
+
+public:
+    Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator(Iterator&&) = default;
+
+    inline uint64_t idx() const { return m_idx; }
+
+    ~Iterator() = default;
+
+private:
+    Iterator(const Archetype* archetype, uint64_t idx)
+        : m_archetype(archetype)
+        , m_idx(idx)
+    {
+        assert(m_archetype);
+    }
+
+    const Archetype* m_archetype = nullptr;
+    uint64_t m_idx = 0;
+
+public:
+    Iterator& operator=(const Iterator& cp) = default;
+    Iterator& operator=(Iterator&& mv) = default;
+
+    inline EntityID operator*() const { return m_archetype->getEntityID(m_idx); }
+
+    inline Iterator& operator++() { return m_idx++, *this; }
+    inline void operator++(int) { ++(*this); }
+
+    inline bool operator==(std::default_sentinel_t) const { return m_idx == m_archetype->m_size; }
+};
diff --git a/include/Game-Engine/AssetManager.hpp b/include/Game-Engine/AssetManager.hpp
new file mode 100644
index 0000000..23b8f4f
--- /dev/null
+++ b/include/Game-Engine/AssetManager.hpp
@@ -0,0 +1,271 @@
+/*
+ * ---------------------------------------------------
+ * AssetManager.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/13 11:49:48
+ * ---------------------------------------------------
+ */
+
+#ifndef ASSETMANAGER_HPP
+#define ASSETMANAGER_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Mesh.hpp"
+#include "Game-Engine/TypeList.hpp"
+
+#include <Graphics/Device.hpp>
+#include <Graphics/Texture.hpp>
+#include <Graphics/CommandBuffer.hpp>
+
+#include <yaml-cpp/yaml.h>
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <functional>
+#include <future>
+#include <map>
+#include <memory>
+#include <ranges>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+#include <algorithm>
+
+namespace GE
+{
+
+using ManagableAssetTypes = TypeList<Mesh, gfx::Texture>;
+
+template<typename T>
+concept ManagableAsset = IsTypeInList<std::remove_cvref_t<T>, ManagableAssetTypes>;
+
+template<ManagableAsset T>
+struct AssetPath
+{
+    using AssetType = T;
+    std::filesystem::path path;
+    AssetPath() = default;
+    AssetPath(std::filesystem::path path) : path(std::move(path)) {}
+    inline operator std::filesystem::path& () { return path; }
+    inline operator const std::filesystem::path& () const { return path; }
+    friend bool operator==(const AssetPath&, const AssetPath&) = default;
+    friend bool operator<(const AssetPath& lhs, const AssetPath& rhs) { return lhs.path < rhs.path; }
+};
+
+template<typename T>
+struct AssetPathYamlTraits;
+
+template<>
+struct AssetPathYamlTraits<AssetPath<Mesh>>
+{
+    static constexpr std::string_view name = "Mesh";
+};
+
+template<>
+struct AssetPathYamlTraits<AssetPath<gfx::Texture>>
+{
+    static constexpr std::string_view name = "Texture";
+};
+
+template<typename AssetT>
+using AssetPathType = AssetPath<AssetT>;
+
+using AssetPathTypes = ManagableAssetTypes::wrapped<AssetPathType>;
+using VAssetPath = AssetPathTypes::into<std::variant>;
+
+template<typename T>
+concept VAssetPathRange = std::ranges::range<T> && std::is_same_v<std::ranges::range_value_t<T>, VAssetPath>;
+
+class GE_API AssetManager
+{
+public:
+    AssetManager() = delete;
+    AssetManager(const AssetManager&) = delete;
+    AssetManager(AssetManager&&) = delete;
+
+    AssetManager(gfx::Device*);
+
+    void registerAsset(const VAssetPath&);
+
+    template<ManagableAsset T>
+    inline const std::shared_future<const std::shared_ptr<T>&>& loadAsset(const VAssetPath& vAssetPath) { return loadAssetHandle<T>(m_handles.at(vAssetPath)); }
+
+    std::future<void> loadAssets(VAssetPathRange auto&& vAssetPaths) {
+        std::vector<std::future<void>> futures;
+        if constexpr (std::ranges::sized_range<std::remove_cvref_t<decltype(vAssetPaths)>>)
+            futures.reserve(std::ranges::size(vAssetPaths));
+
+        for (const VAssetPath& vAssetPath : vAssetPaths)
+        {
+            std::visit([&](const auto& assetPath) {
+                using AssetType = typename std::remove_cvref_t<decltype(assetPath)>::AssetType;
+                const auto& future = loadAsset<AssetType>(vAssetPath);
+                futures.push_back(std::async(std::launch::deferred, [future = future]() { future.get(); }));
+            },
+            vAssetPath);
+        }
+        return std::async(std::launch::deferred, [futures = std::move(futures)]() mutable {
+            for (auto& f : futures)
+                f.get();
+        });
+    }
+
+    inline const std::shared_future<const std::shared_ptr<Mesh>&>& loadBuiltInCube() { return loadAssetHandle<Mesh>(m_builtInCubeHandle); }
+
+    inline bool isAssetLoaded(const VAssetPath& vAssetPath) const { return isAssetHandleLoaded(m_handles.at(vAssetPath)); }
+
+    bool areAssetsLoaded(VAssetPathRange auto&& vAssetPaths) const {
+        return std::ranges::all_of(vAssetPaths, [this](const VAssetPath& vAssetPath) {
+            return isAssetLoaded(vAssetPath);
+        });
+    }
+
+    inline bool isBuiltInCubeLoaded() const { return isAssetHandleLoaded(m_builtInCubeHandle); }
+
+    inline void unloadAsset(const VAssetPath& vAssetPath) { unloadAssetHandle(m_handles.at(vAssetPath)); }
+
+    void unloadAssets(VAssetPathRange auto&& vAssetPaths) {
+        for (const VAssetPath& vAssetPath : vAssetPaths)
+            unloadAsset(vAssetPath);
+    }
+
+    inline void unloadBuiltInCube() { unloadAssetHandle(m_builtInCubeHandle); }
+
+    template<ManagableAsset T>
+    inline const std::shared_ptr<T>& getAsset(VAssetPath& vAssetPath) { return loadAsset<T>(vAssetPath).get(); }
+
+    ~AssetManager();
+
+private:
+    enum class AssetHandleLoadingStatus : std::uint8_t
+    {
+        unloaded,
+        loading,
+        loaded
+    };
+
+    template<ManagableAsset T>
+    struct AssetHandle
+    {
+        using AssetType = T;
+
+        std::function<std::shared_ptr<T>(gfx::CommandBuffer&)> loader;
+        std::atomic<AssetHandleLoadingStatus> status = AssetHandleLoadingStatus::unloaded;
+        std::shared_future<const std::shared_ptr<T>&> future;
+        std::shared_ptr<T> asset;
+    };
+
+    template<typename AssetT>
+    using AssetHandleType = AssetHandle<AssetT>;
+
+    using AssetHandleTypes = ManagableAssetTypes::wrapped<AssetHandleType>;
+    using VAssetHandle = AssetHandleTypes::into<std::variant>;
+
+    template<ManagableAsset T>
+    const std::shared_future<const std::shared_ptr<T>&>& loadAssetHandle(VAssetHandle& vHandle) {
+        auto& handle = std::get<AssetHandle<T>>(vHandle);
+        auto expected = AssetHandleLoadingStatus::unloaded;
+        if (handle.status.compare_exchange_strong(expected, AssetHandleLoadingStatus::loading))
+        {
+            handle.future = std::async(std::launch::async, [device = m_device, handle = &handle]() -> const std::shared_ptr<T>& {
+                std::unique_ptr<gfx::CommandBufferPool> commandBufferPool = device->newCommandBufferPool();
+                assert(commandBufferPool);
+                std::shared_ptr<gfx::CommandBuffer> commandBuffer = commandBufferPool->get();
+                assert(commandBuffer);
+                handle->asset = handle->loader(*commandBuffer);
+                device->submitCommandBuffers(commandBuffer);
+                handle->status.store(AssetHandleLoadingStatus::loaded);
+                return handle->asset;
+            });
+        }
+        return handle.future;
+    }
+
+    bool isAssetHandleLoaded(const VAssetHandle& vHandle) const {
+        return std::visit([](const auto& handle) {
+            return handle.status.load() == AssetHandleLoadingStatus::loaded;
+        },
+        vHandle);
+    }
+
+    void unloadAssetHandle(VAssetHandle&);
+
+    static std::shared_ptr<gfx::Buffer> newDeviceLocalBuffer(gfx::Device& device, gfx::CommandBuffer& commandBuffer, gfx::BufferUsage usage, const std::ranges::sized_range auto& data) {
+        std::shared_ptr<gfx::Buffer> indexBuffer = device.newBuffer(gfx::Buffer::Descriptor{
+            .size = sizeof(std::ranges::range_value_t<decltype(data)>) * data.size(),
+            .usages = usage | gfx::BufferUsage::copyDestination,
+            .storageMode = gfx::ResourceStorageMode::deviceLocal });
+        assert(indexBuffer);
+
+        std::shared_ptr<gfx::Buffer> stagingBuffer = device.newBuffer(gfx::Buffer::Descriptor{
+            .size = indexBuffer->size(),
+            .usages = gfx::BufferUsage::copySource,
+            .storageMode = gfx::ResourceStorageMode::hostVisible });
+        assert(stagingBuffer);
+
+        std::ranges::copy(data, stagingBuffer->content<std::ranges::range_value_t<decltype(data)>>());
+
+        commandBuffer.copyBufferToBuffer(stagingBuffer, indexBuffer, indexBuffer->size());
+
+        return indexBuffer;
+    }
+
+    static Mesh loadMesh(gfx::Device&, const std::filesystem::path&, gfx::CommandBuffer&);
+    static std::shared_ptr<gfx::Texture> loadTexture(gfx::Device&, const std::filesystem::path&, gfx::CommandBuffer&);
+    static std::shared_ptr<gfx::Texture> loadTexture(gfx::Device&, const std::byte* bytes, uint32_t width, uint32_t height, gfx::CommandBuffer&);
+    static Mesh loadBuiltInCube(gfx::Device&, gfx::CommandBuffer&);
+
+    gfx::Device* m_device = nullptr;
+    std::map<VAssetPath, VAssetHandle> m_handles;
+    VAssetHandle m_builtInCubeHandle;
+
+public:
+    AssetManager& operator=(const AssetManager&) = delete;
+    AssetManager& operator=(AssetManager&&) = delete;
+};
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<GE::VAssetPath>
+{
+    static Node encode(const GE::VAssetPath& rhs)
+    {
+        Node node;
+        std::visit([&](const auto& assetPath)
+        {
+            using AssetPathT = std::remove_cvref_t<decltype(assetPath)>;
+            node["type"] = std::string(GE::AssetPathYamlTraits<AssetPathT>::name);
+            node["path"] = assetPath.path.string();
+        },
+        rhs);
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::VAssetPath& rhs)
+    {
+        if (!node.IsMap() || !node["type"] || !node["path"])
+            return false;
+
+        const std::string type = node["type"].as<std::string>();
+        const std::filesystem::path path = node["path"].as<std::string>();
+        return GE::anyOfType<GE::AssetPathTypes>([&]<typename AssetPathT>() {
+            if (type != GE::AssetPathYamlTraits<AssetPathT>::name)
+                return false;
+            rhs = AssetPathT(path);
+            return true;
+        });
+    }
+};
+
+}
+#endif // ASSETMANAGER_HPP
diff --git a/include/Game-Engine/AssetManagerView.hpp b/include/Game-Engine/AssetManagerView.hpp
new file mode 100644
index 0000000..7b0a56a
--- /dev/null
+++ b/include/Game-Engine/AssetManagerView.hpp
@@ -0,0 +1,142 @@
+/*
+ * ---------------------------------------------------
+ * AssetManagerView.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef ASSETMANAGERVIEW_HPP
+#define ASSETMANAGERVIEW_HPP
+
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/Export.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <future>
+#include <map>
+#include <ranges>
+#include <utility>
+
+namespace GE
+{
+
+using AssetID = uint64_t;
+constexpr AssetID BUILT_IN_CUBE_ASSET_ID = 0;
+
+template<typename T>
+concept AssetIdRange = std::ranges::range<T> && std::convertible_to<std::ranges::range_value_t<T>, AssetID>;
+
+class GE_API AssetManagerView
+{
+public:
+    AssetManagerView() = delete;
+    AssetManagerView(const AssetManagerView&) = delete;
+    AssetManagerView(AssetManagerView&&) = default;
+
+    AssetManagerView(AssetManager*);
+    AssetManagerView(AssetManager*, const std::map<VAssetPath, AssetID>& registredAssets);
+
+    template<ManagableAsset T>
+    AssetID registerAsset(const std::filesystem::path& path)
+    {
+        assert(m_assetManager);
+        const AssetID assetId = s_nextAssetId++;
+        auto [it, inserted] = m_registredAssets.insert(std::make_pair(AssetPath<T>(path), assetId));
+        if (inserted)
+        {
+            m_assetManager->registerAsset(AssetPath<T>(path));
+            auto [_, inserted] = m_assets.insert(std::make_pair(assetId, AssetPath<T>(path)));
+            assert(inserted);
+        }
+        return it->second;
+    }
+
+    template<ManagableAsset T>
+    const std::shared_future<const std::shared_ptr<T>&>& loadAsset(AssetID assetId) const
+    {
+        assert(m_assetManager);
+        if (assetId == BUILT_IN_CUBE_ASSET_ID)
+            return m_assetManager->loadBuiltInCube();
+        else
+            return m_assetManager->loadAsset<T>(m_assets.at(assetId));
+    }
+
+    std::future<void> loadAssets(AssetIdRange auto&& assetIds) const
+    {
+        assert(m_assetManager);
+        std::array<std::future<void>, 2> futures;
+        futures[1] = m_assetManager->loadAssets(assetIds
+                                                | std::views::filter([&](const auto& id) {
+                                                      if (id == BUILT_IN_CUBE_ASSET_ID)
+                                                          futures[0] = std::async(std::launch::deferred, [future = m_assetManager->loadBuiltInCube()] { future.get(); });
+                                                      return id != BUILT_IN_CUBE_ASSET_ID;
+                                                  })
+                                                | std::ranges::views::transform([&](const auto& assetId) { return m_assets.at(assetId); }));
+
+        return std::async(std::launch::deferred, [futures = std::move(futures)]() mutable {
+            for (auto& f : futures)
+                if (f.valid())
+                    f.get();
+        });
+    }
+
+    inline std::future<void> loadAllAssets() const { return loadAssets(m_assets | std::views::transform([](const auto& asset) { return asset.first; })); }
+
+    inline bool isAssetLoaded(AssetID assetId) const
+    {
+        assert(m_assetManager);
+        if (assetId == BUILT_IN_CUBE_ASSET_ID)
+            return m_assetManager->isBuiltInCubeLoaded();
+        return m_assetManager->isAssetLoaded(m_assets.at(assetId));
+    }
+
+    bool areAssetsLoaded(AssetIdRange auto&& assetIds) const
+    {
+        return std::ranges::all_of(assetIds, [this](const auto& assetId) {
+            return isAssetLoaded(assetId);
+        });
+    }
+
+    inline bool areAllAssetsLoaded() const { return areAssetsLoaded(m_assets | std::views::transform([](const auto& asset) { return asset.first; })); }
+
+    inline const std::map<VAssetPath, AssetID>& registredAssets() const { return m_registredAssets; }
+
+    void unloadAssets(AssetIdRange auto&& assetIds)
+    {
+        assert(m_assetManager);
+        m_assetManager->unloadAssets(assetIds
+                                     | std::views::filter([&](const auto& id) {
+                                           if (id == BUILT_IN_CUBE_ASSET_ID)
+                                               m_assetManager->unloadBuiltInCube();
+                                           return id != BUILT_IN_CUBE_ASSET_ID;
+                                       })
+                                     | std::views::transform([&](const auto& assetId) { return m_assets.at(assetId); }));
+    }
+
+    void unloadAsset(AssetID);
+    void unloadAllAssets();
+
+    template<ManagableAsset T>
+    inline const std::shared_ptr<T>& getAsset(AssetID assetId) { return loadAsset<T>(assetId).get(); }
+
+    ~AssetManagerView();
+
+private:
+    AssetManager* m_assetManager = nullptr;
+    inline static AssetID s_nextAssetId = 1; // 0 is builtin cube
+
+    std::map<VAssetPath, AssetID> m_registredAssets;
+    std::map<AssetID, VAssetPath> m_assets;
+
+public:
+    AssetManagerView& operator=(const AssetManagerView&) = delete;
+    AssetManagerView& operator=(AssetManagerView&&) = default;
+};
+
+} // namespace GE
+
+#endif // ASSETMANAGERVIEW_HPP
diff --git a/include/Game-Engine/Components.hpp b/include/Game-Engine/Components.hpp
new file mode 100644
index 0000000..04518ad
--- /dev/null
+++ b/include/Game-Engine/Components.hpp
@@ -0,0 +1,426 @@
+/*
+ * ---------------------------------------------------
+ * Components.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/10/18 17:35:21
+ * ---------------------------------------------------
+ */
+
+#ifndef COMPONENTS_HPP
+#define COMPONENTS_HPP
+
+#include "Game-Engine/AssetManagerView.hpp"
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/Script.hpp"
+#include "Game-Engine/TypeList.hpp"
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <string>
+#include <string_view>
+#include <map>
+#include <memory>
+#include <type_traits>
+#include <variant>
+
+#include <yaml-cpp/yaml.h>
+
+namespace GE
+{
+
+template<typename T>
+struct ECSComponentYamlTraits;
+
+struct NameComponent
+{
+    std::string name;
+
+    inline operator std::string& () { return name; }
+    inline operator const std::string& () const { return name; }
+};
+
+struct HierarchyComponent
+{
+    ECSWorld::EntityID parent = INVALID_ENTITY_ID;
+    ECSWorld::EntityID firstChild = INVALID_ENTITY_ID;
+    ECSWorld::EntityID nextChild = INVALID_ENTITY_ID;
+};
+
+struct TransformComponent
+{
+    glm::vec3 position = {0.0f, 0.0f, 0.0f};
+    glm::vec3 rotation = {0.0f, 0.0f, 0.0f};
+    glm::vec3 scale    = {1.0f, 1.0f, 1.0f};
+
+    inline operator glm::mat4 () const
+    {
+        auto matrix = glm::mat4x4(1.0f);
+        matrix = glm::translate(matrix, position);
+        matrix = glm::rotate(matrix, rotation.x, glm::vec3(1, 0, 0));
+        matrix = glm::rotate(matrix, rotation.y, glm::vec3(0, 1, 0));
+        matrix = glm::rotate(matrix, rotation.z, glm::vec3(0, 0, 1));
+        matrix = glm::scale(matrix, glm::vec3(scale));
+        return matrix;
+    }
+};
+
+struct CameraComponent
+{
+    float fov   = glm::radians(60.0f);
+    float zFar  = 1000.0f;
+    float zNear = 0.1f;
+
+    inline glm::mat4 projectionMatrix(float aspectRatio) const
+    {
+        return glm::perspective(fov, aspectRatio, zNear, zFar);
+    }
+};
+
+struct LightComponent
+{
+    enum class Type : glm::uint8_t
+    {
+        directional = 0,
+        point       = 1
+    }
+    type = LightComponent::Type::point;
+    glm::vec3 color = {1.0f, 1.0f, 1.0f};
+    float intentsity = 1.0f;
+    float attenuation = 0.0f;
+};
+
+struct MeshComponent
+{
+    AssetID id = 0;
+
+    inline operator AssetID& () { return id; }
+    inline operator const AssetID& () const { return id; }
+};
+
+struct ScriptComponent
+{
+    std::string name;
+    std::map<std::string, VScriptValue> parameters;
+    std::shared_ptr<Script> instance;
+};
+
+using ECSComponentTypes = TypeList<NameComponent, HierarchyComponent, TransformComponent, CameraComponent, LightComponent, MeshComponent, ScriptComponent>;
+using ComponentVariant = ECSComponentTypes::into<std::variant>;
+
+template<> struct ECSComponentYamlTraits<NameComponent>      { static constexpr std::string_view name = "NameComponent";      };
+template<> struct ECSComponentYamlTraits<HierarchyComponent> { static constexpr std::string_view name = "HierarchyComponent"; };
+template<> struct ECSComponentYamlTraits<TransformComponent> { static constexpr std::string_view name = "TransformComponent"; };
+template<> struct ECSComponentYamlTraits<CameraComponent>    { static constexpr std::string_view name = "CameraComponent";    };
+template<> struct ECSComponentYamlTraits<LightComponent>     { static constexpr std::string_view name = "LightComponent";     };
+template<> struct ECSComponentYamlTraits<MeshComponent>      { static constexpr std::string_view name = "MeshComponent";      };
+template<> struct ECSComponentYamlTraits<ScriptComponent>    { static constexpr std::string_view name = "ScriptComponent";    };
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<glm::vec2>
+{
+    static Node encode(const glm::vec2& rhs)
+    {
+        Node node(NodeType::Sequence);
+        node.push_back(rhs.x);
+        node.push_back(rhs.y);
+        return node;
+    }
+
+    static bool decode(const Node& node, glm::vec2& rhs)
+    {
+        if (!node.IsSequence() || node.size() != 2)
+            return false;
+
+        rhs.x = node[0].as<float>();
+        rhs.y = node[1].as<float>();
+        return true;
+    }
+};
+
+template<>
+struct convert<glm::vec3>
+{
+    static Node encode(const glm::vec3& rhs)
+    {
+        Node node(NodeType::Sequence);
+        node.push_back(rhs.x);
+        node.push_back(rhs.y);
+        node.push_back(rhs.z);
+        return node;
+    }
+
+    static bool decode(const Node& node, glm::vec3& rhs)
+    {
+        if (!node.IsSequence() || node.size() != 3)
+            return false;
+
+        rhs.x = node[0].as<float>();
+        rhs.y = node[1].as<float>();
+        rhs.z = node[2].as<float>();
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::NameComponent>
+{
+    static Node encode(const GE::NameComponent& rhs)
+    {
+        Node node;
+        node["name"] = rhs.name;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::NameComponent& rhs)
+    {
+        if (!node.IsMap() || !node["name"])
+            return false;
+
+        rhs.name = node["name"].as<std::string>();
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::HierarchyComponent>
+{
+    static Node encode(const GE::HierarchyComponent& rhs)
+    {
+        Node node;
+        node["parent"] = rhs.parent;
+        node["firstChild"] = rhs.firstChild;
+        node["nextChild"] = rhs.nextChild;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::HierarchyComponent& rhs)
+    {
+        if (!node.IsMap())
+            return false;
+
+        rhs.parent = node["parent"] ? node["parent"].as<GE::ECSWorld::EntityID>() : INVALID_ENTITY_ID;
+        rhs.firstChild = node["firstChild"] ? node["firstChild"].as<GE::ECSWorld::EntityID>() : INVALID_ENTITY_ID;
+        rhs.nextChild = node["nextChild"] ? node["nextChild"].as<GE::ECSWorld::EntityID>() : INVALID_ENTITY_ID;
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::TransformComponent>
+{
+    static Node encode(const GE::TransformComponent& rhs)
+    {
+        Node node;
+        node["position"] = rhs.position;
+        node["rotation"] = rhs.rotation;
+        node["scale"] = rhs.scale;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::TransformComponent& rhs)
+    {
+        if (!node.IsMap())
+            return false;
+
+        rhs.position = node["position"] ? node["position"].as<glm::vec3>() : glm::vec3{0.0f, 0.0f, 0.0f};
+        rhs.rotation = node["rotation"] ? node["rotation"].as<glm::vec3>() : glm::vec3{0.0f, 0.0f, 0.0f};
+        rhs.scale = node["scale"] ? node["scale"].as<glm::vec3>() : glm::vec3{1.0f, 1.0f, 1.0f};
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::CameraComponent>
+{
+    static Node encode(const GE::CameraComponent& rhs)
+    {
+        Node node;
+        node["fov"] = rhs.fov;
+        node["zFar"] = rhs.zFar;
+        node["zNear"] = rhs.zNear;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::CameraComponent& rhs)
+    {
+        if (!node.IsMap())
+            return false;
+
+        rhs.fov = node["fov"] ? node["fov"].as<float>() : glm::radians(60.0f);
+        rhs.zFar = node["zFar"] ? node["zFar"].as<float>() : 1000.0f;
+        rhs.zNear = node["zNear"] ? node["zNear"].as<float>() : 0.1f;
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::LightComponent::Type>
+{
+    static Node encode(const GE::LightComponent::Type& rhs)
+    {
+        switch (rhs)
+        {
+            case GE::LightComponent::Type::directional: return Node("directional");
+            case GE::LightComponent::Type::point: return Node("point");
+        }
+        return Node();
+    }
+
+    static bool decode(const Node& node, GE::LightComponent::Type& rhs)
+    {
+        if (!node.IsScalar())
+            return false;
+
+        const std::string value = node.as<std::string>();
+        if (value == "directional")
+            rhs = GE::LightComponent::Type::directional;
+        else if (value == "point")
+            rhs = GE::LightComponent::Type::point;
+        else
+            return false;
+
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::LightComponent>
+{
+    static Node encode(const GE::LightComponent& rhs)
+    {
+        Node node;
+        node["type"] = rhs.type;
+        node["color"] = rhs.color;
+        node["intentsity"] = rhs.intentsity;
+        node["attenuation"] = rhs.attenuation;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::LightComponent& rhs)
+    {
+        if (!node.IsMap())
+            return false;
+
+        rhs.type = node["type"] ? node["type"].as<GE::LightComponent::Type>() : GE::LightComponent::Type::point;
+        rhs.color = node["color"] ? node["color"].as<glm::vec3>() : glm::vec3{1.0f, 1.0f, 1.0f};
+        rhs.intentsity = node["intentsity"] ? node["intentsity"].as<float>() : 1.0f;
+        rhs.attenuation = node["attenuation"] ? node["attenuation"].as<float>() : 0.0f;
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::MeshComponent>
+{
+    static Node encode(const GE::MeshComponent& rhs)
+    {
+        Node node;
+        node["id"] = rhs.id;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::MeshComponent& rhs)
+    {
+        if (!node.IsMap() || !node["id"])
+            return false;
+
+        rhs.id = node["id"].as<GE::AssetID>();
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::VScriptValue>
+{
+    static Node encode(const GE::VScriptValue& rhs)
+    {
+        Node node;
+        std::visit([&](const auto& value) {
+            using T = std::remove_cvref_t<decltype(value)>;
+            node["type"] = std::string(GE::ScriptValueTraits<T>::name);
+            node["data"] = value;
+        }, rhs);
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::VScriptValue& rhs)
+    {
+        if (!node.IsMap() || !node["type"] || !node["data"])
+            return false;
+
+        const std::string type = node["type"].as<std::string>();
+        const Node data = node["data"];
+        return GE::anyOfType<GE::ScriptValueTypes>([&]<typename ValueT>() {
+            if (type != GE::ScriptValueTraits<ValueT>::name)
+                return false;
+            rhs = data.as<ValueT>();
+            return true;
+        });
+    }
+};
+
+template<>
+struct convert<GE::ScriptComponent>
+{
+    static Node encode(const GE::ScriptComponent& rhs)
+    {
+        Node node;
+        node["name"] = rhs.name;
+        node["parameters"] = rhs.parameters;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::ScriptComponent& rhs)
+    {
+        if (!node.IsMap() || !node["name"])
+            return false;
+
+        rhs.name = node["name"].as<std::string>();
+        rhs.parameters = node["parameters"] ? node["parameters"].as<std::map<std::string, GE::VScriptValue>>() : std::map<std::string, GE::VScriptValue>();
+        return true;
+    }
+};
+
+template<>
+struct convert<GE::ComponentVariant>
+{
+    static Node encode(const GE::ComponentVariant& rhs)
+    {
+        Node node;
+
+        std::visit([&](const auto& component) {
+            using ComponentT = std::remove_cvref_t<decltype(component)>;
+
+            node["type"] = std::string(GE::ECSComponentYamlTraits<ComponentT>::name);
+            node["data"] = component;
+        }, rhs);
+
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::ComponentVariant& rhs)
+    {
+        if (!node.IsMap() || !node["type"] || !node["data"])
+            return false;
+
+        const std::string type = node["type"].as<std::string>();
+        const Node data = node["data"];
+        return GE::anyOfType<GE::ECSComponentTypes>([&]<typename ComponentT>() {
+            if (type != GE::ECSComponentYamlTraits<ComponentT>::name)
+                return false;
+            rhs = data.as<ComponentT>();
+            return true;
+        });
+    }
+};
+
+} // namespace YAML
+
+#endif // COMPONENTS_HPP
diff --git a/include/Game-Engine/ECSView.hpp b/include/Game-Engine/ECSView.hpp
new file mode 100644
index 0000000..067e13b
--- /dev/null
+++ b/include/Game-Engine/ECSView.hpp
@@ -0,0 +1,163 @@
+/*
+ * ---------------------------------------------------
+ * ECSView.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/07/28 18:24:19
+ * ---------------------------------------------------
+ */
+
+#ifndef ECSVIEW_HPP
+#define ECSVIEW_HPP
+
+#include "Game-Engine/ECSWorld.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <ranges>
+#include <set>
+#include <tuple> // IWYU pragma: keep
+#include <type_traits> // IWYU pragma: keep
+#include <utility> // IWYU pragma: keep
+
+namespace GE
+{
+
+template<ECSWorldLike ECSWorldT, Component... Cs>
+struct ecs_view_item
+{
+    template<typename C>
+    using ComponentReference = std::conditional_t<std::is_const_v<ECSWorldT>, const C&, C&>;
+
+    typename ECSWorldT::EntityID entityId = INVALID_ENTITY_ID;
+    std::tuple<ComponentReference<Cs>...> components;
+
+    template<std::size_t I>
+    inline decltype(auto) get() const { return std::get<I>(components); }
+
+    inline operator typename ECSWorldT::EntityID() const { return entityId; }
+};
+
+template<ECSWorldLike ECSWorldT, Component... Cs> requires(sizeof...(Cs) > 0)
+class basic_ecsView : public std::ranges::view_interface<basic_ecsView<ECSWorldT, Cs...>>
+{
+public:
+    class Iterator;
+    using iterator = Iterator;
+    using Predicate = std::set<typename ECSWorldT::ComponentID>;
+
+public:
+    basic_ecsView() : m_predicate(makePredicate<Cs...>()) {}
+    basic_ecsView(const basic_ecsView&) = default;
+    basic_ecsView(basic_ecsView&&) = default;
+
+    inline Iterator begin() const;
+    inline std::default_sentinel_t end() const { return std::default_sentinel; }
+
+    uint32_t count() const
+    {
+        uint32_t output = 0;
+        for (const auto& [archetypeId, archetype] : m_world->m_archetypes)
+        {
+            if (std::ranges::includes(archetypeId, m_predicate))
+                output += archetype.size();
+        }
+        return output;
+    }
+
+    ~basic_ecsView() = default;
+
+private:
+    ECSWorldT* m_world = nullptr;
+    std::set<typename ECSWorldT::ComponentID> m_predicate;
+
+    inline void setWorld(ECSWorldT* world) { m_world = world; }
+
+    template<typename T>
+    static Predicate makePredicate()
+    {
+        return std::set<typename ECSWorldT::ComponentID>{ ECSWorld::componentID<T>() };
+    }
+
+    template<typename T, typename Y, typename... Ys>
+    static Predicate makePredicate()
+    {
+        auto predicate = makePredicate<T>();
+        auto tail = makePredicate<Y, Ys...>();
+        predicate.insert(tail.begin(), tail.end());
+        return predicate;
+    }
+
+public:
+    basic_ecsView& operator=(const basic_ecsView&) = default;
+    basic_ecsView& operator=(basic_ecsView&&) = default;
+
+    template<Component... Ts>
+    friend basic_ecsView<ECSWorld, Ts...> operator|(ECSWorld& world, basic_ecsView<ECSWorld, Ts...> view);
+
+    template<Component... Ts>
+    friend basic_ecsView<const ECSWorld, Ts...> operator|(const ECSWorld& world, basic_ecsView<const ECSWorld, Ts...> view);
+
+public:
+    #include "Game-Engine/ECSViewIterator.inl"
+};
+
+template<ECSWorldLike ECSWorldT, Component... Cs> requires(sizeof...(Cs) > 0)
+inline typename basic_ecsView<ECSWorldT, Cs...>::Iterator basic_ecsView<ECSWorldT, Cs...>::begin() const
+{
+    if (m_world == nullptr)
+        return Iterator();
+
+    auto archetypeIt = m_world->m_archetypes.begin();
+    while (archetypeIt != m_world->m_archetypes.end())
+    {
+        if (std::ranges::includes(archetypeIt->first, m_predicate))
+        {
+            auto entityIt = archetypeIt->second.begin();
+            if (entityIt != archetypeIt->second.end())
+                return Iterator(m_world, m_predicate, archetypeIt, entityIt);
+        }
+        ++archetypeIt;
+    }
+
+    return Iterator(m_world, m_predicate, m_world->m_archetypes.end(), {});
+}
+
+template<Component... Cs>
+basic_ecsView<ECSWorld, Cs...> operator|(ECSWorld& world, basic_ecsView<ECSWorld, Cs...> view)
+{
+    view.m_world = &world;
+    return view;
+}
+
+template<Component... Cs>
+basic_ecsView<const ECSWorld, Cs...> operator|(const ECSWorld& world, basic_ecsView<const ECSWorld, Cs...> view)
+{
+    view.m_world = &world;
+    return view;
+}
+
+template<Component... Cs>
+using ECSView = basic_ecsView<ECSWorld, Cs...>;
+
+template<Component... Cs>
+using const_ECSView = basic_ecsView<const ECSWorld, Cs...>;
+
+} // namespace GE
+
+namespace std
+{
+
+template<GE::ECSWorldLike ECSWorldT, GE::Component... Cs>
+struct tuple_size<GE::ecs_view_item<ECSWorldT, Cs...>> : std::tuple_size<decltype(std::declval<GE::ecs_view_item<ECSWorldT, Cs...>>().components)> {};
+
+template<std::size_t I, GE::ECSWorldLike ECSWorldT, GE::Component... Cs>
+struct tuple_element<I, GE::ecs_view_item<ECSWorldT, Cs...>>
+{
+    using type = std::tuple_element_t<I, decltype(std::declval<GE::ecs_view_item<ECSWorldT, Cs...>>().components)>;
+};
+
+} // namespace std
+
+#endif // ECSVIEW_HPP
diff --git a/include/Game-Engine/ECSViewIterator.inl b/include/Game-Engine/ECSViewIterator.inl
new file mode 100644
index 0000000..d513c8a
--- /dev/null
+++ b/include/Game-Engine/ECSViewIterator.inl
@@ -0,0 +1,69 @@
+/*
+ * ---------------------------------------------------
+ * ECSViewIterator.inl
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+class Iterator
+{
+public:
+    using iterator_concept = std::input_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = ecs_view_item<ECSWorldT, Cs...>;
+
+private:
+    friend class basic_ecsView;
+    using ArchetypeMapIterator = decltype(std::declval<ECSWorldT&>().m_archetypes.begin());
+
+public:
+    Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator(Iterator&&) = default;
+
+    ~Iterator() = default;
+
+private:
+    Iterator(ECSWorldT* world, const Predicate& predicate, const ArchetypeMapIterator& archetypeIt, const typename ECSWorldT::Archetype::Iterator& entityIt)
+        : m_world(world)
+        , m_predicate(predicate)
+        , m_archetypeIt(archetypeIt)
+        , m_entityIt(entityIt)
+    {
+    }
+
+    ECSWorldT* m_world = nullptr;
+    Predicate m_predicate;
+    ArchetypeMapIterator m_archetypeIt;
+    typename ECSWorldT::Archetype::Iterator m_entityIt;
+
+public:
+    Iterator& operator=(const Iterator& cp) = default;
+    Iterator& operator=(Iterator&& mv) = default;
+
+    inline value_type operator*() const
+    {
+        return value_type{
+            .entityId = *m_entityIt,
+            .components = {*m_archetypeIt->second.template getComponentPointer<Cs>(m_entityIt.idx())...}
+        };
+    }
+
+    inline Iterator& operator++()
+    {
+        ++m_entityIt;
+        if (m_entityIt == m_archetypeIt->second.end())
+        {
+            do ++m_archetypeIt;
+            while (m_archetypeIt != m_world->m_archetypes.end() && (std::ranges::includes(m_archetypeIt->first, m_predicate) == false || m_archetypeIt->second.size() == 0));
+
+            if (m_archetypeIt != m_world->m_archetypes.end())
+                m_entityIt = m_archetypeIt->second.begin();
+        }
+        return *this;
+    }
+
+    inline void operator++(int) { ++(*this); }
+    inline bool operator==(std::default_sentinel_t) const { return m_archetypeIt == m_world->m_archetypes.end(); }
+};
diff --git a/include/Game-Engine/ECSWorld.hpp b/include/Game-Engine/ECSWorld.hpp
new file mode 100644
index 0000000..3ecf598
--- /dev/null
+++ b/include/Game-Engine/ECSWorld.hpp
@@ -0,0 +1,313 @@
+/*
+ * ---------------------------------------------------
+ * ECSWorld.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * Date: 2024/07/20 18:41:43
+ * ---------------------------------------------------
+ */
+
+#ifndef ECSWORLD_HPP
+#define ECSWORLD_HPP
+
+#include "Game-Engine/Export.hpp"
+
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+#include <set>
+#include <functional>
+#include <map>
+#include <iterator>
+#include <type_traits>
+#include <typeinfo>
+
+#define INVALID_ENTITY_ID 18446744073709551615ul
+
+namespace GE
+{
+
+class ECSWorld;
+
+template<typename T>
+concept ECSWorldLike = std::is_same_v<std::remove_const_t<T>, GE::ECSWorld>;
+
+template<typename T>
+concept Component = std::is_copy_constructible_v<T> && std::is_move_constructible_v<T> && std::is_destructible_v<T>;
+
+class GE_API ECSWorld
+{
+public:
+    using EntityID = uint64_t;
+
+    struct Iterator;
+    using iterator = Iterator;
+
+private:
+    template<ECSWorldLike ECSWorldT, Component  ... Cs> requires(sizeof...(Cs) > 0) friend class basic_ecsView;
+
+    using ComponentID = uint32_t;
+    using ArchetypeID = std::set<ComponentID>;
+
+    using CopyConstructor = std::function<void(void* src, void* dst)>;
+    using MoveConstructor = std::function<void(void* src, void* dst)>;
+    using Destructor = std::function<void(void* ptr)>;
+
+public:
+    ECSWorld();
+    ECSWorld(const ECSWorld&) = default;
+    ECSWorld(ECSWorld&&) = default;
+
+    EntityID newEntityID();
+    void registerEntityID(ECSWorld::EntityID);
+    void deleteEntityID(EntityID);
+    inline bool isValidEntityID(EntityID id) const { return id < m_entityDatas.size() && m_availableEntityIDs.contains(id) == false; }
+
+    template<Component T, typename... Args> T& emplace(EntityID entityId, Args&&... args);
+    template<Component T> void remove(EntityID);
+    template<Component T> bool has(EntityID) const;
+    template<Component T> auto& get(this auto&& self, EntityID);
+
+    inline uint32_t entityCount() {
+        const size_t count = m_entityDatas.size() - m_availableEntityIDs.size();
+        assert(count <= UINT32_MAX);
+        return static_cast<uint32_t>(count);
+    }
+
+    inline uint32_t archetypeCount() {
+        const size_t count = m_archetypes.size();
+        assert(count <= UINT32_MAX);
+        return static_cast<uint32_t>(count);
+    }
+
+    uint32_t componentCount();
+
+    inline Iterator begin() const;
+    inline std::default_sentinel_t end() const { return std::default_sentinel; }
+
+    ~ECSWorld() = default;
+
+private:
+    #include "Game-Engine/Archetype.inl"
+
+    struct EntityData
+    {
+        ArchetypeID archetypeId;
+        uint64_t idx = 0;
+    };
+
+    static ComponentID nextComponentID();
+    static ComponentID componentID(const std::type_info&);
+    template<Component T> static ComponentID componentID();
+
+    template<Component T> static uint64_t componentSize();
+    template<Component T> static CopyConstructor componentCopyConstructor();
+    template<Component T> static MoveConstructor componentMoveConstructor();
+    template<Component T> static Destructor componentDestructor();
+
+    std::vector<EntityData> m_entityDatas;
+    std::set<EntityID> m_availableEntityIDs;
+
+    std::map<ArchetypeID, Archetype> m_archetypes;
+
+public:
+    ECSWorld& operator=(const ECSWorld&) = default;
+    ECSWorld& operator=(ECSWorld&&) = default;
+
+public:
+    #include "Game-Engine/ECSWorldIterator.inl"
+};
+
+inline ECSWorld::Iterator ECSWorld::begin() const
+{
+    auto id = 0;
+    while (m_availableEntityIDs.contains(id))
+        id++;
+    return Iterator(this, id);
+}
+
+template<Component T, typename... Args>
+T& ECSWorld::emplace(EntityID entityId, Args&&... args)
+{
+    assert(isValidEntityID(entityId));
+    assert(has<T>(entityId) == false);
+
+    ArchetypeID& entityArchID = m_entityDatas[entityId].archetypeId;
+    Archetype& entityArch = m_archetypes[entityArchID];
+    uint64_t& entityIdx = m_entityDatas[entityId].idx;
+
+    ArchetypeID dstArchID = entityArchID;
+    dstArchID.insert(componentID<T>());
+    auto it = m_archetypes.find(dstArchID);
+    if (it == m_archetypes.end())
+    {
+        Archetype newArchetype = entityArch.duplicateRowTypes();
+        newArchetype.addRowType<T>();
+        auto [newIt, err] = m_archetypes.insert(std::make_pair(dstArchID, std::move(newArchetype)));
+        assert(err);
+        it = newIt;
+    }
+    Archetype& dstArchetype = it->second;
+    uint64_t dstIdx = dstArchetype.allocateCollum();
+
+    Archetype::moveComponents(entityArch, entityIdx, dstArchetype, dstIdx);
+
+    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
+
+    if (entityIdx != entityArch.size() - 1)
+    {
+        entityArch.destructCollum(entityIdx);
+        Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
+    }
+    entityArch.destructCollum(entityArch.size() - 1);
+    entityArch.freeLastCollum();
+
+    entityArchID = dstArchID;
+    entityIdx = dstIdx;
+
+    T* componentPtr = m_archetypes[entityArchID].getComponentPointer<T>(entityIdx);
+    new (componentPtr) T(std::forward<Args>(args)...);
+    return *componentPtr;
+}
+
+template<Component T>
+void ECSWorld::remove(EntityID entityId)
+{
+    assert(isValidEntityID(entityId));
+    assert(has<T>(entityId));
+
+    ArchetypeID& entityArchID = m_entityDatas[entityId].archetypeId;
+    Archetype& entityArch = m_archetypes[entityArchID];
+    uint64_t& entityIdx = m_entityDatas[entityId].idx;
+
+    ArchetypeID dstArchID = entityArchID;
+    dstArchID.erase(componentID<T>());
+    auto it = m_archetypes.find(dstArchID);
+    if (it == m_archetypes.end())
+    {
+        Archetype newArchetype = entityArch.duplicateRowTypes();
+        newArchetype.rmvRowType<T>();
+        auto [newIt, err] = m_archetypes.insert(std::make_pair(dstArchID, std::move(newArchetype)));
+        assert(err);
+        it = newIt;
+    }
+    Archetype& dstArchetype = it->second;
+    uint64_t dstIdx = dstArchetype.allocateCollum();
+
+    Archetype::moveComponents(entityArch, entityIdx, dstArchetype, dstIdx);
+
+    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
+
+    if (entityIdx != entityArch.size() - 1)
+    {
+        entityArch.destructCollum(entityIdx);
+        Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
+    }
+    entityArch.destructCollum(entityArch.size() - 1);
+    entityArch.freeLastCollum();
+
+    entityArchID = dstArchID;
+    entityIdx = dstIdx;
+}
+
+template<Component T>
+bool ECSWorld::has(EntityID entityId) const
+{
+    assert(isValidEntityID(entityId));
+    return m_entityDatas[entityId].archetypeId.contains(componentID<T>());
+}
+
+template<Component T>
+auto& ECSWorld::get(this auto&& self, EntityID entityId)
+{
+    assert(self.isValidEntityID(entityId));
+    assert(self.template has<T>(entityId));
+
+    auto& entityArch = self.m_archetypes.at(self.m_entityDatas[entityId].archetypeId);
+    uint64_t entityIdx = self.m_entityDatas.at(entityId).idx;
+
+    return *entityArch.template getComponentPointer<T>(entityIdx);
+}
+
+template<Component T>
+ECSWorld::ComponentID ECSWorld::componentID()
+{
+    static const ComponentID id = componentID(typeid(T));
+    return id;
+}
+
+template<Component T>
+uint64_t ECSWorld::componentSize()
+{
+    uint64_t size = sizeof(T);
+    return size;
+}
+
+template<Component T>
+ECSWorld::CopyConstructor ECSWorld::componentCopyConstructor()
+{
+    auto fn = [](void* src, void* dst) { new (dst) T(*(T*)src); };
+    return fn;
+}
+
+template<Component T>
+ECSWorld::MoveConstructor ECSWorld::componentMoveConstructor()
+{
+    auto fn = [](void* src, void* dst) { new (dst) T(std::move(*(T*)src)); };
+    return fn;
+}
+
+template<Component T>
+ECSWorld::Destructor ECSWorld::componentDestructor()
+{
+    auto fn = [](void* ptr) { ((T*)ptr)->~T(); };
+    return fn;
+}
+
+template<typename T>
+void ECSWorld::Archetype::addRowType()
+{
+    m_rows.insert(std::make_pair(componentID<T>(), Row{
+        operator new (componentSize<T>() * m_capacity),
+        componentSize<T>(),
+        componentCopyConstructor<T>(),
+        componentMoveConstructor<T>(),
+        componentDestructor<T>(),
+    }));
+}
+
+template<typename T>
+void ECSWorld::Archetype::rmvRowType()
+{
+    Row& row = m_rows.at(componentID<T>());
+    if (row.buffer != nullptr)
+    {
+        for (uint64_t i = 0; i < m_size; i++)
+            row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
+        operator delete(row.buffer);
+    }
+    m_rows.erase(componentID<T>());
+}
+
+template<Component T>
+auto* ECSWorld::Archetype::getComponentPointer(this auto&& self, uint64_t idx)
+{
+    using Self = std::remove_reference_t<decltype(self)>;
+    using ComponentPtr = std::conditional_t<std::is_const_v<Self>, const T*, T*>;
+    auto& row = self.m_rows.at(componentID<T>());
+    return static_cast<ComponentPtr>(row.buffer) + idx;
+}
+
+inline auto ECSWorld::Archetype::getEntityID(this auto&& self, uint64_t idx)
+    -> std::conditional_t<std::is_const_v<std::remove_reference_t<decltype(self)>>, const EntityID&, EntityID&>
+{
+    using Self = std::remove_reference_t<decltype(self)>;
+    using EntityPtr = std::conditional_t<std::is_const_v<Self>, const EntityID*, EntityID*>;
+    return static_cast<EntityPtr>(self.m_rows.at(0).buffer)[idx];
+}
+
+} // namespace GE
+
+#endif // ECSWORLD_HPP
diff --git a/include/Game-Engine/ECSWorldIterator.inl b/include/Game-Engine/ECSWorldIterator.inl
new file mode 100644
index 0000000..b166941
--- /dev/null
+++ b/include/Game-Engine/ECSWorldIterator.inl
@@ -0,0 +1,51 @@
+/*
+ * ---------------------------------------------------
+ * ECSWorldIterator.inl
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+struct Iterator
+{
+private:
+    friend class ECSWorld;
+
+public:
+    using iterator_concept = std::input_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = EntityID;
+
+    Iterator() = default;
+    Iterator(const Iterator&) = default;
+    Iterator(Iterator&&) = default;
+
+    ~Iterator() = default;
+
+private:
+    Iterator(const ECSWorld* world, EntityID id)
+        : m_world(world), m_id(id)
+    {
+        assert(m_world);
+    }
+
+    const ECSWorld* m_world = nullptr;
+    EntityID m_id = INVALID_ENTITY_ID;
+
+public:
+    Iterator& operator=(const Iterator& cp) = default;
+    Iterator& operator=(Iterator&& mv) = default;
+
+    inline EntityID operator*() const { return m_id; }
+
+    inline Iterator& operator++()
+    {
+        do ++m_id;
+        while (m_world->m_availableEntityIDs.contains(m_id));
+        return *this;
+    }
+
+    inline void operator++(int) { ++(*this); }
+
+    inline bool operator==(std::default_sentinel_t) const { return m_id == m_world->m_entityDatas.size(); }
+};
diff --git a/include/Game-Engine/Entity.hpp b/include/Game-Engine/Entity.hpp
new file mode 100644
index 0000000..4304cd2
--- /dev/null
+++ b/include/Game-Engine/Entity.hpp
@@ -0,0 +1,310 @@
+/*
+ * ---------------------------------------------------
+ * Entity.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/07 14:10:20
+ * ---------------------------------------------------
+ *
+ * Entity is just a handle that provide easier access to the component of an entity ID.
+ * entity object can be pass by value, there is no raii so when an entity goes out of scop
+ * nothing is deleted
+ *
+ */
+
+#ifndef ENTITY_HPP
+#define ENTITY_HPP
+
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/Components.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <optional>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace GE
+{
+
+template<ECSWorldLike ECSWorldT>
+struct basic_entity;
+
+template<typename T>
+concept EntityLike =
+    std::is_same_v<std::remove_reference_t<T>, basic_entity<ECSWorld>>;
+
+template<typename T>
+concept ConstEntityLike =
+    std::is_convertible_v<std::remove_reference_t<T>, const basic_entity<ECSWorld>> ||
+    std::is_same_v<std::remove_cvref_t<T>, basic_entity<const ECSWorld>>;
+
+template<ECSWorldLike ECSWorldT>
+struct basic_entity
+{
+    ECSWorldT* world = nullptr;
+    typename ECSWorldT::EntityID entityId = INVALID_ENTITY_ID;
+
+    template<Component T, typename... Args>
+    inline T& emplace(this EntityLike auto&& self, Args&&... arg)
+    {
+        return self.world->template emplace<T>(self.entityId, std::forward<Args>(arg)...);
+    }
+
+    template<Component T>
+    inline void remove(this EntityLike auto&& self)
+    {
+        self.world->template remove<T>(self.entityId);
+    }
+
+    template<Component T>
+    inline bool has(this ConstEntityLike auto&& self)
+    {
+        return self.world->template has<T>(self.entityId);
+    }
+
+    template<Component T>
+    inline auto& get(this auto&& self)
+    {
+        if constexpr (std::is_const_v<std::remove_reference_t<decltype(self)>>)
+            return static_cast<const std::remove_pointer_t<decltype(self.world)>*>(self.world)->template get<T>(self.entityId);
+        else
+            return self.world->template get<T>(self.entityId);
+    }
+
+    void destroy(this EntityLike auto&& self)
+    {
+        if (auto parent = self.parent())
+            parent->removeChild(self);
+        for (auto& child : self.children())
+            self.removeChild(child);
+
+        self.world->deleteEntityID(self.entityId);
+        self = basic_entity<ECSWorldT>();
+    }
+
+    auto& name(this auto&& self)
+    {
+        if constexpr (EntityLike<decltype(self)>)
+        {
+            if (self.template has<NameComponent>() == false)
+                return self.template emplace<NameComponent>().name;
+        }
+        return self.template get<NameComponent>().name;
+    }
+
+    inline glm::mat4 transform() const { return static_cast<glm::mat4>(get<TransformComponent>()); }
+
+    glm::vec3 worldPosition() const
+    {
+        const TransformComponent& transform = get<TransformComponent>();
+        if (auto parent = this->parent())
+        {
+            assert(parent->template has<TransformComponent>());
+            const glm::vec3 scaledLocalPosition = parent->worldScale() * transform.position;
+            return parent->worldPosition() + parent->worldRotation() * scaledLocalPosition;
+        }
+        return transform.position;
+    }
+
+    glm::mat3 worldRotation() const
+    {
+        const TransformComponent& transform = get<TransformComponent>();
+
+        glm::mat4 rotationMatrix = glm::mat4(1.0f);
+        rotationMatrix = glm::rotate(rotationMatrix, transform.rotation.x, glm::vec3(1, 0, 0));
+        rotationMatrix = glm::rotate(rotationMatrix, transform.rotation.y, glm::vec3(0, 1, 0));
+        rotationMatrix = glm::rotate(rotationMatrix, transform.rotation.z, glm::vec3(0, 0, 1));
+        const glm::mat3 localRotation = glm::mat3(rotationMatrix);
+
+        if (auto parent = this->parent())
+        {
+            assert(parent->template has<TransformComponent>());
+            return parent->worldRotation() * localRotation;
+        }
+        return localRotation;
+    }
+
+    glm::vec3 worldScale() const
+    {
+        const TransformComponent& transform = get<TransformComponent>();
+        if (auto parent = this->parent())
+        {
+            assert(parent->template has<TransformComponent>());
+            return parent->worldScale() * transform.scale;
+        }
+        return transform.scale;
+    }
+
+    glm::mat4 worldTransform() const
+    {
+        if (auto parent = this->parent())
+        {
+            assert(parent->template has<TransformComponent>());
+            return parent->worldTransform() * transform();
+        }
+        return transform();
+    }
+
+    std::optional<basic_entity<ECSWorldT>> parent(this auto&& self)
+    {
+        if (self.template has<HierarchyComponent>())
+        {
+            auto& component = self.template get<HierarchyComponent>();
+            if (component.parent != INVALID_ENTITY_ID)
+            {
+                assert(self.world->isValidEntityID(component.parent));
+                return basic_entity<ECSWorldT>{
+                    .world = self.world,
+                    .entityId = component.parent
+                };
+            }
+        }
+        return std::nullopt;
+    }
+
+    std::optional<basic_entity<ECSWorldT>> firstChild(this auto&& self)
+    {
+        if (self.template has<HierarchyComponent>())
+        {
+            auto& component = self.template get<HierarchyComponent>();
+            if (component.firstChild != INVALID_ENTITY_ID)
+            {
+                assert(self.world->isValidEntityID(component.firstChild));
+                return basic_entity<ECSWorldT>{
+                    .world = self.world,
+                    .entityId = component.firstChild
+                };
+            }
+        }
+        return std::nullopt;
+    }
+
+    std::optional<basic_entity<ECSWorldT>> nextChild(this auto&& self)
+    {
+        if (self.template has<HierarchyComponent>())
+        {
+            auto& component = self.template get<HierarchyComponent>();
+            if (component.nextChild != INVALID_ENTITY_ID)
+            {
+                assert(self.world->isValidEntityID(component.nextChild));
+                return basic_entity<ECSWorldT>{
+                    .world = self.world,
+                    .entityId = component.nextChild
+                };
+            }
+        }
+        return std::nullopt;
+    }
+
+    std::vector<basic_entity<ECSWorldT>> children(this auto&& self)
+    {
+        std::vector<basic_entity<ECSWorldT>> vec;
+        std::optional<basic_entity<ECSWorldT>> curr = self.firstChild();
+        while (curr.has_value())
+        {
+            vec.push_back(*curr);
+            curr = curr->nextChild();
+        }
+        return vec;
+    }
+
+    bool isParentOf(this ConstEntityLike auto&& self, ConstEntityLike auto& entity) // or grand parent ect
+    {
+        std::optional<basic_entity<ECSWorldT>> curr = entity.parent();
+        while (curr)
+        {
+            if (curr == self)
+                return true;
+            curr = curr->parent();
+        }
+        return false;
+    }
+
+    void addChild(this EntityLike auto&& self, EntityLike auto& child, EntityLike auto& after)
+    {
+        assert(self.world == child.world);
+        assert(child.isParentOf(self) == false);
+        assert(child.parent() == std::nullopt);
+        assert(std::ranges::contains(self.children(), after)); // the `after` entity need to be a direct child
+        assert(self.template has<HierarchyComponent>()); // if it has `after` as a direct child it should have the hierarchy component
+        assert(after.template has<HierarchyComponent>()); // if `after` is a direct child it should have the hierarchy component
+
+        if (child.template has<HierarchyComponent>() == false)
+            child.template emplace<HierarchyComponent>();
+
+        HierarchyComponent& childComp = child.template get<HierarchyComponent>();
+        HierarchyComponent& afterComp = after.template get<HierarchyComponent>();
+
+        if (after.nextChild()) {
+            childComp.nextChild = after.nextChild()->entityId;
+        }
+        afterComp.nextChild = child.entityId;
+        childComp.parent = self.entityId;
+    }
+
+    void addChild(this EntityLike auto&& self, EntityLike auto& child)
+    {
+        assert(self.world == child.world);
+        assert(child.isParentOf(self) == false);
+        assert(child.parent() == std::nullopt);
+
+        if (self.template has<HierarchyComponent>() == false)
+            self.template emplace<HierarchyComponent>();
+        if (child.template has<HierarchyComponent>() == false)
+            child.template emplace<HierarchyComponent>();
+
+        HierarchyComponent& selfComp = self.template get<HierarchyComponent>(); // need to be done after any emplace as `emplace` can invalidate references
+        HierarchyComponent& childComp = child.template get<HierarchyComponent>();
+
+        if (self.firstChild())
+            return self.addChild(child, self.children().back());
+        selfComp.firstChild = child.entityId;
+        childComp.parent = self.entityId;
+    }
+
+    void removeChild(this EntityLike auto&& self, EntityLike auto& child)
+    {
+        assert(self.world == child.world);
+        assert(std::ranges::contains(self.children(), child));
+
+        HierarchyComponent& selfComp = self.template get<HierarchyComponent>();
+        HierarchyComponent& childComp = child.template get<HierarchyComponent>();
+
+        assert(self.firstChild().has_value());
+        if (*self.firstChild() == child)
+        {
+            std::optional<basic_entity<ECSWorldT>> next = self.firstChild()->nextChild();
+            selfComp.firstChild = next ? next->entityId : INVALID_ENTITY_ID;
+        }
+        else
+        {
+            basic_entity<ECSWorldT> curr = *self.firstChild();
+
+            assert(curr.nextChild().has_value());
+            while (*curr.nextChild() != child) { // we checked that child is a child of self so this will happen before `nextChild.has_value == false`
+                assert(curr.nextChild().has_value());
+                curr = *curr.nextChild();
+            }
+
+            assert(curr.nextChild().has_value());
+            curr.get<HierarchyComponent>().nextChild = curr.nextChild()->nextChild() ? curr.nextChild()->nextChild()->entityId : INVALID_ENTITY_ID;
+        }
+
+        childComp.parent = INVALID_ENTITY_ID;
+        childComp.nextChild = INVALID_ENTITY_ID;
+    }
+
+    inline bool operator==(this ConstEntityLike auto&& lhs, ConstEntityLike auto& rhs) { return lhs.world == rhs.world && lhs.entityId == rhs.entityId; }
+    inline bool operator!=(this ConstEntityLike auto&& lhs, ConstEntityLike auto& rhs) { return !(lhs == rhs); }
+
+    inline operator basic_entity<const ECSWorld>() const requires std::is_same_v<ECSWorldT, ECSWorld> { return basic_entity<const ECSWorld>{ world, entityId }; }
+};
+
+using Entity = basic_entity<ECSWorld>;
+using const_Entity = basic_entity<const ECSWorld>;
+
+} // namespace GE
+
+#endif // ENTITY_HPP
diff --git a/include/Game-Engine/Event.hpp b/include/Game-Engine/Event.hpp
new file mode 100644
index 0000000..315497e
--- /dev/null
+++ b/include/Game-Engine/Event.hpp
@@ -0,0 +1,456 @@
+/*
+ * ---------------------------------------------------
+ * Event.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * Date: 2023/11/17 00:53:33
+ * ---------------------------------------------------
+ */
+
+#ifndef EVENT_HPP
+#define EVENT_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Window.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <format>
+#include <utility>
+
+namespace GE
+{
+
+class GE_API Event
+{
+public:
+    Event(const Event&) = delete;
+    Event(Event&&)      = delete;
+
+    template<typename T>
+    bool dispatch(const std::function<void(T&)>& f)
+    {
+        T* casted_event = dynamic_cast<T*>(this);
+        if (casted_event == nullptr)
+            return false;
+        f(*casted_event);
+        return true;
+    }
+
+    inline bool processed() { return m_processed; }
+    inline void markAsProcessed() { m_processed = true; }
+
+    virtual ~Event() = default;
+
+protected:
+    Event() = default;
+
+private:
+    friend struct std::formatter<GE::Event>;
+    virtual std::string to_string() const = 0;
+
+    bool m_processed = false;
+
+public:
+    Event& operator = (const Event&) = delete;
+    Event& operator = (Event&&)      = delete;
+};
+
+class GE_API ApplicationRequestTerminationEvent final : public Event
+{
+public:
+    ApplicationRequestTerminationEvent()                                          = default;
+    ApplicationRequestTerminationEvent(const ApplicationRequestTerminationEvent&) = delete;
+    ApplicationRequestTerminationEvent(ApplicationRequestTerminationEvent&&)      = delete;
+
+    ~ApplicationRequestTerminationEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(ApplicationRequestTerminationEvent) ->"); }
+
+public:
+    ApplicationRequestTerminationEvent& operator = (const ApplicationRequestTerminationEvent&) = delete;
+    ApplicationRequestTerminationEvent& operator = (ApplicationRequestTerminationEvent&&)      = delete;
+};
+
+class GE_API WindowEvent : public Event
+{
+public:
+    WindowEvent()                   = delete;
+    WindowEvent(const WindowEvent&) = delete;
+    WindowEvent(WindowEvent&&)      = delete;
+
+    inline const Window& window() const { return m_window; }
+
+    ~WindowEvent() override = default;
+
+protected:
+    inline explicit WindowEvent(Window& window)
+        : m_window(window)
+    {
+    }
+
+private:
+    inline std::string to_string() const override = 0;
+
+protected:
+    Window& m_window;
+
+public:
+    WindowEvent& operator = (const WindowEvent&) = delete;
+    WindowEvent& operator = (WindowEvent&&)      = delete;
+};
+
+class GE_API WindowResizeEvent final : public WindowEvent
+{
+public:
+    WindowResizeEvent()                         = delete;
+    WindowResizeEvent(const WindowResizeEvent&) = delete;
+    WindowResizeEvent(WindowResizeEvent&&)      = delete;
+
+    inline WindowResizeEvent(Window& window, int w, int h)
+        : WindowEvent(window)
+        , m_width(w)
+        , m_height(h)
+    {
+    }
+
+    inline int width() const { return m_width; }
+    inline int height() const { return m_height; }
+
+    ~WindowResizeEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(WindowResizeEvent) -> Window: {:x} width: {} height: {}", (std::uintptr_t)&m_window, m_width, m_height); }
+
+    int m_width;
+    int m_height;
+
+public:
+    WindowResizeEvent& operator = (const WindowResizeEvent&) = delete;
+    WindowResizeEvent& operator = (WindowResizeEvent&&)      = delete;
+};
+
+class GE_API WindowRequestCloseEvent final : public WindowEvent
+{
+public:
+    WindowRequestCloseEvent()                               = delete;
+    WindowRequestCloseEvent(const WindowRequestCloseEvent&) = delete;
+    WindowRequestCloseEvent(WindowRequestCloseEvent&&)      = delete;
+
+    inline explicit WindowRequestCloseEvent(Window& window)
+        : WindowEvent(window)
+    {
+    }
+
+    ~WindowRequestCloseEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(WindowRequestCloseEvent) -> Window: {:x}", (std::uintptr_t)&m_window); }
+
+public:
+    WindowRequestCloseEvent& operator = (const WindowRequestCloseEvent&) = delete;
+    WindowRequestCloseEvent& operator = (WindowRequestCloseEvent&&)      = delete;
+};
+
+class GE_API InputEvent : public WindowEvent
+{
+public:
+    InputEvent()                  = delete;
+    InputEvent(const InputEvent&) = delete;
+    InputEvent(InputEvent&&)      = delete;
+
+    ~InputEvent() override = default;
+
+protected:
+    inline explicit InputEvent(Window& window)
+        : WindowEvent(window)
+    {
+    }
+
+private:
+    inline std::string to_string() const override = 0;
+
+public:
+    InputEvent& operator = (const InputEvent&) = delete;
+    InputEvent& operator = (InputEvent&&)      = delete;
+};
+
+class GE_API KeyboardEvent : public InputEvent
+{
+public:
+    KeyboardEvent()                     = delete;
+    KeyboardEvent(const KeyboardEvent&) = delete;
+    KeyboardEvent(KeyboardEvent&&)      = delete;
+
+    inline int keyCode() const { return m_keyCode; }
+
+    ~KeyboardEvent() override = default;
+
+protected:
+    inline KeyboardEvent(Window& window, int keyCode)
+        : InputEvent(window)
+        , m_keyCode(keyCode)
+    {
+    }
+
+private:
+    inline std::string to_string() const override = 0;
+
+protected:
+    int m_keyCode;
+
+public:
+    KeyboardEvent& operator = (const KeyboardEvent&) = delete;
+    KeyboardEvent& operator = (KeyboardEvent&&)      = delete;
+};
+
+class GE_API KeyDownEvent final : public KeyboardEvent
+{
+public:
+    KeyDownEvent()                    = delete;
+    KeyDownEvent(const KeyDownEvent&) = delete;
+    KeyDownEvent(KeyDownEvent&&)      = delete;
+
+    inline KeyDownEvent(Window& window, int keyCode, bool isRepeat)
+        : KeyboardEvent(window, keyCode)
+        , m_isRepeat(isRepeat)
+    {
+    }
+
+    inline bool isRepeat() const { return m_isRepeat; }
+
+    ~KeyDownEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(KeyDownEvent) -> Window: {:x} keyCode: {} isRepeat: {}", (std::uintptr_t)&m_window, (int)m_keyCode, m_isRepeat); }
+
+    bool m_isRepeat;
+
+public:
+    KeyDownEvent& operator = (const KeyDownEvent&) = delete;
+    KeyDownEvent& operator = (KeyDownEvent&&)      = delete;
+};
+
+class GE_API KeyUpEvent final : public KeyboardEvent
+{
+public:
+    KeyUpEvent()                  = delete;
+    KeyUpEvent(const KeyUpEvent&) = delete;
+    KeyUpEvent(KeyUpEvent&&)      = delete;
+
+    inline KeyUpEvent(Window& window, int keyCode)
+        : KeyboardEvent(window, keyCode)
+    {
+    }
+
+    ~KeyUpEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(KeyUpEvent) -> Window: {:x} keyCode: {}", (std::uintptr_t)&m_window, (int)m_keyCode); }
+
+public:
+    KeyUpEvent& operator = (const KeyUpEvent&) = delete;
+    KeyUpEvent& operator = (KeyUpEvent&&)      = delete;
+};
+
+class GE_API CharEvent final : public InputEvent
+{
+public:
+    CharEvent()                 = delete;
+    CharEvent(const CharEvent&) = delete;
+    CharEvent(CharEvent&&)      = delete;
+
+    inline CharEvent(Window& window, unsigned int codePoint)
+        : InputEvent(window)
+        , m_codePoint(codePoint)
+    {
+    }
+
+    inline unsigned int codePoint() const { return m_codePoint; }
+
+    ~CharEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(CharEvent) -> Window: {:x} codePoint: {}", (std::uintptr_t)&m_window, m_codePoint); }
+
+    unsigned int m_codePoint;
+
+public:
+    CharEvent& operator = (const CharEvent&) = delete;
+    CharEvent& operator = (CharEvent&&)      = delete;
+};
+
+class GE_API MouseEvent : public InputEvent
+{
+public:
+    MouseEvent()                  = delete;
+    MouseEvent(const MouseEvent&) = delete;
+    MouseEvent(MouseEvent&&)      = delete;
+
+    inline std::pair<double, double> mousePos() const { return std::make_pair(m_pos_x, m_pos_y); }
+
+    ~MouseEvent() override = default;
+
+protected:
+    inline MouseEvent(Window& window, double posX, double posY)
+        : InputEvent(window)
+        , m_pos_x(posX)
+        , m_pos_y(posY)
+    {
+    }
+
+private:
+    inline std::string to_string() const override = 0;
+
+protected:
+    double m_pos_x;
+    double m_pos_y;
+
+public:
+    MouseEvent& operator = (const MouseEvent&) = delete;
+    MouseEvent& operator = (MouseEvent&&)      = delete;
+};
+
+class GE_API ScrollEvent final : public MouseEvent
+{
+public:
+    ScrollEvent()                   = delete;
+    ScrollEvent(const ScrollEvent&) = delete;
+    ScrollEvent(ScrollEvent&&)      = delete;
+
+    inline ScrollEvent(Window& window, double posX, double posY, double offsetX, double offsetY)
+        : MouseEvent(window, posX, posY)
+        , m_offsetX(offsetX)
+        , m_offsetY(offsetY)
+    {
+    }
+
+    inline double offsetX() const { return m_offsetX; }
+    inline double offsetY() const { return m_offsetY; }
+
+    ~ScrollEvent() override = default;
+
+private:
+    double m_offsetX;
+    double m_offsetY;
+
+private:
+    inline std::string to_string() const override { return std::format("(ScrollEvent) -> Window: {:x} pos: {},{} offset: {},{}", (std::uintptr_t)&m_window, m_pos_x, m_pos_y, m_offsetX, m_offsetY); }
+
+public:
+    ScrollEvent& operator = (const ScrollEvent&) = delete;
+    ScrollEvent& operator = (ScrollEvent&&)      = delete;
+};
+
+class GE_API MouseMoveEvent final : public MouseEvent
+{
+public:
+    MouseMoveEvent()                      = delete;
+    MouseMoveEvent(const MouseMoveEvent&) = delete;
+    MouseMoveEvent(MouseMoveEvent&&)      = delete;
+
+    inline MouseMoveEvent(Window& window, double posX, double posY)
+        : MouseEvent(window, posX, posY)
+    {
+    }
+
+    ~MouseMoveEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(MouseMoveEvent) -> Window: {:x} X: {} Y: {}", (std::uintptr_t)&m_window, m_pos_x, m_pos_y); }
+
+public:
+    MouseMoveEvent& operator = (const MouseMoveEvent&) = delete;
+    MouseMoveEvent& operator = (MouseMoveEvent&&)      = delete;
+};
+
+class GE_API MouseButtonEvent : public MouseEvent
+{
+public:
+    MouseButtonEvent()                        = delete;
+    MouseButtonEvent(const MouseButtonEvent&) = delete;
+    MouseButtonEvent(MouseButtonEvent&&)      = delete;
+
+    inline int mouseCode() const { return m_mouseCode; }
+
+    ~MouseButtonEvent() override = default;
+
+protected:
+    inline MouseButtonEvent(Window& window, double posX, double posY, int mouseCode)
+        : MouseEvent(window, posX, posY)
+        , m_mouseCode(mouseCode)
+    {
+    }
+
+    int m_mouseCode;
+
+private:
+    inline std::string to_string() const override = 0;
+
+public:
+    MouseButtonEvent& operator = (const MouseButtonEvent&) = delete;
+    MouseButtonEvent& operator = (MouseButtonEvent&&)      = delete;
+
+};
+
+class GE_API MouseDownEvent final : public MouseButtonEvent
+{
+public:
+    MouseDownEvent()                      = delete;
+    MouseDownEvent(const MouseDownEvent&) = delete;
+    MouseDownEvent(MouseDownEvent&&)      = delete;
+
+    inline MouseDownEvent(Window& window, double posX, double posY, int mouseCode)
+        : MouseButtonEvent(window, posX, posY, mouseCode)
+    {
+    }
+
+    ~MouseDownEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(MouseDownEvent) -> Window: {:x} mouseCode: {} X: {} Y: {}", (std::uintptr_t)&m_window, (int)m_mouseCode, m_pos_x, m_pos_y); }
+
+public:
+    MouseDownEvent& operator = (const MouseDownEvent&) = delete;
+    MouseDownEvent& operator = (MouseDownEvent&&)      = delete;
+};
+
+class GE_API MouseUpEvent final : public MouseButtonEvent
+{
+public:
+    MouseUpEvent()                    = delete;
+    MouseUpEvent(const MouseUpEvent&) = delete;
+    MouseUpEvent(MouseUpEvent&&)      = delete;
+
+    inline MouseUpEvent(Window& window, double posX, double posY, int mouseCode)
+        : MouseButtonEvent(window, posX, posY, mouseCode)
+    {
+    }
+
+    ~MouseUpEvent() override = default;
+
+private:
+    inline std::string to_string() const override { return std::format("(MouseUpEvent) -> Window: {:x} mouseCode: {} X: {} Y: {}", (std::uintptr_t)&m_window, (int)m_mouseCode, m_pos_x, m_pos_y); }
+
+public:
+    MouseUpEvent& operator = (const MouseUpEvent&) = delete;
+    MouseUpEvent& operator = (MouseUpEvent&&)      = delete;
+};
+
+}
+
+template<>
+struct std::formatter<GE::Event> {
+    constexpr auto parse(std::format_parse_context& ctx) {
+        auto it = ctx.begin();
+        for(; it != ctx.end() && *it != '}'; it++);
+        return it;
+    }
+
+    auto format(const GE::Event& event, std::format_context& ctx) const {
+        return std::format_to(ctx.out(), "{}", event.to_string());
+    }
+};
+
+#endif // EVENT_HPP
diff --git a/include/Game-Engine/Export.hpp b/include/Game-Engine/Export.hpp
new file mode 100644
index 0000000..b59223c
--- /dev/null
+++ b/include/Game-Engine/Export.hpp
@@ -0,0 +1,26 @@
+/*
+ * ---------------------------------------------------
+ * Export.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef EXPORT_HPP
+#define EXPORT_HPP
+
+#if defined(_WIN32)
+    #if defined(GE_DLL_EXPORT)
+        #define GE_API __declspec(dllexport)
+    #elif defined(GE_DLL_IMPORT)
+        #define GE_API __declspec(dllimport)
+    #else
+        #define GE_API
+    #endif
+#elif defined(__GNUC__) || defined(__clang__)
+    #define GE_API __attribute__((visibility("default")))
+#else
+    #define GE_API
+#endif
+
+#endif // EXPORT_HPP
diff --git a/include/Game-Engine/FrameGraph.hpp b/include/Game-Engine/FrameGraph.hpp
new file mode 100644
index 0000000..507e031
--- /dev/null
+++ b/include/Game-Engine/FrameGraph.hpp
@@ -0,0 +1,150 @@
+/*
+ * ---------------------------------------------------
+ * FrameGraph.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef FRAMEGRAPH_HPP
+#define FRAMEGRAPH_HPP
+
+#include "Game-Engine/Export.hpp"
+
+#include <Graphics/CommandBuffer.hpp>
+#include <Graphics/ParameterBlockPool.hpp>
+#include <Graphics/Enums.hpp>
+#include <Graphics/Texture.hpp>
+#include <Graphics/Buffer.hpp>
+
+#include <concepts>
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+#include <memory>
+#include <optional>
+#include <array>
+
+namespace GE
+{
+
+struct FramePass;
+
+template<class T>
+concept FramePassBuilder = requires(const T& b) {
+    { b.build() } -> std::convertible_to<FramePass>;
+};
+
+struct TextureDescriptor
+{
+    std::string name;
+    std::pair<uint32_t, uint32_t> size;
+    gfx::PixelFormat pixelFormat;
+};
+
+struct ConstantBufferDescriptor
+{
+    std::string name;
+    uint32_t size;
+};
+
+struct StructuredBufferDescriptor
+{
+    std::string name;
+};
+
+struct AttachmentDescriptor
+{
+    std::string texture;
+    gfx::LoadAction loadAction;
+    union {
+        std::array<float, 4> clearColor;
+        float clearDepth;
+    };
+};
+
+struct FramePassSetupContext
+{
+    std::map<std::string, std::shared_ptr<gfx::Texture>>& textureMap;
+    std::map<std::string, std::shared_ptr<gfx::Buffer>>& constantBuffers;
+    std::function<void(const std::string& name, const void* data, uint32_t size)> setStructuredBufferContent;
+};
+
+struct FramePassExecuteContext
+{
+    gfx::CommandBuffer& commandBuffer;
+    gfx::ParameterBlockPool& parameterBlockPool;
+    std::map<std::string, std::shared_ptr<gfx::Texture>>& textureMap;
+    std::map<std::string, std::shared_ptr<gfx::Buffer>>& bufferMap;
+
+    std::shared_ptr<gfx::ParameterBlockLayout> frameDataBlockLayout;
+    std::shared_ptr<gfx::ParameterBlockLayout> materialBlockLayout;
+    std::shared_ptr<gfx::GraphicsPipeline> gfxPipeline; // only one for now
+};
+
+struct FramePass
+{
+    std::vector<AttachmentDescriptor> colorAttachments;
+    std::optional<AttachmentDescriptor> depthAttachment;
+    std::vector<std::string> sampledTextures;
+    std::vector<std::string> usedBuffers;
+    std::vector<TextureDescriptor> textureDeclarations;
+    std::vector<ConstantBufferDescriptor> constantBufferDeclarations;
+    std::vector<StructuredBufferDescriptor> structuredBufferDeclarations;
+    std::function<void(FramePassSetupContext&)> setup;
+    std::function<void(FramePassExecuteContext&)> execute;
+
+    FramePass() = default;
+    FramePass(const FramePass&) = default;
+    FramePass(FramePass&&) = default;
+    FramePass(const FramePassBuilder auto& builder) : FramePass(builder.build()) {}
+    FramePass& operator=(const FramePass&) = default;
+    FramePass& operator=(FramePass&&) = default;
+};
+
+class GE_API FrameGraph
+{
+public:
+    struct Descriptor
+    {
+        std::string backBufferName;
+        std::vector<TextureDescriptor> textures;
+        std::vector<ConstantBufferDescriptor> constantBuffers;
+        std::vector<StructuredBufferDescriptor> structuredBuffers;
+        std::vector<FramePass> passes;
+    };
+
+public:
+    FrameGraph() = default;
+    FrameGraph(const FrameGraph&) = default;
+    FrameGraph(FrameGraph&&) = default;
+
+    FrameGraph(const Descriptor&);
+
+    const std::string& backBufferName() const { return m_backBufferName; }
+    const std::map<std::string, gfx::Texture::Descriptor>& textureDescriptors() const { return m_textureDescriptors; }
+    const std::map<std::string, gfx::Buffer::Descriptor>& constantBufferDescriptors() const { return m_constantBufferDescriptors; }
+    const std::set<std::string>& structuredBufferNames() const { return m_structuredBufferNames; }
+    const std::vector<FramePass>& passes() const { return m_passes; }
+
+    ~FrameGraph() = default;
+
+private:
+    std::vector<FramePass> m_passes;
+    std::string m_backBufferName;
+    std::map<std::string, gfx::Texture::Descriptor> m_textureDescriptors;
+    std::map<std::string, gfx::Buffer::Descriptor> m_constantBufferDescriptors;
+    std::set<std::string> m_structuredBufferNames;
+
+public:
+    FrameGraph& operator=(const FrameGraph&) = default;
+    FrameGraph& operator=(FrameGraph&&) = default;
+};
+
+} // namespace GE
+
+#endif
diff --git a/include/Game-Engine/FramePassBuilder.hpp b/include/Game-Engine/FramePassBuilder.hpp
new file mode 100644
index 0000000..e283ee1
--- /dev/null
+++ b/include/Game-Engine/FramePassBuilder.hpp
@@ -0,0 +1,127 @@
+/*
+ * ---------------------------------------------------
+ * FramePassBuilder.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef FRAMEPASSBUILDER_HPP
+#define FRAMEPASSBUILDER_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/FrameGraph.hpp"
+#include "Game-Engine/ICamera.hpp"
+#include "Game-Engine/Scene.hpp"
+
+#include <Graphics/Enums.hpp>
+#include <Graphics/ParameterBlock.hpp>
+
+#include <imgui.h>
+#include <glm/glm.hpp>
+
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace GE
+{
+
+class AssetManager;
+
+template<typename Derived>
+class FramePassBuilderBase
+{
+public:
+    inline FramePass build() const
+    {
+        GE::FramePass framePass;
+        framePass.colorAttachments = { m_colorAttachment };
+        framePass.depthAttachment = m_depthAttachment;
+        framePass.sampledTextures = m_sampledTextureNames;
+        framePass.usedBuffers = m_usedBufferNames;
+        return framePass;
+    }
+
+    inline Derived& setColorAttachment(const std::string& name, gfx::LoadAction loadAction = gfx::LoadAction::clear, std::array<float, 4> clearColor = {0.0f, 0.0f, 0.0f, 1.0f})
+    {
+        m_colorAttachment.texture = name;
+        m_colorAttachment.loadAction = loadAction;
+        m_colorAttachment.clearColor = clearColor;
+        return static_cast<Derived&>(*this);
+    }
+
+    inline Derived& setDepthAttachment(const std::string& name, gfx::LoadAction loadAction = gfx::LoadAction::clear, float clearDepth = 1.0f)
+    {
+        m_depthAttachment.emplace(AttachmentDescriptor{.texture = name, .loadAction = loadAction, .clearDepth = clearDepth});
+        return static_cast<Derived&>(*this);
+    }
+
+    inline Derived& addSampledTexture(const std::string& name)
+    {
+        m_sampledTextureNames.push_back(name);
+        return static_cast<Derived&>(*this);
+    }
+
+    inline Derived& addUsedBuffer(const std::string& name)
+    {
+        m_usedBufferNames.push_back(name);
+        return static_cast<Derived&>(*this);
+    }
+
+protected:
+    AttachmentDescriptor m_colorAttachment = AttachmentDescriptor{.clearColor={0.0f, 0.0f, 0.0f, 1.0f}};
+    std::optional<AttachmentDescriptor> m_depthAttachment;
+    std::vector<std::string> m_sampledTextureNames;
+    std::vector<std::string> m_usedBufferNames;
+};
+
+class GE_API ImguiPassBuilder : public FramePassBuilderBase<ImguiPassBuilder>
+{
+public:
+    inline FramePass build() const
+    {
+        GE::FramePass framePass = FramePassBuilderBase<ImguiPassBuilder>::build();
+        framePass.execute = [](FramePassExecuteContext& ctx) {
+            ImDrawData* drawData = ImGui::GetDrawData();
+            for (int i = 0; i < drawData->CmdListsCount; ++i) {
+                for (ImDrawCmd& cmd : drawData->CmdLists[i]->CmdBuffer) {
+                    if (cmd.TexRef._TexID == 0)
+                        continue;
+                    assert(cmd.TexRef._TexData == nullptr);
+                    auto vistor = [&](auto& v) {
+                        if constexpr (std::is_same_v<std::remove_cvref_t<decltype(v)>, std::string>) {
+                            if (ctx.textureMap[v]->imTextureId().has_value() == false)
+                                ctx.textureMap[v]->initImTextureId();
+                            cmd.TexRef._TexID = *ctx.textureMap[v]->imTextureId();
+                        }
+                        else if constexpr (std::is_same_v<std::remove_cvref_t<decltype(v)>, uint64_t>)
+                            cmd.TexRef._TexID = v;
+                        else
+                            std::unreachable();
+                    };
+                    std::visit(std::move(vistor), *std::bit_cast<std::variant<std::string, uint64_t>*>(cmd.TexRef._TexID));
+                }
+            }
+            ctx.commandBuffer.imGuiRenderDrawData(drawData);
+        };
+        return framePass;
+    }
+};
+
+class GE_API FlatGeometryPassBuilder : public FramePassBuilderBase<FlatGeometryPassBuilder>
+{
+public:
+    FlatGeometryPassBuilder(const Scene*, const ICamera*);
+    FlatGeometryPassBuilder(std::function<const Scene*()>, std::function<const ICamera*()>);
+
+    FramePass build() const;
+
+private:
+    std::function<const Scene*()> m_sceneProvider;
+    std::function<const ICamera*()> m_cameraProvider;
+};
+
+}
+
+#endif
diff --git a/include/Game-Engine/Game.hpp b/include/Game-Engine/Game.hpp
new file mode 100644
index 0000000..d1d95d2
--- /dev/null
+++ b/include/Game-Engine/Game.hpp
@@ -0,0 +1,62 @@
+/*
+ * ---------------------------------------------------
+ * Game.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef GAME_HPP
+#define GAME_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/InputContext.hpp"
+#include "Game-Engine/Scene.hpp"
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/ScriptLibrary.hpp"
+
+#include <map>
+#include <string>
+
+namespace GE
+{
+
+class GE_API Game
+{
+public:
+    struct Descriptor
+    {
+        std::map<std::string, Scene::Descriptor> scenes;
+        std::string activeScene;
+        InputContext inputContext;
+    };
+
+public:
+    Game() = delete;
+    Game(const Game&) = delete;
+    Game(Game&&) = delete;
+
+    Game(AssetManager* assetManager, const ScriptLibrary* scriptLibrary, const Descriptor& descriptor);
+
+    auto& activeScene(this auto&& self) { return *self.m_activeScene; }
+    void setActiveScene(const std::string& name);
+
+    auto& inputContext(this auto&& self) { return self.m_inputContext; }
+
+    ~Game();
+
+private:
+    std::map<std::string, Scene> m_scenes;
+    Scene* m_activeScene = nullptr;
+    InputContext m_inputContext;
+
+    const ScriptLibrary* m_scriptLibrary = nullptr;
+
+public:
+    Game& operator = (const Game&) = delete;
+    Game& operator = (Game&&) = delete;
+};
+
+}
+
+#endif
diff --git a/include/Game-Engine/ICamera.hpp b/include/Game-Engine/ICamera.hpp
new file mode 100644
index 0000000..a7a2000
--- /dev/null
+++ b/include/Game-Engine/ICamera.hpp
@@ -0,0 +1,34 @@
+/*
+ * ---------------------------------------------------
+ * ICamera.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ *
+ * Camera interface, provide an way for the application
+ * to give application specific camera to the renderer
+ *
+ */
+
+#ifndef ICAMERA_HPP
+#define ICAMERA_HPP
+
+#include "Game-Engine/Export.hpp"
+
+#include <glm/glm.hpp>
+
+namespace GE
+{
+
+class GE_API ICamera
+{
+public:
+    virtual glm::vec3 position() const = 0;
+    virtual glm::mat4 viewProjectionMatrix(float aspectRatio) const = 0;
+
+    virtual ~ICamera() = default;
+};
+
+}
+
+#endif
diff --git a/include/Game-Engine/Input.hpp b/include/Game-Engine/Input.hpp
new file mode 100644
index 0000000..dd58638
--- /dev/null
+++ b/include/Game-Engine/Input.hpp
@@ -0,0 +1,240 @@
+/*
+ * ---------------------------------------------------
+ * Input.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef INPUT_HPP
+#define INPUT_HPP
+
+#include "Game-Engine/InputFwd.hpp"
+#include "Game-Engine/InputMapper.hpp"
+#include "Game-Engine/RawInput.hpp"
+
+#include <yaml-cpp/yaml.h>
+
+#include <concepts>
+#include <functional>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+namespace GE
+{
+
+template<typename T>
+struct InputCallback
+{
+    using type = std::function<void(const T&)>;
+};
+
+template<>
+struct InputCallback<void>
+{
+    using type = std::function<void()>;
+};
+
+template<typename T>
+struct InputValue
+{
+    using type = T;
+};
+
+template<>
+struct InputValue<void>
+{
+    using type = std::monostate;
+};
+
+template<InputClass Class, typename T>
+struct Input
+{
+    using CallbackType = typename InputCallback<T>::type;
+    using ValueType = typename InputValue<T>::type;
+    template<RawInput RI> using MapperType = InputMapper<RI, Input<Class, T>>;
+
+    CallbackType callback;
+    ValueType value;
+
+    std::optional<VInputMapper> mapper;
+    bool triggered = false;
+
+    template<RawInput RI, typename... Args>
+    void setMapper(Args&&... args) requires std::constructible_from<MapperType<RI>, Args...>
+    {
+        mapper = MapperType<RI>(std::forward<Args>(args)...);
+        std::get<MapperType<RI>>(*mapper).input = this;
+    }
+
+    template<RawInput RI>
+    void setMapper(MapperType<RI> m)
+    {
+        mapper = std::move(m);
+        std::get<MapperType<RI>>(*mapper).input = this;
+    }
+
+    void dispatch()
+    {
+        if (triggered && callback)
+        {
+            if constexpr (std::is_void_v<T>)
+                callback();
+            else
+                callback(value);
+        }
+        if constexpr (Class == InputClass::action)
+            triggered = false;
+    }
+
+    Input() = default;
+    Input(const Input& other)
+        : callback(other.callback)
+        , value(other.value)
+        , mapper(other.mapper)
+        , triggered(other.triggered)
+    {
+        rebindMapper();
+    }
+
+    Input(Input&& other) noexcept
+        : callback(std::move(other.callback))
+        , value(std::move(other.value))
+        , mapper(std::move(other.mapper))
+        , triggered(other.triggered)
+    {
+        rebindMapper();
+    }
+
+    Input& operator=(const Input& other)
+    {
+        if (this == &other)
+            return *this;
+
+        callback = other.callback;
+        value = other.value;
+        mapper = other.mapper;
+        triggered = other.triggered;
+        rebindMapper();
+        return *this;
+    }
+
+    Input& operator=(Input&& other) noexcept
+    {
+        if (this == &other)
+            return *this;
+
+        callback = std::move(other.callback);
+        value = std::move(other.value);
+        mapper = std::move(other.mapper);
+        triggered = other.triggered;
+        rebindMapper();
+        return *this;
+    }
+
+private:
+    void rebindMapper()
+    {
+        if (!mapper)
+            return;
+        std::visit([&](auto& m)
+        {
+            if constexpr (std::is_same_v<typename std::remove_cvref_t<decltype(m)>::InputType, Input<Class, T>>)
+                m.input = this;
+        },
+        *mapper);
+    }
+};
+
+using VInput = InputTypes::into<std::variant>;
+
+template<InputType T> struct InputTraits;
+
+template<> struct InputTraits<ActionInput>  { static constexpr std::string_view name = "Action";  };
+template<> struct InputTraits<StateInput>   { static constexpr std::string_view name = "State";   };
+template<> struct InputTraits<RangeInput>   { static constexpr std::string_view name = "Range";   };
+template<> struct InputTraits<Range2DInput> { static constexpr std::string_view name = "Range2D"; };
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<GE::VInput>
+{
+    static YAML::Node encode(const GE::VInput& rhs)
+    {
+        return std::visit([](const auto& input) -> YAML::Node
+        {
+            YAML::Node node;
+            using InputType = std::remove_cvref_t<decltype(input)>;
+            node["type"] = std::string(GE::InputTraits<InputType>::name);
+            if (input.mapper)
+            {
+                Node mapperNode;
+                std::visit([&](const auto& mapper)
+                {
+                    using MapperType = std::remove_cvref_t<decltype(mapper)>;
+                    using RawInputType = typename MapperType::RawInputType;
+                    mapperNode["type"] = std::string(GE::RawInputTraits<RawInputType>::name);
+                    mapperNode["data"] = mapper;
+                },
+                *input.mapper);
+                node["mapper"] = mapperNode;
+            }
+            return node;
+        },
+        rhs);
+    }
+
+    static bool decode(const YAML::Node& node, GE::VInput& rhs)
+    {
+        if (!node.IsMap() || !node["type"])
+            return false;
+
+        const std::string type = node["type"].as<std::string>();
+        return GE::anyOfType<GE::InputTypes>([&]<typename InputType>() {
+            if (type != GE::InputTraits<InputType>::name)
+                return false;
+
+            InputType input;
+            if (node["mapper"])
+            {
+                const YAML::Node& mapperNode = node["mapper"];
+                if (!mapperNode.IsMap() || !mapperNode["type"] || !mapperNode["data"])
+                    return false;
+
+                const std::string mapperType = mapperNode["type"].as<std::string>();
+                const bool decoded = GE::anyOfType<GE::InputMapperTypes>([&]<typename MapperType>() {
+                    if constexpr (!std::same_as<typename MapperType::InputType, InputType>)
+                        return false;
+                    else
+                    {
+                        using RawInputType = typename MapperType::RawInputType;
+                        if (mapperType != GE::RawInputTraits<RawInputType>::name)
+                            return false;
+
+                        MapperType mapper = mapperNode["data"].as<MapperType>();
+                        input.setMapper(mapper);
+                        return true;
+                    }
+                });
+
+                if (!decoded)
+                    return false;
+            }
+
+            rhs = input;
+            return true;
+        });
+    }
+};
+
+} // namespace YAML
+
+#endif
diff --git a/include/Game-Engine/InputContext.hpp b/include/Game-Engine/InputContext.hpp
new file mode 100644
index 0000000..b83de85
--- /dev/null
+++ b/include/Game-Engine/InputContext.hpp
@@ -0,0 +1,95 @@
+/*
+ * ---------------------------------------------------
+ * InputContext.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef INPUTCONTEXT_HPP
+#define INPUTCONTEXT_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Event.hpp"
+#include "Game-Engine/Input.hpp"
+
+#include <yaml-cpp/yaml.h>
+
+#include <map>
+#include <string>
+#include <type_traits>
+#include <variant>
+
+namespace GE
+{
+
+class GE_API InputContext
+{
+public:
+    InputContext() = default;
+    InputContext(const InputContext&) = default;
+    InputContext(InputContext&&) = default;
+
+    void addInput(const std::string& name, const VInput&);
+    void removeInput(const std::string& name);
+    bool renameInput(const std::string& oldName, const std::string& newName);
+
+    inline auto& inputs(this auto&& self) { return self.m_inputs; }
+
+    template<InputType T>
+    void setInputCallback(const std::string& name, const T::CallbackType&);
+
+    void clearAllInputCallbacks();
+
+    virtual void onInputEvent(InputEvent&);
+    void dispatchInputs();
+
+    virtual ~InputContext() = default;
+
+private:
+    std::map<std::string, VInput> m_inputs;
+
+public:
+    InputContext& operator = (const InputContext&) = default;
+    InputContext& operator = (InputContext&&) = default;
+};
+
+template<InputType T>
+void InputContext::setInputCallback(const std::string& name, const T::CallbackType& callback)
+{
+    std::visit([&](auto& input)
+    {
+        if constexpr (std::is_same_v<std::remove_cvref_t<decltype(input)>, T>)
+            input.callback = callback;
+    },
+    m_inputs.at(name));
+}
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<GE::InputContext>
+{
+    static Node encode(const GE::InputContext& rhs)
+    {
+        Node node;
+        node["inputs"] = rhs.inputs();
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::InputContext& rhs)
+    {
+        if (!node.IsMap() || !node["inputs"])
+            return false;
+
+        rhs.inputs() = node["inputs"].as<std::map<std::string, GE::VInput>>();
+        return true;
+    }
+};
+
+} // namespace YAML
+
+#endif
diff --git a/include/Game-Engine/InputFwd.hpp b/include/Game-Engine/InputFwd.hpp
new file mode 100644
index 0000000..46c7111
--- /dev/null
+++ b/include/Game-Engine/InputFwd.hpp
@@ -0,0 +1,48 @@
+/*
+ * ---------------------------------------------------
+ * InputFwd.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef INPUTFWD_HPP
+#define INPUTFWD_HPP
+
+#include "Game-Engine/TypeList.hpp"
+
+#include <glm/glm.hpp>
+
+#include <type_traits>
+
+namespace GE
+{
+
+enum class InputClass
+{
+    action, // triggered only once
+    state   // triggered every frames
+};
+
+template<InputClass Class, typename T = void>
+struct Input;
+
+template<typename T>
+struct IsInput : std::false_type {};
+
+template<InputClass Class, typename T>
+struct IsInput<Input<Class, T>> : std::true_type {};
+
+template<typename T>
+concept InputType = IsInput<std::remove_cvref_t<T>>::value;
+
+using ActionInput  = Input<InputClass::action>;
+using StateInput   = Input<InputClass::state>;
+using RangeInput   = Input<InputClass::state, float>;
+using Range2DInput = Input<InputClass::state, glm::vec2>;
+
+using InputTypes = TypeList<ActionInput, StateInput, RangeInput, Range2DInput>;
+
+}
+
+#endif
diff --git a/include/Game-Engine/InputMapper.hpp b/include/Game-Engine/InputMapper.hpp
new file mode 100644
index 0000000..a9d36e3
--- /dev/null
+++ b/include/Game-Engine/InputMapper.hpp
@@ -0,0 +1,191 @@
+/*
+ * ---------------------------------------------------
+ * InputMapper.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef INPUTMAPPER_HPP
+#define INPUTMAPPER_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Event.hpp"
+#include "Game-Engine/InputFwd.hpp"
+#include "Game-Engine/RawInput.hpp"
+#include "Game-Engine/TypeList.hpp"
+
+#include <yaml-cpp/yaml.h>
+
+#include <glm/glm.hpp>
+
+#include <variant>
+
+namespace GE
+{
+
+template<RawInput RI, InputType I> struct InputMapper;
+
+template<>
+struct GE_API InputMapper<KeyboardButton, ActionInput>
+{
+    using RawInputType = KeyboardButton;
+    using InputType = ActionInput;
+
+    KeyboardButton button = KeyboardButton::space;
+    ActionInput* input = nullptr;
+
+    InputMapper() = default;
+    InputMapper(KeyboardButton);
+    void onInputEvent(InputEvent& event);
+};
+
+template<>
+struct GE_API InputMapper<KeyboardButton, StateInput>
+{
+    using RawInputType = KeyboardButton;
+    using InputType = StateInput;
+
+    KeyboardButton button = KeyboardButton::space;
+    StateInput* input = nullptr;
+
+    InputMapper() = default;
+    InputMapper(KeyboardButton);
+    void onInputEvent(InputEvent& event);
+};
+
+template<>
+struct GE_API InputMapper<KeyboardButton, RangeInput>
+{
+    using RawInputType = KeyboardButton;
+    using InputType = RangeInput;
+
+    KeyboardButton button = KeyboardButton::space;
+    float scale = 1.0f;
+
+    RangeInput* input = nullptr;
+
+    InputMapper() = default;
+    InputMapper(KeyboardButton, float scale);
+    void onInputEvent(InputEvent& event);
+};
+
+template<>
+struct GE_API InputMapper<KeyboardButton, Range2DInput>
+{
+    using RawInputType = KeyboardButton;
+    using InputType = Range2DInput;
+
+    struct Descriptor
+    {
+        KeyboardButton xPos;
+        KeyboardButton xNeg;
+        float xScale = 1.0f;
+
+        KeyboardButton yPos;
+        KeyboardButton yNeg;
+        float yScale = 1.0f;
+
+        float triggerValue = 0.5f;
+    };
+
+    KeyboardButton xPos = KeyboardButton::d;
+    KeyboardButton xNeg = KeyboardButton::a;
+    float xScale = 1.0f;
+
+    KeyboardButton yPos = KeyboardButton::w;
+    KeyboardButton yNeg = KeyboardButton::s;
+    float yScale = 1.0f;
+
+    float triggerValue = 0.5f;
+
+    bool xPosPressed = false;
+    bool xNegPressed = false;
+    bool yPosPressed = false;
+    bool yNegPressed = false;
+
+    Range2DInput* input = nullptr;
+
+    InputMapper() = default;
+    InputMapper(const Descriptor&);
+    void onInputEvent(InputEvent& event);
+};
+
+template<typename InputT>
+using KeyboardButtonInputMapper = InputMapper<KeyboardButton, InputT>;
+
+using InputMapperTypes = InputTypes::wrapped<KeyboardButtonInputMapper>;
+
+using VInputMapper = InputMapperTypes::into<std::variant>;
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<GE::InputType I>
+struct convert<GE::InputMapper<GE::KeyboardButton, I>>
+{
+    static Node encode(const GE::InputMapper<GE::KeyboardButton, I>& rhs)
+    {
+        Node node;
+        if constexpr (std::is_same_v<I, GE::Range2DInput>)
+        {
+            node["xPos"] = rhs.xPos;
+            node["xNeg"] = rhs.xNeg;
+            node["xScale"] = rhs.xScale;
+            node["yPos"] = rhs.yPos;
+            node["yNeg"] = rhs.yNeg;
+            node["yScale"] = rhs.yScale;
+            node["triggerValue"] = rhs.triggerValue;
+        }
+        else
+        {
+            node["button"] = rhs.button;
+            if constexpr (std::is_same_v<I, GE::RangeInput>)
+                node["scale"] = rhs.scale;
+        }
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::InputMapper<GE::KeyboardButton, I>& rhs)
+    {
+        if (!node.IsMap())
+            return false;
+
+        if constexpr (std::is_same_v<I, GE::Range2DInput>)
+        {
+            if (!node["xPos"] || !node["xNeg"] || !node["yPos"] || !node["yNeg"])
+                return false;
+
+            rhs = GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>(GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>::Descriptor{
+                .xPos         = node["xPos"].as<GE::KeyboardButton>(),
+                .xNeg         = node["xNeg"].as<GE::KeyboardButton>(),
+                .xScale       = node["xScale"] ? node["xScale"].as<float>() : 1.0f,
+                .yPos         = node["yPos"].as<GE::KeyboardButton>(),
+                .yNeg         = node["yNeg"].as<GE::KeyboardButton>(),
+                .yScale       = node["yScale"] ? node["yScale"].as<float>() : 1.0f,
+                .triggerValue = node["triggerValue"] ? node["triggerValue"].as<float>() : 0.5f
+            });
+        }
+        else
+        {
+            if (!node["button"])
+                return false;
+
+            if constexpr (std::is_same_v<I, GE::RangeInput>)
+                rhs = GE::InputMapper<GE::KeyboardButton, I>(
+                    node["button"].as<GE::KeyboardButton>(),
+                    node["scale"] ? node["scale"].as<float>() : 1.0f
+                );
+            else
+                rhs = GE::InputMapper<GE::KeyboardButton, I>(node["button"].as<GE::KeyboardButton>());
+        }
+
+        return true;
+    }
+};
+
+} // namespace YAML
+
+#endif
diff --git a/include/Game-Engine/Mesh.hpp b/include/Game-Engine/Mesh.hpp
new file mode 100644
index 0000000..398763b
--- /dev/null
+++ b/include/Game-Engine/Mesh.hpp
@@ -0,0 +1,50 @@
+/*
+ * ---------------------------------------------------
+ * Mesh.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/14 13:06:07
+ * ---------------------------------------------------
+ */
+
+#ifndef MESH_HPP
+#define MESH_HPP
+
+#include <Graphics/Buffer.hpp>
+
+#include <glm/glm.hpp>
+
+#include <string>
+#include <memory>
+#include <vector>
+
+namespace GE
+{
+
+struct Vertex
+{
+    glm::vec3 pos;
+    glm::vec2 uv;
+    glm::vec3 normal;
+    glm::vec3 tangent;
+};
+
+struct SubMesh
+{
+    std::string name;
+    glm::mat4x4 transform;
+    std::shared_ptr<gfx::Buffer> vertexBuffer;
+    std::shared_ptr<gfx::Buffer> indexBuffer;
+    // std::shared_ptr<Material> material;
+    std::vector<SubMesh> subMeshes;
+};
+
+struct Mesh
+{
+    std::string name;
+    std::vector<SubMesh> subMeshes;
+};
+
+}
+
+#endif // MESH_HPP
diff --git a/include/Game-Engine/RawInput.hpp b/include/Game-Engine/RawInput.hpp
new file mode 100644
index 0000000..bac87ef
--- /dev/null
+++ b/include/Game-Engine/RawInput.hpp
@@ -0,0 +1,133 @@
+/*
+ * ---------------------------------------------------
+ * RawInput.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/24 15:47:29
+ * ---------------------------------------------------
+ */
+
+#ifndef RAWINPUT_HPP
+#define RAWINPUT_HPP
+
+#include "GLFW/glfw3.h"
+#include "Game-Engine/TypeList.hpp"
+
+#include <yaml-cpp/yaml.h>
+
+#include <array>
+#include <optional>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace GE
+{
+
+enum class KeyboardButton : unsigned int
+{
+    esc        = GLFW_KEY_ESCAPE,
+    one        = GLFW_KEY_1,
+    two        = GLFW_KEY_2,
+    w          = GLFW_KEY_W,
+    a          = GLFW_KEY_A,
+    s          = GLFW_KEY_S,
+    d          = GLFW_KEY_D,
+    space      = GLFW_KEY_SPACE,
+    up         = GLFW_KEY_UP,
+    left       = GLFW_KEY_LEFT,
+    down       = GLFW_KEY_DOWN,
+    right      = GLFW_KEY_RIGHT,
+    left_shift = GLFW_KEY_LEFT_SHIFT,
+};
+
+enum class MouseButton : unsigned int
+{
+    l = GLFW_MOUSE_BUTTON_1,
+    r = GLFW_MOUSE_BUTTON_2
+};
+
+using RawInputTypes = TypeList<KeyboardButton, MouseButton>;
+
+inline constexpr std::array<KeyboardButton, 13> KEYBOARD_BUTTONS = {
+    KeyboardButton::esc,
+    KeyboardButton::one,
+    KeyboardButton::two,
+    KeyboardButton::w,
+    KeyboardButton::a,
+    KeyboardButton::s,
+    KeyboardButton::d,
+    KeyboardButton::space,
+    KeyboardButton::up,
+    KeyboardButton::left,
+    KeyboardButton::down,
+    KeyboardButton::right,
+    KeyboardButton::left_shift
+};
+
+constexpr std::string_view keyboardButtonName(KeyboardButton button)
+{
+    switch (button)
+    {
+        case KeyboardButton::esc:        return "esc";
+        case KeyboardButton::one:        return "1";
+        case KeyboardButton::two:        return "2";
+        case KeyboardButton::w:          return "w";
+        case KeyboardButton::a:          return "a";
+        case KeyboardButton::s:          return "s";
+        case KeyboardButton::d:          return "d";
+        case KeyboardButton::space:      return "space";
+        case KeyboardButton::up:         return "up";
+        case KeyboardButton::left:       return "left";
+        case KeyboardButton::down:       return "down";
+        case KeyboardButton::right:      return "right";
+        case KeyboardButton::left_shift: return "left_shift";
+    }
+    std::unreachable();
+}
+
+inline std::optional<KeyboardButton> keyboardButtonFromName(std::string_view name)
+{
+    for (KeyboardButton button : KEYBOARD_BUTTONS)
+    {
+        if (keyboardButtonName(button) == name)
+            return button;
+    }
+    return std::nullopt;
+}
+
+template<typename T>
+concept RawInput = IsTypeInList<std::remove_cvref_t<T>, RawInputTypes>;
+
+template<RawInput T> struct RawInputTraits;
+
+template<> struct RawInputTraits<KeyboardButton> { static constexpr std::string_view name = "KeyboardButton"; };
+template<> struct RawInputTraits<MouseButton>    { static constexpr std::string_view name = "MouseButton";    };
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<GE::KeyboardButton>
+{
+    static Node encode(const GE::KeyboardButton& rhs)
+    {
+        return Node(std::string(GE::keyboardButtonName(rhs)));
+    }
+
+    static bool decode(const Node& node, GE::KeyboardButton& rhs)
+    {
+        if (!node.IsScalar())
+            return false;
+
+        if (const std::optional<GE::KeyboardButton> button = GE::keyboardButtonFromName(node.as<std::string>()))
+            return rhs = *button, true;
+        return false;
+    }
+};
+
+}
+
+#endif // RAWINPUT_HPP
diff --git a/include/Game-Engine/Renderer.hpp b/include/Game-Engine/Renderer.hpp
new file mode 100644
index 0000000..c376563
--- /dev/null
+++ b/include/Game-Engine/Renderer.hpp
@@ -0,0 +1,79 @@
+/*
+ * ---------------------------------------------------
+ * Renderer.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/09 15:49:29
+ * ---------------------------------------------------
+ */
+
+#ifndef RENDERER_HPP
+#define RENDERER_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/FrameGraph.hpp"
+
+#include <Graphics/Device.hpp>
+#include <Graphics/Surface.hpp>
+#include <Graphics/Swapchain.hpp>
+#include <Graphics/Texture.hpp>
+#include <Graphics/Buffer.hpp>
+#include <Graphics/GraphicsPipeline.hpp>
+
+#include <cstdint>
+#include <array>
+#include <map>
+#include <memory>
+#include <set>
+
+#define cfd m_inFlightDatas.at(m_frameIdx)
+
+namespace GE
+{
+
+constexpr uint8_t maxFrameInFlight = 3;
+
+class GE_API Renderer
+{
+public:
+    Renderer() = delete;
+    Renderer(const Renderer&) = delete;
+    Renderer(Renderer&&) = delete;
+
+    Renderer(gfx::Device*, gfx::Surface*);
+
+    void renderFrame(const FrameGraph&);
+
+    ~Renderer();
+
+private:
+    struct InFlightData
+    {
+        std::unique_ptr<gfx::CommandBufferPool> commandBufferPool;
+        std::unique_ptr<gfx::ParameterBlockPool> parameterBlockPool;
+        gfx::CommandBuffer* waitedCmdBuffer = nullptr;
+
+        std::map<gfx::Texture::Descriptor, std::set<std::shared_ptr<gfx::Texture>>> textureCache;
+        std::map<gfx::Buffer::Descriptor, std::set<std::shared_ptr<gfx::Buffer>>> bufferCache;
+    };
+
+    gfx::Device* m_device;
+    gfx::Surface* m_surface;
+
+    std::shared_ptr<gfx::ParameterBlockLayout> m_frameDataBlockLayout;
+    std::shared_ptr<gfx::ParameterBlockLayout> m_materialBlockLayout;
+    std::shared_ptr<gfx::GraphicsPipeline> m_gfxPipeline; // only one for now
+
+    std::unique_ptr<gfx::Swapchain> m_swapchain;
+
+    uint8_t m_frameIdx = 0;
+    std::array<InFlightData, maxFrameInFlight> m_inFlightDatas;
+
+public:
+    Renderer& operator=(const Renderer&) = delete;
+    Renderer& operator=(Renderer&&) = delete;
+};
+
+} // namespace GE
+
+#endif // RENDERER_HPP
diff --git a/include/Game-Engine/Scene.hpp b/include/Game-Engine/Scene.hpp
new file mode 100644
index 0000000..9821c32
--- /dev/null
+++ b/include/Game-Engine/Scene.hpp
@@ -0,0 +1,132 @@
+/*
+ * ---------------------------------------------------
+ * Scene.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/31 16:52:15
+ * ---------------------------------------------------
+ */
+
+#ifndef SCENE_HPP
+#define SCENE_HPP
+
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/AssetManagerView.hpp"
+#include "Game-Engine/Components.hpp"
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/Entity.hpp"
+#include "Game-Engine/Export.hpp"
+
+#include "yaml-cpp/yaml.h"
+
+#include <future>
+#include <string>
+#include <vector>
+
+namespace GE
+{
+
+class GE_API Scene
+{
+public:
+    struct Descriptor
+    {
+        std::string name;
+        ECSWorld::EntityID activeCamera = INVALID_ENTITY_ID;
+        std::map<VAssetPath, AssetID> registredAssets;
+        std::map<ECSWorld::EntityID, std::vector<ComponentVariant>> entities;
+    };
+
+public:
+    Scene() = delete;
+    Scene(const Scene&) = delete;
+    Scene(Scene&&) = default;
+
+    Scene(AssetManager*, const std::string& name);
+    Scene(AssetManager*, const Descriptor&);
+
+    inline auto& ecsWorld(this auto&& self) { return self.m_ecsWorld; }
+    inline auto& assetManagerView(this auto&& self) { return self.m_assetManagerView; }
+
+    inline const std::string& name() const { return m_name; }
+    inline void setName(const std::string& s) { m_name = s; }
+
+    inline auto activeCamera(this auto&& self) { return basic_entity{&self.m_ecsWorld, self.m_activeCamera}; }
+    void setActiveCamera(const Entity& e);
+
+    Entity newEntity(const std::string& name);
+
+    inline bool isLoaded() const { return m_assetManagerView.areAllAssetsLoaded(); }
+    inline std::future<void> load() const { return m_assetManagerView.loadAllAssets(); }
+    inline void unload() { m_assetManagerView.unloadAllAssets(); }
+
+    Descriptor makeDescriptor() const;
+
+    ~Scene() = default;
+
+private:
+    ECSWorld m_ecsWorld;
+    AssetManagerView m_assetManagerView;
+
+    std::string m_name;
+    ECSWorld::EntityID m_activeCamera = INVALID_ENTITY_ID;
+
+public:
+    Scene& operator=(const Scene&) = delete;
+    Scene& operator=(Scene&&) = default;
+};
+
+} // namespace GE
+
+namespace YAML
+{
+
+template<>
+struct convert<GE::Scene::Descriptor>
+{
+    static Node encode(const GE::Scene::Descriptor& rhs)
+    {
+        Node node;
+        node["name"] = rhs.name;
+        node["activeCamera"] = rhs.activeCamera;
+        node["registredAssets"] = rhs.registredAssets;
+        node["entities"] = rhs.entities;
+        return node;
+    }
+
+    static bool decode(const Node& node, GE::Scene::Descriptor& rhs)
+    {
+        if (!node.IsMap() || !node["name"] || !node["activeCamera"] || !node["registredAssets"])
+            return false;
+        rhs.name = node["name"].as<std::string>();
+        rhs.activeCamera = node["activeCamera"].as<GE::ECSWorld::EntityID>();
+        const Node& registredAssets = node["registredAssets"];
+        if (!registredAssets.IsMap())
+            return false;
+
+        rhs.registredAssets.clear();
+        for (const auto& asset : registredAssets)
+        {
+            GE::VAssetPath vAssetPath;
+            GE::AssetID assetId;
+            if (asset.first.IsMap())
+            {
+                if (!YAML::convert<GE::VAssetPath>::decode(asset.first, vAssetPath) || !YAML::convert<GE::AssetID>::decode(asset.second, assetId))
+                    return false;
+            }
+            else if (!YAML::convert<GE::AssetID>::decode(asset.first, assetId) || !YAML::convert<GE::VAssetPath>::decode(asset.second, vAssetPath))
+            {
+                return false;
+            }
+
+            if (!rhs.registredAssets.emplace(vAssetPath, assetId).second)
+                return false;
+        }
+        rhs.entities = node["entities"].as<std::map<GE::ECSWorld::EntityID, std::vector<GE::ComponentVariant>>>();
+        return true;
+    }
+};
+
+}
+
+#endif // SCENE_HPP
diff --git a/include/Game-Engine/Script.hpp b/include/Game-Engine/Script.hpp
new file mode 100644
index 0000000..3131914
--- /dev/null
+++ b/include/Game-Engine/Script.hpp
@@ -0,0 +1,209 @@
+/*
+ * ---------------------------------------------------
+ * Script.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef SCRIPT_HPP
+#define SCRIPT_HPP
+
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/TypeList.hpp"
+
+#include <glm/glm.hpp>
+
+#include <cassert>
+#include <cstddef>
+#include <concepts>
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+#include <string_view>
+
+namespace GE
+{
+
+class Script;
+class Game;
+template<ECSWorldLike ECSWorldT>
+struct basic_entity;
+using Entity = basic_entity<ECSWorld>;
+
+using ScriptValueTypes = TypeList<bool, int64_t, float, glm::vec2, glm::vec3, std::string>;
+using VScriptValue = ScriptValueTypes::into<std::variant>;
+
+template<typename T>
+concept ScriptValueType = IsTypeInList<std::remove_cvref_t<T>, ScriptValueTypes>;
+
+template<typename T>
+struct ScriptValueTraits;
+
+template<> struct ScriptValueTraits<bool>        { static constexpr std::string_view name = "bool"; };
+template<> struct ScriptValueTraits<int64_t>     { static constexpr std::string_view name = "int"; };
+template<> struct ScriptValueTraits<float>       { static constexpr std::string_view name = "float"; };
+template<> struct ScriptValueTraits<glm::vec2>   { static constexpr std::string_view name = "vec2"; };
+template<> struct ScriptValueTraits<glm::vec3>   { static constexpr std::string_view name = "vec3"; };
+template<> struct ScriptValueTraits<std::string> { static constexpr std::string_view name = "string"; };
+
+class GE_API Script
+{
+public:
+    Script() = default;
+    Script(const Script&) = delete;
+    Script(Script&&) = delete;
+
+    virtual void setup(Entity&, Game&) {}
+    virtual void onUpdate() {}
+    virtual void teardown(Entity&, Game&) {}
+
+    virtual ~Script() = default;
+
+    Script& operator=(const Script&) = delete;
+    Script& operator=(Script&&) = delete;
+};
+
+template<typename T>
+concept ScriptClass = std::derived_from<T, Script>;
+
+class ScriptRegistry
+{
+public:
+    static ScriptRegistry& instance()
+    {
+        static ScriptRegistry registry;
+        return registry;
+    }
+
+    template<ScriptClass ScriptT>
+    void registerScript(std::string_view name)
+    {
+        m_scripts.insert_or_assign(name, ScriptDescriptor{ .factory = []() -> GE::Script* { return new ScriptT; } });
+    }
+
+    template<ScriptClass ScriptT, ScriptValueType ValueT>
+    void registerParameter(std::string_view scriptName, std::string_view parameterName, ValueT ScriptT::* member, ValueT defaultValue)
+    {
+        m_scripts.at(scriptName).parameters.insert_or_assign(parameterName, RegisteredScriptParameter{
+            .typeName = ScriptValueTraits<ValueT>::name,
+            .defaultValue = VScriptValue(defaultValue),
+            .setParameter = [member](Script& script, const void* data) {
+                static_cast<ScriptT&>(script).*member = *reinterpret_cast<const ValueT*>(data);
+            }
+        });
+    }
+
+    void listScriptNames(const char*** names, size_t* count) const
+    {
+        thread_local static std::vector<const char*> scriptNames;
+        scriptNames.clear();
+        scriptNames.reserve(m_scripts.size());
+        for (const auto& [name, _] : m_scripts)
+            scriptNames.push_back(name.data()); // ? data() safe because we know it come from a string literal
+        *names = scriptNames.data();
+        *count = scriptNames.size();
+    }
+
+    void listScriptParameterNames(const char* scriptName, const char*** names, size_t* count) const
+    {
+        const ScriptDescriptor& script = m_scripts.at(scriptName);
+        thread_local static std::vector<const char*> parameterNames;
+        parameterNames.clear();
+        parameterNames.reserve(script.parameters.size());
+        for (const auto& [name, _] : script.parameters)
+            parameterNames.push_back(name.data()); // ? data() safe because we know it come from a string literal
+        *names = parameterNames.data();
+        *count = parameterNames.size();
+    }
+
+    const char* getScriptParameterTypeName(const char* scriptName, const char* parameterName) const
+    {
+        return m_scripts.at(scriptName).parameters.at(parameterName).typeName.data();
+    }
+
+    void getScriptDefaultParameterValue(const char* scriptName, const char* parameterName, void* data) const
+    {
+        const RegisteredScriptParameter& parameter = m_scripts.at(scriptName).parameters.at(parameterName);
+        std::visit([&](const auto& defaultValue){
+            using ValueT = std::remove_cvref_t<decltype(defaultValue)>;
+            *reinterpret_cast<ValueT*>(data) = defaultValue;
+        }, parameter.defaultValue);
+    }
+
+    GE::Script* makeScriptInstance(const char* name) const
+    {
+        assert(name);
+        return m_scripts.at(name).factory();
+    }
+
+    void destroyScriptInstance(GE::Script* instance)
+    {
+        assert(instance);
+        delete instance;
+    }
+
+    void setScriptParameter(const char* scriptName, const char* parameterName, GE::Script* instance, const void* data)
+    {
+        assert(scriptName);
+        assert(parameterName);
+        assert(instance);
+        assert(data);
+        m_scripts.at(scriptName).parameters.at(parameterName).setParameter(*instance, data);
+    }
+
+private:
+    struct RegisteredScriptParameter
+    {
+        std::string_view typeName;
+        VScriptValue defaultValue;
+        std::function<void(Script&, const void*)> setParameter;
+    };
+
+    struct ScriptDescriptor
+    {
+        std::function<GE::Script*()> factory;
+        std::map<std::string_view, RegisteredScriptParameter> parameters;
+    };
+
+    std::map<std::string_view, ScriptDescriptor> m_scripts;
+};
+
+template<typename ScriptT>
+struct ScriptRegistrar
+{
+    ScriptRegistrar(std::string_view name)
+    {
+        ScriptRegistry::instance().registerScript<ScriptT>(name);
+    }
+};
+
+template<typename ScriptT, ScriptValueType ValueT>
+struct ScriptParameterRegistrar
+{
+    ScriptParameterRegistrar(std::string_view scriptName, std::string_view parameterName, ValueT ScriptT::* member, ValueT defaultValue)
+    {
+        ScriptRegistry::instance().registerParameter(scriptName, parameterName, member, std::move(defaultValue));
+    }
+};
+
+} // namespace GE
+
+#define GE_SCRIPT(TypeName, DisplayName)                                                       \
+    using GE_ScriptSelf = TypeName;                                                            \
+    static constexpr const char* ge_scriptName() { return DisplayName; }                       \
+    inline static const GE::ScriptRegistrar<GE_ScriptSelf> ge_scriptRegistrar{ ge_scriptName() } \
+
+#define GE_SCRIPT_PARAM(Type, Name, DefaultValue)                                                   \
+    Type Name = DefaultValue;                                                                       \
+    inline static const GE::ScriptParameterRegistrar<GE_ScriptSelf, Type> ge_paramRegistrar_##Name{ \
+        ge_scriptName(), #Name, &GE_ScriptSelf::Name, DefaultValue                                  \
+    }                                                                                               \
+
+#endif // SCRIPT_HPP
diff --git a/include/Game-Engine/ScriptLibrary.hpp b/include/Game-Engine/ScriptLibrary.hpp
new file mode 100644
index 0000000..edeee1d
--- /dev/null
+++ b/include/Game-Engine/ScriptLibrary.hpp
@@ -0,0 +1,68 @@
+/*
+ * ---------------------------------------------------
+ * ScriptLibrary.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef SCRIPT_LIBRARY_HPP
+#define SCRIPT_LIBRARY_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/Script.hpp"
+
+#include <filesystem>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace GE
+{
+
+
+class GE_API ScriptLibrary
+{
+public:
+
+    ScriptLibrary(const std::filesystem::path& path);
+    ScriptLibrary(const ScriptLibrary&) = delete;
+    ScriptLibrary(ScriptLibrary&&) = default;
+
+    std::vector<std::string> listScriptNames() const;
+    std::vector<std::string> listScriptParameterNames(const std::string& scriptName) const;
+    std::string getScriptParameterTypeName(const std::string& scriptName, const std::string& parameterName) const;
+    VScriptValue getScriptDefaultParameterValue(const std::string& scriptName, const std::string& parameterName) const;
+    void setScriptParameter(const std::string& scriptName, const std::string& parameterName, Script& script, const VScriptValue& value) const;
+    std::shared_ptr<Script> makeScriptInstance(const std::string& scriptName) const;
+
+    ~ScriptLibrary() = default;
+
+private:
+    using MakeScriptInstanceSym = Script* (*)(const char*);
+    using DestroyScriptInstanceSym = void (*)(Script*);
+    using ListScriptNamesSym = void (*)(const char***, size_t*);
+    using ListScriptParameterNamesSym = void (*)(const char*, const char***, size_t*);
+    using GetScriptParameterTypeNameSym = const char* (*)(const char*, const char*);
+    using GetScriptDefaultParameterValueSym = void (*)(const char*, const char*, void*);
+    using SetScriptParameterSym = void (*)(const char*, const char*, Script*, const void*);
+
+    std::shared_ptr<void> m_libraryHandle;
+
+    ListScriptNamesSym m_listScriptNames = nullptr;
+    ListScriptParameterNamesSym m_listScriptParameterNames = nullptr;
+    GetScriptParameterTypeNameSym m_getScriptParameterTypeName = nullptr;
+    GetScriptDefaultParameterValueSym m_getScriptDefaultParameterValue = nullptr;
+    SetScriptParameterSym m_setScriptParameter = nullptr;
+    MakeScriptInstanceSym m_makeScriptInstance = nullptr;
+    DestroyScriptInstanceSym m_destroyScriptInstance = nullptr;
+
+public:
+    ScriptLibrary& operator=(const ScriptLibrary&) = delete;
+    ScriptLibrary& operator=(ScriptLibrary&&) = default;
+};
+
+} // namespace GE
+
+#endif // SCRIPT_LIBRARY_HPP
diff --git a/include/Game-Engine/TypeList.hpp b/include/Game-Engine/TypeList.hpp
new file mode 100644
index 0000000..f7798ba
--- /dev/null
+++ b/include/Game-Engine/TypeList.hpp
@@ -0,0 +1,76 @@
+/*
+ * ---------------------------------------------------
+ * TypeList.hpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2026/04/26
+ * ---------------------------------------------------
+ */
+
+#ifndef TYPELIST_HPP
+#define TYPELIST_HPP
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace GE
+{
+
+template<typename... Ts>
+struct TypeList
+{
+    template<template<typename...> typename Container>
+    using into = Container<Ts...>;
+
+    template<template<typename> typename WrappedType>
+    using wrapped = TypeList<WrappedType<Ts>...>;
+};
+
+template<typename T, typename TList>
+struct TypeListContains;
+
+template<typename T, typename... Ts>
+struct TypeListContains<T, TypeList<Ts...>> : std::bool_constant<(std::is_same_v<T, Ts> || ...)>
+{
+};
+
+template<typename T, typename TList>
+concept IsTypeInList = TypeListContains<T, TList>::value;
+
+template<typename TList, typename Fn>
+inline constexpr void forEachType(Fn&& fn)
+{
+    auto helper = [&]<typename... Ts>(TypeList<Ts...>) requires (std::same_as<decltype(fn.template operator()<Ts>()), void> && ...) {
+        (fn.template operator()<Ts>(), ...);
+    };
+    return helper(TList{});
+}
+
+template<typename TList, typename Fn>
+inline constexpr bool anyOfType(Fn&& fn)
+{
+    auto helper = [&]<typename... Ts>(TypeList<Ts...>) requires (std::convertible_to<decltype(fn.template operator()<Ts>()), bool> && ...) {
+        return (static_cast<bool>(fn.template operator()<Ts>()) || ...);
+    };
+    return helper(TList{});
+}
+
+template<typename TList, typename Fn>
+inline constexpr bool allOfType(Fn&& fn)
+{
+    auto helper = [&]<typename... Ts>(TypeList<Ts...>) requires (std::convertible_to<decltype(fn.template operator()<Ts>()), bool> && ...) {
+        return (static_cast<bool>(fn.template operator()<Ts>()) && ...);
+    };
+    return helper(TList{});
+}
+
+template<typename TList, typename Fn>
+inline constexpr bool noneOfType(Fn&& fn)
+{
+    return !anyOfType<TList>(std::forward<Fn>(fn));
+}
+
+} // namespace GE
+
+#endif // TYPELIST_HPP
diff --git a/include/Game-Engine/Window.hpp b/include/Game-Engine/Window.hpp
new file mode 100644
index 0000000..ba5a9ca
--- /dev/null
+++ b/include/Game-Engine/Window.hpp
@@ -0,0 +1,100 @@
+/*
+ * ---------------------------------------------------
+ * Window.hpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * Date: 2023/11/14 17:09:45
+ * ---------------------------------------------------
+ */
+
+#ifndef WINDOW_HPP
+#define WINDOW_HPP
+
+#include "Game-Engine/Export.hpp"
+#include "Game-Engine/RawInput.hpp"
+
+#include <Graphics/Instance.hpp>
+#include <Graphics/Surface.hpp>
+
+#include <cstdint>
+#include <filesystem>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <set>
+#include <utility>
+#include <deque>
+
+struct GLFWwindow; // glfw is not accessible outside the engine
+
+namespace GE
+{
+
+class Event;
+
+class GE_API Window
+{
+public:
+    struct Descriptor
+    {
+        uint32_t width = 1280;
+        uint32_t height = 720;
+        const char* title = "";
+    };
+
+public:
+    Window() = delete;
+    Window(const Window&) = delete;
+    Window(Window&&) = delete;
+
+    Window(const Descriptor&);
+
+    std::pair<uint32_t, uint32_t> size() const; // std::pair<WIDTH, HEIGHT>
+
+    std::pair<uint32_t, uint32_t> frameBufferSize() const; // std::pair<WIDTH, HEIGHT>
+
+    std::pair<float, float> contentScale() const; // std::pair<X, Y>
+
+    inline void addEventCallBack(void* id, const std::function<void(Event&)>& fn) { m_eventCallbacks[id].push_back(fn); }
+    inline void addEventCallBack(const std::function<void(Event&)>& cb) { addEventCallBack(nullptr, cb); }
+
+    inline void clearCallbacks(void* id) { m_eventCallbacks.erase(id); }
+    inline void clearCallbacks() { m_eventCallbacks.clear(); }
+
+    bool isPressed(KeyboardButton);
+    bool isPressed(MouseButton);
+
+    std::pair<double, double> cursorPos() const; // std::pair<X, Y>
+    void setCursorPos(double x, double y);
+
+    void setCursorVisibility(bool);
+
+    std::optional<std::filesystem::path> popDroppedFile();
+
+    std::string clipboardString() const;
+    void setClipboardString(const std::string&) const;
+
+    void createSurface(gfx::Instance*);
+    inline gfx::Surface* surface() const { return m_surface.get(); }
+
+    GLFWwindow* glfwWindow() const { return m_glfwWindow; }
+
+    ~Window();
+
+private:
+    ::GLFWwindow* m_glfwWindow = nullptr;
+    std::unordered_map<void*, std::deque<std::function<void(Event&)>>> m_eventCallbacks;
+    std::set<std::filesystem::path> m_droppedFilePool;
+
+    std::unique_ptr<gfx::Surface> m_surface;
+
+public:
+    Window& operator=(const Window&) = delete;
+    Window& operator=(Window&&) = delete;
+};
+
+} // namespace GE
+
+#endif // WINDOW_HPP
diff --git a/project1_video.gif b/project1_video.gif
new file mode 100644
index 0000000..9bc797e
Binary files /dev/null and b/project1_video.gif differ
diff --git a/project_properties.png b/project_properties.png
new file mode 100644
index 0000000..56974bf
Binary files /dev/null and b/project_properties.png differ
diff --git a/shaders/CMakeLists.txt b/shaders/CMakeLists.txt
new file mode 100644
index 0000000..9976d13
--- /dev/null
+++ b/shaders/CMakeLists.txt
@@ -0,0 +1,28 @@
+# ---------------------------------------------------
+# CMakeLists.txt
+#
+# Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+# ---------------------------------------------------
+
+set(SHADER_TARGET_LIST)
+if (GE_BUILD_METAL)
+    list(APPEND SHADER_TARGET_LIST metal)
+endif()
+if (GE_BUILD_VULKAN)
+    list(APPEND SHADER_TARGET_LIST spirv)
+endif()
+list(JOIN SHADER_TARGET_LIST "," SHADER_TARGETS)
+
+set(FLAT_COLOR_SSRC "${CMAKE_CURRENT_SOURCE_DIR}/flat_color.slang")
+set(FLAT_COLOR_SLIB ${CMAKE_CURRENT_BINARY_DIR}/flat_color.slib)
+add_custom_command(
+    OUTPUT ${FLAT_COLOR_SLIB}
+    COMMAND $<TARGET_FILE:gfxsc> -t ${SHADER_TARGETS} -o ${FLAT_COLOR_SLIB} ${FLAT_COLOR_SSRC}
+    DEPENDS gfxsc ${FLAT_COLOR_SSRC} "FrameData.slang" "Light.slang" "phong_shading.slang" "shader.h"
+    COMMENT "Building flat_color shader"
+    VERBATIM
+)
+add_custom_target(flat_color_shader ALL DEPENDS ${FLAT_COLOR_SLIB})
+set_target_properties(flat_color_shader PROPERTIES FOLDER "shaders")
+
+set(SHADER_DIR ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
diff --git a/shaders/FrameData.slang b/shaders/FrameData.slang
new file mode 100644
index 0000000..8d2584a
--- /dev/null
+++ b/shaders/FrameData.slang
@@ -0,0 +1,36 @@
+/*
+ * ---------------------------------------------------
+ * FrameData.slang
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef FRAMEDATA_SLANG
+#define FRAMEDATA_SLANG
+
+#include "shader.h"
+
+SLANG_MODULE_DEF(FrameData);
+SLANG_MODULE_IMP(Light);
+
+namespace shader
+{
+
+SLANG_PUBLIC struct FrameData
+{
+    SLANG_PUBLIC CBUFFER_BEGIN(_)
+        SLANG_PUBLIC float4x4 vpMatrix;
+        SLANG_PUBLIC float3 cameraPosition;    FLOAT3_PADDING(0);
+        SLANG_PUBLIC float3 ambientLightColor; FLOAT3_PADDING(1);
+        SLANG_PUBLIC int directionalLightCount;
+        SLANG_PUBLIC int pointLightCount;
+    CBUFFER_END
+    #ifndef __cplusplus
+        SLANG_PUBLIC  StructuredBuffer<DirectionalLight> directionalLights;
+        SLANG_PUBLIC  StructuredBuffer<PointLight> pointLights;
+    #endif
+};
+
+}
+#endif
diff --git a/shaders/Light.slang b/shaders/Light.slang
new file mode 100644
index 0000000..4b4bd02
--- /dev/null
+++ b/shaders/Light.slang
@@ -0,0 +1,34 @@
+/*
+ * ---------------------------------------------------
+ * Light.slang
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#ifndef LIGHT_SLANG
+#define LIGHT_SLANG
+
+#include "shader.h"
+
+SLANG_MODULE_DEF(Light);
+
+namespace shader
+{
+
+SLANG_PUBLIC struct alignas(16) DirectionalLight
+{
+    SLANG_PUBLIC float3 position; FLOAT3_PADDING(0);
+    SLANG_PUBLIC float3 color;    FLOAT3_PADDING(1);
+};
+
+SLANG_PUBLIC struct alignas(16) PointLight
+{
+    SLANG_PUBLIC float3 position;   FLOAT3_PADDING(0);
+    SLANG_PUBLIC float3 color;      FLOAT3_PADDING(1);
+    SLANG_PUBLIC float attenuation; FLOAT1_PADDING(0);
+};
+
+}
+
+#endif
diff --git a/shaders/default.fs b/shaders/default.fs
deleted file mode 100644
index 4a6debb..0000000
--- a/shaders/default.fs
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * ---------------------------------------------------
- * default.fs
- *
- * Author: Thomas Choquet <thomas.publique@icloud.com>
- * Date: 2024/07/13 11:42:39
- * ---------------------------------------------------
- */
-
-#version 410 core
-
-in VertexOut
-{
-    vec3 pos;
-    vec2 uv;
-    vec3 tangent;
-    vec3 bitangent;
-    vec3 normal;
-} fsIn;
-
-out vec4 finalColor;
-
-struct PointLight
-{
-    vec3  pos;
-    float _pad0;
-    vec3  color;
-    float _pad1;
-    float intentsity;
-};
-
-layout (std140) uniform lightsBuffer
-{
-    PointLight pointLights[32];
-    uint pointLightCount;
-};
-
-
-void main()
-{
-    vec3 fragNormal = normalize(fsIn.normal);
-    vec3 fragDiffuse = vec3(1.0f, 1.0f, 1.0f);
-
-    finalColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);
-
-    for(uint i = 0; i < pointLightCount; i++)
-    {
-        PointLight light = pointLights[i];
-
-        float diffuseFactor = dot(fragNormal, normalize(light.pos - fsIn.pos));
-
-        vec3 ambiant = fragDiffuse * light.color * (light.intentsity * 0.2);
-        vec3 diffuse = fragDiffuse * light.color * light.intentsity * max(diffuseFactor, 0.0f);
-
-        finalColor += vec4(ambiant + diffuse, 1.0F);
-    }
-}
\ No newline at end of file
diff --git a/shaders/default.metal b/shaders/default.metal
deleted file mode 100644
index c06eb60..0000000
--- a/shaders/default.metal
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * ---------------------------------------------------
- * default.metal
- *
- * Author: Thomas Choquet <thomas.publique@icloud.com>
- * Date: 2024/07/07 09:27:04
- * ---------------------------------------------------
- */
-
-#include <metal_stdlib>
-
-using namespace metal;
-
-struct VertexIn
-{
-    float3 pos     [[attribute(0)]];
-    float2 uv      [[attribute(1)]];
-    float3 normal  [[attribute(2)]];
-};
-
-struct VertexOut
-{
-    float4   clipPos [[position]];
-    float3   pos;
-    float2   uv;
-    float3   normal;
-};
-
-vertex VertexOut default_vs(VertexIn in [[stage_in]],
-    constant float4x4& vpMatrixBuffer    [[buffer(1)]],
-    constant float4x4& modelMatrix [[buffer(2)]]
-)
-{
-    float4 worldPos  = modelMatrix * float4(in.pos, 1.0);
-
-    return (VertexOut){
-        .clipPos   = vpMatrixBuffer * worldPos,
-        .pos       = worldPos.xyz,
-        .uv        = in.uv,
-        .normal    = (modelMatrix * float4(in.normal,  0)).xyz,
-    };
-}
-
-struct LightsBuffer
-{
-    struct {
-        float3 pos;
-        float3 color;
-        float intensity;
-    }
-    pointLights[32];
-    uint pointLightCount;
-};
-
-fragment float4 default_fs(VertexOut in [[stage_in]],
-    constant LightsBuffer& lightsBuffer [[buffer(1)]]
-)
-{
-    float3 fragNormal = normalize(in.normal);
-    float3 fragDiffuse = float3(1.0f, 1.0f, 1.0f);
-
-    float3 finalColor = float3(0.0f, 0.0f, 0.0f);
-
-    for (uint i = 0; i < lightsBuffer.pointLightCount; i++)
-    {
-        constant auto& light = lightsBuffer.pointLights[i];
-
-        float diffuseFactor = dot(fragNormal, normalize(light.pos - in.pos));
-
-        float3 ambient = fragDiffuse * light.color * (light.intensity * 0.2);
-        float3 diffuse = fragDiffuse * light.color * light.intensity * max(diffuseFactor, 0.0f);
-        
-        finalColor += ambient + diffuse;
-    }
-
-    return float4(finalColor, 1.0F);
-}
\ No newline at end of file
diff --git a/shaders/default.vs b/shaders/default.vs
deleted file mode 100644
index b491be7..0000000
--- a/shaders/default.vs
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * ---------------------------------------------------
- * default.vs
- *
- * Author: Thomas Choquet <thomas.publique@icloud.com>
- * Date: 2024/07/13 11:38:32
- * ---------------------------------------------------
- */
-
-#version 410 core
-
-layout (location = 0) in vec3 pos;
-layout (location = 1) in vec2 uv;
-layout (location = 2) in vec3 normal;
-layout (location = 3) in vec3 tangent;
-
-out VertexOut
-{
-    vec3 pos;
-    vec2 uv;
-    vec3 tangent;
-    vec3 bitangent;
-    vec3 normal;
-} vsOut;
-
-layout (std140) uniform vpMatrixBuffer
-{
-    mat4 vpMatrix;
-};
-
-uniform mat4 modelMatrix;
-
-void main()
-{
-    vec4 worldPos = modelMatrix * vec4(pos, 1.0);
-    vec3 bitangent = cross(tangent, normal);
-
-    vsOut.pos       = worldPos.xyz;
-    gl_Position     = vpMatrix * worldPos;
-    vsOut.uv        = uv;
-    vsOut.tangent   = (modelMatrix * vec4(tangent,   0)).xyz;
-    vsOut.bitangent = (modelMatrix * vec4(bitangent, 0)).xyz;
-    vsOut.normal    = (modelMatrix * vec4(normal,    0)).xyz;
-}
diff --git a/shaders/flat_color.slang b/shaders/flat_color.slang
new file mode 100644
index 0000000..bb54347
--- /dev/null
+++ b/shaders/flat_color.slang
@@ -0,0 +1,96 @@
+/*
+ * ---------------------------------------------------
+ * flat_color.slang
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "shader.h"
+
+SLANG_MODULE_IMP(Light);
+SLANG_MODULE_IMP(FrameData);
+SLANG_MODULE_IMP(phong_shading);
+
+namespace shader::flat_color
+{
+
+/* -------------------------Vertex Shader------------------------------- */
+
+#ifndef __cplusplus
+
+ParameterBlock<FrameData> frameData;
+
+PUSH_CONSTANT
+{
+    float4x4 modelMatrix;
+}
+
+struct Vertex
+{
+    float3 pos;
+    float3 normal;
+};
+
+struct VSOutput
+{
+    float3 pos;
+    float4 clipPos : SV_Position;
+    float3 normal;
+};
+
+[shader("vertex")]
+VSOutput vertexMain(Vertex input)
+{
+    float4 worldPos  = mul(float4(input.pos, 1.0), modelMatrix);
+
+    VSOutput output;
+    output.pos     = worldPos.xyz;
+    output.clipPos = mul(worldPos, frameData.vpMatrix);
+    output.normal  = mul(input.normal, (float3x3)modelMatrix);
+    return output;
+}
+
+#endif // ifndef _cplusplus
+
+/* -------------------------Fragment Shader------------------------------- */
+
+struct Material
+{
+    float4 diffuseColor;
+    float3 specularColor; FLOAT3_PADDING(0);
+    float shininess;
+};
+
+#ifndef __cplusplus
+
+struct _Material { ConstantBuffer<Material> data; };
+ParameterBlock<_Material> _material;
+#define material _material.data
+
+[shader("fragment")]
+float4 fragmentMain(VSOutput input) : SV_TARGET
+{
+    if (material.diffuseColor.a < 1.0f)
+        discard;
+
+    phong::FragmentContext fragCtx;
+    fragCtx.position      = input.pos;
+    fragCtx.normal        = normalize(input.normal);
+    fragCtx.cameraDir     = normalize(frameData.cameraPosition - input.pos);
+    fragCtx.diffuseColor  = material.diffuseColor.rgb;
+    fragCtx.specularColor = material.specularColor;
+    fragCtx.shininess     = material.shininess;
+
+    float3 finalColor = frameData.ambientLightColor * fragCtx.diffuseColor;
+    for (int i = 0; i < frameData.directionalLightCount; ++i)
+        finalColor += phong::evalDirectionalLight(fragCtx, frameData.directionalLights[i]);
+    for (int i = 0; i < frameData.pointLightCount; ++i)
+        finalColor += phong::evalPointLight(fragCtx, frameData.pointLights[i]);
+
+    return float4(saturate(finalColor), material.diffuseColor.a);
+}
+
+#endif // ifndef _cplusplus
+
+} // namespace shader::flat_color
diff --git a/shaders/phong_shading.slang b/shaders/phong_shading.slang
new file mode 100644
index 0000000..1213696
--- /dev/null
+++ b/shaders/phong_shading.slang
@@ -0,0 +1,47 @@
+/*
+ * ---------------------------------------------------
+ * phong_shading.slang
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+module phong_shading;
+import Light;
+
+namespace shader::phong
+{
+
+public struct FragmentContext
+{
+    public float3 position;
+    public float3 normal;
+    public float3 cameraDir;
+    public float3 diffuseColor;
+    public float3 specularColor;
+    public float  shininess;
+};
+
+public float3 evalDirectionalLight(FragmentContext fragCtx, DirectionalLight light)
+{
+    float3 lightDir   = normalize(light.position);
+    float3 halfwayDir = normalize(lightDir + fragCtx.cameraDir);
+
+    float3 diffuse  = fragCtx.diffuseColor  * light.color *     max(dot(fragCtx.normal, lightDir  ), 0.0f);
+    float3 specular = fragCtx.specularColor * light.color * pow(max(dot(fragCtx.normal, halfwayDir), 0.0f), clamp(fragCtx.shininess, 0.001, 256.0));
+
+    return diffuse + specular;
+}
+
+public float3 evalPointLight(FragmentContext fragCtx, PointLight light)
+{
+    float3 lightDir   = normalize(light.position - fragCtx.position);
+    float3 halfwayDir = normalize(lightDir + fragCtx.cameraDir);
+
+    float3 diffuse = fragCtx.diffuseColor * light.color * max(dot(fragCtx.normal, lightDir), 0.0f);
+    float3 specular = fragCtx.specularColor * light.color * pow(max(dot(fragCtx.normal, halfwayDir), 0.0f), clamp(fragCtx.shininess, 0.001, 256.0));
+
+    return diffuse + specular;
+}
+
+}
diff --git a/shaders/shader.h b/shaders/shader.h
new file mode 100644
index 0000000..5704f83
--- /dev/null
+++ b/shaders/shader.h
@@ -0,0 +1,54 @@
+
+/*
+ * ---------------------------------------------------
+ * shader.h
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ *
+ * file included by all slang files
+ */
+
+
+#ifndef SHADER_H
+#define SHADER_H
+
+namespace shader
+{
+
+#ifdef __cplusplus
+    #include <glm/glm.hpp>
+    using float2 = glm::vec2;
+    using float3 = glm::vec3;
+    using float4 = glm::vec4;
+    using float4x4 = glm::mat4;
+    #define SLANG_PUBLIC
+    #define SLANG_MODULE_DEF(name)
+    #define SLANG_MODULE_IMP(name)
+    #define CBUFFER_BEGIN(name)
+    #define CBUFFER_END
+    #define FLOAT3_PADDING(n) float _padding3##n
+    #define FLOAT1_PADDING(n) float _padding1a##n, _padding1b##n, _padding1c##n
+#else
+    #define SLANG_PUBLIC public
+    #define SLANG_MODULE_DEF(name) module name
+    #define SLANG_MODULE_IMP(name) import name
+    #define alignas(n)
+    #define CBUFFER_BEGIN(name) cbuffer name {
+    #define CBUFFER_END };
+    #ifdef __SPIRV__
+        #define FLOAT3_PADDING(n) float _padding3##n
+        #define FLOAT1_PADDING(n) float _padding1a##n, _padding1b##n, _padding1c##n
+    #else
+        #define FLOAT3_PADDING(n)
+        #define FLOAT1_PADDING(n)
+    #endif
+    #ifdef __METAL__
+        #define PUSH_CONSTANT [[vk::push_constant]] cbuffer PushConstant : register(b6)
+    #else
+        #define PUSH_CONSTANT [[vk::push_constant]] cbuffer PushConstant
+    #endif
+#endif
+
+}
+#endif
diff --git a/src/Application.cpp b/src/Application.cpp
new file mode 100644
index 0000000..f5dcd0f
--- /dev/null
+++ b/src/Application.cpp
@@ -0,0 +1,133 @@
+/*
+ * ---------------------------------------------------
+ * Application.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/09/02 17:15:13
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/Application.hpp"
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/Event.hpp"
+#include "Game-Engine/Window.hpp"
+#include "Game-Engine/Renderer.hpp"
+
+#include <Graphics/Instance.hpp>
+#include <Graphics/Surface.hpp>
+#include <Graphics/Device.hpp>
+
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+
+#include <cassert>
+#include <memory>
+
+namespace GE
+{
+
+Application::Application()
+{
+    auto res = ::glfwInit();
+    assert(res == GLFW_TRUE);
+    (void)res;
+    m_glfwGuard = { (void*)(1), [](void*){ ::glfwTerminate(); } };
+
+    m_instance = gfx::Instance::newInstance(gfx::Instance::Descriptor{});
+    assert(m_instance);
+
+    m_window = std::make_unique<Window>(Window::Descriptor{
+        .width = 1280,
+        .height = 720,
+        .title = ""
+    });
+
+    m_window->addEventCallBack(this, [&](Event& event)
+    {
+        event.dispatch<InputEvent>([this](InputEvent& inputEvent)
+        {
+            for (auto it = m_inputContextStack.rbegin(); it != m_inputContextStack.rend(); it++)
+                (*it)->onInputEvent(inputEvent);
+        });
+        if (event.processed() == false)
+            onEvent(event);
+    });
+    m_window->createSurface(m_instance.get());
+
+    m_device = m_instance->newDevice(gfx::Device::Descriptor{
+        .queueCaps = {
+            .graphics = true,
+            .compute = true,
+            .transfer = true,
+            .present = {m_window->surface()}}});
+    assert(m_device);
+
+    if (m_window->surface()->supportedPixelFormats(*m_device).contains(gfx::PixelFormat::BGRA8Unorm) == false)
+        throw std::runtime_error("surface does not support the BGRA8Unorm pixel format");
+
+    if (m_window->surface()->supportedPresentModes(*m_device).contains(gfx::PresentMode::fifo) == false)
+        throw std::runtime_error("surface does not support the fifo present mode");
+
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.IniFilename = nullptr;
+    switch (m_device->backend())
+    {
+        case gfx::Backend::vulkan:
+            ImGui_ImplGlfw_InitForVulkan(m_window->glfwWindow(), false);
+            break;
+        default:
+            ImGui_ImplGlfw_InitForOther(m_window->glfwWindow(), false);
+            break;
+    }
+    m_device->imguiInit({gfx::PixelFormat::BGRA8Unorm});
+    m_imguiGuard = {
+        (void*)(1),
+        [device=m_device.get()](void*){
+            device->imguiShutdown();
+            ImGui_ImplGlfw_Shutdown();
+            ImGui::DestroyContext();
+        }
+    };
+
+    m_renderer = std::make_unique<Renderer>(m_device.get(), m_window->surface());
+    m_assetManager = std::make_unique<AssetManager>(m_device.get());
+}
+
+void Application::run()
+{
+    m_running = true;
+    while (true)
+    {
+        ::glfwPollEvents();
+
+        for (InputContext* inputContext : m_inputContextStack)
+            inputContext->dispatchInputs();
+
+        if (m_running == false)
+            break;
+
+        m_device->imguiNewFrame();
+        ImGui_ImplGlfw_NewFrame();
+
+        onUpdate();
+
+        m_renderer->renderFrame(frameGraph());
+    }
+}
+
+void Application::pushInputContext(InputContext* inputContext)
+{
+    assert(inputContext != nullptr);
+    m_inputContextStack.push_back(inputContext);
+}
+
+void Application::popInputContext()
+{
+    assert(m_inputContextStack.size() > 0);
+    m_inputContextStack.pop_back();
+}
+
+}
diff --git a/engine/ECS/Archetype.cpp b/src/Archetype.cpp
similarity index 58%
rename from engine/ECS/Archetype.cpp
rename to src/Archetype.cpp
index 16e2a2f..03157ba 100644
--- a/engine/ECS/Archetype.cpp
+++ b/src/Archetype.cpp
@@ -7,41 +7,44 @@
  * ---------------------------------------------------
  */
 
-#include "ECS/ECSWorld.hpp"
-#include "UtilsCPP/Types.hpp"
+#include "Game-Engine/ECSWorld.hpp"
+
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
 
 namespace GE
 {
 
-ECSWorld::Archetype::Archetype()
-    : m_size(0), m_capacity(1)
+ECSWorld::Archetype::Archetype() : m_size(0), m_capacity(1) // TODO : start capacity at 0 ?
 {
-    m_rows.insert(0, Row{
+    m_rows.insert(std::pair(0, Row{
         operator new (sizeof(EntityID) * m_capacity),
         componentSize<EntityID>(),
         componentCopyConstructor<EntityID>(),
         componentMoveConstructor<EntityID>(),
         componentDestructor<EntityID>(),
-    });
+    }));
 }
 
-ECSWorld::Archetype::Archetype(const Archetype& cp)
-    : m_size(cp.m_size), m_capacity(cp.m_capacity)
+ECSWorld::Archetype::Archetype(const Archetype& cp) : m_size(cp.m_size), m_capacity(cp.m_capacity)
 {
     for (auto& [id, row] : cp.m_rows)
     {
-        Row& newRow = m_rows.insert(id, Row{
+        auto [it, sucess] = m_rows.insert(std::pair(id, Row{
             operator new (row.componentSize * m_capacity),
             row.componentSize, row.copyConstructor,
             row.moveConstructor, row.destructor
-        })->val;
+        }));
+        assert(sucess);
+        Row& newRow = it->second;
 
-        for (utils::uint64 idx = 0; idx < cp.m_size; idx++)
+        for (uint64_t idx = 0; idx < cp.m_size; idx++)
         {
             row.copyConstructor(
-                static_cast<utils::byte*>(row.buffer) + (row.componentSize * idx),
-                static_cast<utils::byte*>(newRow.buffer) + (newRow.componentSize * idx)
+                static_cast<std::byte*>(row.buffer) + (row.componentSize * idx),
+                static_cast<std::byte*>(newRow.buffer) + (newRow.componentSize * idx)
             );
         }
     }
@@ -52,10 +55,11 @@ ECSWorld::Archetype::Archetype(Archetype&& mv)
 {
     for (auto& [id, row] : mv.m_rows)
     {
-        Row& newRow = m_rows.insert(id, Row{
+        auto [_, sucess] = m_rows.insert(std::pair(id, Row{
             row.buffer, row.componentSize, row.copyConstructor,
             row.moveConstructor, row.destructor
-        })->val;
+        }));
+        assert(sucess);
         row.buffer = nullptr;
     }
 }
@@ -68,41 +72,31 @@ ECSWorld::Archetype ECSWorld::Archetype::duplicateRowTypes()
     {
         if (row.buffer != nullptr)
         {
-            for (utils::uint64 i = 0; i < newArchetype.m_size; i++)
-                row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
+            for (uint64_t i = 0; i < newArchetype.m_size; i++)
+                row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
             operator delete (row.buffer);
         }
     }
     newArchetype.m_rows.clear();
     for (auto& [id, row] : m_rows)
     {
-        newArchetype.m_rows.insert(id, Row{
+        newArchetype.m_rows.insert(std::make_pair(id, Row{
             operator new (row.componentSize * newArchetype.m_capacity),
             row.componentSize, row.copyConstructor,
             row.moveConstructor, row.destructor
-        });
+        }));
     }
     return newArchetype;
 }
 
-utils::uint64 ECSWorld::Archetype::allocateCollum()
+uint64_t ECSWorld::Archetype::allocateCollum()
 {
     if (m_size == m_capacity)
         extendCapacity();
     return m_size++;
 }
 
-ECSWorld::EntityID& ECSWorld::Archetype::getEntityID(utils::uint64 idx)
-{
-    return static_cast<EntityID*>(m_rows[0].buffer)[idx];
-}
-
-const ECSWorld::EntityID& ECSWorld::Archetype::getEntityID(utils::uint64 idx) const
-{
-    return static_cast<const EntityID*>(m_rows[0].buffer)[idx];
-}
-
-void ECSWorld::Archetype::moveComponents(Archetype& arcSrc, utils::uint64 idxSrc, Archetype& arcDst, utils::uint64 idxDst)
+void ECSWorld::Archetype::moveComponents(Archetype& arcSrc, uint64_t idxSrc, Archetype& arcDst, uint64_t idxDst)
 {
     for (auto& [id, row] : arcSrc.m_rows)
     {
@@ -110,17 +104,17 @@ void ECSWorld::Archetype::moveComponents(Archetype& arcSrc, utils::uint64 idxSrc
         if (it != arcDst.m_rows.end())
         {
             row.moveConstructor(
-                static_cast<utils::byte*>(row.buffer) + (row.componentSize * idxSrc),
-                static_cast<utils::byte*>(it->val.buffer) + (it->val.componentSize * idxDst)
+                static_cast<std::byte*>(row.buffer) + (row.componentSize * idxSrc),
+                static_cast<std::byte*>(it->second.buffer) + (it->second.componentSize * idxDst)
             );
         }
     }
 }
 
-void ECSWorld::Archetype::destructCollum(utils::uint64 idx)
+void ECSWorld::Archetype::destructCollum(uint64_t idx)
 {
     for (auto& [_, row] : m_rows)
-        row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * idx));
+        row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * idx));
 }
 
 void ECSWorld::Archetype::freeLastCollum()
@@ -136,27 +130,27 @@ ECSWorld::Archetype::~Archetype()
     {
         if (row.buffer != nullptr)
         {
-            for (utils::uint64 i = 0; i < m_size; i++)
-                row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
+            for (uint64_t i = 0; i < m_size; i++)
+                row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
             operator delete (row.buffer);
         }
     }
 }
 
-void ECSWorld::Archetype::setCapacity(utils::uint64 newCapacity)
+void ECSWorld::Archetype::setCapacity(uint64_t newCapacity)
 {
     if (newCapacity == m_capacity)
         return;
     for (auto& [_, row] : m_rows)
     {
         void* newBuffer = operator new (row.componentSize * newCapacity);
-        for (utils::uint64 i = 0; i < m_size; i++)
+        for (uint64_t i = 0; i < m_size; i++)
         {
             row.moveConstructor(
-                static_cast<utils::byte*>(row.buffer) + (row.componentSize * i),
-                static_cast<utils::byte*>(newBuffer) + (row.componentSize * i)
+                static_cast<std::byte*>(row.buffer) + (row.componentSize * i),
+                static_cast<std::byte*>(newBuffer) + (row.componentSize * i)
             );
-            row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
+            row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
         }
         operator delete (row.buffer);
         row.buffer = newBuffer;
@@ -172,8 +166,8 @@ ECSWorld::Archetype& ECSWorld::Archetype::operator = (const Archetype& cp)
         {
             if (row.buffer != nullptr)
             {
-                for (utils::uint64 i = 0; i < m_size; i++)
-                    row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
+                for (uint64_t i = 0; i < m_size; i++)
+                    row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
                 operator delete (row.buffer);
             }
         }
@@ -182,17 +176,19 @@ ECSWorld::Archetype& ECSWorld::Archetype::operator = (const Archetype& cp)
         m_capacity = cp.m_capacity;
         for (auto& [id, row] : cp.m_rows)
         {
-            Row& newRow = m_rows.insert(id, Row{
+            auto [it, success] = m_rows.insert(std::make_pair(id, Row{
                 operator new (row.componentSize * m_capacity),
                 row.componentSize, row.copyConstructor,
                 row.moveConstructor, row.destructor
-            })->val;
+            }));
+            assert(success);
+            Row& newRow = it->second;
 
-            for (utils::uint64 idx = 0; idx < cp.m_size; idx++)
+            for (uint64_t idx = 0; idx < cp.m_size; idx++)
             {
                 row.copyConstructor(
-                    static_cast<utils::byte*>(row.buffer) + (row.componentSize * idx),
-                    static_cast<utils::byte*>(newRow.buffer) + (newRow.componentSize * idx)
+                    static_cast<std::byte*>(row.buffer) + (row.componentSize * idx),
+                    static_cast<std::byte*>(newRow.buffer) + (newRow.componentSize * idx)
                 );
             }
         }
@@ -208,8 +204,8 @@ ECSWorld::Archetype& ECSWorld::Archetype::operator = (Archetype&& mv)
         {
             if (row.buffer != nullptr)
             {
-                for (utils::uint64 i = 0; i < m_size; i++)
-                    row.destructor(static_cast<utils::byte*>(row.buffer) + (row.componentSize * i));
+                for (uint64_t i = 0; i < m_size; i++)
+                    row.destructor(static_cast<std::byte*>(row.buffer) + (row.componentSize * i));
                 operator delete (row.buffer);
             }
         }
@@ -218,14 +214,15 @@ ECSWorld::Archetype& ECSWorld::Archetype::operator = (Archetype&& mv)
         m_capacity = mv.m_capacity;
         for (auto& [id, row] : mv.m_rows)
         {
-            Row& newRow = m_rows.insert(id, Row{
+            auto [_, success] = m_rows.insert(std::make_pair(id, Row{
                 row.buffer, row.componentSize, row.copyConstructor,
                 row.moveConstructor, row.destructor
-            })->val;
+            }));
+            assert(success);
             row.buffer = nullptr;
         }
     }
     return *this;
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/AssetManager.cpp b/src/AssetManager.cpp
new file mode 100644
index 0000000..4dcf59a
--- /dev/null
+++ b/src/AssetManager.cpp
@@ -0,0 +1,285 @@
+/*
+ * ---------------------------------------------------
+ * AssetManager.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/13 12:00:28
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/Mesh.hpp"
+
+#include <Graphics/Device.hpp>
+#include <Graphics/Enums.hpp>
+
+#include <array>
+#include <stb_image/stb_image.h>
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/types.h>
+
+#include <cassert>
+#include <cstdint>
+#include <ranges>
+#include <bit>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#ifdef __cpp_lib_containers_ranges
+    #define APPEND_RANGE(self, range) self.append_range(range)
+#else
+    #define APPEND_RANGE(self, range) self.insert(self.end(), range.cbegin(), range.cend())
+#endif
+
+constexpr unsigned int POST_PROCESSING_FLAGS = aiProcess_CalcTangentSpace
+                                               | aiProcess_JoinIdenticalVertices
+                                               | aiProcess_Triangulate
+                                               | aiProcess_GenNormals
+                                               | aiProcess_OptimizeMeshes
+                                               | aiProcess_FlipUVs;
+
+namespace
+{
+
+static inline glm::mat4x4 toGlmMat4(const aiMatrix4x4& from)
+{
+    glm::mat4x4 to;
+    to[0][0] = from.a1; to[1][0] = from.a2; to[2][0] = from.a3; to[3][0] = from.a4;
+    to[0][1] = from.b1; to[1][1] = from.b2; to[2][1] = from.b3; to[3][1] = from.b4;
+    to[0][2] = from.c1; to[1][2] = from.c2; to[2][2] = from.c3; to[3][2] = from.c4;
+    to[0][3] = from.d1; to[1][3] = from.d2; to[2][3] = from.d3; to[3][3] = from.d4;
+    return to;
+}
+
+} // namespace
+
+namespace GE
+{
+
+AssetManager::AssetManager(gfx::Device* device)
+    : m_device(device)
+    , m_builtInCubeHandle(std::in_place_type<AssetHandle<Mesh>>)
+{
+    std::get<AssetHandle<Mesh>>(m_builtInCubeHandle).loader = [device=m_device](gfx::CommandBuffer& commandBuffer) -> std::shared_ptr<Mesh> {
+        return std::make_shared<Mesh>(loadBuiltInCube(*device, commandBuffer));
+    };
+}
+
+void AssetManager::registerAsset(const VAssetPath& vAssetPath)
+{
+    std::visit([&](const auto& assetPath) {
+        using AssetType = typename std::remove_cvref_t<decltype(assetPath)>::AssetType;
+        auto [it, inserted] = m_handles.try_emplace(vAssetPath, std::in_place_type<AssetHandle<AssetType>>);
+        if (inserted)
+        {
+            AssetHandle<AssetType>& handle = std::get<AssetHandle<AssetType>>(it->second);
+            if constexpr (std::is_same_v<AssetType, Mesh>) {
+                handle.loader = [device=m_device, path=assetPath](gfx::CommandBuffer& commandBuffer) {
+                    return std::make_shared<Mesh>(loadMesh(*device, path, commandBuffer));
+                };
+            }
+            else if constexpr (std::is_same_v<AssetType, gfx::Texture>) {
+                handle.loader = [device=m_device, path=assetPath](gfx::CommandBuffer& commandBuffer) {
+                    return loadTexture(*device, path, commandBuffer);
+                };
+            }
+            else std::unreachable();
+        }
+    },
+    vAssetPath);
+}
+
+void AssetManager::unloadAssetHandle(VAssetHandle& vHandle)
+{
+    std::visit([](auto& handle) {
+        if (handle.future.valid())
+            handle.future.wait(); // dont need to propagate errors
+        auto expected = AssetHandleLoadingStatus::loaded;
+        if (handle.status.compare_exchange_strong(expected, AssetHandleLoadingStatus::unloaded))
+            handle.asset.reset();
+    },
+    vHandle);
+}
+
+AssetManager::~AssetManager()
+{
+    for (auto& [_, handle] : m_handles)
+        unloadAssetHandle(handle);
+}
+
+Mesh AssetManager::loadMesh(gfx::Device& device, const std::filesystem::path& path, gfx::CommandBuffer& commandBuffer)
+{
+    assert(std::filesystem::is_regular_file(path));
+
+    Assimp::Importer importer;
+
+    const aiScene* scene = importer.ReadFile(path.string(), POST_PROCESSING_FLAGS);
+    if (scene == nullptr)
+        throw std::runtime_error("fail to load the model using assimp");
+
+    const auto aiMeshToSubMesh = [&](aiMesh* aiMesh) {
+        const auto aiVtxToVtx = [aiMesh](uint32_t i) -> Vertex {
+            return Vertex{
+                .pos = glm::vec3(aiMesh->mVertices[i].x, aiMesh->mVertices[i].y, aiMesh->mVertices[i].z),
+                .uv = aiMesh->mTextureCoords[0] != nullptr ? glm::vec2(aiMesh->mTextureCoords[0][i].x, aiMesh->mTextureCoords[0][i].y) : glm::vec2(0.0f),
+                .normal = aiMesh->mNormals != nullptr ? glm::vec3(aiMesh->mNormals[i].x, aiMesh->mNormals[i].y, aiMesh->mNormals[i].z) : glm::vec3(0.0f),
+                .tangent = aiMesh->mTangents != nullptr ? glm::vec3(aiMesh->mTangents[i].x, aiMesh->mTangents[i].y, aiMesh->mTangents[i].z) : glm::vec3(0.0f)
+            };
+        };
+        const auto aiVtxToIdx = [aiMesh](uint32_t i) -> uint32_t {
+            return aiMesh->mFaces[i / 3].mIndices[i % 3];
+        };
+        return SubMesh{
+            .name = aiMesh->mName.C_Str(),
+            .transform = glm::mat4x4(1.0f),
+            .vertexBuffer = newDeviceLocalBuffer(device, commandBuffer, gfx::BufferUsage::vertexBuffer, std::views::iota(0u, aiMesh->mNumVertices) | std::views::transform(std::move(aiVtxToVtx))),
+            .indexBuffer = newDeviceLocalBuffer(device, commandBuffer, gfx::BufferUsage::indexBuffer, std::views::iota(0u, aiMesh->mNumFaces * 3) | std::views::transform(std::move(aiVtxToIdx))),
+            // .material = materials[aiMesh->mMaterialIndex],
+            .subMeshes = {}
+        };
+    };
+
+    commandBuffer.beginBlitPass();
+    auto flatSubMeshes = std::span(scene->mMeshes, scene->mNumMeshes) | std::views::transform(std::move(aiMeshToSubMesh)) | std::ranges::to<std::vector>();
+    commandBuffer.endBlitPass();
+
+    std::function<void(std::vector<SubMesh>&, aiNode*, glm::mat4x4)> addNode = [&](std::vector<SubMesh>& dest, aiNode* aiNode, glm::mat4x4 additionalTransform) {
+        glm::mat4x4 transform = additionalTransform * toGlmMat4(aiNode->mTransformation);
+
+        const auto nodeMeshToSubmesh = [&](uint32_t i) -> SubMesh {
+            SubMesh submesh = flatSubMeshes[i];
+            submesh.transform = transform;
+            return submesh;
+        };
+        auto subMeshes = std::span(aiNode->mMeshes, aiNode->mNumMeshes) | std::views::transform(std::move(nodeMeshToSubmesh));
+
+        for (auto* node : std::span(aiNode->mChildren, aiNode->mNumChildren))
+        {
+            if (subMeshes.empty())
+                addNode(dest, node, transform);
+            else
+            {
+                std::vector<SubMesh> subDest;
+                addNode(subDest, node, glm::mat4x4(1.0F));
+                APPEND_RANGE(subMeshes.front().subMeshes, subDest);
+            }
+        }
+        APPEND_RANGE(dest, subMeshes);
+    };
+
+    Mesh mesh = {
+        .name = scene->mRootNode->mName.C_Str(),
+        .subMeshes = std::span(scene->mRootNode->mMeshes, scene->mRootNode->mNumMeshes)
+                     | std::views::transform([&](uint32_t i) -> SubMesh {
+                           SubMesh submesh = flatSubMeshes[i];
+                           submesh.transform = glm::mat4x4(1.0F);
+                           return submesh;
+                       })
+                     | std::ranges::to<std::vector>()
+    };
+
+    for (auto* node : std::span(scene->mRootNode->mChildren, scene->mRootNode->mNumChildren))
+        addNode(mesh.subMeshes, node, glm::mat4x4(1.0F));
+
+    return mesh;
+}
+
+std::shared_ptr<gfx::Texture> AssetManager::loadTexture(gfx::Device& device, const std::filesystem::path& path, gfx::CommandBuffer& commandBuffer)
+{
+    using UniqueStbiUc = std::unique_ptr<stbi_uc, decltype(&stbi_image_free)>;
+
+    int width = 0;
+    int height = 0;
+    UniqueStbiUc bytes = UniqueStbiUc(stbi_load(path.string().c_str(), &width, &height, nullptr, STBI_rgb_alpha), stbi_image_free);
+    if (!bytes)
+        throw std::runtime_error("failed to load texture: " + path.string());
+    return loadTexture(device, std::bit_cast<const std::byte*>(bytes.get()), static_cast<uint32_t>(width), static_cast<uint32_t>(height), commandBuffer);
+}
+
+std::shared_ptr<gfx::Texture> AssetManager::loadTexture(gfx::Device& device, const std::byte* bytes, uint32_t width, uint32_t height, gfx::CommandBuffer& commandBuffer)
+{
+    assert(bytes);
+    std::shared_ptr<gfx::Texture> texture = device.newTexture(gfx::Texture::Descriptor{
+        .type = gfx::TextureType::texture2d,
+        .width = width,
+        .height = height,
+        .pixelFormat = gfx::PixelFormat::RGBA8Unorm,
+        .usages = gfx::TextureUsage::copyDestination | gfx::TextureUsage::shaderRead,
+        .storageMode = gfx::ResourceStorageMode::deviceLocal });
+    assert(texture);
+
+    std::shared_ptr<gfx::Buffer> stagingBuffer = device.newBuffer(gfx::Buffer::Descriptor{
+        .size = static_cast<size_t>(width) * static_cast<size_t>(height) * pixelFormatSize(gfx::PixelFormat::RGBA8Unorm),
+        .usages = gfx::BufferUsage::copySource,
+        .storageMode = gfx::ResourceStorageMode::hostVisible });
+    assert(stagingBuffer);
+
+    std::memcpy(stagingBuffer->content<uint32_t>(), bytes, stagingBuffer->size());
+
+    commandBuffer.beginBlitPass();
+    commandBuffer.copyBufferToTexture(stagingBuffer, texture);
+    commandBuffer.endBlitPass();
+
+    return texture;
+}
+
+Mesh AssetManager::loadBuiltInCube(gfx::Device& device, gfx::CommandBuffer& commandBuffer)
+{
+    constexpr auto vertices = std::to_array<Vertex>({
+        { {-1, -1, -1}, {0, 1}, {-1,  0,  0}, { 0,  1,  0} },
+        { {-1,  1, -1}, {1, 1}, {-1,  0,  0}, { 0,  1,  0} },
+        { {-1,  1,  1}, {1, 0}, {-1,  0,  0}, { 0,  1,  0} },
+        { {-1, -1,  1}, {0, 0}, {-1,  0,  0}, { 0,  1,  0} },
+        { {-1, -1,  1}, {0, 1}, { 0,  0,  1}, { 0,  1,  1} },
+        { {-1,  1,  1}, {1, 1}, { 0,  0,  1}, { 0,  1,  1} },
+        { { 1,  1,  1}, {1, 0}, { 0,  0,  1}, { 0,  1,  1} },
+        { { 1, -1,  1}, {0, 0}, { 0,  0,  1}, { 0,  1,  1} },
+        { { 1, -1,  1}, {0, 1}, { 1,  0,  0}, { 0,  1,  0} },
+        { { 1,  1,  1}, {1, 1}, { 1,  0,  0}, { 0,  1,  0} },
+        { { 1,  1, -1}, {1, 0}, { 1,  0,  0}, { 0,  1,  0} },
+        { { 1, -1, -1}, {0, 0}, { 1,  0,  0}, { 0,  1,  0} },
+        { { 1, -1, -1}, {1, 0}, { 0,  0, -1}, { 0, -1, -1} },
+        { { 1,  1, -1}, {0, 0}, { 0,  0, -1}, { 0, -1, -1} },
+        { {-1,  1, -1}, {0, 1}, { 0,  0, -1}, { 0, -1, -1} },
+        { {-1, -1, -1}, {1, 1}, { 0,  0, -1}, { 0, -1, -1} },
+        { {-1, -1,  1}, {0, 1}, { 0, -1,  0}, { 1,  0,  0} },
+        { { 1, -1,  1}, {1, 1}, { 0, -1,  0}, { 1,  0,  0} },
+        { { 1, -1, -1}, {1, 0}, { 0, -1,  0}, { 1,  0,  0} },
+        { {-1, -1, -1}, {0, 0}, { 0, -1,  0}, { 1,  0,  0} },
+        { { 1,  1,  1}, {0, 1}, { 0,  1,  0}, {-1,  0,  0} },
+        { {-1,  1,  1}, {1, 1}, { 0,  1,  0}, {-1,  0,  0} },
+        { {-1,  1, -1}, {1, 0}, { 0,  1,  0}, {-1,  0,  0} },
+        { { 1,  1, -1}, {0, 0}, { 0,  1,  0}, {-1,  0,  0} },
+    });
+
+    constexpr auto indices = std::to_array<uint32_t>({
+         2,  1,  0,  3,  2,  0,
+         6,  5,  4,  7,  6,  4,
+        10,  9,  8, 11, 10,  8,
+        14, 13, 12, 15, 14, 12,
+        18, 17, 16, 19, 18, 16,
+        22, 21, 20, 23, 22, 20
+    });
+
+    commandBuffer.beginBlitPass();
+    auto mesh = Mesh {
+        .name = "built_in_cube",
+        .subMeshes = std::vector<SubMesh> {
+            {
+                .name = "built_in_cube_submesh",
+                .transform = glm::mat4(1.0f),
+                .vertexBuffer = newDeviceLocalBuffer(device, commandBuffer, gfx::BufferUsage::vertexBuffer, vertices),
+                .indexBuffer = newDeviceLocalBuffer(device, commandBuffer, gfx::BufferUsage::indexBuffer, indices),
+                .subMeshes = {}
+            }
+        }
+    };
+    commandBuffer.endBlitPass();
+    return mesh;
+}
+
+} // namespace GE
diff --git a/src/AssetManagerView.cpp b/src/AssetManagerView.cpp
new file mode 100644
index 0000000..193e861
--- /dev/null
+++ b/src/AssetManagerView.cpp
@@ -0,0 +1,58 @@
+/*
+ * ---------------------------------------------------
+ * AssetManagerView.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/AssetManagerView.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <utility>
+
+namespace GE
+{
+
+AssetManagerView::AssetManagerView(AssetManager* assetManager)
+    : m_assetManager(assetManager)
+{
+    assert(m_assetManager);
+}
+
+AssetManagerView::AssetManagerView(AssetManager* assetManager, const std::map<VAssetPath, AssetID>& registredAssets)
+    : m_assetManager(assetManager)
+    , m_registredAssets(registredAssets)
+{
+    assert(m_assetManager);
+    for (const auto& [vAssetPath, assetID] : m_registredAssets)
+    {
+        if (assetID != BUILT_IN_CUBE_ASSET_ID)
+            m_assetManager->registerAsset(vAssetPath);
+        auto [it, inserted] = m_assets.insert(std::make_pair(assetID, vAssetPath));
+        assert(inserted);
+        s_nextAssetId = std::max(s_nextAssetId, assetID + 1);
+    }
+}
+
+void AssetManagerView::unloadAsset(AssetID assetId)
+{
+    assert(m_assetManager);
+    if (assetId == BUILT_IN_CUBE_ASSET_ID)
+        return m_assetManager->unloadBuiltInCube();
+    return m_assetManager->unloadAsset(m_assets.at(assetId));
+}
+
+void AssetManagerView::unloadAllAssets()
+{
+    assert(m_assetManager);
+    unloadAssets(m_assets | std::views::transform([](const auto& asset) { return asset.first; }));
+}
+
+AssetManagerView::~AssetManagerView()
+{
+    unloadAllAssets();
+}
+
+}
diff --git a/src/ECSWorld.cpp b/src/ECSWorld.cpp
new file mode 100644
index 0000000..ce09460
--- /dev/null
+++ b/src/ECSWorld.cpp
@@ -0,0 +1,117 @@
+/*
+ * ---------------------------------------------------
+ * ECSWorld.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/07/21 09:35:25
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/ECSWorld.hpp"
+
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <mutex>
+#include <ranges>
+#include <string>
+#include <typeinfo>
+
+namespace GE
+{
+
+ECSWorld::ECSWorld()
+{
+    m_archetypes.insert(std::make_pair(ArchetypeID{0}, Archetype()));
+}
+
+ECSWorld::EntityID ECSWorld::newEntityID()
+{
+    EntityID newEntityId;
+    if (m_availableEntityIDs.empty())
+        newEntityId = m_entityDatas.size();
+    else
+        newEntityId = *m_availableEntityIDs.begin();
+    registerEntityID(newEntityId);
+    return newEntityId;
+}
+
+void ECSWorld::registerEntityID(ECSWorld::EntityID id)
+{
+    assert(isValidEntityID(id) == false); // user is responsible to be sure the id is not already used
+
+    // new entity has no component so directly inserting in empty archetype (the one with only the entity id)
+    ArchetypeID newEntityArcId = { 0 };
+    Archetype& newEntityArchetype = m_archetypes[newEntityArcId];
+    uint64_t newEntityIdx = newEntityArchetype.allocateCollum();
+    auto it = m_availableEntityIDs.find(id);
+    if (it != m_availableEntityIDs.end())
+    {
+        m_availableEntityIDs.erase(it);
+        m_entityDatas[id] = EntityData{newEntityArcId, newEntityIdx};
+    }
+    else
+    {
+        if (id > m_entityDatas.size()) {
+            for (auto availableID : std::views::iota(m_entityDatas.size(), id))
+                m_availableEntityIDs.insert(availableID);
+            m_entityDatas.resize(id);
+        }
+        m_entityDatas.push_back(EntityData{newEntityArcId, newEntityIdx});
+    }
+    newEntityArchetype.getEntityID(newEntityIdx) = id;
+    assert(isValidEntityID(id));
+}
+
+void ECSWorld::deleteEntityID(EntityID entityId)
+{
+    assert(isValidEntityID(entityId));
+    Archetype& entityArch = m_archetypes[m_entityDatas[entityId].archetypeId];
+    uint64_t entityIdx = m_entityDatas[entityId].idx;
+
+    // last entity of the archetype will be move to the index of the delete entity
+    // so the idx in the entity datas need to be change
+    m_entityDatas[entityArch.getEntityID(entityArch.size() - 1)].idx = entityIdx;
+
+    if (entityIdx != entityArch.size() -1)
+    {
+        entityArch.destructCollum(entityIdx);
+        Archetype::moveComponents(entityArch, entityArch.size() - 1, entityArch, entityIdx);
+    }
+    entityArch.destructCollum(entityArch.size() - 1);
+    entityArch.freeLastCollum();
+
+    m_availableEntityIDs.insert(entityId);
+}
+
+uint32_t ECSWorld::componentCount()
+{
+    uint64_t count = 0;
+    for (auto& [id, arch] : m_archetypes)
+        count += (id.size() - 1) * arch.size();
+    assert(count <= UINT32_MAX);
+    return static_cast<uint32_t>(count);
+}
+
+ECSWorld::ComponentID ECSWorld::nextComponentID()
+{
+    // start at 1 because 0 is reserved for the entity id
+    static ComponentID id = 1;
+    return id++;
+};
+
+ECSWorld::ComponentID ECSWorld::componentID(const std::type_info& typeInfo)
+{
+    static std::mutex mutex;
+    static std::map<std::string, ComponentID> componentIDs;
+
+    std::lock_guard lock(mutex);
+
+    auto [it, inserted] = componentIDs.emplace(typeInfo.name(), 0);
+    if (inserted)
+        it->second = nextComponentID();
+
+    return it->second;
+}
+
+}
diff --git a/src/FrameGraph.cpp b/src/FrameGraph.cpp
new file mode 100644
index 0000000..e1bf232
--- /dev/null
+++ b/src/FrameGraph.cpp
@@ -0,0 +1,128 @@
+/*
+ * ---------------------------------------------------
+ * FrameGraph.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/FrameGraph.hpp"
+#include "Graphics/Enums.hpp"
+
+#include <Graphics/Texture.hpp>
+#include <Graphics/Buffer.hpp>
+
+#include <stdexcept>
+
+namespace GE
+{
+
+FrameGraph::FrameGraph(const Descriptor& desc)
+    : m_passes(desc.passes)
+    , m_backBufferName(desc.backBufferName)
+{
+    // Process texture declarations - all go into m_textureDescriptors including back buffer
+    for (const TextureDescriptor& texture : desc.textures)
+    {
+        const gfx::Texture::Descriptor newDescriptor{
+            .width = texture.size.first,
+            .height = texture.size.second,
+            .pixelFormat = texture.pixelFormat,
+            .usages = {},
+        };
+
+        auto [it, inserted] = m_textureDescriptors.emplace(texture.name, newDescriptor);
+        if (!inserted)
+            throw std::runtime_error("Duplicate texture declaration for \"" + texture.name + "\"");
+    }
+
+    // Process constant buffer declarations from graph level
+    for (const ConstantBufferDescriptor& cbDesc : desc.constantBuffers)
+    {
+        gfx::Buffer::Descriptor bufferDesc{
+            .size = cbDesc.size,
+            .usages = gfx::BufferUsage::constantBuffer,
+            .storageMode = gfx::ResourceStorageMode::hostVisible
+        };
+
+        auto [it, inserted] = m_constantBufferDescriptors.emplace(cbDesc.name, bufferDesc);
+        if (!inserted)
+            throw std::runtime_error("Duplicate constant buffer declaration for \"" + cbDesc.name + "\"");
+    }
+
+    // Process structured buffer declarations from graph level
+    for (const StructuredBufferDescriptor& sbDesc : desc.structuredBuffers)
+    {
+        auto [it, inserted] = m_structuredBufferNames.insert(sbDesc.name);
+        if (!inserted)
+            throw std::runtime_error("Duplicate structured buffer declaration for \"" + sbDesc.name + "\"");
+    }
+
+    // Process resource declarations from passes
+    for (const FramePass& pass : m_passes)
+    {
+        for (const TextureDescriptor& texture : pass.textureDeclarations)
+        {
+            const gfx::Texture::Descriptor newDescriptor{
+                .width = texture.size.first,
+                .height = texture.size.second,
+                .pixelFormat = texture.pixelFormat,
+                .usages = {},
+            };
+
+            auto [it, inserted] = m_textureDescriptors.emplace(texture.name, newDescriptor);
+            if (!inserted)
+                throw std::runtime_error("Duplicate texture declaration for \"" + texture.name + "\"");
+        }
+
+        for (const ConstantBufferDescriptor& cbDesc : pass.constantBufferDeclarations)
+        {
+            gfx::Buffer::Descriptor bufferDesc{
+                .size = cbDesc.size,
+                .usages = gfx::BufferUsage::constantBuffer,
+                .storageMode = gfx::ResourceStorageMode::hostVisible
+            };
+
+            auto [it, inserted] = m_constantBufferDescriptors.emplace(cbDesc.name, bufferDesc);
+            if (!inserted)
+                throw std::runtime_error("Duplicate constant buffer declaration for \"" + cbDesc.name + "\"");
+        }
+
+        for (const StructuredBufferDescriptor& sbDesc : pass.structuredBufferDeclarations)
+        {
+            auto [it, inserted] = m_structuredBufferNames.insert(sbDesc.name);
+            if (!inserted)
+                throw std::runtime_error("Duplicate structured buffer declaration for \"" + sbDesc.name + "\"");
+        }
+    }
+
+    // Add texture usage flags based on how passes reference the textures
+    auto addUsageToTexture = [&](const std::string& name, gfx::TextureUsages usage) {
+        auto it = m_textureDescriptors.find(name);
+        if (it == m_textureDescriptors.end())
+            throw std::runtime_error("Texture \"" + name + "\" is used but not declared");
+        it->second.usages |= usage;
+    };
+
+    for (const FramePass& pass : m_passes)
+    {
+        for (const AttachmentDescriptor& colorAttachment : pass.colorAttachments)
+            addUsageToTexture(colorAttachment.texture, gfx::TextureUsage::colorAttachment);
+
+        if (pass.depthAttachment)
+            addUsageToTexture(pass.depthAttachment->texture, gfx::TextureUsage::depthStencilAttachment);
+
+        for (const std::string& sampledTexture : pass.sampledTextures)
+            addUsageToTexture(sampledTexture, gfx::TextureUsage::shaderRead);
+
+        // Validate usedBuffers reference declared buffers
+        for (const std::string& bufferName : pass.usedBuffers)
+        {
+            if (m_constantBufferDescriptors.find(bufferName) == m_constantBufferDescriptors.end()
+                && m_structuredBufferNames.find(bufferName) == m_structuredBufferNames.end())
+                throw std::runtime_error("Buffer \"" + bufferName + "\" is used but not declared");
+        }
+    }
+}
+
+}
diff --git a/src/FramePassBuilder.cpp b/src/FramePassBuilder.cpp
new file mode 100644
index 0000000..5c16939
--- /dev/null
+++ b/src/FramePassBuilder.cpp
@@ -0,0 +1,192 @@
+/*
+ * ---------------------------------------------------
+ * FramePassBuilder.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/FramePassBuilder.hpp"
+#include "Game-Engine/Components.hpp"
+#include "Game-Engine/ECSView.hpp"
+#include "Game-Engine/Entity.hpp"
+#include "Game-Engine/ICamera.hpp"
+#include "Game-Engine/Mesh.hpp"
+
+#include "shaders/FrameData.slang"
+#include "shaders/Light.slang"
+#include "shaders/flat_color.slang"
+
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <cassert>
+#include <functional>
+#include <future>
+#include <limits>
+#include <memory>
+#include <vector>
+
+namespace GE
+{
+
+FlatGeometryPassBuilder::FlatGeometryPassBuilder(const Scene* scene, const ICamera* camera)
+    : FlatGeometryPassBuilder(
+        [scene]() { return scene; },
+        [camera]() { return camera; })
+{
+}
+
+FlatGeometryPassBuilder::FlatGeometryPassBuilder(std::function<const Scene*()> sceneProvider, std::function<const ICamera*()> cameraProvider)
+    : m_sceneProvider(std::move(sceneProvider))
+    , m_cameraProvider(std::move(cameraProvider))
+{
+    assert(m_sceneProvider);
+    assert(m_cameraProvider);
+}
+
+FramePass FlatGeometryPassBuilder::build() const
+{
+    GE::FramePass framePass = FramePassBuilderBase<FlatGeometryPassBuilder>::build();
+    const std::string colorAttachmentName = m_colorAttachment.texture;
+
+    framePass.constantBufferDeclarations = {
+        { .name = "frameData", .size = sizeof(shader::FrameData) },
+        { .name = "material",  .size = sizeof(shader::flat_color::Material) },
+    };
+    framePass.structuredBufferDeclarations = {
+        { .name = "directionalLights" },
+        { .name = "pointLights" },
+    };
+    framePass.usedBuffers.insert(framePass.usedBuffers.end(), {
+        "frameData", "material", "directionalLights", "pointLights"
+    });
+
+    framePass.setup = [sceneProvider=m_sceneProvider, cameraProvider=m_cameraProvider, colorAttachmentName](FramePassSetupContext& ctx)
+    {
+        const Scene* scene = sceneProvider();
+        assert(scene);
+        assert(colorAttachmentName.empty() == false);
+
+        const std::shared_ptr<gfx::Texture>& colorAttachment = ctx.textureMap.at(colorAttachmentName);
+        assert(colorAttachment->height() != 0);
+        const float aspectRatio = static_cast<float>(colorAttachment->width()) / static_cast<float>(colorAttachment->height());
+
+        shader::FrameData& frameData = *ctx.constantBuffers.at("frameData")->content<shader::FrameData>();
+        if (const ICamera* camera = cameraProvider())
+        {
+            frameData.vpMatrix = camera->viewProjectionMatrix(aspectRatio);
+            frameData.cameraPosition = camera->position();
+        }
+        else
+        {
+            const_Entity activeCamera = scene->activeCamera();
+            assert(activeCamera.world != nullptr);
+            assert(activeCamera.world->isValidEntityID(activeCamera.entityId));
+            assert(activeCamera.has<TransformComponent>());
+            assert(activeCamera.has<CameraComponent>());
+
+            const glm::vec3 position = activeCamera.worldPosition();
+            const glm::mat3 rotation = activeCamera.worldRotation();
+            const glm::vec3 direction = rotation * glm::vec3(0.0f, 0.0f, -1.0f);
+            const glm::vec3 up = rotation * glm::vec3(0.0f, 1.0f, 0.0f);
+
+            frameData.vpMatrix = activeCamera.get<CameraComponent>().projectionMatrix(aspectRatio) * glm::lookAt(position, position + direction, up);
+            frameData.cameraPosition = position;
+        }
+        frameData.ambientLightColor = glm::vec3(1.0f, 1.0f, 1.0f) * 0.1f;
+
+        std::vector<shader::DirectionalLight> directionalLights;
+        std::vector<shader::PointLight> pointLights;
+        for (GE::const_Entity entity : scene->ecsWorld()
+                                       | const_ECSView<TransformComponent, LightComponent>()
+                                       | std::views::transform([&](auto id){ return GE::const_Entity{&scene->ecsWorld(), id}; }))
+        {
+            const LightComponent& light = entity.get<LightComponent>();
+            switch (light.type)
+            {
+            case LightComponent::Type::directional:
+                directionalLights.push_back({
+                    .position = entity.worldTransform()[3],
+                    .color = light.color * light.intentsity,
+                });
+                break;
+            case LightComponent::Type::point:
+                pointLights.push_back({
+                    .position = entity.worldTransform()[3],
+                    .color = light.color * light.intentsity,
+                    .attenuation = light.attenuation
+                });
+                break;
+            }
+        }
+
+        const size_t directionalCount = directionalLights.size();
+        const size_t pointCount = pointLights.size();
+
+        assert(directionalCount <= static_cast<size_t>(std::numeric_limits<int>::max()));
+        assert(pointCount <= static_cast<size_t>(std::numeric_limits<int>::max()));
+        frameData.directionalLightCount = static_cast<int>(directionalCount);
+        frameData.pointLightCount = static_cast<int>(pointCount);
+
+        const size_t directionalBufferBytes = (directionalCount > 0 ? directionalCount : 1) * sizeof(shader::DirectionalLight);
+        const size_t pointBufferBytes = (pointCount > 0 ? pointCount : 1) * sizeof(shader::PointLight);
+        assert(directionalBufferBytes <= std::numeric_limits<uint32_t>::max());
+        assert(pointBufferBytes <= std::numeric_limits<uint32_t>::max());
+
+        ctx.setStructuredBufferContent("directionalLights", directionalLights.data(), static_cast<uint32_t>(directionalBufferBytes));
+        ctx.setStructuredBufferContent("pointLights", pointLights.data(), static_cast<uint32_t>(pointBufferBytes));
+
+        shader::flat_color::Material& material = *ctx.constantBuffers.at("material")->content<shader::flat_color::Material>();
+        material.diffuseColor = glm::vec4(1.0f);
+        material.specularColor = glm::vec3(0.0f);
+        material.shininess = 0.0f;
+    };
+
+    framePass.execute = [sceneProvider=m_sceneProvider](FramePassExecuteContext& ctx)
+    {
+        const Scene* scene = sceneProvider();
+        assert(scene);
+
+        std::shared_ptr<gfx::ParameterBlock> frameDataPBlock = ctx.parameterBlockPool.get(ctx.frameDataBlockLayout);
+        frameDataPBlock->setBinding(0, ctx.bufferMap.at("frameData"));
+        frameDataPBlock->setBinding(1, ctx.bufferMap.at("directionalLights"));
+        frameDataPBlock->setBinding(2, ctx.bufferMap.at("pointLights"));
+
+        std::shared_ptr<gfx::ParameterBlock> materialPBlock = ctx.parameterBlockPool.get(ctx.materialBlockLayout);
+        materialPBlock->setBinding(0, ctx.bufferMap.at("material"));
+
+        ctx.commandBuffer.usePipeline(ctx.gfxPipeline);
+        ctx.commandBuffer.setParameterBlock(frameDataPBlock, 0);
+        ctx.commandBuffer.setParameterBlock(materialPBlock, 1);
+
+        for (auto entity : scene->ecsWorld() | const_ECSView<TransformComponent, MeshComponent>() | std::views::transform([&](auto id){ return GE::const_Entity{&scene->ecsWorld(), id}; }))
+        {
+            const MeshComponent& meshComponent = entity.get<MeshComponent>();
+            // ? maybe i should not load asset here, just skip them, so user is require to load assets befor using
+            // ? loading here could cause unexpected asset load
+            std::shared_future<const std::shared_ptr<Mesh>&> meshFuture = scene->assetManagerView().loadAsset<Mesh>(meshComponent);
+            if (meshFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
+            {
+                std::shared_ptr<Mesh> loadedMesh = meshFuture.get();
+
+                std::function<void(const SubMesh&, glm::mat4)> drawSubmesh = [&](const SubMesh& submesh, const glm::mat4& transform) {
+                    glm::mat4 modelMatrix = transform * submesh.transform;
+
+                    for (auto& childSubmesh : submesh.subMeshes)
+                        drawSubmesh(childSubmesh, modelMatrix);
+
+                    ctx.commandBuffer.setPushConstants(&modelMatrix);
+                    ctx.commandBuffer.useVertexBuffer(submesh.vertexBuffer);
+                    ctx.commandBuffer.drawIndexedVertices(submesh.indexBuffer);
+                };
+
+                for (auto& submesh : loadedMesh->subMeshes)
+                    drawSubmesh(submesh, entity.worldTransform());
+            }
+        }
+    };
+
+    return framePass;
+}
+
+}
diff --git a/src/Game.cpp b/src/Game.cpp
new file mode 100644
index 0000000..8d5704c
--- /dev/null
+++ b/src/Game.cpp
@@ -0,0 +1,91 @@
+/*
+ * ---------------------------------------------------
+ * Game.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/Game.hpp"
+#include "Game-Engine/ScriptLibrary.hpp"
+#include "Game-Engine/ECSView.hpp"
+#include "Game-Engine/Scene.hpp"
+#include "Game-Engine/AssetManager.hpp"
+
+#include <cassert>
+#include <ranges>
+#include <utility>
+
+namespace GE
+{
+
+namespace
+{
+
+void setupScene(Game& game, Scene& scene, const ScriptLibrary* scriptLibrary)
+{
+    scene.load();
+    if (scriptLibrary)
+    {
+        for (Entity entity : scene.ecsWorld() | ECSView<ScriptComponent>() | std::views::transform([&](auto id) { return Entity{ &scene.ecsWorld(), id }; }))
+        {
+            ScriptComponent& scriptComponent = entity.get<ScriptComponent>();
+            scriptComponent.instance = scriptLibrary->makeScriptInstance(scriptComponent.name);
+            assert(scriptComponent.instance);
+            for (const std::string& parameterName : scriptLibrary->listScriptParameterNames(scriptComponent.name))
+            {
+                auto it = scriptComponent.parameters.find(parameterName);
+                scriptLibrary->setScriptParameter(
+                    scriptComponent.name,
+                    parameterName,
+                    *scriptComponent.instance,
+                    it == scriptComponent.parameters.end() ? scriptLibrary->getScriptDefaultParameterValue(scriptComponent.name, parameterName) : it->second
+                );
+            }
+            scriptComponent.instance->setup(entity, game);
+        }
+    }
+}
+
+void tearDownScene(Game& game, Scene& scene)
+{
+    for (Entity entity : scene.ecsWorld() | ECSView<ScriptComponent>() | std::views::transform([&](auto id) { return Entity{ &scene.ecsWorld(), id }; }))
+    {
+        ScriptComponent& scriptComponent = entity.get<ScriptComponent>();
+        if (scriptComponent.instance != nullptr)
+            scriptComponent.instance->teardown(entity, game);
+        scriptComponent.instance.reset();
+    }
+    scene.unload();
+}
+
+}
+
+Game::Game(AssetManager* assetManager, const ScriptLibrary* scriptLibrary, const Descriptor& descriptor)
+    : m_scenes(descriptor.scenes
+               | std::views::transform([&](const auto& sceneDesc) {
+                     return std::make_pair(sceneDesc.first, Scene(assetManager, sceneDesc.second));
+                 })
+               | std::ranges::to<std::map<std::string, Scene>>())
+    , m_inputContext(descriptor.inputContext)
+    , m_scriptLibrary(scriptLibrary)
+{
+    setActiveScene(descriptor.activeScene);
+}
+
+void Game::setActiveScene(const std::string& name)
+{
+    if (m_activeScene)
+        tearDownScene(*this, *m_activeScene);
+    m_activeScene = &m_scenes.at(name);
+    setupScene(*this, *m_activeScene, m_scriptLibrary);
+}
+
+Game::~Game()
+{
+    assert(m_activeScene);
+    tearDownScene(*this, *m_activeScene);
+    m_inputContext.clearAllInputCallbacks();
+}
+
+}
diff --git a/src/InputContext.cpp b/src/InputContext.cpp
new file mode 100644
index 0000000..69028e6
--- /dev/null
+++ b/src/InputContext.cpp
@@ -0,0 +1,68 @@
+/*
+ * ---------------------------------------------------
+ * InputContext.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/InputContext.hpp"
+
+#include <cassert>
+#include <optional>
+#include <utility>
+
+namespace GE
+{
+
+void InputContext::addInput(const std::string& name, const VInput& input)
+{
+    auto [_, insterted] = m_inputs.insert(std::make_pair(name, input));
+    assert(insterted);
+}
+
+void InputContext::removeInput(const std::string& name)
+{
+    m_inputs.erase(name);
+}
+
+bool InputContext::renameInput(const std::string& oldName, const std::string& newName)
+{
+    if (oldName == newName)
+        return true;
+
+    assert(newName.empty() == false);
+    const VInput input = m_inputs.at(oldName);
+    m_inputs.erase(oldName);
+    auto [_, inserted] = m_inputs.emplace(newName, input);
+    assert(inserted);
+    return inserted;
+}
+
+void InputContext::clearAllInputCallbacks()
+{
+    for (auto& [_, vInput] : m_inputs)
+        std::visit([&](auto& input) { input.callback = {}; }, vInput);
+}
+
+void InputContext::onInputEvent(InputEvent& event)
+{
+    for (auto& [_, vInput] : m_inputs)
+    {
+        std::visit([&](auto& input)
+        {
+            if (input.mapper == std::nullopt)
+                return;
+            std::visit([&](auto& mapper){ mapper.onInputEvent(event); }, *input.mapper);
+        },
+        vInput);
+    }
+}
+
+void InputContext::dispatchInputs()
+{
+    for (auto& [_, vInput] : m_inputs)
+        std::visit([](auto& input) { input.dispatch(); }, vInput);
+}
+
+}
diff --git a/src/InputMapper.cpp b/src/InputMapper.cpp
new file mode 100644
index 0000000..c333158
--- /dev/null
+++ b/src/InputMapper.cpp
@@ -0,0 +1,171 @@
+/*
+ * ---------------------------------------------------
+ * InputMapper.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/InputMapper.hpp"
+#include "Game-Engine/Input.hpp" // IWYU pragma: keep
+
+#include <cmath>
+#include <glm/geometric.hpp>
+
+namespace GE
+{
+
+InputMapper<KeyboardButton, ActionInput>::InputMapper(KeyboardButton button)
+    : button(button)
+{
+}
+
+void InputMapper<KeyboardButton, ActionInput>::onInputEvent(InputEvent& event)
+{
+    if (input == nullptr)
+        return;
+    event.dispatch<KeyDownEvent>([this, &event](const KeyDownEvent& keyDownEvent)
+    {
+        if (event.processed())
+            return;
+        if (keyDownEvent.keyCode() == static_cast<int>(button) && keyDownEvent.isRepeat() == false)
+        {
+            input->triggered = true;
+            event.markAsProcessed();
+        }
+    });
+}
+
+InputMapper<KeyboardButton, StateInput>::InputMapper(KeyboardButton button)
+    : button(button)
+{
+}
+
+void InputMapper<KeyboardButton, StateInput>::onInputEvent(InputEvent& event)
+{
+    if (input == nullptr)
+        return;
+    event.dispatch<KeyDownEvent>([this, &event](const KeyDownEvent& keyDownEvent)
+    {
+        if (event.processed())
+            return;
+        if (keyDownEvent.keyCode() == static_cast<int>(button))
+        {
+            input->triggered = true;
+            event.markAsProcessed();
+        }
+    });
+    event.dispatch<KeyUpEvent>([this, &event](const KeyUpEvent& keyUpEvent)
+    {
+        if (keyUpEvent.keyCode() == static_cast<int>(button))
+        {
+            input->triggered = false;
+            event.markAsProcessed();
+        }
+    });
+}
+
+InputMapper<KeyboardButton, RangeInput>::InputMapper(KeyboardButton button, float scale)
+    : button(button)
+    , scale(scale)
+{
+}
+
+void InputMapper<KeyboardButton, RangeInput>::onInputEvent(InputEvent& event)
+{
+    if (input == nullptr)
+        return;
+    event.dispatch<KeyDownEvent>([this, &event](const KeyDownEvent& keyDownEvent)
+    {
+        if (event.processed())
+            return;
+        if (keyDownEvent.keyCode() == static_cast<int>(button))
+        {
+            input->value = scale;
+            input->triggered = true;
+            event.markAsProcessed();
+        }
+    });
+    event.dispatch<KeyUpEvent>([this, &event](const KeyUpEvent& keyUpEvent)
+    {
+        if (keyUpEvent.keyCode() == static_cast<int>(button))
+        {
+            input->value = 0.0f;
+            input->triggered = false;
+            event.markAsProcessed();
+        }
+    });
+}
+
+InputMapper<KeyboardButton, Range2DInput>::InputMapper(const Descriptor& desc)
+    : xPos(desc.xPos) , xNeg(desc.xNeg) , xScale(desc.xScale)
+    , yPos(desc.yPos) , yNeg(desc.yNeg) , yScale(desc.yScale)
+    , triggerValue(desc.triggerValue)
+{
+}
+
+void InputMapper<KeyboardButton, Range2DInput>::onInputEvent(InputEvent& event)
+{
+    if (input == nullptr)
+        return;
+
+    auto updateInputValue = [&]()
+    {
+        glm::vec2 rawValue = { 0.0f, 0.0f };
+
+        if (xPosPressed)
+            rawValue.x += xScale;
+        if (xNegPressed)
+            rawValue.x -= xScale;
+        if (yPosPressed)
+            rawValue.y += yScale;
+        if (yNegPressed)
+            rawValue.y -= yScale;
+
+        if (std::abs(rawValue.x) > 0.0f || std::abs(rawValue.y) > 0.0f)
+            input->value = glm::normalize(rawValue);
+        else
+            input->value = {0.0f, 0.0f};
+
+        input->triggered = std::abs(input->value.x) >= triggerValue || std::abs(input->value.y) >= triggerValue;
+    };
+
+    event.dispatch<KeyDownEvent>([&](const KeyDownEvent& keyDownEvent)
+    {
+        if (event.processed() || keyDownEvent.isRepeat())
+            return;
+
+        if (keyDownEvent.keyCode() == static_cast<int>(xPos))
+            xPosPressed = true;
+        else if (keyDownEvent.keyCode() == static_cast<int>(xNeg))
+            xNegPressed = true;
+        else if (keyDownEvent.keyCode() == static_cast<int>(yPos))
+            yPosPressed = true;
+        else if (keyDownEvent.keyCode() == static_cast<int>(yNeg))
+            yNegPressed = true;
+        else
+            return;
+
+        updateInputValue();
+        event.markAsProcessed();
+    });
+
+    event.dispatch<KeyUpEvent>([&](const KeyUpEvent& keyUpEvent)
+    {
+        if (keyUpEvent.keyCode() == static_cast<int>(xPos))
+            xPosPressed = false;
+        else if (keyUpEvent.keyCode() == static_cast<int>(xNeg))
+            xNegPressed = false;
+        else if (keyUpEvent.keyCode() == static_cast<int>(yPos))
+            yPosPressed = false;
+        else if (keyUpEvent.keyCode() == static_cast<int>(yNeg))
+            yNegPressed = false;
+        else
+            return;
+
+        updateInputValue();
+        event.markAsProcessed();
+    });
+}
+
+}
diff --git a/src/Renderer.cpp b/src/Renderer.cpp
new file mode 100644
index 0000000..afc65b5
--- /dev/null
+++ b/src/Renderer.cpp
@@ -0,0 +1,250 @@
+/*
+ * ---------------------------------------------------
+ * Renderer.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/08/09 15:54:42
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/Renderer.hpp"
+#include "Game-Engine/FrameGraph.hpp"
+#include "Game-Engine/Mesh.hpp"
+
+#include <Graphics/CommandBuffer.hpp>
+#include <Graphics/Drawable.hpp>
+#include <Graphics/Framebuffer.hpp>
+#include <Graphics/Texture.hpp>
+#include <Graphics/GraphicsPipeline.hpp>
+#include <Graphics/Enums.hpp>
+#include <Graphics/Buffer.hpp>
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <optional>
+#include <print>
+#include <string>
+#include <utility>
+#include <vector>
+#include <ranges>
+
+namespace GE
+{
+
+Renderer::Renderer(gfx::Device* device, gfx::Surface* surface)
+    : m_device(device), m_surface(surface)
+{
+    m_frameDataBlockLayout = m_device->newParameterBlockLayout({
+        .bindings = {
+            { .type = gfx::BindingType::constantBuffer,   .usages = gfx::BindingUsage::vertexRead | gfx::BindingUsage::fragmentRead },
+            { .type = gfx::BindingType::structuredBuffer, .usages = gfx::BindingUsage::vertexRead | gfx::BindingUsage::fragmentRead },
+            { .type = gfx::BindingType::structuredBuffer, .usages = gfx::BindingUsage::vertexRead | gfx::BindingUsage::fragmentRead }
+        }
+    });
+    m_materialBlockLayout = m_device->newParameterBlockLayout({
+        .bindings = {
+            { .type = gfx::BindingType::constantBuffer, .usages = gfx::BindingUsage::fragmentRead }
+        }
+    });
+
+    auto shaderLib = m_device->newShaderLib(SHADER_DIR"/flat_color.slib");
+
+    m_gfxPipeline = m_device->newGraphicsPipeline(gfx::GraphicsPipeline::Descriptor{
+        .vertexLayout = gfx::VertexLayout{
+            .stride = sizeof(Vertex),
+            .attributes = {
+                gfx::VertexAttribute{
+                    .format = gfx::VertexAttributeFormat::float3,
+                    .offset = offsetof(Vertex, pos)},
+                gfx::VertexAttribute{
+                    .format = gfx::VertexAttributeFormat::float3,
+                    .offset = offsetof(Vertex, normal)},
+            }
+        },
+        .vertexShader = &shaderLib->getFunction("vertexMain"),
+        .fragmentShader = &shaderLib->getFunction("fragmentMain"),
+        .colorAttachmentPxFormats = {gfx::PixelFormat::BGRA8Unorm},
+        .depthAttachmentPxFormat = gfx::PixelFormat::Depth32Float,
+        .blendOperation = gfx::BlendOperation::blendingOff,
+        .cullMode = gfx::CullMode::back,
+        .parameterBlockLayouts = {
+            m_frameDataBlockLayout,
+            m_materialBlockLayout
+        }
+    });
+
+    for (auto& inFlightData : m_inFlightDatas)
+    {
+        inFlightData.commandBufferPool = m_device->newCommandBufferPool();
+        assert(inFlightData.commandBufferPool);
+
+        inFlightData.parameterBlockPool = m_device->newParameterBlockPool({
+            .maxBindingCount = {
+                {gfx::BindingType::constantBuffer, 2},
+                {gfx::BindingType::structuredBuffer, 2},
+            }
+        });
+        assert(inFlightData.parameterBlockPool);
+    }
+
+}
+
+void Renderer::renderFrame(const FrameGraph& frameGraph)
+{
+    if (cfd.waitedCmdBuffer != nullptr)
+    {
+        m_device->waitCommandBuffer(*cfd.waitedCmdBuffer);
+        cfd.waitedCmdBuffer = nullptr;
+        cfd.commandBufferPool->reset();
+        cfd.parameterBlockPool->reset();
+    }
+
+    std::map<std::string, std::shared_ptr<gfx::Texture>> textureMap;
+    std::map<gfx::Texture::Descriptor, std::set<std::shared_ptr<gfx::Texture>>> newTextureCache;
+    for (auto& [textureName, textureDescriptor] : frameGraph.textureDescriptors())
+    {
+        if (textureName == frameGraph.backBufferName() && (m_swapchain == nullptr || m_swapchain->drawablesTextureDescriptor() != textureDescriptor))
+        {
+            gfx::Swapchain::Descriptor swapchainDescriptor = {
+                .surface = m_surface,
+                .width = textureDescriptor.width,
+                .height = textureDescriptor.height,
+                .imageCount = 3,
+                .drawableCount = maxFrameInFlight,
+                .pixelFormat = textureDescriptor.pixelFormat,
+                .presentMode = gfx::PresentMode::fifo,
+            };
+            // std::println("recreating swapchain with size w:{}, h:{}", swapchainDescriptor.width, swapchainDescriptor.height);
+            m_device->waitIdle();
+            m_swapchain = m_device->newSwapchain(swapchainDescriptor);
+            assert(m_swapchain);
+        }
+        else
+        {
+            std::shared_ptr<gfx::Texture> texture;
+            auto it = cfd.textureCache.find(textureDescriptor);
+            if (it == cfd.textureCache.end() || it->second.empty())
+                texture = m_device->newTexture(textureDescriptor);
+            else
+                texture = it->second.extract(it->second.begin()).value();
+            auto [_, inserted] = textureMap.insert(std::make_pair(textureName, texture));
+            assert(inserted);
+            newTextureCache[textureDescriptor].insert(texture);
+        }
+    }
+
+    std::map<std::string, std::shared_ptr<gfx::Buffer>> bufferMap;
+    std::map<gfx::Buffer::Descriptor, std::set<std::shared_ptr<gfx::Buffer>>> newBufferCache;
+    for (auto& [bufferName, bufferDescriptor] : frameGraph.constantBufferDescriptors())
+    {
+        std::shared_ptr<gfx::Buffer> buffer;
+        auto it = cfd.bufferCache.find(bufferDescriptor);
+        if (it == cfd.bufferCache.end() || it->second.empty())
+            buffer = m_device->newBuffer(bufferDescriptor);
+        else
+            buffer = it->second.extract(it->second.begin()).value();
+        auto [_, inserted] = bufferMap.insert(std::make_pair(bufferName, buffer));
+        assert(inserted);
+        newBufferCache[bufferDescriptor].insert(buffer);
+    }
+
+    auto setStructuredBufferContent = [&](const std::string& bufferName, const void* data, uint32_t size) {
+        if (size == 0)
+            return;
+        gfx::Buffer::Descriptor bufferDescriptor = gfx::Buffer::Descriptor{
+            .size = size,
+            .usages = gfx::BufferUsage::structuredBuffer,
+            .storageMode = gfx::ResourceStorageMode::hostVisible
+        };
+        std::shared_ptr<gfx::Buffer> buffer;
+        auto it = cfd.bufferCache.find(bufferDescriptor);
+        if (it == cfd.bufferCache.end() || it->second.empty())
+            buffer = m_device->newBuffer(bufferDescriptor);
+        else
+            buffer = it->second.extract(it->second.begin()).value();
+        auto [_, inserted] = bufferMap.insert(std::make_pair(bufferName, buffer));
+        assert(inserted);
+        newBufferCache[bufferDescriptor].insert(buffer);
+        if (data != nullptr)
+            std::memcpy(buffer->content<std::byte>(), data, size);
+    };
+
+    std::shared_ptr<gfx::CommandBuffer> commandBuffer = cfd.commandBufferPool->get();
+    std::shared_ptr<gfx::Drawable> drawable;
+    for (auto& framePass : frameGraph.passes())
+    {
+        if (drawable == nullptr /* TODO check if pass uses swapchain image */)
+        {
+            drawable = m_swapchain->nextDrawable();
+            if (drawable == nullptr)
+                return;
+            textureMap[frameGraph.backBufferName()] = drawable->texture();
+        }
+
+        if (framePass.setup)
+        {
+            FramePassSetupContext setupContext = {
+                .textureMap = textureMap,
+                .constantBuffers = bufferMap,
+                .setStructuredBufferContent = setStructuredBufferContent,
+            };
+            framePass.setup(setupContext);
+        }
+
+        gfx::Framebuffer framebuffer = gfx::Framebuffer{
+            .colorAttachments = framePass.colorAttachments
+                                | std::views::transform([&](const AttachmentDescriptor& attachment) {
+                                      return gfx::Framebuffer::Attachment{
+                                          .loadAction = attachment.loadAction,
+                                          .clearColor = attachment.clearColor,
+                                          .texture = textureMap.at(attachment.texture)
+                                      };
+                                  })
+                                | std::ranges::to<std::vector>(),
+            .depthAttachment = framePass.depthAttachment
+                                   ? std::make_optional(gfx::Framebuffer::Attachment{
+                                         .loadAction = framePass.depthAttachment->loadAction,
+                                         .clearDepth = framePass.depthAttachment->clearDepth,
+                                         .texture = textureMap.at(framePass.depthAttachment->texture) })
+                                   : std::nullopt
+        };
+
+        for (auto& textureName : framePass.sampledTextures)
+            commandBuffer->addSampledTexture(textureMap.at(textureName));
+
+        commandBuffer->beginRenderPass(framebuffer);
+        {
+            FramePassExecuteContext framePassContext = {
+                .commandBuffer = *commandBuffer,
+                .parameterBlockPool = *cfd.parameterBlockPool,
+                .textureMap = textureMap,
+                .bufferMap = bufferMap,
+                .frameDataBlockLayout = m_frameDataBlockLayout,
+                .materialBlockLayout = m_materialBlockLayout,
+                .gfxPipeline = m_gfxPipeline
+            };
+            framePass.execute(framePassContext);
+        }
+        commandBuffer->endRenderPass();
+    }
+
+    if (drawable)
+        commandBuffer->presentDrawable(drawable);
+
+    m_device->submitCommandBuffers(commandBuffer);
+    cfd.waitedCmdBuffer = commandBuffer.get();
+
+    cfd.textureCache = std::move(newTextureCache);
+    cfd.bufferCache = std::move(newBufferCache);
+    m_frameIdx = (m_frameIdx + 1) % maxFrameInFlight;
+}
+
+Renderer::~Renderer()
+{
+    m_device->waitIdle();
+}
+
+} // namespace GE
diff --git a/src/Scene.cpp b/src/Scene.cpp
new file mode 100644
index 0000000..8c2961d
--- /dev/null
+++ b/src/Scene.cpp
@@ -0,0 +1,85 @@
+/*
+ * ---------------------------------------------------
+ * Scene.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2024/09/08 12:10:58
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/Scene.hpp"
+
+#include "Game-Engine/Components.hpp"
+
+#include <type_traits>
+#include <variant>
+
+namespace GE
+{
+
+Scene::Scene(AssetManager* assetManager, const std::string& name)
+    : m_assetManagerView(assetManager)
+    , m_name(name)
+{
+}
+
+Scene::Scene(AssetManager* assetManager, const Descriptor& desc)
+    : m_assetManagerView(assetManager, desc.registredAssets)
+    , m_name(desc.name)
+    , m_activeCamera(desc.activeCamera)
+{
+    for (auto& [id, vComponents] : desc.entities) {
+        m_ecsWorld.registerEntityID(id);
+        for (auto& vComponent : vComponents) {
+            std::visit([&](auto& component) {
+                m_ecsWorld.emplace<std::remove_cvref_t<decltype(component)>>(id, component);
+            }, vComponent);
+        }
+    }
+}
+
+void Scene::setActiveCamera(const Entity& e)
+{
+    assert(e.world == &m_ecsWorld);
+    m_activeCamera = e.entityId;
+}
+
+Entity Scene::newEntity(const std::string& name)
+{
+    Entity newEntity(&m_ecsWorld, m_ecsWorld.newEntityID());
+    newEntity.emplace<NameComponent>(name);
+    return newEntity;
+}
+
+Scene::Descriptor Scene::makeDescriptor() const
+{
+    Scene::Descriptor desc;
+    desc.name = m_name;
+    desc.activeCamera = m_activeCamera;
+    desc.registredAssets = m_assetManagerView.registredAssets();
+
+    for (ECSWorld::EntityID entityId : m_ecsWorld)
+    {
+        std::vector<ComponentVariant> components;
+        const_Entity entity{&m_ecsWorld, entityId};
+
+        forEachType<ECSComponentTypes>([&]<typename ComponentT>() {
+            if (!entity.has<ComponentT>())
+                return;
+
+            if constexpr (std::is_same_v<ComponentT, ScriptComponent>) {
+                ScriptComponent scriptComponent = entity.get<ScriptComponent>();
+                // TODO find a solution to not have to do that
+                scriptComponent.instance.reset();
+                components.emplace_back(std::move(scriptComponent));
+            } else
+                components.emplace_back(entity.get<ComponentT>());
+        });
+
+        desc.entities.emplace(entityId, std::move(components));
+    }
+
+    return desc;
+}
+
+}
diff --git a/src/ScriptLibrary.cpp b/src/ScriptLibrary.cpp
new file mode 100644
index 0000000..d221536
--- /dev/null
+++ b/src/ScriptLibrary.cpp
@@ -0,0 +1,123 @@
+/*
+ * ---------------------------------------------------
+ * ScriptLibrary.cpp
+ *
+ * Author: Thomas Choquet <thomas.publique@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/ScriptLibrary.hpp"
+
+#include <dlLoad/dlLoad.h>
+
+#include <format>
+#include <stdexcept>
+
+namespace GE
+{
+
+ScriptLibrary::ScriptLibrary(const std::filesystem::path& path)
+{
+    DlHandle handle = dlLoad(path.string().c_str(), DL_NOW | DL_LOCAL);
+    if (handle == nullptr)
+        throw std::runtime_error(std::format("unable to load shared lib : {}", path.string()));
+
+    m_libraryHandle = std::shared_ptr<void>(handle, [](void* ptr) {
+        if (ptr != nullptr)
+            dlFree(ptr);
+    });
+    m_listScriptNames = reinterpret_cast<ListScriptNamesSym>(getSym(handle, "listScriptNames"));
+    m_listScriptParameterNames = reinterpret_cast<ListScriptParameterNamesSym>(getSym(handle, "listScriptParameterNames"));
+    m_getScriptParameterTypeName = reinterpret_cast<GetScriptParameterTypeNameSym>(getSym(handle, "getScriptParameterTypeName"));
+    m_getScriptDefaultParameterValue = reinterpret_cast<GetScriptDefaultParameterValueSym>(getSym(handle, "getScriptDefaultParameterValue"));
+    m_setScriptParameter = reinterpret_cast<SetScriptParameterSym>(getSym(handle, "setScriptParameter"));
+    m_makeScriptInstance = reinterpret_cast<MakeScriptInstanceSym>(getSym(handle, "makeScriptInstance"));
+    m_destroyScriptInstance = reinterpret_cast<DestroyScriptInstanceSym>(getSym(handle, "destroyScriptInstance"));
+
+    if (m_listScriptNames == nullptr
+        || m_listScriptParameterNames == nullptr
+        || m_getScriptParameterTypeName == nullptr
+        || m_getScriptDefaultParameterValue == nullptr
+        || m_setScriptParameter == nullptr
+        || m_makeScriptInstance == nullptr
+        || m_destroyScriptInstance == nullptr)
+    {
+        throw std::runtime_error(std::format("unable to get symbols in lib : {}", path.string()));
+    }
+}
+
+std::vector<std::string> ScriptLibrary::listScriptNames() const
+{
+    const char** names = nullptr;
+    size_t count = 0;
+    m_listScriptNames(&names, &count);
+
+    std::vector<std::string> output;
+    output.reserve(count);
+    for (size_t i = 0; i < count; i++)
+        output.emplace_back(names[i]);
+    return output;
+}
+
+std::vector<std::string> ScriptLibrary::listScriptParameterNames(const std::string& scriptName) const
+{
+    const char** parameterNames = nullptr;
+    size_t count = 0;
+    m_listScriptParameterNames(scriptName.c_str(), &parameterNames, &count);
+
+    std::vector<std::string> output;
+    output.reserve(count);
+    for (size_t i = 0; i < count; i++)
+        output.emplace_back(parameterNames[i]);
+    return output;
+}
+
+std::string ScriptLibrary::getScriptParameterTypeName(const std::string& scriptName, const std::string& parameterName) const
+{
+    return m_getScriptParameterTypeName(scriptName.c_str(), parameterName.c_str());
+}
+
+VScriptValue ScriptLibrary::getScriptDefaultParameterValue(const std::string& scriptName, const std::string& parameterName) const
+{
+    const char* typeName = m_getScriptParameterTypeName(scriptName.c_str(), parameterName.c_str());
+    VScriptValue defaultValue = false;
+    const bool matchedDefaultType = anyOfType<ScriptValueTypes>([&]<typename T>() {
+        if (ScriptValueTraits<T>::name != typeName)
+            return false;
+
+        T value{};
+        m_getScriptDefaultParameterValue(scriptName.c_str(), parameterName.c_str(), &value);
+        defaultValue = VScriptValue(value);
+        return true;
+    });
+    assert(matchedDefaultType);
+    return defaultValue;
+}
+
+void ScriptLibrary::setScriptParameter(const std::string& scriptName, const std::string& parameterName, Script& script, const VScriptValue& value) const
+{
+    const char* typeName = m_getScriptParameterTypeName(scriptName.c_str(), parameterName.c_str());
+    const bool matchedSetType = anyOfType<ScriptValueTypes>([&]<typename T>() {
+        if (ScriptValueTraits<T>::name != typeName)
+            return false;
+
+        T typedValue = std::get<T>(value);
+        m_setScriptParameter(scriptName.c_str(), parameterName.c_str(), &script, &typedValue);
+        return true;
+    });
+    assert(matchedSetType);
+}
+
+std::shared_ptr<Script> ScriptLibrary::makeScriptInstance(const std::string& scriptName) const
+{
+    Script* script = m_makeScriptInstance(scriptName.c_str());
+    if (script == nullptr)
+        return {};
+
+    return std::shared_ptr<Script>(script, [libraryHandle = m_libraryHandle, destroyScriptInstanceFn = m_destroyScriptInstance](Script* ptr) {
+        (void)libraryHandle;
+        destroyScriptInstanceFn(ptr);
+    });
+}
+
+} // namespace GE
diff --git a/src/Window.cpp b/src/Window.cpp
new file mode 100644
index 0000000..faceb20
--- /dev/null
+++ b/src/Window.cpp
@@ -0,0 +1,247 @@
+//
+// ---------------------------------------------------
+// Window.cpp
+//
+// Author: Thomas Choquet <thomas.publique@icloud.com>
+// ---------------------------------------------------
+//
+
+#include "Game-Engine/Window.hpp"
+#include "Game-Engine/Event.hpp"
+
+#include <GLFW/glfw3.h>
+
+#include <cassert>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace GE
+{
+
+Window::Window(const Descriptor& desc)
+{
+    ::glfwDefaultWindowHints();
+    ::glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+
+    m_glfwWindow = ::glfwCreateWindow(desc.width, desc.height, desc.title, nullptr, nullptr);
+    assert(m_glfwWindow);
+
+    using CallbackMap = std::unordered_map<void*, std::deque<std::function<void(Event&)>>>;
+
+    glfwSetWindowUserPointer(m_glfwWindow, this);
+
+    ::glfwSetKeyCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, int key, int, int action, int) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        if (action == GLFW_PRESS)
+        {
+            KeyDownEvent keyDownEvent(window, key, false);
+            for (auto& [callbackKey, callbacks] : callbackMap)
+            {
+                for (auto& callback : callbacks)
+                    callback(keyDownEvent);
+            }
+        }
+        else if (action == GLFW_REPEAT)
+        {
+            KeyDownEvent keyDownEvent(window, key, true);
+            for (auto& [callbackKey, callbacks] : callbackMap)
+            {
+                for (auto& callback : callbacks)
+                    callback(keyDownEvent);
+            }
+        }
+        else if (action == GLFW_RELEASE)
+        {
+            KeyUpEvent keyUpEvent(window, key);
+            for (auto& [callbackKey, callbacks] : callbackMap)
+            {
+                for (auto& callback : callbacks)
+                    callback(keyUpEvent);
+            }
+        }
+    });
+
+    ::glfwSetMouseButtonCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, int button, int action, int) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        auto [x, y] = window.cursorPos();
+
+        if (action == GLFW_PRESS)
+        {
+            MouseDownEvent mouseDownEvent(window, x, y, button);
+            for (auto& [callbackKey, callbacks] : callbackMap)
+            {
+                for (auto& callback : callbacks)
+                    callback(mouseDownEvent);
+            }
+        }
+        else if (action == GLFW_RELEASE)
+        {
+            MouseUpEvent mouseUpEvent(window, (int)x, (int)y, button);
+            for (auto& [callbackKey, callbacks] : callbackMap)
+            {
+                for (auto& callback : callbacks)
+                    callback(mouseUpEvent);
+            }
+        }
+    });
+
+    ::glfwSetScrollCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, double xoffset, double yoffset) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        auto [x, y] = window.cursorPos();
+
+        ScrollEvent scrollEvent(window, x, y, xoffset, yoffset);
+        for (auto& [callbackKey, callbacks] : callbackMap)
+        {
+            for (auto& callback : callbacks)
+                callback(scrollEvent);
+        }
+    });
+
+    ::glfwSetCharCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, unsigned int codepoint) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        CharEvent charEvent(window, codepoint);
+        for (auto& [callbackKey, callbacks] : callbackMap)
+        {
+            for (auto& callback : callbacks)
+                callback(charEvent);
+        }
+    });
+
+    ::glfwSetCursorPosCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, double x, double y) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        MouseMoveEvent mouseMoveEvent(window, x, y);
+        for (auto& [callbackKey, callbacks] : callbackMap)
+        {
+            for (auto& callback : callbacks)
+                callback(mouseMoveEvent);
+        }
+    });
+
+    ::glfwSetWindowSizeCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, int width, int height) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        WindowResizeEvent windowResizeEvent(window, width, height);
+        for (auto& [callbackKey, callbacks] : callbackMap)
+        {
+            for (auto& callback : callbacks)
+                callback(windowResizeEvent);
+        }
+    });
+
+    ::glfwSetWindowCloseCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        CallbackMap callbackMap = window.m_eventCallbacks;
+
+        ::glfwSetWindowShouldClose(glfwWindow, GLFW_FALSE);
+
+        WindowRequestCloseEvent windowRequestCloseEvent(window);
+        for (auto& [key, val] : callbackMap)
+        {
+            for (auto& callback : val)
+                callback(windowRequestCloseEvent);
+        }
+    });
+
+    ::glfwSetDropCallback(m_glfwWindow, [](::GLFWwindow* glfwWindow, int count, const char** paths) {
+        Window& window = *static_cast<Window*>(glfwGetWindowUserPointer(glfwWindow));
+        for (int i = 0; i < count; i++)
+        {
+            std::filesystem::path path = std::filesystem::path(paths[i]);
+            assert(path.is_absolute());
+            assert(std::filesystem::exists(path));
+            window.m_droppedFilePool.insert(path);
+        }
+    });
+}
+
+std::pair<uint32_t, uint32_t> Window::size() const
+{
+    int w, h;
+    ::glfwGetWindowSize(m_glfwWindow, &w, &h);
+    return std::make_pair(static_cast<uint32_t>(w), static_cast<uint32_t>(h));
+}
+
+std::pair<uint32_t, uint32_t> Window::frameBufferSize() const
+{
+    int w, h;
+    ::glfwGetFramebufferSize(m_glfwWindow, &w, &h);
+    return std::make_pair(static_cast<uint32_t>(w), static_cast<uint32_t>(h));
+}
+
+std::pair<float, float> Window::contentScale() const
+{
+    float x, y;
+    ::glfwGetWindowContentScale(m_glfwWindow, &x, &y);
+    return std::make_pair(x, y);
+}
+
+bool Window::isPressed(KeyboardButton btn)
+{
+    return ::glfwGetKey(m_glfwWindow, static_cast<int>(btn)) == GLFW_PRESS;
+}
+
+bool Window::isPressed(MouseButton key)
+{
+    return ::glfwGetMouseButton(m_glfwWindow, static_cast<int>(key)) == GLFW_PRESS;
+}
+
+std::pair<double, double> Window::cursorPos() const
+{
+    double x, y;
+    ::glfwGetCursorPos(m_glfwWindow, &x, &y);
+    return std::make_pair(x, y);
+}
+
+void Window::setCursorPos(double x, double y)
+{
+    ::glfwSetCursorPos(m_glfwWindow, x, y);
+}
+
+void Window::setCursorVisibility(bool value)
+{
+    ::glfwSetInputMode(m_glfwWindow, GLFW_CURSOR, value ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN);
+}
+
+std::optional<std::filesystem::path> Window::popDroppedFile()
+{
+    if (m_droppedFilePool.empty())
+        return std::nullopt;
+    auto node = m_droppedFilePool.extract(m_droppedFilePool.begin());
+    return node.value();
+}
+
+std::string Window::clipboardString() const
+{
+    return ::glfwGetClipboardString(m_glfwWindow);
+}
+
+void Window::setClipboardString(const std::string& str) const
+{
+    ::glfwSetClipboardString(m_glfwWindow, str.c_str());
+}
+
+void Window::createSurface(gfx::Instance* instance)
+{
+    m_surface = instance->createSurface(m_glfwWindow);
+    assert(m_surface);
+}
+
+Window::~Window()
+{
+    ::glfwDestroyWindow(m_glfwWindow);
+}
+
+} // namespace GE
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..f08fd1c
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,40 @@
+/*
+ * ---------------------------------------------------
+ * main.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include "Game-Engine/Application.hpp"
+
+#include <imgui.h>
+
+#include <memory>
+
+#if (defined(__GNUC__) || defined(__clang__))
+    #define GE_EXPORT __attribute__((used, visibility("default")))
+#elif defined(_MSC_VER)
+    #define GE_EXPORT __declspec(dllexport)
+#else
+    #error "unknown compiler"
+#endif
+
+extern "C"
+{
+    GE_EXPORT ImGuiContext* GetCurrentContext() { return ImGui::GetCurrentContext(); }
+    GE_EXPORT ImGuiIO* GetIO() { return &ImGui::GetIO(); }
+    GE_EXPORT ImGuiPlatformIO* GetPlatformIO() { return &ImGui::GetPlatformIO(); }
+    GE_EXPORT ImGuiViewport* GetMainViewport() { return ImGui::GetMainViewport(); }
+    GE_EXPORT bool DebugCheckVersionAndDataLayout(const char* version_str, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_drawvert, size_t sz_drawidx) { return ImGui::DebugCheckVersionAndDataLayout(version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx); }
+    GE_EXPORT void* MemAlloc(size_t size) { return ImGui::MemAlloc(size); }
+    GE_EXPORT void MemFree(void* ptr) { return ImGui::MemFree(ptr); }
+    GE_EXPORT void DestroyPlatformWindows() { return ImGui::DestroyPlatformWindows(); }
+}
+
+extern std::unique_ptr<GE::Application> createApplication(int argc, char* argv[]);
+
+int main(int argc, char* argv[])
+{
+    createApplication(argc, argv)->run();
+}
diff --git a/tests/AssetManager_testCases.cpp b/tests/AssetManager_testCases.cpp
new file mode 100644
index 0000000..980d646
--- /dev/null
+++ b/tests/AssetManager_testCases.cpp
@@ -0,0 +1,251 @@
+/*
+ * ---------------------------------------------------
+ * AssetManager_testCases.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/AssetManagerView.hpp"
+#include "Game-Engine/Scene.hpp"
+
+#include <Graphics/Buffer.hpp>
+#include <Graphics/CommandBuffer.hpp>
+#include <Graphics/CommandBufferPool.hpp>
+#include <Graphics/Device.hpp>
+#include <Graphics/Texture.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <vector>
+
+namespace GE_tests
+{
+
+namespace
+{
+
+class MockBuffer final : public gfx::Buffer
+{
+public:
+    explicit MockBuffer(const Descriptor& desc)
+        : m_desc(desc)
+        , m_bytes(desc.size)
+    {
+    }
+
+    size_t size() const override { return m_desc.size; }
+    gfx::BufferUsages usages() const override { return m_desc.usages; }
+    gfx::ResourceStorageMode storageMode() const override { return m_desc.storageMode; }
+
+    void setContent(const void* data, size_t size) override
+    {
+        if (size > m_bytes.size())
+            throw std::runtime_error("buffer overflow in mock buffer");
+        std::memcpy(m_bytes.data(), data, size);
+    }
+
+protected:
+    void* contentVoid() override { return m_bytes.data(); }
+
+private:
+    Descriptor m_desc;
+    std::vector<std::byte> m_bytes;
+};
+
+class TestTexture final : public gfx::Texture
+{
+public:
+    explicit TestTexture(const Descriptor& desc)
+        : m_desc(desc)
+    {
+    }
+
+    gfx::TextureType type() const override { return m_desc.type; }
+    uint32_t width() const override { return m_desc.width; }
+    uint32_t height() const override { return m_desc.height; }
+    gfx::PixelFormat pixelFormat() const override { return m_desc.pixelFormat; }
+    gfx::TextureUsages usages() const override { return m_desc.usages; }
+    gfx::ResourceStorageMode storageMode() const override { return m_desc.storageMode; }
+
+#if defined(GFX_IMGUI_ENABLED)
+    void initImTextureId() override {}
+    std::optional<uint64_t> imTextureId() const override { return std::nullopt; }
+#endif
+
+private:
+    Descriptor m_desc;
+};
+
+class MockCommandBuffer : public gfx::CommandBuffer
+{
+public:
+    MOCK_METHOD(void, beginRenderPass, (const gfx::Framebuffer&), (override));
+    MOCK_METHOD(void, usePipeline, ((const std::shared_ptr<const gfx::GraphicsPipeline>&)), (override));
+    MOCK_METHOD(void, useVertexBuffer, ((const std::shared_ptr<gfx::Buffer>&)), (override));
+    MOCK_METHOD(void, setParameterBlock, ((const std::shared_ptr<const gfx::ParameterBlock>&), uint32_t), (override));
+    MOCK_METHOD(void, setPushConstants, (const void*, size_t), (override));
+    MOCK_METHOD(void, drawVertices, (uint32_t, uint32_t), (override));
+    MOCK_METHOD(void, drawIndexedVertices, ((const std::shared_ptr<gfx::Buffer>&)), (override));
+#if defined(GFX_IMGUI_ENABLED)
+    MOCK_METHOD(void, imGuiRenderDrawData, (ImDrawData*), (const, override));
+#endif
+    MOCK_METHOD(void, endRenderPass, (), (override));
+
+    MOCK_METHOD(void, beginBlitPass, (), (override));
+    MOCK_METHOD(void, copyBufferToBuffer, ((const std::shared_ptr<gfx::Buffer>&), (const std::shared_ptr<gfx::Buffer>&), size_t), (override));
+    MOCK_METHOD(void, copyBufferToTexture, ((const std::shared_ptr<gfx::Buffer>&), size_t, (const std::shared_ptr<gfx::Texture>&), uint32_t), (override));
+    MOCK_METHOD(void, endBlitPass, (), (override));
+    MOCK_METHOD(void, presentDrawable, ((const std::shared_ptr<gfx::Drawable>&)), (override));
+    MOCK_METHOD(void, addSampledTexture, ((const std::shared_ptr<gfx::Texture>&)), (override));
+};
+
+class MockCommandBufferPool : public gfx::CommandBufferPool
+{
+public:
+    MOCK_METHOD(std::shared_ptr<gfx::CommandBuffer>, get, (), (override));
+    MOCK_METHOD(void, reset, (), (override));
+};
+
+class MockDevice : public gfx::Device
+{
+public:
+    MOCK_METHOD(gfx::Backend, backend, (), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::Swapchain>, newSwapchain, (const gfx::Swapchain::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::ShaderLib>, newShaderLib, (const std::filesystem::path&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::ParameterBlockLayout>, newParameterBlockLayout, (const gfx::ParameterBlockLayout::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::GraphicsPipeline>, newGraphicsPipeline, (const gfx::GraphicsPipeline::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::Buffer>, newBuffer, (const gfx::Buffer::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::Texture>, newTexture, (const gfx::Texture::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::CommandBufferPool>, newCommandBufferPool, (), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::ParameterBlockPool>, newParameterBlockPool, (const gfx::ParameterBlockPool::Descriptor&), (const, override));
+    MOCK_METHOD(std::unique_ptr<gfx::Sampler>, newSampler, (const gfx::Sampler::Descriptor&), (const, override));
+
+#if defined(GFX_IMGUI_ENABLED)
+    MOCK_METHOD(void, imguiInit, (std::vector<gfx::PixelFormat>, std::optional<gfx::PixelFormat>), (const, override));
+    MOCK_METHOD(void, imguiNewFrame, (), (const, override));
+    MOCK_METHOD(void, imguiShutdown, (), (override));
+#endif
+
+    MOCK_METHOD(void, submitCommandBuffers, ((const std::shared_ptr<gfx::CommandBuffer>&)), (override));
+    MOCK_METHOD(void, submitCommandBuffers, ((const std::vector<std::shared_ptr<gfx::CommandBuffer>>&)), (override));
+    MOCK_METHOD(void, waitCommandBuffer, (const gfx::CommandBuffer&), (override));
+    MOCK_METHOD(void, waitIdle, (), (override));
+};
+
+class AssetManagerMockDeviceTest : public ::testing::Test
+{
+protected:
+    AssetManagerMockDeviceTest()
+        : m_commandBuffer(std::make_shared<testing::NiceMock<MockCommandBuffer>>())
+    {
+        ON_CALL(m_device, backend()).WillByDefault(testing::Return(gfx::Backend::metal));
+        ON_CALL(m_device, newBuffer(testing::_)).WillByDefault([](const gfx::Buffer::Descriptor& desc) {
+            return std::make_unique<MockBuffer>(desc);
+        });
+        ON_CALL(m_device, newTexture(testing::_)).WillByDefault([](const gfx::Texture::Descriptor& desc) {
+            return std::make_unique<TestTexture>(desc);
+        });
+        ON_CALL(m_device, newCommandBufferPool()).WillByDefault([this]() {
+            auto pool = std::make_unique<testing::NiceMock<MockCommandBufferPool>>();
+            ON_CALL(*pool, get()).WillByDefault(testing::Return(m_commandBuffer));
+            return pool;
+        });
+        ON_CALL(*m_commandBuffer, copyBufferToBuffer(testing::_, testing::_, testing::_)).WillByDefault([](const std::shared_ptr<gfx::Buffer>& src, const std::shared_ptr<gfx::Buffer>& dst, size_t size) {
+            dst->setContent(src->content<std::byte>(), size);
+        });
+    }
+
+    testing::NiceMock<MockDevice> m_device;
+    std::shared_ptr<testing::NiceMock<MockCommandBuffer>> m_commandBuffer;
+};
+
+std::filesystem::path dummyTexturePath()
+{
+    return std::filesystem::path(GE_TEST_RESOURCE_DIR) / "dummy_texture.png";
+}
+
+TEST_F(AssetManagerMockDeviceTest, reportsTextureLoadedState)
+{
+    const std::filesystem::path texturePath = dummyTexturePath();
+    ASSERT_TRUE(std::filesystem::is_regular_file(texturePath));
+
+    GE::AssetManager assetManager(&m_device);
+    GE::VAssetPath assetPath = GE::AssetPath<gfx::Texture>(texturePath);
+
+    assetManager.registerAsset(assetPath);
+
+    EXPECT_FALSE(assetManager.isAssetLoaded(assetPath));
+
+    assetManager.loadAsset<gfx::Texture>(assetPath).get();
+    EXPECT_TRUE(assetManager.isAssetLoaded(assetPath));
+
+    assetManager.unloadAsset(assetPath);
+    EXPECT_FALSE(assetManager.isAssetLoaded(assetPath));
+}
+
+TEST_F(AssetManagerMockDeviceTest, reportsBuiltInCubeLoadedState)
+{
+    GE::AssetManager assetManager(&m_device);
+    GE::AssetManagerView assetManagerView(&assetManager, {
+        { GE::AssetPath<GE::Mesh>(), GE::BUILT_IN_CUBE_ASSET_ID }
+    });
+
+    EXPECT_FALSE(assetManagerView.isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+
+    assetManagerView.loadAsset<GE::Mesh>(GE::BUILT_IN_CUBE_ASSET_ID).get();
+    EXPECT_TRUE(assetManagerView.isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+
+    assetManagerView.unloadAsset(GE::BUILT_IN_CUBE_ASSET_ID);
+    EXPECT_FALSE(assetManagerView.isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+}
+
+TEST_F(AssetManagerMockDeviceTest, loadAndUnloadAffectsAllRegisteredAssets)
+{
+    const std::filesystem::path texturePath = dummyTexturePath();
+    ASSERT_TRUE(std::filesystem::is_regular_file(texturePath));
+
+    GE::AssetManager assetManager(&m_device);
+    GE::VAssetPath textureAssetPath = GE::AssetPath<gfx::Texture>(texturePath);
+    assetManager.registerAsset(textureAssetPath);
+
+    constexpr GE::AssetID textureAssetId = 42;
+    GE::Scene scene(&assetManager, GE::Scene::Descriptor{
+        .name = "test_scene",
+        .activeCamera = INVALID_ENTITY_ID,
+        .registredAssets = {
+            { GE::AssetPath<GE::Mesh>(), GE::BUILT_IN_CUBE_ASSET_ID },
+            { textureAssetPath, textureAssetId }
+        },
+        .entities = {}
+    });
+
+    EXPECT_FALSE(scene.isLoaded());
+    EXPECT_FALSE(scene.assetManagerView().isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+    EXPECT_FALSE(scene.assetManagerView().isAssetLoaded(textureAssetId));
+
+    scene.load().get();
+
+    EXPECT_TRUE(scene.isLoaded());
+    EXPECT_TRUE(scene.assetManagerView().isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+    EXPECT_TRUE(scene.assetManagerView().isAssetLoaded(textureAssetId));
+
+    scene.unload();
+
+    EXPECT_FALSE(scene.isLoaded());
+    EXPECT_FALSE(scene.assetManagerView().isAssetLoaded(GE::BUILT_IN_CUBE_ASSET_ID));
+    EXPECT_FALSE(scene.assetManagerView().isAssetLoaded(textureAssetId));
+}
+
+} // namespace
+
+} // namespace GE_tests
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e84456c..f43263e 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -7,31 +7,57 @@
 
 include(FetchContent)
 include(GoogleTest)
+include(../cmake/ScriptLibrary.cmake)
 
-add_executable(ECS_test)
+add_executable(GE_test)
+set_target_properties(GE_test PROPERTIES ENABLE_EXPORTS ON)
 
-set_target_properties(ECS_test PROPERTIES
-    CXX_STANDARD          20
-    CXX_STANDARD_REQUIRED ON
-    FOLDER                "tests"
-)
+target_compile_features(GE_test PUBLIC cxx_std_23)
+set_target_properties(GE_test PROPERTIES FOLDER "tests")
 
-target_sources(ECS_test PRIVATE "ECS_testCases.cpp")
+file(GLOB SRC "*.cpp")
+target_sources(GE_test PRIVATE ${SRC})
 
-target_include_directories(ECS_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} "${CMAKE_SOURCE_DIR}/engine")
+target_include_directories(GE_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+target_compile_definitions(GE_test PRIVATE GE_TEST_RESOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}/resources")
 
 FetchContent_Declare(googletest
     GIT_REPOSITORY https://github.com/google/googletest.git
     GIT_TAG        main
     GIT_SHALLOW    v1.15.2
 )
-set(BUILD_GMOCK OFF)
+set(BUILD_GMOCK ON)
 set(INSTALL_GTEST OFF)
 FetchContent_MakeAvailable(googletest)
-
 set_target_properties(gtest PROPERTIES FOLDER "dependencies")
 set_target_properties(gtest_main PROPERTIES FOLDER "dependencies")
-target_link_libraries(ECS_test PRIVATE GTest::gtest_main)
-target_link_libraries(ECS_test PRIVATE Game-Engine)
-
-gtest_discover_tests(ECS_test)
\ No newline at end of file
+set_target_properties(gmock PROPERTIES FOLDER "dependencies")
+set_target_properties(gmock_main PROPERTIES FOLDER "dependencies")
+
+target_link_libraries(GE_test PRIVATE GTest::gmock GTest::gtest_main Game-Engine)
+target_include_directories(GE_test INTERFACE $<TARGET_PROPERTY:Game-Engine,INTERFACE_INCLUDE_DIRECTORIES>)
+
+add_subdirectory(scriptLib)
+
+target_compile_definitions(GE_test PRIVATE GE_TEST_SCRIPT_LIB="$<TARGET_FILE:GE_test_scriptLib>")
+
+gtest_discover_tests(GE_test)
+
+if(APPLE AND NOT CMAKE_GENERATOR STREQUAL "Xcode")
+    set(CODESIGN_IDENTITY "-" CACHE STRING "Codesigning identity")
+
+    set(GE_TEST_ENTITLEMENTS_FILE "${CMAKE_CURRENT_SOURCE_DIR}/ge-test.entitlements")
+    if(EXISTS "${GE_TEST_ENTITLEMENTS_FILE}")
+        add_custom_command(TARGET GE_test POST_BUILD
+            COMMAND /bin/sh -c "codesign --sign \"${CODESIGN_IDENTITY}\" --force --entitlements \"${GE_TEST_ENTITLEMENTS_FILE}\" \"$<TARGET_FILE:GE_test>\" >/dev/null 2>&1"
+            COMMENT "Codesigning GE_test (with entitlements) [identity: ${CODESIGN_IDENTITY}]"
+            VERBATIM
+        )
+    else()
+        add_custom_command(TARGET GE_test POST_BUILD
+            COMMAND /bin/sh -c "codesign --sign \"${CODESIGN_IDENTITY}\" --force \"$<TARGET_FILE:GE_test>\" >/dev/null 2>&1"
+            COMMENT "Codesigning GE_test [identity: ${CODESIGN_IDENTITY}]"
+            VERBATIM
+        )
+    endif()
+endif()
diff --git a/tests/ECS_testCases.cpp b/tests/ECS_testCases.cpp
index 7759d60..883d454 100644
--- a/tests/ECS_testCases.cpp
+++ b/tests/ECS_testCases.cpp
@@ -9,11 +9,13 @@
 
 #include <gtest/gtest.h>
 
-#include "ECS/ECSWorld.hpp"
-#include "ECS/ECSView.hpp"
-#include "UtilsCPP/Set.hpp"
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/ECSView.hpp"
 
-namespace ECS_tests
+#include <set>
+#include <vector>
+
+namespace GE_tests
 {
 
 using EntityID = GE::ECSWorld::EntityID;
@@ -66,7 +68,7 @@ TEST(ECSTest, newEntity)
     EXPECT_EQ(world.entityCount(), 2);
     EXPECT_EQ(world.archetypeCount(), 1);
     EXPECT_EQ(world.componentCount(), 0);
-    
+
     world.deleteEntityID(entity1);
     EXPECT_FALSE(world.isValidEntityID(entity1));
     EXPECT_EQ(world.entityCount(), 1);
@@ -91,7 +93,7 @@ TYPED_TEST(ECSTest, oneComponent)
     EXPECT_EQ(world.entityCount(), 1);
     EXPECT_EQ(world.archetypeCount(), 2);
     EXPECT_EQ(world.componentCount(), 1);
-    
+
     EXPECT_EQ(world.get<TypeParam>(entity).val(), 0);
 }
 
@@ -106,30 +108,22 @@ TEST(ECSTest, twoComponent)
     EXPECT_EQ(world.archetypeCount(), 2);
     EXPECT_EQ(world.componentCount(), 1);
 
-    #ifdef NDEBUG
-    EXPECT_ANY_THROW({
-        world.emplace<Component1>(entity, 1);
-    });
-    #else
+#ifndef NDEBUG
     EXPECT_DEATH({
         world.emplace<Component1>(entity, 1);
     }, "");
-    #endif
+#endif
 
     EXPECT_EQ(world.emplace<Component2>(entity, 2).val(), 2);
     EXPECT_EQ(world.entityCount(), 1);
     EXPECT_EQ(world.archetypeCount(), 3);
     EXPECT_EQ(world.componentCount(), 2);
 
-    #ifdef NDEBUG
-    EXPECT_ANY_THROW({
-        world.emplace<Component2>(entity, 2);
-    });
-    #else
+#ifndef NDEBUG
     EXPECT_DEATH({
         world.emplace<Component2>(entity, 2);
     }, "");
-    #endif
+#endif
 
     EXPECT_EQ(world.get<Component1>(entity).val(), 1);
     EXPECT_EQ(world.get<Component2>(entity).val(), 2);
@@ -171,7 +165,7 @@ TYPED_TEST(ECSTest, removeOneComponent)
     EntityID entity = world.newEntityID(); // 1 arch ({id})
     world.emplace<TypeParam>(entity, 1); // 2 arch ({id}, {id, TypeParam})
 
-    world.remove<TypeParam>(entity); 
+    world.remove<TypeParam>(entity);
     EXPECT_EQ(world.entityCount(), 1);
     EXPECT_EQ(world.archetypeCount(), 2); // 2 arch ({id}, {id, TypeParam})
     EXPECT_EQ(world.componentCount(), 0);
@@ -185,12 +179,12 @@ TEST(ECSTest, removeTwoComponent)
     world.emplace<Component1>(entity, 1); // 2 arch ({id}, {id, comp1})
     world.emplace<Component2>(entity, 1); // 3 arch ({id}, {id, comp1}, {id, comp1, comp2})
 
-    world.remove<Component1>(entity); 
+    world.remove<Component1>(entity);
     EXPECT_EQ(world.entityCount(), 1);
     EXPECT_EQ(world.archetypeCount(), 4); // 4 arch ({id}, {id, comp1}, {id, comp1, comp2}, {id, comp2})
     EXPECT_EQ(world.componentCount(), 1);
 
-    world.remove<Component2>(entity); 
+    world.remove<Component2>(entity);
     EXPECT_EQ(world.entityCount(), 1);
     EXPECT_EQ(world.archetypeCount(), 4); // 4 arch ({id}, {id, comp1}, {id, comp1, comp2}, {id, comp2})
     EXPECT_EQ(world.componentCount(), 0);
@@ -245,6 +239,28 @@ TEST(ECSTest, multipleEntityTwoComponent)
     EXPECT_EQ(world.componentCount(), 6);
 }
 
+TEST(ECSTest, worldRange)
+{
+    GE::ECSWorld world;
+
+    EntityID entity1 = world.newEntityID();
+    EntityID entity2 = world.newEntityID();
+    EntityID entity3 = world.newEntityID();
+
+    world.deleteEntityID(entity2);
+
+    EXPECT_EQ(std::ranges::distance(world), 2);
+
+    std::vector<EntityID> forward;
+    for (EntityID id : world)
+        forward.push_back(id);
+
+    ASSERT_EQ(forward.size(), 2);
+
+    EXPECT_EQ(forward[0], entity1);
+    EXPECT_EQ(forward[1], entity3);
+}
+
 TYPED_TEST(ECSTest, componentEdit)
 {
     GE::ECSWorld world;
@@ -294,57 +310,81 @@ TEST(ECSTest, view)
     world.emplace<Component2>(entity3, 3);
 
     {
-        GE::ECSView<Component1> view(world);
+        GE::ECSView<Component1> view = world | GE::ECSView<Component1>();
         EXPECT_EQ(view.count(), 2);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values;
+            std::set<EntityID> entities;
+            std::set<int> values;
+            std::set<int> structuredValues;
 
-            view.onEach([&](GE::Entity entity, Component1& comp){ 
-                entities.insert(entity.entityID());
-                values.insert(comp.val());
-            });
+            for (auto row : view)
+                entities.insert(static_cast<EntityID>(row));
+
+            for (auto [component1] : view)
+            {
+                values.insert(component1.val());
+                structuredValues.insert(component1.val());
+            }
 
             EXPECT_EQ(entities.size(), 2);
             EXPECT_EQ(values.size(), 2);
+            EXPECT_EQ(structuredValues.size(), 2);
         });
     }
     {
-        GE::ECSView<Component2> view(world);
+        GE::ECSView<Component2> view = world | GE::ECSView<Component2>();
         EXPECT_EQ(view.count(), 2);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values;
+            std::set<EntityID> entities;
+            std::set<int> values;
+            std::set<int> structuredValues;
+
+            for (auto row : view)
+                entities.insert(static_cast<EntityID>(row));
 
-            view.onEach([&](GE::Entity entity, Component2& comp){ 
-                entities.insert(entity.entityID());
-                values.insert(comp.val());
-            });
+            for (auto [component2] : view)
+            {
+                values.insert(component2.val());
+                structuredValues.insert(component2.val());
+            }
 
             EXPECT_EQ(entities.size(), 2);
             EXPECT_EQ(values.size(), 2);
+            EXPECT_EQ(structuredValues.size(), 2);
         });
     }
     {
-        GE::ECSView<Component1, Component2> view(world);
+        GE::ECSView<Component1, Component2> view = world | GE::ECSView<Component1, Component2>();
         EXPECT_EQ(view.count(), 1);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values1;
-            utils::Set<int> values2;
-
-            view.onEach([&](GE::Entity entity, Component1& comp1, Component2& comp2){ 
-                entities.insert(entity.entityID());
-                values1.insert(comp1.val());
-                values2.insert(comp2.val());
-            });
-
-            EXPECT_EQ(entities.size(), 1);
+            std::set<EntityID> entityIds;
+            std::set<int> values1;
+            std::set<int> values2;
+            std::set<int> structuredValues1;
+            std::set<int> structuredValues2;
+
+            for (auto row : view)
+                entityIds.insert(static_cast<EntityID>(row));
+
+            for (auto row : world | GE::ECSView<Component1, Component2>())
+                entityIds.insert(static_cast<EntityID>(row));
+
+            for (auto [component1, component2] : world | GE::ECSView<Component1, Component2>())
+            {
+                values1.insert(component1.val());
+                values2.insert(component2.val());
+                structuredValues1.insert(component1.val());
+                structuredValues2.insert(component2.val());
+            }
+
+            EXPECT_EQ(entityIds.size(), 1);
             EXPECT_EQ(values1.size(), 1);
             EXPECT_EQ(values2.size(), 1);
+            EXPECT_EQ(structuredValues1.size(), 1);
+            EXPECT_EQ(structuredValues2.size(), 1);
         });
     }
 }
@@ -363,60 +403,86 @@ TEST(ECSTest, constView)
     world.emplace<Component1>(entity3, 3);
     world.emplace<Component2>(entity3, 3);
 
+    const GE::ECSWorld& constWorld = world;
+
     {
-        GE::const_ECSView<Component1> view(const_cast<const GE::ECSWorld&>(world));
+        GE::const_ECSView<Component1> view = constWorld | GE::const_ECSView<Component1>();
         EXPECT_EQ(view.count(), 2);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values;
+            std::set<EntityID> entities;
+            std::set<int> values;
+            std::set<int> structuredValues;
 
-            view.onEach([&](const GE::Entity entity, const Component1& comp){ 
-                entities.insert(entity.entityID());
-                values.insert(comp.val());
-            });
+            for (auto row : view)
+                entities.insert(static_cast<EntityID>(row));
+
+            for (auto [component1] : view)
+            {
+                values.insert(component1.val());
+                structuredValues.insert(component1.val());
+            }
 
             EXPECT_EQ(entities.size(), 2);
             EXPECT_EQ(values.size(), 2);
+            EXPECT_EQ(structuredValues.size(), 2);
         });
     }
     {
-        GE::const_ECSView<Component2> view(const_cast<const GE::ECSWorld&>(world));
+        GE::const_ECSView<Component2> view = constWorld | GE::const_ECSView<Component2>();
         EXPECT_EQ(view.count(), 2);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values;
+            std::set<EntityID> entities;
+            std::set<int> values;
+            std::set<int> structuredValues;
+
+            for (auto row : view)
+                entities.insert(static_cast<EntityID>(row));
 
-            view.onEach([&](const GE::Entity entity, const Component2& comp){ 
-                entities.insert(entity.entityID());
-                values.insert(comp.val());
-            });
+            for (auto [component2] : view)
+            {
+                values.insert(component2.val());
+                structuredValues.insert(component2.val());
+            }
 
             EXPECT_EQ(entities.size(), 2);
             EXPECT_EQ(values.size(), 2);
+            EXPECT_EQ(structuredValues.size(), 2);
         });
     }
     {
-        GE::const_ECSView<Component1, Component2> view(const_cast<const GE::ECSWorld&>(world));
+        GE::const_ECSView<Component1, Component2> view = constWorld | GE::const_ECSView<Component1, Component2>();
         EXPECT_EQ(view.count(), 1);
 
         EXPECT_NO_THROW({
-            utils::Set<EntityID> entities;
-            utils::Set<int> values1;
-            utils::Set<int> values2;
-
-            view.onEach([&](const GE::Entity entity, const Component1& comp1, const Component2& comp2){ 
-                entities.insert(entity.entityID());
-                values1.insert(comp1.val());
-                values2.insert(comp2.val());
-            });
-
-            EXPECT_EQ(entities.size(), 1);
+            std::set<EntityID> entityIds;
+            std::set<int> values1;
+            std::set<int> values2;
+            std::set<int> structuredValues1;
+            std::set<int> structuredValues2;
+
+            for (auto row : view)
+                entityIds.insert(static_cast<EntityID>(row));
+
+            for (auto row : constWorld | GE::const_ECSView<Component1, Component2>())
+                entityIds.insert(static_cast<EntityID>(row));
+
+            for (auto [component1, component2] : constWorld | GE::const_ECSView<Component1, Component2>())
+            {
+                values1.insert(component1.val());
+                values2.insert(component2.val());
+                structuredValues1.insert(component1.val());
+                structuredValues2.insert(component2.val());
+            }
+
+            EXPECT_EQ(entityIds.size(), 1);
             EXPECT_EQ(values1.size(), 1);
             EXPECT_EQ(values2.size(), 1);
+            EXPECT_EQ(structuredValues1.size(), 1);
+            EXPECT_EQ(structuredValues2.size(), 1);
         });
     }
 }
 
-}
\ No newline at end of file
+}
diff --git a/tests/Entity_testCases.cpp b/tests/Entity_testCases.cpp
new file mode 100644
index 0000000..37eab5e
--- /dev/null
+++ b/tests/Entity_testCases.cpp
@@ -0,0 +1,241 @@
+/*
+ * ---------------------------------------------------
+ * Entity_testCases.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * Date: 2026/02/01 11:09:03
+ * ---------------------------------------------------
+ */
+
+#include <gtest/gtest.h>
+
+#include "Game-Engine/ECSWorld.hpp"
+#include "Game-Engine/Entity.hpp"
+#include "Game-Engine/Components.hpp"
+
+namespace GE_tests
+{
+
+namespace
+{
+
+GE::Entity makeEntity(GE::ECSWorld& world)
+{
+    return GE::Entity{
+        .world = &world,
+        .entityId = world.newEntityID()
+    };
+}
+
+}
+
+TEST(EntityTest, staticAssert)
+{
+    static_assert(GE::EntityLike<GE::Entity>, "Entity is not EntityLike");
+    static_assert(!GE::EntityLike<const GE::Entity>, "const Entity is EntityLike");
+    static_assert(GE::ConstEntityLike<GE::Entity>, "Entity is not ConstEntityLike");
+    static_assert(GE::ConstEntityLike<const GE::Entity>, "const Entity is not ConstEntityLike");
+
+    static_assert(!GE::EntityLike<GE::const_Entity>, "const_Entity is EntityLike");
+    static_assert(!GE::EntityLike<const GE::const_Entity>, "const const_Entity is EntityLike");
+    static_assert(GE::ConstEntityLike<GE::const_Entity>, "const_Entity is not ConstEntityLike");
+    static_assert(GE::ConstEntityLike<const GE::const_Entity>, "const const_Entity is not ConstEntityLike");
+}
+
+TEST(EntityTest, emplaceAndGetCameraComponent)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity = makeEntity(ecsWorld);
+
+    entity.emplace<GE::CameraComponent>().fov = 90.0f;
+    ASSERT_FLOAT_EQ(entity.get<GE::CameraComponent>().fov, 90.0f);
+}
+
+TEST(EntityTest, emplaceAndGetHierarchyComponent)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity = makeEntity(ecsWorld);
+
+    entity.emplace<GE::HierarchyComponent>().parent = 123;
+    ASSERT_FLOAT_EQ(entity.get<GE::HierarchyComponent>().parent, 123);
+}
+
+template<typename T>
+class EntityEmplaceRemoveHasTest : public testing::Test {};
+using EntityEmplaceRemoveHasTestedComponents = ::testing::Types<GE::TransformComponent, GE::HierarchyComponent>;
+TYPED_TEST_SUITE(EntityEmplaceRemoveHasTest, EntityEmplaceRemoveHasTestedComponents);
+
+TYPED_TEST(EntityEmplaceRemoveHasTest, _)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity = makeEntity(ecsWorld);
+
+    EXPECT_FALSE(entity.has<TypeParam>());
+
+    entity.emplace<TypeParam>();
+    EXPECT_TRUE(entity.has<TypeParam>());
+
+    entity.remove<TypeParam>();
+    EXPECT_FALSE(entity.has<TypeParam>());
+}
+
+TEST(EntityTest, nameAccess)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity = makeEntity(ecsWorld);
+
+    EXPECT_FALSE(entity.has<GE::NameComponent>());
+    EXPECT_EQ(entity.name(), GE::NameComponent().name);
+    EXPECT_TRUE(entity.has<GE::NameComponent>());
+    entity.name() = "Enemy";
+    EXPECT_EQ(entity.name(), "Enemy");
+    EXPECT_EQ(entity.get<GE::NameComponent>().name, "Enemy");
+}
+
+TEST(EntityTest, parentChildQueries)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity root = makeEntity(ecsWorld);
+    GE::Entity child1 = makeEntity(ecsWorld);
+    GE::Entity child2 = makeEntity(ecsWorld);
+
+    root.addChild(child1);
+    root.addChild(child2);
+
+    ASSERT_TRUE(root.firstChild().has_value());
+    EXPECT_EQ(*root.firstChild(), child1);
+
+    ASSERT_TRUE(child1.nextChild().has_value());
+    EXPECT_EQ(*child1.nextChild(), child2);
+    EXPECT_FALSE(child2.nextChild().has_value());
+
+    auto children = root.children();
+    ASSERT_EQ(children.size(), 2u);
+    EXPECT_EQ(children[0], child1);
+    EXPECT_EQ(children[1], child2);
+}
+
+TEST(EntityTest, isParentOf)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity root = makeEntity(ecsWorld);
+    GE::Entity child = makeEntity(ecsWorld);
+    GE::Entity grandChild = makeEntity(ecsWorld);
+
+    root.addChild(child);
+    child.addChild(grandChild);
+
+    EXPECT_TRUE(root.isParentOf(child));
+    EXPECT_TRUE(root.isParentOf(grandChild));
+    EXPECT_TRUE(child.isParentOf(grandChild));
+    EXPECT_FALSE(grandChild.isParentOf(root));
+}
+
+TEST(EntityTest, addChildWithAfter)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity root = makeEntity(ecsWorld);
+    GE::Entity child1 = makeEntity(ecsWorld);
+    GE::Entity child2 = makeEntity(ecsWorld);
+    GE::Entity child3 = makeEntity(ecsWorld);
+
+    root.addChild(child1);
+    root.addChild(child2);
+
+    root.addChild(child3, child1);
+
+    auto children = root.children();
+    ASSERT_EQ(children.size(), 3u);
+    EXPECT_EQ(children[0], child1);
+    EXPECT_EQ(children[1], child3);
+    EXPECT_EQ(children[2], child2);
+}
+
+TEST(EntityTest, removeChild)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity root = makeEntity(ecsWorld);
+    GE::Entity child1 = makeEntity(ecsWorld);
+    GE::Entity child2 = makeEntity(ecsWorld);
+    GE::Entity child3 = makeEntity(ecsWorld);
+
+    root.addChild(child1);
+    root.addChild(child2);
+    root.addChild(child3);
+
+    root.removeChild(child2);
+
+    EXPECT_FALSE(child2.parent().has_value());
+    EXPECT_FALSE(child2.nextChild().has_value());
+
+    auto children = root.children();
+    ASSERT_EQ(children.size(), 2u);
+    EXPECT_EQ(children[0], child1);
+    EXPECT_EQ(children[1], child3);
+}
+
+TEST(EntityTest, destroyEntity)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity parent = makeEntity(ecsWorld);
+    GE::Entity child1 = makeEntity(ecsWorld);
+    GE::Entity child2 = makeEntity(ecsWorld);
+
+    parent.addChild(child1);
+    parent.addChild(child2);
+
+    GE::ECSWorld::EntityID parentId = parent.entityId;
+    parent.destroy();
+
+    EXPECT_FALSE(ecsWorld.isValidEntityID(parentId));
+    EXPECT_EQ(parent.world, nullptr);
+    EXPECT_EQ(parent.entityId, INVALID_ENTITY_ID);
+
+    EXPECT_FALSE(child1.parent().has_value());
+    EXPECT_FALSE(child1.nextChild().has_value());
+    EXPECT_FALSE(child2.parent().has_value());
+    EXPECT_FALSE(child2.nextChild().has_value());
+}
+
+TEST(EntityTest, destroyChildUnlinksFromParent)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity parent = makeEntity(ecsWorld);
+    GE::Entity child = makeEntity(ecsWorld);
+
+    parent.addChild(child);
+
+    GE::ECSWorld::EntityID childId = child.entityId;
+    child.destroy();
+
+    EXPECT_FALSE(ecsWorld.isValidEntityID(childId));
+    EXPECT_FALSE(parent.firstChild().has_value());
+}
+
+TEST(EntityTest, equalityOperators)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity1 = makeEntity(ecsWorld);
+    GE::Entity entity2 = makeEntity(ecsWorld);
+    GE::Entity entity3 = entity1;
+
+    EXPECT_TRUE(entity1 == entity3);
+    EXPECT_FALSE(entity1 != entity3);
+    EXPECT_TRUE(entity1 != entity2);
+}
+
+TEST(EntityTest, conversionToConstEntity)
+{
+    GE::ECSWorld ecsWorld;
+    GE::Entity entity = makeEntity(ecsWorld);
+
+    GE::const_Entity constEntity = entity;
+    EXPECT_EQ(constEntity.world, entity.world);
+    EXPECT_EQ(constEntity.entityId, entity.entityId);
+
+    const GE::const_Entity constEntity2 = entity;
+    EXPECT_EQ(constEntity2.world, entity.world);
+    EXPECT_EQ(constEntity2.entityId, entity.entityId);
+}
+
+}
diff --git a/tests/Script_testCases.cpp b/tests/Script_testCases.cpp
new file mode 100644
index 0000000..17c554f
--- /dev/null
+++ b/tests/Script_testCases.cpp
@@ -0,0 +1,98 @@
+#include <Game-Engine/Script.hpp>
+#include <Game-Engine/ScriptLibrary.hpp>
+
+#include <dlLoad/dlLoad.h>
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+static_assert(GE::ScriptValueType<bool>);
+static_assert(GE::ScriptValueType<int64_t>);
+static_assert(GE::ScriptValueType<float>);
+static_assert(GE::ScriptValueType<glm::vec2>);
+static_assert(GE::ScriptValueType<glm::vec3>);
+static_assert(GE::ScriptValueType<std::string>);
+static_assert(!GE::ScriptValueType<double>);
+
+namespace
+{
+
+struct DlHandleDeleter
+{
+    void operator()(DlHandle handle) const
+    {
+        if (handle != nullptr)
+            dlFree(handle);
+    }
+};
+
+using UniqueDlHandle = std::unique_ptr<std::remove_pointer_t<DlHandle>, DlHandleDeleter>;
+
+template<typename FnT>
+FnT loadFunction(DlHandle handle, const char* name)
+{
+    void* symbol = getSym(handle, name);
+    EXPECT_NE(symbol, nullptr) << name;
+    return reinterpret_cast<FnT>(symbol);
+}
+
+bool containsName(const std::vector<std::string>& names, const std::string& name)
+{
+    return std::ranges::find(names, name) != names.end();
+}
+
+}
+
+TEST(ScriptLibraryTest, loadsGeneratedScriptLibraryExports)
+{
+    EXPECT_NO_THROW({
+        GE::ScriptLibrary scriptLibrary(GE_TEST_SCRIPT_LIB);
+
+        std::vector<std::string> names = scriptLibrary.listScriptNames();
+
+        ASSERT_EQ(names.size(), 1u);
+        EXPECT_EQ(names[0], std::string("TestScript"));
+
+        std::vector<std::string> parameters = scriptLibrary.listScriptParameterNames("TestScript");
+
+        ASSERT_EQ(parameters.size(), 3u);
+        EXPECT_TRUE(containsName(parameters, "speed"));
+        EXPECT_TRUE(containsName(parameters, "enabled"));
+        EXPECT_TRUE(containsName(parameters, "label"));
+        EXPECT_EQ(scriptLibrary.getScriptParameterTypeName("TestScript", "speed"), "float");
+        EXPECT_EQ(scriptLibrary.getScriptParameterTypeName("TestScript", "enabled"), "bool");
+        EXPECT_EQ(scriptLibrary.getScriptParameterTypeName("TestScript", "label"), "string");
+        EXPECT_EQ(std::get<float>(scriptLibrary.getScriptDefaultParameterValue("TestScript", "speed")), 2.5f);
+        EXPECT_EQ(std::get<bool>(scriptLibrary.getScriptDefaultParameterValue("TestScript", "enabled")), true);
+        EXPECT_EQ(std::get<std::string>(scriptLibrary.getScriptDefaultParameterValue("TestScript", "label")), "default");
+
+        std::shared_ptr<GE::Script> script = scriptLibrary.makeScriptInstance("TestScript");
+        ASSERT_NE(script, nullptr);
+        scriptLibrary.setScriptParameter("TestScript", "speed", *script, 7.0f);
+        scriptLibrary.setScriptParameter("TestScript", "enabled", *script, false);
+        scriptLibrary.setScriptParameter("TestScript", "label", *script, std::string("changed"));
+    });
+}
+
+TEST(ScriptLibraryTest, keepsLibraryAliveForScriptInstanceLifetime)
+{
+    std::shared_ptr<GE::Script> script;
+    {
+        GE::ScriptLibrary scriptLibrary(GE_TEST_SCRIPT_LIB);
+        std::vector<std::string> parameters = scriptLibrary.listScriptParameterNames("TestScript");
+        ASSERT_EQ(parameters.size(), 3u);
+        EXPECT_TRUE(containsName(parameters, "speed"));
+        EXPECT_EQ(std::get<float>(scriptLibrary.getScriptDefaultParameterValue("TestScript", "speed")), 2.5f);
+
+        script = scriptLibrary.makeScriptInstance("TestScript");
+        ASSERT_NE(script, nullptr);
+        scriptLibrary.setScriptParameter("TestScript", "speed", *script, 11.0f);
+    }
+
+    script.reset();
+}
diff --git a/tests/TypeList_testCases.cpp b/tests/TypeList_testCases.cpp
new file mode 100644
index 0000000..6218b49
--- /dev/null
+++ b/tests/TypeList_testCases.cpp
@@ -0,0 +1,108 @@
+#include <Game-Engine/TypeList.hpp>
+#include <Game-Engine/RawInput.hpp>
+
+#include <gtest/gtest.h>
+
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+namespace
+{
+
+struct FirstType
+{
+    static constexpr int id = 1;
+};
+
+struct SecondType
+{
+    static constexpr int id = 2;
+};
+
+struct ThirdType
+{
+    static constexpr int id = 3;
+};
+
+using TestTypeList = GE::TypeList<FirstType, SecondType, ThirdType>;
+using EmptyTypeList = GE::TypeList<>;
+
+template<typename T>
+using PointerType = T*;
+
+static_assert(std::is_same_v<TestTypeList::into<std::tuple>, std::tuple<FirstType, SecondType, ThirdType>>);
+static_assert(std::is_same_v<TestTypeList::wrapped<PointerType>, GE::TypeList<FirstType*, SecondType*, ThirdType*>>);
+
+static_assert(GE::IsTypeInList<FirstType, TestTypeList>);
+static_assert(GE::IsTypeInList<SecondType, TestTypeList>);
+static_assert(!GE::IsTypeInList<int, TestTypeList>);
+static_assert(GE::IsTypeInList<GE::KeyboardButton, GE::RawInputTypes>);
+static_assert(GE::IsTypeInList<GE::MouseButton, GE::RawInputTypes>);
+static_assert(!GE::IsTypeInList<int, GE::RawInputTypes>);
+
+static_assert(requires { GE::forEachType<TestTypeList>([]<typename>() {}); });
+static_assert(requires { GE::anyOfType<TestTypeList>([]<typename>() { return true; }); });
+static_assert(requires { GE::allOfType<TestTypeList>([]<typename>() { return true; }); });
+static_assert(requires { GE::noneOfType<TestTypeList>([]<typename>() { return true; }); });
+
+}
+
+TEST(TypeListTest, forEachTypeVisitsTypesInOrder)
+{
+    std::vector<int> visitedIds;
+
+    GE::forEachType<TestTypeList>([&]<typename T>() {
+        visitedIds.push_back(T::id);
+    });
+
+    EXPECT_EQ(visitedIds, (std::vector<int>{1, 2, 3}));
+}
+
+TEST(TypeListTest, anyOfTypeReturnsTrueWhenAnyTypeMatches)
+{
+    EXPECT_TRUE((GE::anyOfType<TestTypeList>([]<typename T>() {
+        return T::id == 2;
+    })));
+
+    EXPECT_FALSE((GE::anyOfType<TestTypeList>([]<typename T>() {
+        return T::id == 42;
+    })));
+}
+
+TEST(TypeListTest, allOfTypeReturnsTrueOnlyWhenAllTypesMatch)
+{
+    EXPECT_TRUE((GE::allOfType<TestTypeList>([]<typename T>() {
+        return T::id > 0;
+    })));
+
+    EXPECT_FALSE((GE::allOfType<TestTypeList>([]<typename T>() {
+        return T::id < 3;
+    })));
+}
+
+TEST(TypeListTest, noneOfTypeReturnsTrueOnlyWhenNoTypesMatch)
+{
+    EXPECT_TRUE((GE::noneOfType<TestTypeList>([]<typename T>() {
+        return T::id == 42;
+    })));
+
+    EXPECT_FALSE((GE::noneOfType<TestTypeList>([]<typename T>() {
+        return T::id == 3;
+    })));
+}
+
+TEST(TypeListTest, emptyTypeListsUseIdentityFoldValues)
+{
+    EXPECT_FALSE((GE::anyOfType<EmptyTypeList>([]<typename>() {
+        return true;
+    })));
+
+    EXPECT_TRUE((GE::allOfType<EmptyTypeList>([]<typename>() {
+        return false;
+    })));
+
+    EXPECT_TRUE((GE::noneOfType<EmptyTypeList>([]<typename>() {
+        return true;
+    })));
+}
diff --git a/tests/ge-test.entitlements b/tests/ge-test.entitlements
new file mode 100644
index 0000000..2104a7c
--- /dev/null
+++ b/tests/ge-test.entitlements
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "www.apple.com">
+<plist version="1.0">
+    <dict>
+        <key>com.apple.security.get-task-allow</key>
+        <true/>
+    </dict>
+</plist>
diff --git a/tests/resources/dummy_texture.png b/tests/resources/dummy_texture.png
new file mode 100644
index 0000000..1a64655
Binary files /dev/null and b/tests/resources/dummy_texture.png differ
diff --git a/tests/scriptLib/CMakeLists.txt b/tests/scriptLib/CMakeLists.txt
new file mode 100644
index 0000000..72213bf
--- /dev/null
+++ b/tests/scriptLib/CMakeLists.txt
@@ -0,0 +1,19 @@
+# ---------------------------------------------------
+# CMakeLists.txt
+#
+# Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+# ---------------------------------------------------
+
+include(../../cmake/ScriptLibrary.cmake)
+
+ge_add_script_library(GE_test_scriptLib "TestScript.cpp")
+target_link_libraries(GE_test_scriptLib PRIVATE GE_test)
+
+set_target_properties(GE_test_scriptLib PROPERTIES
+    FOLDER "tests"
+    PREFIX ""
+    DEBUG_POSTFIX ""
+    RUNTIME_OUTPUT_DIRECTORY $<1:${CMAKE_CURRENT_BINARY_DIR}>
+    LIBRARY_OUTPUT_DIRECTORY $<1:${CMAKE_CURRENT_BINARY_DIR}>
+    ARCHIVE_OUTPUT_DIRECTORY $<1:${CMAKE_CURRENT_BINARY_DIR}>
+)
diff --git a/tests/scriptLib/TestScript.cpp b/tests/scriptLib/TestScript.cpp
new file mode 100644
index 0000000..25dbba2
--- /dev/null
+++ b/tests/scriptLib/TestScript.cpp
@@ -0,0 +1,26 @@
+#include <Game-Engine/Components.hpp>
+#include <Game-Engine/Entity.hpp>
+#include <Game-Engine/Game.hpp>
+#include <Game-Engine/Script.hpp>
+
+class TestScript final : public GE::Script
+{
+    GE_SCRIPT(TestScript, "TestScript");
+    GE_SCRIPT_PARAM(float, speed, 2.5f);
+    GE_SCRIPT_PARAM(bool, enabled, true);
+    GE_SCRIPT_PARAM(std::string, label, std::string("default"));
+
+    void setup(GE::Entity& entity, GE::Game& game) override
+    {
+        (void)game;
+        wasSetup = entity.has<GE::TransformComponent>();
+    }
+
+    void onUpdate() override
+    {
+        updateCount++;
+    }
+
+    bool wasSetup = false;
+    int64_t updateCount = 0;
+};
diff --git a/tests/serialization_testCases.cpp b/tests/serialization_testCases.cpp
new file mode 100644
index 0000000..77c8fef
--- /dev/null
+++ b/tests/serialization_testCases.cpp
@@ -0,0 +1,385 @@
+/*
+ * ---------------------------------------------------
+ * serialization_testCases.cpp
+ *
+ * Author: Thomas Choquet <semoir.dense-0h@icloud.com>
+ * ---------------------------------------------------
+ */
+
+#include <gtest/gtest.h>
+
+#include "Game-Engine/Components.hpp"
+#include "Game-Engine/AssetManager.hpp"
+#include "Game-Engine/InputContext.hpp"
+#include "Game-Engine/Scene.hpp"
+
+#include <Graphics/Texture.hpp>
+
+#include <yaml-cpp/yaml.h>
+
+#include <map>
+#include <vector>
+
+namespace GE_tests
+{
+
+TEST(SerializationTest, componentVariantMapYamlRoundTrip)
+{
+    std::map<GE::ECSWorld::EntityID, std::vector<GE::ComponentVariant>> entities = {
+        {
+            2, {
+                GE::NameComponent{"camera"},
+                GE::TransformComponent{
+                    .position = {3.0f, 4.0f, 5.0f},
+                    .rotation = {0.1f, 0.2f, 0.3f},
+                    .scale = {1.0f, 2.0f, 3.0f}
+                },
+                GE::CameraComponent{
+                    .fov = 1.2f,
+                    .zFar = 500.0f,
+                    .zNear = 0.5f
+                }
+            }
+        },
+        {
+            7, {
+                GE::HierarchyComponent{
+                    .parent = 2,
+                    .firstChild = INVALID_ENTITY_ID,
+                    .nextChild = INVALID_ENTITY_ID
+                },
+                GE::LightComponent{
+                    .type = GE::LightComponent::Type::directional,
+                    .color = {0.5f, 0.6f, 0.7f},
+                    .intentsity = 0.8f,
+                    .attenuation = 0.9f
+                },
+                GE::MeshComponent{GE::BUILT_IN_CUBE_ASSET_ID}
+            }
+        }
+    };
+
+    YAML::Node node = YAML::convert<decltype(entities)>::encode(entities);
+    const std::string yaml = YAML::Dump(node);
+
+    EXPECT_NE(yaml.find("NameComponent"), std::string::npos);
+    EXPECT_NE(yaml.find("LightComponent"), std::string::npos);
+    EXPECT_NE(yaml.find("MeshComponent"), std::string::npos);
+
+    auto decoded = node.as<decltype(entities)>();
+
+    ASSERT_EQ(decoded.size(), entities.size());
+    ASSERT_TRUE(decoded.contains(2));
+    ASSERT_TRUE(decoded.contains(7));
+
+    ASSERT_EQ(decoded.at(2).size(), 3u);
+    EXPECT_EQ(std::get<GE::NameComponent>(decoded.at(2)[0]).name, "camera");
+    const auto& transform = std::get<GE::TransformComponent>(decoded.at(2)[1]);
+    EXPECT_FLOAT_EQ(transform.position.x, 3.0f);
+    EXPECT_FLOAT_EQ(transform.position.y, 4.0f);
+    EXPECT_FLOAT_EQ(transform.position.z, 5.0f);
+    EXPECT_FLOAT_EQ(std::get<GE::CameraComponent>(decoded.at(2)[2]).zNear, 0.5f);
+
+    ASSERT_EQ(decoded.at(7).size(), 3u);
+    EXPECT_EQ(std::get<GE::HierarchyComponent>(decoded.at(7)[0]).parent, 2u);
+    EXPECT_EQ(std::get<GE::LightComponent>(decoded.at(7)[1]).type, GE::LightComponent::Type::directional);
+    EXPECT_EQ(std::get<GE::MeshComponent>(decoded.at(7)[2]).id, GE::BUILT_IN_CUBE_ASSET_ID);
+}
+
+TEST(AssetPathYamlConversion, encodesMeshAssetPathWithTypeAndPath)
+{
+    const std::filesystem::path meshPath("meshes/cube.obj");
+    const GE::VAssetPath assetPath = GE::AssetPath<GE::Mesh>(meshPath);
+
+    const YAML::Node node = YAML::convert<GE::VAssetPath>::encode(assetPath);
+
+    ASSERT_TRUE(node.IsMap());
+    EXPECT_EQ(node["type"].as<std::string>(), "Mesh");
+    EXPECT_EQ(node["path"].as<std::string>(), meshPath.string());
+}
+
+TEST(AssetPathYamlConversion, decodesMeshAssetPathFromYaml)
+{
+    YAML::Node node;
+    node["type"] = "Mesh";
+    node["path"] = "meshes/cube.obj";
+
+    GE::VAssetPath assetPath;
+    ASSERT_TRUE(YAML::convert<GE::VAssetPath>::decode(node, assetPath));
+
+    ASSERT_TRUE(std::holds_alternative<GE::AssetPath<GE::Mesh>>(assetPath));
+    EXPECT_EQ(std::get<GE::AssetPath<GE::Mesh>>(assetPath).path, std::filesystem::path("meshes/cube.obj"));
+}
+
+TEST(AssetPathYamlConversion, roundTripsTextureAssetPathThroughYamlNode)
+{
+    const GE::VAssetPath assetPath = GE::AssetPath<gfx::Texture>(std::filesystem::path("textures/dummy.png"));
+
+    const YAML::Node encoded = YAML::convert<GE::VAssetPath>::encode(assetPath);
+    const GE::VAssetPath decoded = encoded.as<GE::VAssetPath>();
+
+    ASSERT_TRUE(std::holds_alternative<GE::AssetPath<gfx::Texture>>(decoded));
+    EXPECT_EQ(std::get<GE::AssetPath<gfx::Texture>>(decoded).path, std::filesystem::path("textures/dummy.png"));
+}
+
+TEST(AssetPathYamlConversion, rejectsYamlWithoutRequiredKeys)
+{
+    YAML::Node missingPath;
+    missingPath["type"] = "Mesh";
+
+    YAML::Node missingType;
+    missingType["path"] = "meshes/cube.obj";
+
+    GE::VAssetPath assetPath;
+    EXPECT_FALSE(YAML::convert<GE::VAssetPath>::decode(missingPath, assetPath));
+    EXPECT_FALSE(YAML::convert<GE::VAssetPath>::decode(missingType, assetPath));
+}
+
+TEST(AssetPathYamlConversion, rejectsUnknownAssetType)
+{
+    YAML::Node node;
+    node["type"] = "Material";
+    node["path"] = "materials/default.mat";
+
+    GE::VAssetPath assetPath;
+    EXPECT_FALSE(YAML::convert<GE::VAssetPath>::decode(node, assetPath));
+}
+
+TEST(SceneDescriptorYamlConversion, encodesDescriptorFields)
+{
+    const GE::Scene::Descriptor descriptor{
+        .name = "MainScene",
+        .activeCamera = 42,
+        .registredAssets = {
+            {GE::AssetPath<GE::Mesh>(std::filesystem::path("meshes/cube.obj")), 3},
+            {GE::AssetPath<gfx::Texture>(std::filesystem::path("textures/albedo.png")), 5}
+        },
+        .entities = {
+            {42, {
+                GE::NameComponent{"camera"},
+                GE::TransformComponent{
+                    .position = {1.0f, 2.0f, 3.0f},
+                    .rotation = {0.1f, 0.2f, 0.3f},
+                    .scale = {4.0f, 5.0f, 6.0f}
+                },
+                GE::CameraComponent{
+                    .fov = 1.4f,
+                    .zFar = 600.0f,
+                    .zNear = 0.2f
+                }
+            }},
+            {9, {
+                GE::HierarchyComponent{
+                    .parent = 42,
+                    .firstChild = INVALID_ENTITY_ID,
+                    .nextChild = INVALID_ENTITY_ID
+                },
+                GE::MeshComponent{3}
+            }}
+        }
+    };
+
+    const YAML::Node node = YAML::convert<GE::Scene::Descriptor>::encode(descriptor);
+
+    ASSERT_TRUE(node.IsMap());
+    EXPECT_EQ(node["name"].as<std::string>(), "MainScene");
+    EXPECT_EQ(node["activeCamera"].as<GE::ECSWorld::EntityID>(), 42u);
+    ASSERT_TRUE(node["registredAssets"].IsMap());
+    ASSERT_TRUE(node["entities"].IsMap());
+    const auto encodedAssets = node["registredAssets"].as<std::map<GE::VAssetPath, GE::AssetID>>();
+    const GE::VAssetPath cubePath = GE::AssetPath<GE::Mesh>(std::filesystem::path("meshes/cube.obj"));
+    ASSERT_TRUE(encodedAssets.contains(cubePath));
+    EXPECT_EQ(encodedAssets.at(cubePath), 3u);
+    EXPECT_EQ(node["entities"]["42"][0]["type"].as<std::string>(), "NameComponent");
+    EXPECT_EQ(node["entities"]["42"][0]["data"]["name"].as<std::string>(), "camera");
+}
+
+TEST(SceneDescriptorYamlConversion, decodesDescriptorFromYaml)
+{
+    YAML::Node node;
+    node["name"] = "LoadedScene";
+    node["activeCamera"] = 7;
+    node["registredAssets"] = std::map<GE::VAssetPath, GE::AssetID>{
+        {GE::AssetPath<gfx::Texture>(std::filesystem::path("textures/diffuse.png")), 11}
+    };
+    node["entities"]["7"].push_back(YAML::Load("{ type: NameComponent, data: { name: player } }"));
+    node["entities"]["7"].push_back(YAML::Load(
+        "{ type: TransformComponent, data: { position: [7.0, 8.0, 9.0], rotation: [0.0, 0.5, 1.0], scale: [1.0, 1.5, 2.0] } }"
+    ));
+    node["entities"]["7"].push_back(YAML::Load(
+        "{ type: CameraComponent, data: { fov: 1.1, zFar: 250.0, zNear: 0.3 } }"
+    ));
+
+    GE::Scene::Descriptor descriptor;
+    ASSERT_TRUE(YAML::convert<GE::Scene::Descriptor>::decode(node, descriptor));
+
+    EXPECT_EQ(descriptor.name, "LoadedScene");
+    EXPECT_EQ(descriptor.activeCamera, 7u);
+    ASSERT_EQ(descriptor.registredAssets.size(), 1u);
+    const GE::VAssetPath diffusePath = GE::AssetPath<gfx::Texture>(std::filesystem::path("textures/diffuse.png"));
+    ASSERT_TRUE(descriptor.registredAssets.contains(diffusePath));
+    EXPECT_EQ(descriptor.registredAssets.at(diffusePath), 11u);
+
+    ASSERT_EQ(descriptor.entities.size(), 1u);
+    ASSERT_TRUE(descriptor.entities.contains(7));
+    ASSERT_EQ(descriptor.entities.at(7).size(), 3u);
+    EXPECT_EQ(std::get<GE::NameComponent>(descriptor.entities.at(7)[0]).name, "player");
+    const auto& transform = std::get<GE::TransformComponent>(descriptor.entities.at(7)[1]);
+    EXPECT_FLOAT_EQ(transform.position.x, 7.0f);
+    EXPECT_FLOAT_EQ(transform.rotation.y, 0.5f);
+    EXPECT_FLOAT_EQ(transform.scale.z, 2.0f);
+    EXPECT_FLOAT_EQ(std::get<GE::CameraComponent>(descriptor.entities.at(7)[2]).zNear, 0.3f);
+}
+
+TEST(SceneDescriptorYamlConversion, decodesLegacyIdToAssetPathYaml)
+{
+    YAML::Node node;
+    node["name"] = "LegacyScene";
+    node["activeCamera"] = 7;
+    node["registredAssets"]["11"]["type"] = "Texture";
+    node["registredAssets"]["11"]["path"] = "textures/diffuse.png";
+    node["entities"] = YAML::Node(YAML::NodeType::Map);
+
+    GE::Scene::Descriptor descriptor;
+    ASSERT_TRUE(YAML::convert<GE::Scene::Descriptor>::decode(node, descriptor));
+
+    EXPECT_EQ(descriptor.name, "LegacyScene");
+    EXPECT_EQ(descriptor.activeCamera, 7u);
+    ASSERT_EQ(descriptor.registredAssets.size(), 1u);
+    const GE::VAssetPath diffusePath = GE::AssetPath<gfx::Texture>(std::filesystem::path("textures/diffuse.png"));
+    ASSERT_TRUE(descriptor.registredAssets.contains(diffusePath));
+    EXPECT_EQ(descriptor.registredAssets.at(diffusePath), 11u);
+}
+
+TEST(SceneDescriptorYamlConversion, roundTripsDescriptorThroughYamlNode)
+{
+    const GE::Scene::Descriptor descriptor{
+        .name = "RoundTripScene",
+        .activeCamera = 15,
+        .registredAssets = {
+            {GE::AssetPath<GE::Mesh>(std::filesystem::path("meshes/player.obj")), 2}
+        },
+        .entities = {
+            {15, {
+                GE::NameComponent{"player"},
+                GE::MeshComponent{2}
+            }}
+        }
+    };
+
+    const YAML::Node encoded = YAML::convert<GE::Scene::Descriptor>::encode(descriptor);
+    const GE::Scene::Descriptor decoded = encoded.as<GE::Scene::Descriptor>();
+
+    EXPECT_EQ(decoded.name, descriptor.name);
+    EXPECT_EQ(decoded.activeCamera, descriptor.activeCamera);
+    ASSERT_EQ(decoded.registredAssets.size(), 1u);
+    const GE::VAssetPath playerPath = GE::AssetPath<GE::Mesh>(std::filesystem::path("meshes/player.obj"));
+    ASSERT_TRUE(decoded.registredAssets.contains(playerPath));
+    EXPECT_EQ(decoded.registredAssets.at(playerPath), 2u);
+    ASSERT_EQ(decoded.entities.size(), 1u);
+    ASSERT_EQ(decoded.entities.at(15).size(), 2u);
+    EXPECT_EQ(std::get<GE::NameComponent>(decoded.entities.at(15)[0]).name, "player");
+    EXPECT_EQ(std::get<GE::MeshComponent>(decoded.entities.at(15)[1]).id, 2u);
+}
+
+TEST(SceneDescriptorYamlConversion, rejectsYamlWithoutRequiredKeys)
+{
+    YAML::Node missingName;
+    missingName["activeCamera"] = 1;
+    missingName["registredAssets"] = YAML::Node(YAML::NodeType::Map);
+    missingName["entities"] = YAML::Node(YAML::NodeType::Map);
+
+    YAML::Node missingActiveCamera;
+    missingActiveCamera["name"] = "Scene";
+    missingActiveCamera["registredAssets"] = YAML::Node(YAML::NodeType::Map);
+    missingActiveCamera["entities"] = YAML::Node(YAML::NodeType::Map);
+
+    YAML::Node missingRegistredAssets;
+    missingRegistredAssets["name"] = "Scene";
+    missingRegistredAssets["activeCamera"] = 1;
+    missingRegistredAssets["entities"] = YAML::Node(YAML::NodeType::Map);
+
+    GE::Scene::Descriptor descriptor;
+    EXPECT_FALSE(YAML::convert<GE::Scene::Descriptor>::decode(missingName, descriptor));
+    EXPECT_FALSE(YAML::convert<GE::Scene::Descriptor>::decode(missingActiveCamera, descriptor));
+    EXPECT_FALSE(YAML::convert<GE::Scene::Descriptor>::decode(missingRegistredAssets, descriptor));
+}
+
+TEST(InputContextYamlConversion, roundTripsConfiguredInputsThroughYamlNode)
+{
+    GE::InputContext inputContext;
+
+    GE::ActionInput jumpInput;
+    jumpInput.setMapper<GE::KeyboardButton>(GE::KeyboardButton::space);
+    inputContext.addInput("jump", jumpInput);
+
+    GE::StateInput brakeInput;
+    brakeInput.setMapper<GE::KeyboardButton>(GE::KeyboardButton::s);
+    inputContext.addInput("brake", brakeInput);
+
+    GE::RangeInput throttleInput;
+    throttleInput.setMapper<GE::KeyboardButton>(GE::KeyboardButton::w, 2.5f);
+    inputContext.addInput("throttle", throttleInput);
+
+    GE::Range2DInput moveInput;
+    moveInput.setMapper<GE::KeyboardButton>(GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>::Descriptor{
+        .xPos = GE::KeyboardButton::d,
+        .xNeg = GE::KeyboardButton::a,
+        .xScale = 2.0f,
+        .yPos = GE::KeyboardButton::w,
+        .yNeg = GE::KeyboardButton::s,
+        .yScale = 3.0f,
+        .triggerValue = 0.2f
+    });
+    inputContext.addInput("move", moveInput);
+
+    const YAML::Node encoded = YAML::convert<GE::InputContext>::encode(inputContext);
+    EXPECT_EQ(encoded["inputs"]["jump"]["type"].as<std::string>(), "Action");
+    EXPECT_EQ(encoded["inputs"]["jump"]["mapper"]["type"].as<std::string>(), "KeyboardButton");
+    EXPECT_EQ(encoded["inputs"]["brake"]["type"].as<std::string>(), "State");
+    const GE::InputContext decoded = encoded.as<GE::InputContext>();
+
+    ASSERT_EQ(decoded.inputs().size(), 4u);
+    ASSERT_TRUE(decoded.inputs().contains("jump"));
+    ASSERT_TRUE(decoded.inputs().contains("brake"));
+    ASSERT_TRUE(decoded.inputs().contains("throttle"));
+    ASSERT_TRUE(decoded.inputs().contains("move"));
+
+    const auto& jump = std::get<GE::ActionInput>(decoded.inputs().at("jump"));
+    ASSERT_TRUE(jump.mapper.has_value());
+    const auto& jumpMapper = std::get<GE::InputMapper<GE::KeyboardButton, GE::ActionInput>>(*jump.mapper);
+    EXPECT_EQ(jumpMapper.button, GE::KeyboardButton::space);
+
+    const auto& brake = std::get<GE::StateInput>(decoded.inputs().at("brake"));
+    ASSERT_TRUE(brake.mapper.has_value());
+    const auto& brakeMapper = std::get<GE::InputMapper<GE::KeyboardButton, GE::StateInput>>(*brake.mapper);
+    EXPECT_EQ(brakeMapper.button, GE::KeyboardButton::s);
+
+    const auto& throttle = std::get<GE::RangeInput>(decoded.inputs().at("throttle"));
+    ASSERT_TRUE(throttle.mapper.has_value());
+    const auto& throttleMapper = std::get<GE::InputMapper<GE::KeyboardButton, GE::RangeInput>>(*throttle.mapper);
+    EXPECT_EQ(throttleMapper.button, GE::KeyboardButton::w);
+    EXPECT_FLOAT_EQ(throttleMapper.scale, 2.5f);
+
+    const auto& move = std::get<GE::Range2DInput>(decoded.inputs().at("move"));
+    ASSERT_TRUE(move.mapper.has_value());
+    const auto& moveMapper = std::get<GE::InputMapper<GE::KeyboardButton, GE::Range2DInput>>(*move.mapper);
+    EXPECT_EQ(moveMapper.xPos, GE::KeyboardButton::d);
+    EXPECT_EQ(moveMapper.xNeg, GE::KeyboardButton::a);
+    EXPECT_EQ(moveMapper.yPos, GE::KeyboardButton::w);
+    EXPECT_EQ(moveMapper.yNeg, GE::KeyboardButton::s);
+    EXPECT_FLOAT_EQ(moveMapper.xScale, 2.0f);
+    EXPECT_FLOAT_EQ(moveMapper.yScale, 3.0f);
+    EXPECT_FLOAT_EQ(moveMapper.triggerValue, 0.2f);
+}
+
+TEST(InputDispatch, emptyCallbackDoesNotThrowWhenInputIsTriggered)
+{
+    GE::ActionInput input;
+    input.triggered = true;
+
+    EXPECT_NO_THROW(input.dispatch());
+    EXPECT_FALSE(input.triggered);
+}
+
+} // namespace GE_tests
diff --git a/viewport.png b/viewport.png
new file mode 100644
index 0000000..532e3ee
Binary files /dev/null and b/viewport.png differ