wip entity deserialization phase 1. Unit test not passing because of globals that assume only one entity manager / game state.

Serialization : started to unify how to allocate entity whether its from MakeEntity or during deserialization.
updating serialization tdd with latest changes
2026-09-10 22:50:18 -04:00 · 2026-09-08 23:24:48 -04:00 · 2026-09-07 20:05:17 -04:00 · 2026-09-07 19:42:15 -04:00 · 2026-09-07 16:58:57 -04:00 · 2026-09-06 12:08:57 -04:00
264 changed files with 19263 additions and 17055 deletions
@@ -5,12 +5,20 @@ trigger: always_on
 Code compiles with all warning active and warning as errors.
 use static_cast or reinterpret_cast but not parenthesis for casting.
 No exceptions
-Use [[nodiscard]]
+Use [[nodiscard]] when risk of memory leak (anything returning pointer)
 auto is allowed but when its a pointer add the * and when reference adds the &
-Member variable are CamelCase
-Types are CamelCase
-Functions are CamelCase.
 Add Assert to make sure all assumptions are good. Parameters of functions for example should be verified with Assert.
 Code should be self commented using proper variable names, types and functions. No need to add comments most of the time, unless the algorithm is very complex and hard to read.
 When creating a new system framework, make a unit test. To make the unit test we should not modify the framework code for special unit test case.
 Always put braces for if,else,for,while etc.
+Coding Style:
+Note: The code base do not fully use those, if in doubt, use this style and not legacy style.
+Types (Structs/Enums/Unions) : PascalCase. Exemple : Arena, String8, DbgTarget, EvalValue
+Primitive Types : lower_snake_case. Exemple: uint8, uint16, uint32, uint64, size_t, index_t, int32...
+Function Names: lower_snake_case. Exemple: str16_from_8. 
+Namespace: do not use c++ namespace, add PascalCase prefix to function names. Exemple: W32_do_something
+Local Variables and parameters: lower_snake_case. Exemple: arena, str, data.
+Struct members: lower_snake_case. Exemple: data, node, next.
+global/static variables: lower_snake_case prefixed. Exemple: g_my_global.
+const variables: lower_snake_case prefixed. Exemple: k_my_const_var.
+Defines and Macros: ALL_CAPS_SNAKE. Exemple: MY_MACRO
@@ -11,7 +11,7 @@ trusted_commands:
 You are a senior engine architect for the Juliet project. Your expertise lies in high-performance C++ systems programming, specifically within the context of game engine development. You value performance, memory efficiency, and maintainability.

 ## Coding Guidelines
-You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Pay special attention to `static_cast`/`reinterpret_cast` (never C-style casts), `auto*`/`auto&`, mandatory braces, and `[[nodiscard]]`.
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Pay special attention to `static_cast`/`reinterpret_cast` (never C-style casts), `auto*`/`auto&`, mandatory braces, and `[[nodiscard]]` when needed.

 ## Focus Areas
 1.  **High Performance**: Always consider cache locality and CPU cycle cost.
@@ -11,7 +11,7 @@ trusted_commands:
 You are a senior engine architect for the Juliet project. Your expertise lies in debugging C++ game engines. You add logs and use debug tricks to find the root cause of issues.

 ## Coding Guidelines
-You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Even in debug/diagnostic code, use proper casts, braces, and `[[nodiscard]]`.
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Even in debug/diagnostic code, use proper casts, braces, and `[[nodiscard]]` when needed.

 ## Workflows
 -   **Building**: Use the `/build` workflow to compile the project.
@@ -1,21 +1,15 @@
 ---
-description: Build the Juliet project using FastBuild
+description: Build the Juliet projects
 ---

 // turbo-all
-
-This workflow builds the Juliet project and writes output to `misc\agent_output.log`.
-
+This workflow builds the Juliet project.
 1. To build the default (clang-Debug):
 // turbo
-`misc\agent_build.bat clang 2>&1 | tee misc\agent_output.log`
-
+`misc\build.bat clang`
 2. To build a specific configuration (e.g., clang-Debug, msvc-Debug):
 // turbo
-`misc\agent_build.bat clang-Debug 2>&1 | tee misc\agent_output.log`
-
+`misc\build.bat clang-Debug`
 3. To see all available targets:
 // turbo
-`misc\agent_build.bat -showtargets 2>&1 | tee misc\agent_output.log`
-
-4. Check build results by reading `misc\agent_output.log`.
+`misc\build.bat -showtargets`
@@ -12,6 +12,7 @@
 [Ll]ib/
 .idea/
 .vs/
+vs/
 [Ii]ntermediate/
 [sS]hip/

@@ -22,18 +22,20 @@ cbuffer RootConstants : register(b0, space0)
    uint     BufferIndex;
    uint     TextureIndex;
    uint     VertexOffset;          // Base vertex for indexed drawing with bindless buffers
-    uint     _Padding;     // Padding for alignment
-    float2   Scale;        // 2D scale factor
-    float2   Translate;    // 2D translation
-    float2   _Padding2;    // Explicit padding to align LightDirection to 16 bytes
-    
-    float3   GlobalLightDirection;  // Normalized, world-space
-    float    GlobalLightPad;
-    float3   GlobalLightColor;
-    float    GlobalAmbientIntensity;
-
    uint     LightBufferIndex;
    uint     ActiveLightCount;
+    float    GlobalAmbientIntensity;
+
+    float3   GlobalLightDirection;  // Normalized, world-space
+    uint     _Pad1;
+
+    float3   GlobalLightColor;
+    uint     _Pad2;
+    
+    float2   Scale;                 // 2D scale factor
+    float2   Translate;             // 2D translation
+
+    float4   MeshAlbedo;
 };


@@ -11,11 +11,13 @@ float4 main(Input input) : SV_Target0
 {
    float3 normal = normalize(input.WorldNormal);

-    // Initial ambient component
-    float3 result = input.Color.rgb * GlobalLightColor * GlobalAmbientIntensity;
+    // Initial ambient component (Soft blue sky ambient)
+    float3 ambientColor = float3(0.6f, 0.7f, 0.9f);
+    float3 result = input.Color.rgb * ambientColor * GlobalAmbientIntensity;

    // Directional light contribution
-    float ndotl = max(dot(normal, -GlobalLightDirection), 0.0);
+    float3 sunDir = normalize(-GlobalLightDirection);
+    float ndotl = max(dot(normal, sunDir), 0.0);
    result += input.Color.rgb * GlobalLightColor * ndotl;

    // Point lights
@@ -42,5 +44,8 @@ float4 main(Input input) : SV_Target0
        }
    }

+    // Simple Gamma correction
+    result = pow(result, 1.0 / 2.2);
+
    return float4(result, input.Color.a);
 }
@@ -27,7 +27,7 @@ Output main(uint vertexIndex : SV_VertexID)

    float4 worldPos = mul(Model, float4(pos, 1.0f));
    output.Position = mul(ViewProjection, worldPos);
-    output.Color = col;
+    output.Color = col * MeshAlbedo;
    output.WorldPosition = worldPos.xyz;
    
    float3 worldNormal = mul((float3x3)Model, normal);
@@ -1,202 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Profile|x64">
-      <Configuration>Profile</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <CustomBuild Include="imgui\.editorconfig" />
-    <CustomBuild Include="imgui\backends\imgui_impl_allegro5.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_allegro5.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_android.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_android.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx10.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx10.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx11.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx11.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx12.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx12.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx9.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_dx9.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_glfw.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_glfw.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_glut.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_glut.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_metal.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_metal.mm" />
-    <CustomBuild Include="imgui\backends\imgui_impl_metal4.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_metal4.mm" />
-    <CustomBuild Include="imgui\backends\imgui_impl_null.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_null.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl2.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl2.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3_loader.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_osx.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_osx.mm" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl2.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl2.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl3.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl3.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3_shaders.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer2.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer2.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer3.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer3.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_vulkan.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_vulkan.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_wgpu.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_wgpu.h" />
-    <CustomBuild Include="imgui\backends\imgui_impl_win32.cpp" />
-    <CustomBuild Include="imgui\backends\imgui_impl_win32.h" />
-    <CustomBuild Include="imgui\examples\example_allegro5\imconfig_allegro5.h" />
-    <CustomBuild Include="imgui\examples\example_allegro5\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_android_opengl3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_apple_metal4\main.mm" />
-    <CustomBuild Include="imgui\examples\example_apple_metal\main.mm" />
-    <CustomBuild Include="imgui\examples\example_apple_opengl2\main.mm" />
-    <CustomBuild Include="imgui\examples\example_glfw_metal\main.mm" />
-    <CustomBuild Include="imgui\examples\example_glfw_opengl2\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_glfw_opengl3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_glfw_vulkan\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_glfw_wgpu\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_glut_opengl2\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_null\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_directx11\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_metal\main.mm" />
-    <CustomBuild Include="imgui\examples\example_sdl2_opengl2\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_opengl3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_sdlrenderer2\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_vulkan\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl2_wgpu\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_directx11\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_metal4\main.mm" />
-    <CustomBuild Include="imgui\examples\example_sdl3_metal\main.mm" />
-    <CustomBuild Include="imgui\examples\example_sdl3_opengl3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_sdlgpu3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_sdlrenderer3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_vulkan\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_sdl3_wgpu\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_directx10\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_directx11\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_directx12\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_directx9\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_opengl3\main.cpp" />
-    <CustomBuild Include="imgui\examples\example_win32_vulkan\main.cpp" />
-    <CustomBuild Include="imgui\examples\libs\emscripten\emscripten_mainloop_stub.h" />
-    <CustomBuild Include="imgui\examples\libs\glfw\include\GLFW\glfw3.h" />
-    <CustomBuild Include="imgui\examples\libs\glfw\include\GLFW\glfw3native.h" />
-    <CustomBuild Include="imgui\examples\libs\usynergy\uSynergy.c" />
-    <CustomBuild Include="imgui\examples\libs\usynergy\uSynergy.h" />
-    <CustomBuild Include="imgui\imconfig.h" />
-    <CustomBuild Include="imgui\imgui.cpp" />
-    <CustomBuild Include="imgui\imgui.h" />
-    <CustomBuild Include="imgui\imgui_demo.cpp" />
-    <CustomBuild Include="imgui\imgui_draw.cpp" />
-    <CustomBuild Include="imgui\imgui_internal.h" />
-    <CustomBuild Include="imgui\imgui_tables.cpp" />
-    <CustomBuild Include="imgui\imgui_widgets.cpp" />
-    <CustomBuild Include="imgui\imstb_rectpack.h" />
-    <CustomBuild Include="imgui\imstb_textedit.h" />
-    <CustomBuild Include="imgui\imstb_truetype.h" />
-    <CustomBuild Include="imgui\misc\cpp\imgui_stdlib.cpp" />
-    <CustomBuild Include="imgui\misc\cpp\imgui_stdlib.h" />
-    <CustomBuild Include="imgui\misc\debuggers\imgui.natvis" />
-    <CustomBuild Include="imgui\misc\fonts\binary_to_compressed_c.cpp" />
-    <CustomBuild Include="imgui\misc\freetype\imgui_freetype.cpp" />
-    <CustomBuild Include="imgui\misc\freetype\imgui_freetype.h" />
-    <CustomBuild Include="imgui\misc\single_file\imgui_single_file.h" />
-  </ItemGroup>
-  <ItemGroup>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{c16ffe36-6c94-4f93-bc2a-7f5284b7d434}</ProjectGuid>
-    <Keyword>MakeFileProj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <LocalDebuggerCommand>$(SolutionDir)\bin\x64-$(Configuration)\$(ProjectName).exe</LocalDebuggerCommand>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <LocalDebuggerCommand>$(SolutionDir)\bin\x64-$(Configuration)\$(ProjectName).exe</LocalDebuggerCommand>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <LocalDebuggerCommand>$(SolutionDir)\bin\x64-$(Configuration)\$(ProjectName).exe</LocalDebuggerCommand>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Profile|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat $(Configuration) $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean $(Configuration) $(SolutionName)</NMakeReBuildCommandLine>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\x64-$(Configuration)\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)\Intermediate</IntDir>
-    <OutDir>$(SolutionDir)\bin</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat $(Configuration) $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean $(Configuration) $(SolutionName)</NMakeReBuildCommandLine>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\x64-$(Configuration)\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)\Intermediate</IntDir>
-    <OutDir>$(SolutionDir)\bin</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat $(Configuration) $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean $(Configuration) $(SolutionName)</NMakeReBuildCommandLine>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\x64-$(Configuration)\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)\Intermediate</IntDir>
-    <OutDir>$(SolutionDir)\bin</OutDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <BuildLog>
-    <Path>$(SolutionDir)\Intermediate\$(ProjectName)-$(Configuration).log</Path>
-    </BuildLog>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'">
-    <BuildLog>
-    <Path>$(SolutionDir)\Intermediate\$(ProjectName)-$(Configuration).log</Path>
-    </BuildLog>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <BuildLog>
-    <Path>$(SolutionDir)\Intermediate\$(ProjectName)-$(Configuration).log</Path>
-    </BuildLog>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-  <Import Condition="'$(ConfigurationType)' == 'Makefile' and Exists('$(VCTargetsPath)\Platforms\$(Platform)\SCE.Makefile.$(Platform).targets')" Project="$(VCTargetsPath)\Platforms\$(Platform)\SCE.Makefile.$(Platform).targets" />
-  <Import Condition="'$(ConfigurationType)' == 'Makefile' and '$(AndroidAPILevel)' != '' and Exists('$(VCTargetsPath)\Application Type\$(ApplicationType)\$(ApplicationTypeRevision)\Android.Common.targets')" Project="$(VCTargetsPath)\Application Type\$(ApplicationType)\$(ApplicationTypeRevision)\Android.Common.targets" />
-</Project>
@@ -1,540 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <CustomBuild Include="imgui\.editorconfig">
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_allegro5.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_allegro5.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_android.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_android.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx10.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx10.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx11.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx11.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx12.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx12.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx9.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_dx9.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_glfw.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_glfw.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_glut.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_glut.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_metal.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_metal.mm">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_metal4.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_metal4.mm">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_null.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_null.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl2.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl2.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_opengl3_loader.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_osx.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_osx.mm">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl2.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl2.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl3.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdl3.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlgpu3_shaders.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer2.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer2.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer3.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_sdlrenderer3.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_vulkan.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_vulkan.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_wgpu.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_wgpu.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_win32.cpp">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\backends\imgui_impl_win32.h">
-      <Filter>backends</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_allegro5\imconfig_allegro5.h">
-      <Filter>examples\example_allegro5</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_allegro5\main.cpp">
-      <Filter>examples\example_allegro5</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_android_opengl3\main.cpp">
-      <Filter>examples\example_android_opengl3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_apple_metal4\main.mm">
-      <Filter>examples\example_apple_metal4</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_apple_metal\main.mm">
-      <Filter>examples\example_apple_metal</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_apple_opengl2\main.mm">
-      <Filter>examples\example_apple_opengl2</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glfw_metal\main.mm">
-      <Filter>examples\example_glfw_metal</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glfw_opengl2\main.cpp">
-      <Filter>examples\example_glfw_opengl2</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glfw_opengl3\main.cpp">
-      <Filter>examples\example_glfw_opengl3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glfw_vulkan\main.cpp">
-      <Filter>examples\example_glfw_vulkan</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glfw_wgpu\main.cpp">
-      <Filter>examples\example_glfw_wgpu</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_glut_opengl2\main.cpp">
-      <Filter>examples\example_glut_opengl2</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_null\main.cpp">
-      <Filter>examples\example_null</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_directx11\main.cpp">
-      <Filter>examples\example_sdl2_directx11</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_metal\main.mm">
-      <Filter>examples\example_sdl2_metal</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_opengl2\main.cpp">
-      <Filter>examples\example_sdl2_opengl2</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_opengl3\main.cpp">
-      <Filter>examples\example_sdl2_opengl3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_sdlrenderer2\main.cpp">
-      <Filter>examples\example_sdl2_sdlrenderer2</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_vulkan\main.cpp">
-      <Filter>examples\example_sdl2_vulkan</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl2_wgpu\main.cpp">
-      <Filter>examples\example_sdl2_wgpu</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_directx11\main.cpp">
-      <Filter>examples\example_sdl3_directx11</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_metal4\main.mm">
-      <Filter>examples\example_sdl3_metal4</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_metal\main.mm">
-      <Filter>examples\example_sdl3_metal</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_opengl3\main.cpp">
-      <Filter>examples\example_sdl3_opengl3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_sdlgpu3\main.cpp">
-      <Filter>examples\example_sdl3_sdlgpu3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_sdlrenderer3\main.cpp">
-      <Filter>examples\example_sdl3_sdlrenderer3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_vulkan\main.cpp">
-      <Filter>examples\example_sdl3_vulkan</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_sdl3_wgpu\main.cpp">
-      <Filter>examples\example_sdl3_wgpu</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_directx10\main.cpp">
-      <Filter>examples\example_win32_directx10</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_directx11\main.cpp">
-      <Filter>examples\example_win32_directx11</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_directx12\main.cpp">
-      <Filter>examples\example_win32_directx12</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_directx9\main.cpp">
-      <Filter>examples\example_win32_directx9</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_opengl3\main.cpp">
-      <Filter>examples\example_win32_opengl3</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\example_win32_vulkan\main.cpp">
-      <Filter>examples\example_win32_vulkan</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\libs\emscripten\emscripten_mainloop_stub.h">
-      <Filter>examples\libs\emscripten</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\libs\glfw\include\GLFW\glfw3.h">
-      <Filter>examples\libs\glfw\include\GLFW</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\libs\glfw\include\GLFW\glfw3native.h">
-      <Filter>examples\libs\glfw\include\GLFW</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\libs\usynergy\uSynergy.c">
-      <Filter>examples\libs\usynergy</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\examples\libs\usynergy\uSynergy.h">
-      <Filter>examples\libs\usynergy</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\imconfig.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui.cpp">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui_demo.cpp">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui_draw.cpp">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui_internal.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui_tables.cpp">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imgui_widgets.cpp">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imstb_rectpack.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imstb_textedit.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\imstb_truetype.h">
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\cpp\imgui_stdlib.cpp">
-      <Filter>misc\cpp</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\cpp\imgui_stdlib.h">
-      <Filter>misc\cpp</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\debuggers\imgui.natvis">
-      <Filter>misc\debuggers</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\fonts\binary_to_compressed_c.cpp">
-      <Filter>misc\fonts</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\freetype\imgui_freetype.cpp">
-      <Filter>misc\freetype</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\freetype\imgui_freetype.h">
-      <Filter>misc\freetype</Filter>
-    </CustomBuild>
-    <CustomBuild Include="imgui\misc\single_file\imgui_single_file.h">
-      <Filter>misc\single_file</Filter>
-    </CustomBuild>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="backends">
-      <UniqueIdentifier>{76e0cd46-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_allegro5">
-      <UniqueIdentifier>{afb95218-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples">
-      <UniqueIdentifier>{1f18bf0c-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_android_opengl3">
-      <UniqueIdentifier>{e530954e-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_apple_metal4">
-      <UniqueIdentifier>{3cc03c55-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_apple_metal">
-      <UniqueIdentifier>{16c31149-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_apple_opengl2">
-      <UniqueIdentifier>{e40593b1-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glfw_metal">
-      <UniqueIdentifier>{3f752825-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glfw_opengl2">
-      <UniqueIdentifier>{c215e32a-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glfw_opengl3">
-      <UniqueIdentifier>{615ff294-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glfw_vulkan">
-      <UniqueIdentifier>{61582fc8-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glfw_wgpu">
-      <UniqueIdentifier>{a31b119a-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_glut_opengl2">
-      <UniqueIdentifier>{01ccd54d-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_null">
-      <UniqueIdentifier>{f4c8b947-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_directx11">
-      <UniqueIdentifier>{f2d77d32-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_metal">
-      <UniqueIdentifier>{776017f1-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_opengl2">
-      <UniqueIdentifier>{4d812b44-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_opengl3">
-      <UniqueIdentifier>{7be81d1f-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_sdlrenderer2">
-      <UniqueIdentifier>{e190514e-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_vulkan">
-      <UniqueIdentifier>{a2cc40a8-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl2_wgpu">
-      <UniqueIdentifier>{8777abc2-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_directx11">
-      <UniqueIdentifier>{b9c33cde-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_metal4">
-      <UniqueIdentifier>{754be038-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_metal">
-      <UniqueIdentifier>{4dc8b8c8-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_opengl3">
-      <UniqueIdentifier>{3b7dda38-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_sdlgpu3">
-      <UniqueIdentifier>{2505aa94-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_sdlrenderer3">
-      <UniqueIdentifier>{da535992-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_vulkan">
-      <UniqueIdentifier>{bc5700b1-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_sdl3_wgpu">
-      <UniqueIdentifier>{b3511882-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_directx10">
-      <UniqueIdentifier>{ffdcc484-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_directx11">
-      <UniqueIdentifier>{1ec285ef-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_directx12">
-      <UniqueIdentifier>{9c32029b-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_directx9">
-      <UniqueIdentifier>{c1caea97-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_opengl3">
-      <UniqueIdentifier>{b1ac1dca-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\example_win32_vulkan">
-      <UniqueIdentifier>{81f39c9e-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs\emscripten">
-      <UniqueIdentifier>{deff277e-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs">
-      <UniqueIdentifier>{4df04038-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs\glfw\include\GLFW">
-      <UniqueIdentifier>{f6903215-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs\glfw\include">
-      <UniqueIdentifier>{114c63d2-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs\glfw">
-      <UniqueIdentifier>{012e170c-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="examples\libs\usynergy">
-      <UniqueIdentifier>{269d74cc-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc\cpp">
-      <UniqueIdentifier>{405959db-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc">
-      <UniqueIdentifier>{0496d0b7-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc\debuggers">
-      <UniqueIdentifier>{68d63fa2-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc\fonts">
-      <UniqueIdentifier>{ae5b8b78-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc\freetype">
-      <UniqueIdentifier>{c72c0104-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <Filter Include="misc\single_file">
-      <UniqueIdentifier>{2ce20248-6c94-4f93-bc2a-7f5284b7d434}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-</Project>
@@ -1,24 +0,0 @@
-// ImGui
-//------------------------------------------------------------------------------
-{
-    .ProjectName        = 'ImGui'
-    .ProjectPath        = 'External/imgui'
-
-    // Configurations
-    //--------------------------------------------------------------------------
-    ForEach( .BuildConfigName in .BuildConfigs )
-    {
-        #if __WINDOWS__
-            .ProjectConfig              = [ Using( .'Project_x64_$BuildConfigName$' ) ]
-            ^ProjectConfigs             + .ProjectConfig
-        #endif
-    }
-
-    VCXProject( '$ProjectName$' )
-    {
-        .ProjectOutput              = 'External/$ProjectName$.vcxproj'
-        .ProjectBasePath            = '$ProjectPath$/'
-        .ProjectInputPaths          = .ProjectBasePath
-        .ProjectConfigs             = .ProjectConfigs
-    }
-}
@@ -0,0 +1,4 @@
+#pragma once
+
+constexpr index_t kPlayCamera  = 0;
+constexpr index_t kDebugCamera = 1;
@@ -0,0 +1,170 @@
+#include <Controller/DebugCameraController.h>
+
+#include <Controller/ControllerUtils.h>
+#include <Core/Common/CoreUtils.h>
+#include <Core/HAL/Keyboard/Keyboard.h>
+#include <Core/HAL/Mouse/Mouse.h>
+#include <Graphics/Camera.h>
+#include <imgui.h>
+
+namespace
+{
+
+    bool    gIsDebugCameraActive = false;
+    index_t gPreviousCameraIndex = 0;
+
+    float gPitch                   = 0.0f;
+    float gYaw                     = 0.0f;
+    bool  gFirstUpdate             = true;
+    bool  gIsFpsModeActive         = false;
+    bool  gWasRightMouseButtonDown = false;
+} // namespace
+
+void ActivateDebugController()
+{
+    Assert(gIsDebugCameraActive == false);
+
+    Camera* currentCam = GetCurrentCamera();
+    gPreviousCameraIndex       = currentCam->Index;
+
+    SetCurrentCamera(kDebugCamera);
+
+    gIsDebugCameraActive     = true;
+    gFirstUpdate             = true;
+    gIsFpsModeActive         = false;
+    gWasRightMouseButtonDown = false;
+}
+
+void DeactivateDebugController()
+{
+    Assert(gIsDebugCameraActive);
+
+    gIsDebugCameraActive = false;
+
+    SetCurrentCamera(gPreviousCameraIndex);
+}
+
+bool IsDebugControllerActive()
+{
+    return gIsDebugCameraActive;
+}
+
+void UpdateDebugController(float dt)
+{
+    Camera* currentCam = GetCurrentCamera();
+
+    if (gFirstUpdate)
+    {
+        Vector3 dir = Vector3{ 0.0f, 0.0f, 0.0f } - currentCam->Position;
+        dir                 = Normalize(dir);
+        gPitch              = asinf(dir.z);
+        gYaw                = atan2f(dir.y, dir.x);
+        gFirstUpdate        = false;
+
+        Vector3 forward;
+        forward.x             = cosf(gPitch) * cosf(gYaw);
+        forward.y             = cosf(gPitch) * sinf(gYaw);
+        forward.z             = sinf(gPitch);
+        Vector3 right = Normalize(Cross(Vector3{ 0.0f, 0.0f, 1.0f }, forward));
+        currentCam->Target    = currentCam->Position + forward;
+        currentCam->Up        = Cross(forward, right);
+    }
+
+    bool isRightMouseButtonDown = IsMouseButtonDown(MouseButton::Right);
+    if (isRightMouseButtonDown && !gWasRightMouseButtonDown)
+    {
+        gIsFpsModeActive = !gIsFpsModeActive;
+    }
+    gWasRightMouseButtonDown = isRightMouseButtonDown;
+
+    if (!gIsFpsModeActive)
+    {
+        return;
+    }
+
+    MousePosition mouseDelta = GetMouseDelta();
+
+    float sensitivity = 0.005f;
+    gYaw += mouseDelta.X * sensitivity;
+    gPitch -= mouseDelta.Y * sensitivity;
+
+    gPitch = std::min(gPitch, 1.5f);
+    gPitch = std::max(gPitch, -1.5f);
+
+    if (IsKeyDown(ScanCode::Q))
+    {
+        gYaw -= 2.0f * dt;
+    }
+    if (IsKeyDown(ScanCode::E))
+    {
+        gYaw += 2.0f * dt;
+    }
+
+    Vector3 forward;
+    forward.x = cosf(gPitch) * cosf(gYaw);
+    forward.y = cosf(gPitch) * sinf(gYaw);
+    forward.z = sinf(gPitch);
+
+    Vector3 right     = Normalize(Cross(Vector3{ 0.0f, 0.0f, 1.0f }, forward));
+    Vector3 defaultUp = Cross(forward, right);
+
+    static const float kMovementPerFrame = 10.f; // 10m/s
+
+    float speedPerFrame = kMovementPerFrame;
+    if (IsKeyDown(ScanCode::LeftShift))
+    {
+        speedPerFrame *= 10.f; // 100m/s
+    }
+
+    if (IsKeyDown(ScanCode::W))
+    {
+        currentCam->Position = currentCam->Position + forward * (speedPerFrame * dt);
+    }
+    if (IsKeyDown(ScanCode::S))
+    {
+        currentCam->Position = currentCam->Position - forward * (speedPerFrame * dt);
+    }
+    if (IsKeyDown(ScanCode::D))
+    {
+        currentCam->Position = currentCam->Position + right * (speedPerFrame * dt);
+    }
+    if (IsKeyDown(ScanCode::A))
+    {
+        currentCam->Position = currentCam->Position - right * (speedPerFrame * dt);
+    }
+    if (IsKeyDown(ScanCode::Space))
+    {
+        currentCam->Position = currentCam->Position + defaultUp * (speedPerFrame * dt);
+    }
+    if (IsKeyDown(ScanCode::LeftControl))
+    {
+        currentCam->Position = currentCam->Position - defaultUp * (speedPerFrame * dt);
+    }
+
+    currentCam->Target = currentCam->Position + forward;
+    currentCam->Up     = defaultUp;
+}
+
+#if JULIET_DEBUG
+void RenderImGuiDebugController(float dt)
+{
+    Camera* currentCam = GetCurrentCamera();
+
+    ImGui::Text("Delta time: %f", dt);
+
+    ImGui::Text("Camera:");
+    ImGui::Indent();
+    ImGui::BulletText("Index: %zu", (size_t)currentCam->Index);
+    ImGui::BulletText("Position: (%.3f, %.3f, %.3f)", currentCam->Position.x, currentCam->Position.y,
+                      currentCam->Position.z);
+    ImGui::BulletText("Target: (%.3f, %.3f, %.3f)", currentCam->Target.x, currentCam->Target.y, currentCam->Target.z);
+    ImGui::BulletText("Up: (%.3f, %.3f, %.3f)", currentCam->Up.x, currentCam->Up.y, currentCam->Up.z);
+    ImGui::BulletText("FOV: %.3f rad", currentCam->FOV);
+    ImGui::BulletText("AspectRatio: %.3f", currentCam->AspectRatio);
+    ImGui::BulletText("NearPlane: %.3f", currentCam->NearPlane);
+    ImGui::BulletText("FarPlane: %.3f", currentCam->FarPlane);
+    ImGui::BulletText("Pitch: %.3f, Yaw: %.3f", gPitch, gYaw);
+    ImGui::BulletText("FPS Mode: %s", gIsFpsModeActive ? "Active" : "Inactive");
+    ImGui::Unindent();
+}
+#endif
@@ -0,0 +1,12 @@
+#pragma once
+
+// TODO : Should support Debug/Profile/Release properly.
+// I think debug profile should have this controller but not release
+void ActivateDebugController();
+void DeactivateDebugController();
+bool IsDebugControllerActive();
+void UpdateDebugController(float dt);
+
+#if JULIET_DEBUG
+void RenderImGuiDebugController(float dt);
+#endif
@@ -0,0 +1,322 @@
+#include <Data/World.h>
+
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/serialization.h>
+#include <Core/HAL/Filesystem/Filesystem.h>
+#include <Core/HAL/IO/IOStream.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
+#include <Core/Thread/ThreadContext.h>
+#include <Entity/EntityManager.h>
+#include <Graphics/MeshRenderer.h>
+
+#ifdef JULIET_ENABLE_IMGUI
+#include <imgui.h>
+#endif
+
+void InitWorld(NonNullPtr<World> world, NonNullPtr<Arena> arena)
+{
+    world->WorldArena = arena.Get();
+}
+
+void ShutdownWorld(NonNullPtr<World> world)
+{
+    world->WorldArena = nullptr;
+}
+
+void AddToWorld(NonNullPtr<World> /*world*/, NonNullPtr<Entity> /*entity*/)
+{
+    // RegisterEntity(*world->EntityManager, entity.Get());
+}
+
+void RemoveWorldEntity(World& /*world*/, size_t /*index*/) {}
+
+void Serialize(Archive& ar, World& /*world*/, String filename)
+{
+    Assert(IsValid(filename));
+
+    auto& entityManager = GetEntityManager();
+
+    if (ar.loading)
+    {
+        // Load
+        ByteBuffer fileBuffer = LoadFile(ar.arena, filename);
+
+        // TEST SERIALIZATION
+        ParsedArchive archive = tokenize_archive(ar.arena, fileBuffer);
+        // ArchivePropertyNode* property = find_property(&archive, "Position"_crc32);
+        audit_unconsumed_properties(&archive, ConstString("World"));
+
+        // if (fileBuffer.Size >= sizeof(WorldFileHeader))
+        // {
+        //     ar.base_ptr = fileBuffer.Data;
+        //
+        //     WorldFileHeader header;
+        //     serialize_elem(ar, header);
+        //     Assert(header.Magic == kWorldMagic);
+        //
+        //     for (typed_entity_array& type : entityManager.by_type)
+        //     {
+        //         serialize_elem(ar, type.count);
+        //
+        //         if (type.count > 0)
+        //         {
+        //
+        //             // Unserialize the base entity to get informations
+        //             Entity entity;
+        //             // serialize(ar, &entity);
+        //         }
+        //     }
+        // }
+    }
+    else
+    {
+        // Save
+        IOStream* stream = IOFromFile(ar.arena, filename, WrapString("wb"));
+
+        index_t beginPos = ArenaPos(ar.arena);
+
+        // Headers
+        auto* header  = ArenaPushStruct<WorldFileHeader>(ar.arena);
+        header->Magic = kWorldMagic;
+
+        ar.base_ptr = header;
+
+        // TODO : Move to a one file per entity model
+        for (typed_entity_array& type : entityManager.by_type)
+        {
+            serialize_elem(ar, type.count);
+            auto*  element    = type.array;
+            uint8* rawElement = reinterpret_cast<uint8*>(element);
+            size_t stride     = element->base->derived_kind->size_of;
+            for (index_t idx = 0; idx < type.count; ++idx)
+            {
+                // Todo : utils
+                // Get base entity from type
+                Entity* entity = reinterpret_cast<EntityTemplate*>(rawElement + (idx * stride))->base;
+                serialize(ar, entity);
+            }
+        }
+
+        // Write
+        index_t    endPos      = ArenaPos(ar.arena);
+        ByteBuffer writeBuffer = { .Data = reinterpret_cast<Byte*>(header), .Size = endPos - beginPos };
+
+        size_t written = IOWrite(stream, writeBuffer);
+
+        Assert(writeBuffer.Size == written);
+
+        IOClose(stream);
+    }
+
+    //
+    // uint32 entityCount = static_cast<uint32>(world.Entities.Size());
+    // size_t totalBytes  = sizeof(WorldFileHeader) + static_cast<size_t>(entityCount) * sizeof(WorldEntityDiskRecord);
+    //
+    // ArenaParams tempParams = { .ReserveSize = Megabytes(1), .Name = "WorldSaveArena" };
+    // Arena*      tempArena  = ArenaAllocate(tempParams);
+    // if (!tempArena)
+    // {
+    //     LogError(LogCategory::Game, "SaveWorld: Failed to allocate memory for saving world.");
+    //     return false;
+    // }
+    //
+    // auto deferRelease = Defer([&]() { ArenaRelease(tempArena); });
+    //
+    // uint8* bufferData = ArenaPushArray<uint8, false>(tempArena, totalBytes);
+    // if (!bufferData)
+    // {
+    //     LogError(LogCategory::Game, "SaveWorld: Failed to allocate buffer in arena.");
+    //     return false;
+    // }
+    //
+    // auto* header        = reinterpret_cast<WorldFileHeader*>(bufferData);
+    // header->Magic       = kWorldMagic;
+    // header->Version     = kWorldVersion;
+    // header->EntityCount = entityCount;
+    // header->Reserved    = 0;
+    //
+    // auto* records = reinterpret_cast<WorldEntityDiskRecord*>(bufferData + sizeof(WorldFileHeader));
+    // for (size_t i = 0; i < entityCount; ++i)
+    // {
+    //     const Entity& ent = world.Entities[i];
+    //     records[i].X      = ent.X;
+    //     records[i].Y      = ent.Y;
+    //     records[i].Z      = ent.Z;
+    // }
+    //
+    // IOStream* stream = IOFromFile(tempArena, filename, WrapString("wb"));
+    // if (!stream)
+    // {
+    //     LogError(LogCategory::Game, "SaveWorld: Failed to open file for writing: %s", CStr(filename));
+    //     return false;
+    // }
+    //
+    // ByteBuffer writeBuffer = { .Data = reinterpret_cast<Byte*>(bufferData), .Size = totalBytes };
+    //
+    // size_t written = IOWrite(stream, writeBuffer);
+    // IOClose(stream);
+    //
+    // if (written != totalBytes)
+    // {
+    //     LogError(LogCategory::Game, "SaveWorld: Failed to write complete world data to %s (wrote %zu / %zu bytes)",
+    //              CStr(filename), written, totalBytes);
+    //     return false;
+    // }
+    //
+    // LogMessage(LogCategory::Game, "World successfully saved to %s (%u entities)", CStr(filename), entityCount);
+    // return true;
+}
+
+[[nodiscard]] bool LoadWorld(World& /*world*/, String filename)
+{
+    Assert(IsValid(filename));
+    // Assert(world.WorldArena != nullptr);
+    //
+    // TempArena loadArena = scratch_begin(nullptr, 0);
+    //
+    // ByteBuffer fileBuffer = LoadFile(loadArena.Arena, filename);
+    // if (fileBuffer.Data && fileBuffer.Size < sizeof(WorldFileHeader))
+    // {
+    //     const WorldFileHeader* header          = reinterpret_cast<const WorldFileHeader*>(fileBuffer.Data);
+    //     const bool             invalidMagicNum = header->Magic != kWorldMagic;
+    //     const bool             invalidVersion  = header->Version != kWorldVersion;
+    //     if (invalidMagicNum)
+    //     {
+    //         LogError(LogCategory::Game, "LoadWorld: Invalid magic in world file: %s (expected 0x%08X, got 0x%08X)",
+    //                  CStr(filename), kWorldMagic, header->Magic);
+    //     }
+    //
+    //     if (invalidVersion)
+    //     {
+    //         LogError(LogCategory::Game, "LoadWorld: Unsupported world file version: %u in %s", header->Version, CStr(filename));
+    //     }
+    //
+    //     size_t expectedSize = sizeof(WorldFileHeader) + static_cast<size_t>(header->EntityCount) * sizeof(WorldEntityDiskRecord);
+    //     const bool invalidSize = fileBuffer.Size < expectedSize;
+    //     if (invalidSize)
+    //     {
+    //         LogError(LogCategory::Game, "LoadWorld: Corrupted file %s: size %zu < expected %zu for %u entities",
+    //                  CStr(filename), fileBuffer.Size, expectedSize, header->EntityCount);
+    //     }
+    //
+    //     if (!invalidMagicNum && !invalidVersion && !invalidSize)
+    //     {
+    //
+    //         // world.Entities.Clear();
+    //         //
+    //         // const auto* records = reinterpret_cast<const WorldEntityDiskRecord*>(
+    //         //     reinterpret_cast<const uint8*>(fileBuffer.Data) + sizeof(WorldFileHeader));
+    //         //
+    //         // for (uint32 i = 0; i < header->EntityCount; ++i)
+    //         // {
+    //         //     Entity ent;
+    //         //     (void)AddWorldEntity(world, records[i].X, records[i].Y, records[i].Z);
+    //         // }
+    //
+    //         LogMessage(LogCategory::Game, "World successfully loaded from %s (%u entities)", CStr(filename), header->EntityCount);
+    //     }
+    // }
+    // else
+    // {
+    //     LogError(LogCategory::Game, "LoadWorld: Failed to read world file or file is too small: %s", CStr(filename));
+    // }
+    //
+    // scratch_end(loadArena);
+
+    return true;
+}
+
+#ifdef JULIET_EDITOR
+void RenderWorldEditorUI(World& world)
+{
+    if (ImGui::Begin("World Editor"))
+    {
+        TempArena   temp               = scratch_begin(nullptr, 0);
+        static char worldFilePath[256] = "../world.bin";
+        ImGui::InputText("World File", worldFilePath, sizeof(worldFilePath));
+
+        String path = GetAssetPath(temp.Arena, WrapString(worldFilePath));
+
+        if (ImGui::Button("Save World"))
+        {
+            Archive data = { .arena = temp.Arena, .loading = false };
+            Serialize(data, world, path);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Load World"))
+        {
+            Archive data{ .arena = temp.Arena, .loading = true };
+            Serialize(data, world, path);
+        }
+
+        scratch_end(temp);
+
+        //     ImGui::SameLine();
+        //     if (ImGui::Button("Clear All"))
+        //     {
+        //         ClearWorld(world);
+        //     }
+        //
+        //     ImGui::Separator();
+        //
+        //     if (ImGui::Button("Add Entity"))
+        //     {
+        //         (void)AddWorldEntity(world, 0.0f, 0.0f, 0.0f);
+        //     }
+        //
+        //     ImGui::Text("Entity Count: %zu", world.Entities.Size());
+        //     ImGui::Separator();
+        //
+        //     static int selectedEntity = -1;
+        //     if (selectedEntity >= static_cast<int>(world.Entities.Size()))
+        //     {
+        //         selectedEntity = -1;
+        //     }
+        //
+        //     ImGui::BeginChild("EntityList", ImVec2(180, 200), true);
+        //     for (size_t i = 0; i < world.Entities.Size(); ++i)
+        //     {
+        //         char label[64];
+        //         snprintf(label, sizeof(label), "Entity #%zu (ID: %llu)", i, world.Entities[i].ID);
+        //         if (ImGui::Selectable(label, selectedEntity == static_cast<int>(i)))
+        //         {
+        //             selectedEntity = static_cast<int>(i);
+        //         }
+        //     }
+        //     ImGui::EndChild();
+        //
+        //     ImGui::SameLine();
+        //
+        //     ImGui::BeginChild("EntityInspector", ImVec2(0, 200), true);
+        //     if (selectedEntity >= 0 && selectedEntity < static_cast<int>(world.Entities.Size()))
+        //     {
+        //         Entity& ent = world.Entities[static_cast<size_t>(selectedEntity)];
+        //         ImGui::Text("Selected: Entity #%d", selectedEntity);
+        //         ImGui::Text("ID: %llu", ent.ID);
+        //
+        //         float pos[3] = { ent.X, ent.Y, ent.Z };
+        //         if (ImGui::DragFloat3("Position", pos, 0.1f))
+        //         {
+        //             ent.X = pos[0];
+        //             ent.Y = pos[1];
+        //             ent.Z = pos[2];
+        //             UpdateWorld(world);
+        //         }
+        //
+        //         if (ImGui::Button("Delete Entity"))
+        //         {
+        //             RemoveWorldEntity(world, static_cast<size_t>(selectedEntity));
+        //             selectedEntity = -1;
+        //             UpdateWorld(world);
+        //         }
+        //     }
+        //     else
+        //     {
+        //         ImGui::Text("Select an entity to edit its properties.");
+        //     }
+        //     ImGui::EndChild();
+    }
+    ImGui::End();
+}
+#endif
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <Core/Common/NonNullPtr.h>
+#include <Core/Common/String.h>
+#include <Core/Container/Vector.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Entity/Entity.h>
+
+struct Archive;
+struct EntityManager;
+
+#pragma pack(push, 1)
+struct WorldFileHeader
+{
+    uint32 Magic = 0x444C574A; // 'JWLD' in little-endian
+};
+#pragma pack(pop)
+
+constexpr uint32 kWorldMagic   = 0x444C574A; // 'JWLD'
+constexpr uint32 kWorldVersion = 1;
+
+struct World
+{
+    Arena*         WorldArena    = nullptr;
+    EntityManager* EntityManager = nullptr;
+};
+
+void InitWorld(NonNullPtr<World> world, NonNullPtr<Arena> arena);
+void ShutdownWorld(NonNullPtr<World> world);
+
+void AddToWorld(NonNullPtr<World> world, NonNullPtr<Entity> entity);
+void RemoveWorldEntity(World& world, size_t index);
+
+void Serialize(Archive& data, World& world, String filename);
+
+#if JULIET_EDITOR
+void RenderWorldEditorUI(World& world);
+#endif
@@ -0,0 +1,49 @@
+#include <Debug/DebugTopBar.h>
+
+#include <game.h>
+#include <imgui.h>
+
+namespace
+{
+    String GetGameModeName(GameMode gameMode)
+    {
+        switch (gameMode)
+        {
+        case GameMode::Editor: return WrapString("Editor");
+        case GameMode::Play: return WrapString("Play");
+        case GameMode::Debug: return WrapString("Debug");
+        default: return WrapString("Unknown ERROR");
+        }
+    }
+} // namespace
+
+void DrawTopBar()
+{
+    auto* gameState = GetGameState();
+
+    ImGuiViewport* viewport = ImGui::GetMainViewport();
+    ImGui::SetNextWindowPos(viewport->Pos);
+    ImGui::SetNextWindowSize(ImVec2(viewport->Size.x, 10.0f));
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
+                             ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
+
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.6f));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(10.0f, 5.0f));
+
+    if (ImGui::Begin("TopBarOverlay", nullptr, flags))
+    {
+        ImGui::Text("Game Mode: %s", CStr(GetGameModeName(gameState->Mode)));
+
+        char fps_text[32];
+        snprintf(fps_text, sizeof(fps_text), "FPS: %.1f (%.2f ms)", ImGui::GetIO().Framerate, 1000.0f / ImGui::GetIO().Framerate);
+        float text_width = ImGui::CalcTextSize(fps_text).x;
+        ImGui::SameLine(viewport->Size.x - text_width - 15.0f); // 15px right padding
+        // Render FPS text
+        ImGui::Text("%s", fps_text);
+    }
+    ImGui::End();
+
+    ImGui::PopStyleVar();
+    ImGui::PopStyleColor();
+}
@@ -0,0 +1,5 @@
+#pragma once
+
+#if JULIET_DEBUG
+void DrawTopBar();
+#endif
@@ -0,0 +1,50 @@
+#include <Entity/Entity.h>
+
+#include <Core/Common/serialization.h>
+
+void serialize(Archive& ar, NonNullPtr<Entity> entity)
+{
+    // Entity fields
+    serialize(ar, Entity::kind, entity.Get());
+
+    // Derived fields
+    if (entity->derived_kind != nullptr && entity->derived != nullptr)
+    {
+        serialize(ar, entity->derived_kind, entity->derived);
+    }
+}
+
+DEFINE_CLASS_VERSIONED(Entity, 1, nullptr)
+internal void serialize(Archive& ar, uint16 /*version*/, Entity& entity)
+{
+    SERIALIZE(ar, id, entity.ID);
+    SERIALIZE(ar, position, entity.position);
+}
+
+const Class* resolve_entity_class(uint8 kind, uint32 crc)
+{
+    Assert(kind <= ENTITY(Count));
+
+    NonNullPtr<const Class> class_ptr = kEntity_type_class_ptr[kind];
+    Assert(class_ptr->CRC == crc);
+
+    return class_ptr.Get();
+}
+
+const Class* find_class_by_name(String name)
+{
+    Assert(IsValid(name));
+
+    const Class* result   = nullptr;
+    const uint32 name_crc = crc32(name.Str, name.Size);
+    for (uint8 kind = 0; kind < ENTITY(Count); ++kind)
+    {
+        const Class* class_ptr = resolve_entity_class(kind, name_crc);
+        if (class_ptr != nullptr)
+        {
+            result = class_ptr;
+            break;
+        }
+    }
+    return result;
+}
@@ -1,74 +1,71 @@
 #pragma once

-#include <concepts>
 #include <Core/Common/CoreUtils.h>
-#include <Core/Memory/Allocator.h>
-#include <Core/Memory/MemoryArena.h>
+#include <Core/Math/Vector.h>
 #include <Engine/Class.h>
+#include <Entity/entity_common.h>
 #include <Entity/EntityManager.h>
-#include <type_traits>

-// Add any new fields into the concept below
-#define DECLARE_ENTITY()                                                                                               \
-    Entity*                     Base;                                                                                  \
-    static const Juliet::Class* Kind;
-
-// Will register the class globally at launch
-#define DEFINE_ENTITY(entity)                                                                                          \
-    constexpr Juliet::Class entityKind##entity(#entity, sizeof(#entity) / sizeof(char));                               \
-    const Juliet::Class*    entity::Kind = &entityKind##entity;
-
-namespace Game
+struct Entity final
 {
-    using DerivedType = void*;
+    DECLARE_CLASS()

-    struct Entity final
-    {
-        EntityID             ID;
-        const Juliet::Class* Kind;
-        DerivedType          Derived;
-        float                X, Y;
-    };
+    EntityID     ID           = 0;
+    const Class* derived_kind = nullptr;
+    DerivedType  derived      = nullptr;
+    Vector4      position     = {};
+    bool         is_dirty     = false;
+};

-    template <typename EntityType>
-    concept EntityConcept = requires(EntityType entity) {
-        requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
-        requires std::same_as<decltype(entity.Base), Entity*>;
-    };
+// Can reinterpret cast to this to have the offset of Base and Kind for any entity
+struct EntityTemplate
+{
+    DECLARE_ENTITY();
+};

-    template <typename EntityType>
+//
+template <typename EntityType>
+concept EntityConcept = requires(EntityType entity) {
+    { EntityType::kind } -> std::convertible_to<const Class*>;
+    requires std::same_as<decltype(entity.base), Entity*>;
+};
+
+template <typename EntityType>
    requires EntityConcept<EntityType>
-    bool IsA(const Entity* entity)
-    {
-        return entity->Kind == EntityType::Kind;
-    }
+[[nodiscard]] bool IsA(const Entity* entity)
+{
+    Assert(entity != nullptr);
+    return entity->derived_kind == EntityType::kind;
+}

-    template <typename EntityType>
+template <typename EntityType>
    requires EntityConcept<EntityType>
-    EntityType* MakeEntity(EntityManager& manager, float x, float y)
-    {
-        auto*       arena  = manager.Arena;
-        EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
-        Entity      base;
-        base.X       = x;
-        base.Y       = y;
-        base.Derived = result;
-        base.Kind    = EntityType::Kind;
-        manager.Entities.PushBack(base);
+[[nodiscard]] EntityType* MakeEntity(EntityManager& manager, float x, float y, float z)
+{
+    Entity* base_ptr = allocate_entity(manager, EntityType::kind);
+    Assert(base_ptr);

-        result->Base = manager.Entities.Back();
+    base_ptr->ID = EntityManager::ID++;

-        RegisterEntity(manager, &base);
+    base_ptr->position.x = x;
+    base_ptr->position.y = y;
+    base_ptr->position.z = z;
+    base_ptr->position.w = 1.0f;

-        return result;
-    }
+    return (EntityType*)base_ptr->derived;
+}

-    template <typename EntityType>
+template <typename EntityType>
    requires EntityConcept<EntityType>
-    EntityType* DownCast(Entity* entity)
-    {
+[[nodiscard]] EntityType* DownCast(Entity* entity)
+{
+    Assert(entity != nullptr);
    Assert(IsA<EntityType>(entity));
-        return static_cast<EntityType*>(entity->Derived);
-    }
+    return static_cast<EntityType*>(entity->derived);
+}

-} // namespace Game
+void serialize(Archive& ar, NonNullPtr<Entity> entity);
+
+[[nodiscard]] const Class* find_class_by_name(String name);
+
+[[nodiscard]] const Class* resolve_entity_class(uint8 kind, uint32 crc);
@@ -1,34 +1,143 @@
 #include <Entity/EntityManager.h>

+#include <Core/Common/EnumUtils.h>
+#include <Core/Common/serialization.h>
+#include <Data/World.h>
 #include <Entity/Entity.h>
+#include <Entity/entity_types.h>
+#include <game.h>
+#include <Graphics/MeshRenderer.h>

-namespace Game
+EntityID EntityManager::ID = 0;
+
+void InitEntityManager(NonNullPtr<World> world)
 {
-    namespace
+    EntityManager* newManager = ArenaPushStruct<EntityManager>(world->WorldArena);
+    world->EntityManager      = newManager;
+
+    newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
+
+    ArenaParams by_type_params{ .ReserveSize = Kilobytes(1),
+                                .CommitSize  = Kilobytes(1),
+                                .Name        = "" JULIET_DEBUG_ONLY(, .CanReserveMore = false) };
+    for (uint8 i = 0; i < ENTITY(Count); ++i)
    {
-        EntityManager Manager;
+        by_type_params.Name          = kEntity_type_names[i];
+        newManager->by_type[i].arena = ArenaAllocate(by_type_params);
+        newManager->by_type[i].array = nullptr;
+    }
+}
+
+void ShutdownEntityManager()
+{
+    auto& manager = GetEntityManager();
+    for (typed_entity_array& type : manager.by_type)
+    {
+        ArenaRelease(type.arena);
    }

-    EntityID EntityManager::ID = 0;
+    manager.Entities.Destroy();
+}

-    void InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena)
+EntityManager& GetEntityManager()
+{
+    NonNullPtr entityManager = GetGameState()->World->EntityManager;
+    return *entityManager;
+}
+
+EntityTemplate* RegisterEntity(EntityManager& manager, Entity* base, DerivedType entity)
+{
+    base->ID      = EntityManager::ID++;
+    base->derived = entity;
+
+    manager.Entities.PushBack(*base);
+
+    auto* ptr = (EntityTemplate*)ArenaPushSize(manager.by_type[base->derived_kind->kind].arena,
+                                               base->derived_kind->size_of, base->derived_kind->alignment,
+                                               false JULIET_DEBUG_PARAM(kEntity_type_names[base->derived_kind->kind]));
+    MemCopy(ptr, entity, base->derived_kind->size_of);
+    manager.by_type[base->derived_kind->kind].count += 1;
+
+    ptr->base = manager.Entities.Back();
+
+    if (manager.by_type[base->derived_kind->kind].array == nullptr)
    {
-        Manager.Arena = arena.Get();
-        Manager.Entities.Create(arena JULIET_DEBUG_PARAM("Entities"));
+        manager.by_type[base->derived_kind->kind].array = ptr;
    }

-    void ShutdownEntityManager()
+    return ptr;
+}
+
+Entity* allocate_entity(EntityManager& manager, NonNullPtr<const Class> derived_type_class)
+{
+    Assert(derived_type_class->kind < ENTITY(Count));
+    Assert(derived_type_class->size_of >= sizeof(EntityTemplate));
+    Assert(derived_type_class->alignment > 0);
+    Assert(derived_type_class->initialize_fct);
+
+    Entity base_template       = {};
+    base_template.derived_kind = derived_type_class;
+    base_template.is_dirty     = true;
+
+    manager.Entities.PushBack(base_template);
+    Entity* base_ptr = manager.Entities.Back();
+    Assert(base_ptr);
+
+    typed_entity_array& typed_array = manager.by_type[derived_type_class->kind];
+    Assert(typed_array.arena);
+
+    void* derived = ArenaPushSize(typed_array.arena, derived_type_class->size_of, derived_type_class->alignment,
+                                  false JULIET_DEBUG_PARAM(kEntity_type_names[derived_type_class->kind]));
+    Assert(derived);
+    derived_type_class->initialize_fct(derived);
+
+    auto* derived_template = (EntityTemplate*)derived;
+
+    base_ptr->derived      = derived;
+    derived_template->base = base_ptr;
+
+    if (typed_array.array == nullptr)
    {
-        Manager.Entities.Destroy();
+        typed_array.array = derived_template;
+    }
+    typed_array.count += 1;
+
+    return base_ptr;
+}
+
+void UpdateEntityManager(EntityManager& manager)
+{
+    // Todo : inert by definition dont move, but this is for test
+    auto& by_type = manager.by_type[ENTITY(Inert)];
+    for (index_t i = 0; i < by_type.count; ++i)
+    {
+        Inert* inert = reinterpret_cast<Inert*>(by_type.array) + i;
+        if (inert->MeshInstance != indexMax)
+        {
+            SetMeshInstanceTransform(inert->MeshInstance,
+                                     MatrixTranslation(inert->base->position.x, inert->base->position.y,
+                                                       inert->base->position.z));
+        }
+    }
+}
+
+Entity* deserialize_entity(Archive& ar, EntityManager& manager)
+{
+    Assert(ar.loading);
+
+    String class_name;
+    SERIALIZE(ar, Class, class_name);
+
+    NonNullPtr<const Class> class_ptr = find_class_by_name(class_name);
+
+    NonNullPtr<Entity> entity_base = allocate_entity(manager, class_ptr);
+
+    serialize(ar, entity_base);
+
+    if (entity_base->ID >= EntityManager::ID)
+    {
+        EntityManager::ID = entity_base->ID + 1;
    }

-    EntityManager& GetEntityManager()
-    {
-        return Manager;
-    }
-
-    void RegisterEntity(EntityManager& /*manager*/, Entity* entity)
-    {
-        entity->ID = EntityManager::ID++;
-    }
-} // namespace Game
+    entity_base->is_dirty = false;
+}
@@ -1,24 +1,34 @@
 #pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Container/Vector.h>
+#include <Entity/entity_common.h>

-namespace Game
+struct World;
+struct EntityTemplate;
+struct Entity;
+struct Class;
+
+struct typed_entity_array
 {
-    using EntityID = uint64_t;
+    Arena*          arena;
+    EntityTemplate* array;
+    size_t          count;
+};

-    struct Entity;
-    struct EntityManager
-    {
+struct EntityManager
+{
    static EntityID ID;

-        Juliet::Arena* Arena;
    // TODO: Should be a pool
-        Juliet::VectorArena<Entity, 1024> Entities;
-    };
+    VectorArena<Entity, 100'000> Entities;

-    void           InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena);
-    void           ShutdownEntityManager();
-    EntityManager& GetEntityManager();
-    void           RegisterEntity(EntityManager& manager, Entity* entity);
-} // namespace Game
+    typed_entity_array by_type[ENTITY(Count)];
+};
+
+void                  InitEntityManager(NonNullPtr<World> world);
+void                  ShutdownEntityManager();
+EntityManager&        GetEntityManager();
+EntityTemplate*       RegisterEntity(EntityManager& manager, Entity* base, DerivedType entity);
+[[nodiscard]] Entity* allocate_entity(EntityManager& manager, NonNullPtr<const Class> derived_type_class);
+void                  UpdateEntityManager(EntityManager& manager);
+[[nodisacrd]] Entity* deserialize_entity(Archive& archive, EntityManager& manager);
@@ -0,0 +1,21 @@
+#include <Entity/entity_common.h>
+
+#include <Entity/Entity.h>
+#include <Entity/entity_types.h>
+
+// clang-format off
+#define AS_STR(name) #name
+ const char* kEntity_type_names[] = {
+    ENTITY_TYPE_LIST(AS_STR)
+    "Count"
+};
+#undef AS_STR
+
+#define AS_CLASS(name) name::kind
+const Class* kEntity_type_class_ptr[]
+{
+    ENTITY_TYPE_LIST(AS_CLASS)
+    nullptr
+};
+#undef AS_CLASS
+// clang-format on
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <Core/Common/EnumUtils.h>
+#include <Engine/Class.h>
+
+struct Class;
+using DerivedType = void*;
+using EntityID    = uint64_t;
+
+// clang-format off
+#define ENTITY_TYPE_LIST(X) X(Inert),
+
+#define AS_ENUM(name) name
+enum class Entity_Type : uint8
+{
+    ENTITY_TYPE_LIST(AS_ENUM)
+    Count
+};
+#undef AS_ENUM
+
+extern const char* kEntity_type_names[];
+extern const Class* kEntity_type_class_ptr[];
+
+#define ENTITY(kind) ToUnderlying(Entity_Type::kind)
+// clang-format on
+
+struct Entity;
+
+#define DECLARE_ENTITY()                                                                                               \
+    Entity* base;                                                                                                      \
+    DECLARE_CLASS()
+
+#define DEFINE_ENTITY_VERSIONED(entity, version)                                                                       \
+    constexpr Class entityKind##entity =                                                                               \
+        MakeClass(ConstString(#entity), (uint8)Entity_Type::entity, (version), &class_kind_Entity, sizeof(entity),     \
+                  alignof(entity), (&initialize_thunk<entity>), (&serialize_thunk<entity>));                           \
+    Class* entity::kind = const_cast<Class*>(&entityKind##entity);
+
+// Note: Needed by every classes see define above
+extern const Class class_kind_Entity;
@@ -0,0 +1,4 @@
+#include <Entity/entity_types.h>
+
+DEFINE_ENTITY_VERSIONED(Inert, 1)
+internal void serialize(Archive& /*ar*/, uint16 /*version*/, Inert& /*inert*/) {}
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Entity/entity_common.h>
+
+struct Inert
+{
+    DECLARE_ENTITY()
+
+    index_t MeshInstance = indexMax;
+};
@@ -1,24 +0,0 @@
-// Game - Lib/Dll
-//------------------------------------------------------------------------------
-{
-    .ProjectName        = 'Game'
-    .ProjectPath        = 'Game'
-
-    // Library Configurations
-    //--------------------------------------------------------------------------
-    ForEach( .BuildConfigName in .BuildConfigs )
-    {
-        #if __WINDOWS__
-            .ProjectConfig              = [ Using( .'Project_x64_$BuildConfigName$' ) ]
-            ^ProjectConfigs             + .ProjectConfig
-        #endif
-    }
-
-    VCXProject( '$ProjectName$' )
-    {
-        .ProjectOutput              = '$ProjectPath$/$ProjectName$.vcxproj'
-        .ProjectBasePath            = '$ProjectPath$/'
-        .ProjectInputPaths          = .ProjectBasePath
-        .ProjectConfigs             = .ProjectConfigs
-    }
-}
@@ -1,91 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Profile|x64">
-      <Configuration>Profile</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{b568a67e-05a1-9907-ff4b-a129119528bd}</ProjectGuid>
-    <Keyword>MakeFileProj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Debug $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Debug $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Debug $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Debug\Game.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;DEBUG;JULIET_DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Debug\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Debug\Game\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Debug\</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Profile $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Profile $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Profile $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Profile\Game.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;RELEASE;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Profile\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Profile\Game\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Profile\</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Release $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Release $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Release $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Release\Game.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;RELEASE;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Release\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Release\Game\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Release\</OutDir>
-  </PropertyGroup>
-  <ItemGroup>
-    <ClCompile Include="Entity\EntityManager.cpp" />
-    <ClCompile Include="game.cpp" />
-    <ClInclude Include="Entity\Entity.h" />
-    <ClInclude Include="Entity\EntityManager.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Entity">
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="Entity\EntityManager.cpp">
-      <Filter>Entity</Filter>
-    </ClCompile>
-    <ClCompile Include="game.cpp" />
-    <ClInclude Include="Entity\Entity.h">
-      <Filter>Entity</Filter>
-    </ClInclude>
-    <ClInclude Include="Entity\EntityManager.h">
-      <Filter>Entity</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>
@@ -0,0 +1,439 @@
+# Juliet Engine: Serialization & Text Archive Architecture
+
+## Technical Specification & Architectural Design
+
+---
+
+## 1. Executive Summary & Architecture Goals
+
+### 1.1 Context & Motivation
+Juliet historically relied on monolithic, packed binary blobs for world and entity persistence. While fast to read as raw byte offsets, binary serialization suffers from three major flaws:
+1. **Merge Incompatibility**: Binary assets cannot be merged or diffed in version control systems (Git / Perforce), causing unresolvable binary conflicts and data loss.
+2. **Schema Rigidity**: Adding, removing, or reordering a single struct field invalidates all existing binary files unless complex manual byte-offset mapping tables are maintained.
+3. **Opacity**: Designers and engineers cannot inspect, debug, or patch asset properties in a standard text editor.
+
+### 1.2 Architectural Goals
+The `.jasset` text archive framework replaces legacy binary blobs with a human-readable, diff-friendly property serialization pipeline adhering to Juliet's systems programming principles:
+- **Zero Dynamic Heap Allocations**: Parsing, tokenization, formatting, and buffer transformations execute entirely within Juliet memory arenas (`Arena`, `TempArena`, `scratch_begin` / `scratch_end`). Standard library containers (`std::string`, `std::vector`) and raw heap allocators (`malloc`, `new`) are forbidden.
+- **Zero-Copy In-Memory Tokenization**: Files are loaded into arena memory once via `LoadFile`. The tokenizer parses properties into lightweight slices represented by Juliet's `String` (`char* Str; size_t Size;`), referencing existing file buffer bytes without string duplication.
+- **$O(1)$ Property Lookup via Compile-Time & Runtime CRC32**: Property keys in text files are hashed once during tokenization into 32-bit CRC values. In code, lookups utilize compile-time hashed literals (`operator""_crc32`). Property resolution is a single 32-bit integer comparison.
+- **Symmetric Single-Function Serialization**: A single `serialize` implementation per entity or data structure handles both Save and Load paths, guaranteeing read and write schemas never diverge.
+- **Graceful Forward/Backward Compatibility**: Missing keys during load automatically preserve struct default values. Unknown keys present in newer asset files are safely ignored without parse failure.
+- **Two-Tier Decoupled Versioning via Generalized `Class`**: Core engine entity properties (`; version`) and derived gameplay class properties (`; class_version`) are versioned independently through their respective `Class` descriptors.
+- **In-Place Schema Migration**: Deprecated fields no longer present in C++ structs are read into temporary stack variables during load using standard `SERIALIZE` calls guarded by `if (ar.loading && version < N)`, seamlessly converting legacy data without struct pollution or persisting obsolete keys on subsequent saves.
+- **Clean Warning-Free C++**: Fully conforming to Juliet coding guidelines: strict assertions (`Assert`), `[[nodiscard]]`, `auto*`/`auto&`, mandatory braces, and `static_cast`/`reinterpret_cast`.
+
+---
+
+## 2. The `.jasset` Text Format Specification
+
+### 2.1 Grammar & Structural Rules
+The `.jasset` format uses a line-oriented, key-value property hierarchy designed for visual clarity and clean Git diffs.
+
+```ebnf
+AssetFile             ::= { CommentLine | EmptyLine | PropertyDeclaration } ;
+CommentLine           ::= ( "#" | "//" ) { Character } LineEnding ;
+EmptyLine             ::= { Whitespace } LineEnding ;
+PropertyDeclaration   ::= KeyHeader LineEnding ValueBlock ;
+KeyHeader             ::= ";" { Whitespace } Identifier ;
+ValueBlock            ::= { ValueLine LineEnding } ;
+ValueLine             ::= { Whitespace } ValueString { Whitespace } ;
+LineEnding            ::= "\r\n" | "\n" ;
+Identifier            ::= [a-zA-Z_][a-zA-Z0-9_]* ;
+```
+
+#### Formatting Rules:
+1. **Key Declarations**: A property begins with a semicolon `;` followed by optional whitespace and a case-sensitive identifier (e.g. `; position`).
+2. **Value Blocks**: The line(s) immediately following a key header contain its value payload.
+3. **Comments**: Any line whose first non-whitespace character is `#` or `//` is treated as a comment and ignored. Inline comments on property lines are forbidden.
+4. **Whitespace**: Leading and trailing spaces or tabs on both keys and values are stripped during tokenization.
+5. **Line Endings**: Both Windows CRLF (`\r\n`) and Linux LF (`\n`) are transparently accepted.
+
+### 2.2 Formatting Specifications
+
+#### Scalar Types
+Scalars are formatted as decimal representations on a single line:
+```
+; max_speed
+180.500000
+
+; gear_count
+6
+
+; turbo
+true
+```
+- Floats: Output via `%.9g` or `%f`.
+- Integers: Signed (`%d`, `%lld`) and unsigned (`%u`, `%llu`).
+- Booleans: Case-insensitive `true` / `false` or `1` / `0`.
+
+#### Vector Types (`Vector4`)
+Multi-component vectors are space-delimited on a single value line:
+```
+; position
+10.0 20.0 30.0 1.0
+```
+
+#### String Types (`String`)
+Strings containing spaces are wrapped in double quotes `"..."`. Quotes are automatically stripped upon loading and emitted during saving when spaces are present:
+```
+; name
+"Paladin Hero"
+```
+
+#### Asset File Example (`Entity_01.jasset`)
+```
+# Juliet Entity Asset File
+; version
+1
+
+; id
+1001
+
+; position
+12.500000 0.000000 45.200000 1.000000
+
+; class
+Inert
+
+; class_version
+1
+
+; mesh_instance
+42
+```
+
+---
+
+## 3. Zero-Copy Tokenization & Fast Property Lookup
+
+### 3.1 Data Structures (`Core/Common/serialization.h`)
+
+To eliminate heap fragmentation, the parser loads the entire `.jasset` file into contiguous arena memory and parses it into a flat array of lightweight slices.
+
+```cpp
+struct ArchivePropertyNode
+{
+    String key;
+    String value;
+    uint32 key_crc;
+    bool   consumed;
+};
+
+struct ParsedArchive
+{
+    ArchivePropertyNode* nodes          = nullptr;
+    uint32               property_count = 0;
+};
+```
+
+- `key`: Sliced `String` referencing the key name.
+- `value`: Sliced `String` directly referencing file buffer bytes (zero-copy).
+- `key_crc`: 32-bit CRC hash computed once during tokenization.
+- `consumed`: Initialized to `false`. Set to `true` whenever queried by `find_property`.
+
+### 3.2 Dual-Mode CRC32 (`Core/Common/CRC32.h`)
+Lookups rely on compile-time string hashing via `constexpr` / `consteval`:
+```cpp
+[[nodiscard]] constexpr uint32 crc32(const char* str, size_t length);
+[[nodiscard]] constexpr uint32 crc32(String str);
+[[nodiscard]] consteval uint32 operator""_crc32(const char* str, size_t length);
+```
+
+### 3.3 Tokenization API (`tokenize_archive`)
+```cpp
+JULIET_API ParsedArchive tokenize_archive(NonNullPtr<Arena> arena, ByteBuffer file_buffer);
+```
+**Algorithm Invariants**:
+1. **Pass 1 (Count)**: Scans the buffer to count `;` key headers at line starts, allocating the exact node array in `arena`.
+2. **Pass 2 (Extract)**: Slices key and value `String`s, trims whitespace, computes `key_crc = crc32(key)`, and populates nodes. Skips `#` and `//` comments.
+
+### 3.4 Property Lookup & Audit API
+```cpp
+JULIET_API ArchivePropertyNode* find_property(NonNullPtr<ParsedArchive> archive, uint32 property_crc);
+
+#if JULIET_DEBUG
+JULIET_API void audit_unconsumed_properties(NonNullPtr<ParsedArchive> archive, String context_name);
+#endif
+```
+- `find_property`: Performs an $O(1)$ integer comparison against `key_crc`. When found, marks `node->consumed = true`.
+- `audit_unconsumed_properties`: Iterates through all nodes in debug builds and logs warnings for any property with `consumed == false`, catching typos or abandoned schema fields.
+
+---
+
+## 4. The `Archive` Context Struct & Streaming I/O
+
+### 4.1 Struct Definition (`Core/Common/serialization.h`)
+The `Archive` struct unifies loading and saving state into a single decoupled context:
+
+```cpp
+struct Archive
+{
+    Arena*        arena;
+    bool          loading;
+    ParsedArchive base   = {};
+    IOStream*     stream = nullptr;
+
+    // Legacy binary support fields (to be deprecated)
+    void*   base_ptr = nullptr;
+    index_t offset   = 0;
+};
+```
+
+- When `loading == true`: Reads properties from `base.nodes` via `find_property`.
+- When `loading == false`: Writes formatted key-value pairs directly to `stream`.
+
+### 4.2 Property Header Formatting
+```cpp
+JULIET_API void write_property_header(Archive& archive, String property_name);
+```
+Emits `; <property_name>\n` directly to `ar.stream` with zero intermediate heap buffers.
+
+---
+
+## 5. Property Serialization API & Helpers
+
+### 5.1 Unified Serialization Idiom
+All property serialization uses a single template function:
+
+```cpp
+template <typename Type>
+bool serialize(Archive& ar, String property_name, uint32 property_crc, Type& value)
+{
+    Assert(IsValid(property_name));
+
+    bool result = false;
+    if (ar.loading)
+    {
+        if (auto* prop = find_property(&ar.base, property_crc))
+        {
+            if (read_prop(ar, prop->value, value))
+            {
+                result = true;
+            }
+        }
+    }
+    else
+    {
+        write_property_header(ar, property_name);
+        write(ar.stream, value);
+        result = true;
+    }
+
+    return result;
+}
+```
+
+### 5.2 Convenience Macros
+```cpp
+#define SERIALIZE(ar, name, var) serialize((ar), ConstString(#name), #name##_crc32, (var))
+#define SERIALIZE_SIMPLE(ar, var) SERIALIZE(ar, var, var)
+```
+- `SERIALIZE(ar, id, entity->ID)`: Serializes property named `"id"` with `"id"_crc32`.
+- `SERIALIZE_SIMPLE(ar, position)`: Uses variable identifier as property name.
+
+### 5.3 Supported Type Conversions
+Conversion between text and memory is handled by overloaded `read` and `write` primitives:
+
+| C++ Type | Text Format | Conversion Primitive |
+| :--- | :--- | :--- |
+| `float` | `180.500000` | `strtof` / `IOPrintf("%.9g")` |
+| `int8`, `int16`, `int32`, `int64` | `42` / `-100` | `strtol`, `strtoll` / `IOPrintf("%d")` |
+| `uint8`, `uint16`, `uint32`, `uint64` | `1001` / `0x...` | `strtoul`, `strtoull` / `IOPrintf("%u")` |
+| `bool` | `true` / `false` | `true/false/1/0` string compare / `IOPrintf` |
+| `Vector4` | `10.0 20.0 30.0 1.0` | Space-delimited float parse / `IOPrintf` |
+| `String` | `"Paladin Hero"` | Arena-allocated copy, quote strip / `IOPrintf` |
+
+---
+
+## 6. Two-Tier Versioning & Generalized `Class` Architecture
+
+### 6.1 Architectural Principle
+To prevent monolithic engine updates from forcing all gameplay assets to re-version, schema versions are decoupled into two tiers:
+1. **Base Version (`; version`)**: Managed by root classes (e.g. `Entity::kind->version`). Governs core engine properties (`id`, `position`).
+2. **Derived Version (`; class_version`)**: Managed by derived classes (e.g. `Inert::kind->version`). Governs gameplay-specific component properties.
+
+### 6.2 The `Class` Descriptor (`Engine/Class.h`)
+Every serializable entity or component is described by an immutable `Class` instance:
+
+```cpp
+using serialize_fct_type    = void (*)(Archive& ar, uint16 version, void* payload);
+using default_init_fct_type = void (*)(void* payload);
+
+struct Class
+{
+    uint32                CRC;
+    uint8                 kind;
+    uint16                version;
+    const Class*          base_class;
+    serialize_fct_type    serialize_fct;
+    default_init_fct_type default_init_fct;
+    size_t                size_of;
+    size_t                alignment;
+
+#if JULIET_DEBUG
+    String Name;
+#endif
+};
+```
+
+### 6.3 Class Registration Macros
+```cpp
+#define DECLARE_CLASS() \
+    static Class* kind;
+
+#define DEFINE_CLASS_VERSIONED(cls, version, base_class, serialize_fct)                                                \
+    inline void default_init_##cls(void* payload) { *static_cast<cls*>(payload) = cls{}; }                            \
+    constexpr Class classKind##cls =                                                                                   \
+        MakeClass(ConstString(#cls), 0, (version), (base_class), sizeof(cls), alignof(cls),                           \
+                  (serialize_fct), default_init_##cls);                                                                \
+    Class* cls::kind = const_cast<Class*>(&classKind##cls);
+```
+
+For derived entity types, `DECLARE_ENTITY()` and `DEFINE_ENTITY_VERSIONED` compose cleanly:
+```cpp
+#define DECLARE_ENTITY() \
+    Entity* base;        \
+    DECLARE_CLASS()
+
+#define DEFINE_ENTITY_VERSIONED(entity, version, serialize_fct)                                                         \
+    inline void default_init_##entity(void* payload) { *static_cast<entity*>(payload) = entity{}; }                    \
+    constexpr Class entityKind##entity = MakeClass(ConstString(#entity), (uint8)Entity_Type::entity, (version),         \
+                                                   &classKindEntity, sizeof(entity), alignof(entity),                   \
+                                                   (serialize_fct), default_init_##entity);                             \
+    Class*          entity::kind       = const_cast<Class*>(&entityKind##entity);
+```
+
+### 6.4 Universal Class Serializer (`Engine/class.cpp`)
+```cpp
+void serialize(Archive& ar, NonNullPtr<Class> cls, void* instance)
+{
+    Assert(instance != nullptr);
+
+    uint16 version = cls->version;
+    if (cls->base_class)
+    {
+        serialize(ar, ConstString("class_version"), "class_version"_crc32, version);
+    }
+    else
+    {
+        serialize(ar, ConstString("version"), "version"_crc32, version);
+    }
+
+    if (cls->serialize_fct)
+    {
+        cls->serialize_fct(ar, version, instance);
+    }
+}
+```
+
+### 6.5 Runtime Type Queries (`IsA`)
+Polymorphic type safety is resolved without virtual tables or RTTI:
+```cpp
+bool IsA(const Class& query, const Class* target);
+
+template <typename TargetType>
+bool IsA(const Class& cls)
+{
+    return IsA(cls, TargetType::kind);
+}
+```
+
+### 6.6 Entity Serialization Composition
+An entity instance composes base `Entity` properties and derived component properties:
+```cpp
+void serialize_entity(Archive& ar, uint16 /*version*/, void* payload)
+{
+    Assert(payload != nullptr);
+    auto* entity = static_cast<Entity*>(payload);
+
+    SERIALIZE(ar, id, entity->ID);
+    SERIALIZE(ar, position, entity->position);
+}
+
+DEFINE_CLASS_VERSIONED(Entity, 1, nullptr, serialize_entity)
+
+void serialize(Archive& ar, NonNullPtr<Entity> entity)
+{
+    // 1. Serialize base Entity properties (reads/writes '; version')
+    serialize(ar, Entity::kind, entity.Get());
+
+    // 2. Serialize derived component properties (reads/writes '; class_version')
+    if (entity->derived_kind != nullptr && entity->derived != nullptr)
+    {
+        serialize(ar, entity->derived_kind, entity->derived);
+    }
+}
+```
+
+---
+
+## 7. In-Place Schema Migration & Deprecation
+
+### 7.1 Deprecation Principle
+When gameplay code evolves, obsolete member variables are deleted from active C++ structs to avoid memory waste and code clutter. Obsolete properties are migrated exclusively during loading using temporary local stack variables.
+
+### 7.2 The Stack-Allocated Migration Idiom
+In the class's `serialize_fct(Archive& ar, uint16 version, void* payload)`:
+1. When `ar.loading == true` and `version < N`:
+   - Declare a temporary variable on the stack matching the legacy type.
+   - Call `SERIALIZE(ar, old_field_name, deprecated_var)`.
+   - If present, transform the legacy data into the modern struct field(s).
+2. When saving (`ar.loading == false`):
+   - The migration block is skipped. Only modern struct properties are written.
+   - On the next save, obsolete keys are automatically purged from disk.
+
+```cpp
+void serialize_projectile(Archive& ar, uint16 version, void* payload)
+{
+    Assert(payload != nullptr);
+    auto* projectile = static_cast<Projectile*>(payload);
+
+    SERIALIZE(ar, damage, projectile->damage);
+
+    if (ar.loading && version < 2)
+    {
+        // Migrating v1 scalar 'speed' into modern Vector4 'velocity'
+        float deprecated_speed = 0.0f;
+        if (SERIALIZE(ar, speed, deprecated_speed))
+        {
+            projectile->velocity = Vector4{ deprecated_speed, 0.0f, 0.0f, 0.0f };
+        }
+    }
+    else
+    {
+        SERIALIZE(ar, velocity, projectile->velocity);
+    }
+}
+```
+
+---
+
+## 8. Verification & Unit Testing Framework
+
+### 8.1 Engine-Level Test Runner (`Juliet/src/UnitTest/`)
+Unit testing lives inside the Juliet engine layer (`Juliet/src/UnitTest/serialization_test.cpp`) and executes during engine startup in debug builds via `UnitTest::RunUnitTests()` in `RunUnitTests.cpp`.
+
+### 8.2 Test Coverage Matrix
+
+| Test Function | Target Feature | Validation Criteria |
+| :--- | :--- | :--- |
+| `test_parser_tokenization` | Zero-copy text parser | Validates handling of `#` and `//` comments, whitespace trimming, mixed CRLF/LF, and fast CRC property lookups. |
+| `test_default_value_retention` | Partial schema loading | Validates that missing properties in partial files preserve existing struct default values without corruption. |
+| `test_deprecation_migration` | Stack-based schema migration | Loads a v1 asset containing obsolete `; speed`, verifies `version = 1` is received, and validates migration into modern fields. |
+| `test_class_inheritance` | Runtime `IsA` queries | Validates polymorphic inheritance checks across base and derived `Class` instances. |
+| `test_string_and_vector4` | Primitives & text quoting | Verifies parsing and quote handling of `String` and multi-component `Vector4`. |
+
+---
+
+## 9. Deliverables & File Summary
+
+| File | Responsibilities |
+| :--- | :--- |
+| [`Juliet/include/Core/Common/serialization.h`](file:///w:/Classified/Juliet/Juliet/include/Core/Common/serialization.h) | `ArchivePropertyNode`, `ParsedArchive`, `Archive` struct, `serialize` template, and `SERIALIZE` macros. |
+| [`Juliet/src/Core/Common/serialization.cpp`](file:///w:/Classified/Juliet/Juliet/src/Core/Common/serialization.cpp) | `tokenize_archive`, `find_property`, `audit_unconsumed_properties`, `read_prop`, `read`, and `write` primitives. |
+| [`Juliet/include/Engine/Class.h`](file:///w:/Classified/Juliet/Juliet/include/Engine/Class.h) | `Class` struct, `MakeClass`, `DECLARE_CLASS()`, `DEFINE_CLASS_VERSIONED`, and `IsA` declarations. |
+| [`Juliet/src/Engine/class.cpp`](file:///w:/Classified/Juliet/Juliet/src/Engine/class.cpp) | Universal `serialize(Archive&, NonNullPtr<Class>, void*)` and runtime `IsA` traversal. |
+| [`Juliet/src/UnitTest/serialization_test.cpp`](file:///w:/Classified/Juliet/Juliet/src/UnitTest/serialization_test.cpp) | Exhaustive unit tests for tokenization, defaults retention, version migration, and type queries. |
+| [`Game/Entity/Entity.h`](file:///w:/Classified/Juliet/Game/Entity/Entity.h) | `DECLARE_ENTITY()`, `DEFINE_ENTITY_VERSIONED`, and `Entity` struct definition. |
+| [`Game/Entity/Entity.cpp`](file:///w:/Classified/Juliet/Game/Entity/Entity.cpp) | `serialize_entity` registration and two-tier `serialize(Archive&, NonNullPtr<Entity>)` composition. |
@@ -0,0 +1,818 @@
+# Juliet Game Engine Architecture Specification
+## Document: 02 - Entity Allocation & In-Place Lifecycle
+
+**Document ID:** JULIET-SPEC-002  
+**Status:** Approved for Implementation  
+**Author:** Senior Engine Architect  
+**Subsystems:** `Game/Entity`, `Game/Data`, `Game/UnitTest`  
+**Target Files:**
+- [`Entity.h`](file:///w:/Classified/Juliet/Game/Entity/Entity.h)
+- [`Entity.cpp`](file:///w:/Classified/Juliet/Game/Entity/Entity.cpp)
+- [`EntityManager.h`](file:///w:/Classified/Juliet/Game/Entity/EntityManager.h)
+- [`EntityManager.cpp`](file:///w:/Classified/Juliet/Game/Entity/EntityManager.cpp)
+- [`World.h`](file:///w:/Classified/Juliet/Game/Data/World.h)
+- [`World.cpp`](file:///w:/Classified/Juliet/Game/Data/World.cpp)
+- [`WorldUnitTest.h`](file:///w:/Classified/Juliet/Game/UnitTest/WorldUnitTest.h)
+- [`WorldUnitTest.cpp`](file:///w:/Classified/Juliet/Game/UnitTest/WorldUnitTest.cpp)
+
+---
+
+## 1. Executive Summary & Problem Statement
+
+### 1.1 Background & Context
+The Juliet game engine organizes game entities using a hybrid data-oriented architecture:
+1. A flat array of **Base Entities** (`Entity`) encapsulating universal properties: unique 64-bit ID, runtime type reflection pointer (`Class* Kind`), spatial coordinates (`X, Y, Z`), and an opaque pointer to the derived payload (`DerivedType Derived`).
+2. Type-segregated contiguous arrays of **Derived Entities** (`Inert`, etc.) stored in dedicated per-type memory arenas (`typed_entity_array`).
+
+This design is intended to provide maximum cache efficiency during spatial and general-purpose entity processing, while retaining dense SIMD-friendly streaming for type-specific systems (e.g., transform updates on `Inert` mesh instances).
+
+### 1.2 Root-Cause Analysis of `Game/Data/World.cpp` Loading Flaws
+In the initial implementation of entity serialization in [`Game/Data/World.cpp`](file:///w:/Classified/Juliet/Game/Data/World.cpp#L40-L68), loading was fundamentally broken and incomplete:
+
+```cpp
+// Existing flawed deserialization in World.cpp
+for (typed_entity_array& type : entityManager.by_type)
+{
+    serialize_elem(ar, type.count);
+
+    if (type.count > 0)
+    {
+        // Unserialize the base entity to get informations
+        Entity entity;
+        serialize(ar, &entity);
+
+        RegisterBaseEntity(entityManager, entity);
+    }
+}
+```
+
+This implementation suffers from several fatal defects:
+1. **Single-Element Iteration Bug:** It uses `if (type.count > 0)` instead of a loop `for (size_t i = 0; i < type.count; ++i)`, deserializing at most one single entity per type bucket, leaving all subsequent entities in the stream unread and corrupting the archive read offset.
+2. **Missing Derived Allocation:** It invokes `RegisterBaseEntity(entityManager, entity)`, which merely pushes the stack-allocated `Entity` into `manager.Entities`. The derived payload arena (`type.arena`) is completely untouched: `type.array` remains null, `type.count` in the manager is desynchronized, and `entity.Derived` remains unassigned or points to an invalid address.
+3. **Invalid Pointer in `RegisterEntity`:** In [`Game/Entity/EntityManager.cpp`](file:///w:/Classified/Juliet/Game/Entity/EntityManager.cpp#L46-L66), `RegisterEntity` assigns `base->Derived = entity` before pushing `*base` into `manager.Entities`. The parameter `entity` is a pointer to caller-provided memory (often stack-allocated in helper functions like `MakeEntity`). When `ArenaPushSize` later allocates the persistent derived memory block, `base->Derived` stored inside `manager.Entities.Back()` is **never updated**—it remains dangling, pointing to the transient caller stack!
+
+### 1.3 The "Chicken-and-Egg" Stack Allocation Dilemma
+The existing registration API requires a pre-existing derived instance:
+```cpp
+entity_template* RegisterEntity(EntityManager& manager, Entity* base, DerivedType entity);
+```
+During runtime programmatic creation via `MakeEntity<T>()`, a temporary instance of `T` is created on the stack and passed by pointer:
+```cpp
+template <typename EntityType>
+EntityType* MakeEntity(EntityManager& manager, float x, float y, float z)
+{
+    EntityType result; // Stack allocation
+    Entity     base;   // Stack allocation
+    base.X    = x;
+    base.Y    = y;
+    base.Z    = z;
+    base.Kind = EntityType::Kind;
+
+    return (EntityType*)RegisterEntity(manager, &base, &result);
+}
+```
+When loading an entity from a stream or disk file, **the type is not known at compile time**. The engine reads a runtime type tag (`uint8 kind` or `uint32 CRC`), looks up the reflection metadata (`Class*`), and must instantiate the entity dynamically. 
+
+Because C++ does not permit allocating a dynamic struct of unknown type on the stack, and because Juliet strictly forbids heap allocations (`malloc`, `new`, `std::vector`), deserialization cannot construct a temporary instance on the stack to pass to `RegisterEntity`. 
+
+This is the classic **chicken-and-egg memory problem**:
+- `RegisterEntity` requires an existing instance in memory to copy from.
+- Deserialization requires an allocated memory buffer to deserialize into.
+
+### 1.4 Architectural Objectives
+This specification establishes a robust in-place lifecycle pipeline that completely eliminates stack temporaries and dynamic heap allocations:
+1. **Direct In-Place Allocation:** Introduce `AllocateEntity(EntityManager& manager, Class* classPtr)` which allocates both the base `Entity` and the derived struct directly within their respective engine memory arenas.
+2. **Bidirectional Pointer Integrity:** Wire mutual pointers (`base->derived` and `derived->base`) at allocation time before any field deserialization begins.
+3. **In-Place Stream Deserialization:** Read class reflection metadata first, invoke `AllocateEntity`, and stream base and derived properties directly into arena-resident memory.
+4. **Isolated Entity Assets (`.jasset`):** Transition from a monolithic `world.bin` to a modular one-file-per-entity architecture (`Assets/Entities/{ID}.jasset`).
+5. **Dirty Tracking & Optimal Saves:** Introduce an `is_dirty` flag on `Entity` to avoid rewriting unchanged entity files, minimizing disk I/O and eliminating spurious Git repository modifications.
+6. **Robust Deletion Lifecycle:** Decouple in-memory removal (`RemoveAtFast` with pointer fixup) from disk synchronization using `World::PendingDeletions`.
+
+---
+
+## 2. The Dual Arena Memory Model in `EntityManager`
+
+### 2.1 The Need for Dual Storage
+Game engines execute systems with vastly different cache locality profiles:
+- **Spatial / Frustum Culling / Transform Sync:** Iterates every entity in the world, needing only `X, Y, Z`, bounding spheres, and base status flags.
+- **Specialized Logic / Render Updates:** Iterates only entities possessing specific components (e.g., `Inert` static meshes requiring instance transform updates to the GPU bindless descriptor table).
+
+Storing large monolithic polymorphic structs in a single array causes severe cache line pollution during spatial passes. Conversely, storing entities in fragmented individual allocations introduces cache misses and pointer-chasing overhead. 
+
+Juliet resolves this with a **Dual Arena Memory Model**:
+
+```
+---------------------------------------------------------------------------------------------+
+|                                    EntityManager                                            |
+---------------------------------------------------------------------------------------------+
+|                                                                                             |
+|   manager.Entities (VectorArena<Entity, 100'000>)                                          |
+|   +------------------------------------+------------------------------------+           |
+|   | Entity 0 (ID=1001, X, Y, Z)        | Entity 1 (ID=1002, X, Y, Z)        | ...       |
+|   | Derived ------------------------+  | Derived ---------------------+     |           |
+|   +---------------------------------|--+------------------------------|-----+           |
+|                                     |                                 |                     |
+|                                     v                                 v                     |
+|   manager.by_type[ENTITY(Inert)].arena                                                      |
+|   +------------------------------------+------------------------------------+           |
+|   | Inert 0 (MeshInstance=4)           | Inert 1 (MeshInstance=12)          | ...       |
+|   | Base ---------------------------+  | Base ------------------------+     |           |
+|   +---------------------------------|--+------------------------------|-----+           |
+|                                     +---------------------------------+                     |
+---------------------------------------------------------------------------------------------+
+```
+
+### 2.2 `manager.Entities`: Cache-Friendly Base Entity Vector
+Base entities reside in a pre-reserved contiguous array:
+```cpp
+VectorArena<Entity, 100'000> Entities;
+```
+- **Capacity:** Fixed reserve of 100,000 entities allocated from the `WorldArena`.
+- **Memory Footprint:** 
+  $$\text{sizeof(Entity)} = 8\text{ (ID)} + 8\text{ (derived\_kind)} + 8\text{ (derived)} + 16\text{ (position)} + 1\text{ (is\_dirty)} + 7\text{ (Padding)} = 48\text{ bytes}$$
+  Total reserved space: $100{,}000 \times 48\text{ bytes} \approx 4.8\text{ MB}$.
+- **Access Speed:** O(1) random access by index; sequential streaming utilizes L1/L2 hardware prefetchers with zero cache line waste.
+
+### 2.3 `manager.by_type[kind].arena`: Typed Component Arenas
+Derived structs reside in per-type contiguous memory arenas:
+```cpp
+struct typed_entity_array
+{
+    Arena*           arena;
+    entity_template* array;
+    size_t           count;
+};
+```
+- Each `Entity_Type` index owns an isolated `Arena*` allocated during `InitEntityManager`.
+- Allocations are packed linearly with alignment specified by `classPtr->alignment`.
+- `array` points directly to the first element in the arena, permitting typed array indexing:
+  ```cpp
+  Inert* inertArray = reinterpret_cast<Inert*>(manager.by_type[ENTITY(Inert)].array);
+  ```
+
+### 2.4 Mutual Back-Pointer Architecture & Invariants
+Every entity instance consists of two mutually linked allocations:
+1. `basePtr->Derived`: Points from `Entity` in `manager.Entities` to the derived struct in `by_type[kind].arena`.
+2. `derivedPtr->Base`: Points from the derived struct (via `DECLARE_ENTITY()`) back to `Entity` in `manager.Entities`.
+
+#### Invariant Rules:
+1. **Non-Null Invariant:** For any active entity, `basePtr->Derived != nullptr` and `reinterpret_cast<entity_template*>(basePtr->Derived)->Base == basePtr`.
+2. **Type Coherence Invariant:** `basePtr->Kind->kind == derivedTypeId`.
+3. **Array Count Invariant:** 
+   $$\sum_{k=0}^{\text{ENTITY(Count)}-1} \text{manager.by\_type}[k].\text{count} == \text{manager.Entities.Size()}$$
+
+### 2.5 Pointer Stability in `VectorArena`
+`VectorArena::Create` executes `Reserve(ReserveSize)` on creation:
+```cpp
+newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
+```
+Because capacity ($100{,}000$) is fully reserved upfront in virtual address space, `VectorArena::PushBack` **never reallocates or moves existing memory**. Therefore:
+- Pointers to `Entity` elements in `manager.Entities` remain absolutely stable across allocations.
+- Derived struct `Base` pointers remain valid indefinitely unless an element is deleted.
+- Element removal via swap-and-pop alters memory positions, requiring systematic pointer fixups (addressed in Section 5.2).
+
+---
+
+## 3. The Solution: `AllocateEntity(EntityManager& manager, Class* classPtr)`
+
+### 3.1 Function Signature & Contract
+The canonical allocation function is defined in `EntityManager.h`:
+
+```cpp
+[[nodiscard]] Entity* AllocateEntity(EntityManager& manager, Class* classPtr);
+```
+
+#### Preconditions:
+- `classPtr != nullptr`.
+- `classPtr->kind < ENTITY(Count)`.
+- `classPtr->size_of >= sizeof(entity_template)`.
+- `manager.Entities.Size() < manager.Entities.Capacity`.
+- `manager.by_type[classPtr->kind].arena != nullptr`.
+
+#### Postconditions:
+- A new `Entity` record is appended to `manager.Entities`.
+- A new typed block of `classPtr->size_of` bytes is allocated in `manager.by_type[classPtr->kind].arena`.
+- The derived memory is initialized with C++ struct defaults via `classPtr->default_init_fct` (or zeroed via `MemZero` if null).
+- `base->derived` points to the derived struct.
+- `derived->base` points to the base `Entity`.
+- `base->derived_kind` is assigned to `class_ptr`.
+- `base->ID` is initialized to `0` (unassigned; populated by `MakeEntity` or deserialization).
+- `base->is_dirty` is initialized to `true`.
+- `typed_entity_array::count` is incremented.
+- `typed_entity_array::array` is initialized if this is the first entity of this type.
+
+### 3.2 Detailed Step-by-Step Implementation
+The implementation replaces the flawed `RegisterEntity` routine in [`Game/Entity/EntityManager.cpp`](file:///w:/Classified/Juliet/Game/Entity/EntityManager.cpp):
+
+```cpp
+[[nodiscard]] Entity* AllocateEntity(EntityManager& manager, Class* derivedClassPtr)
+{
+    Assert(derivedClassPtr != nullptr);
+    Assert(derivedClassPtr->kind < ENTITY(Count));
+    Assert(derivedClassPtr->size_of >= sizeof(entity_template));
+    Assert(derivedClassPtr->alignment > 0);
+
+    // 1. Allocate Base Entity in the contiguous VectorArena (ID is 0 until assigned by MakeEntity or deserialization)
+    Entity baseTemplate{};
+    baseTemplate.ID           = 0;
+    baseTemplate.derived_kind = derivedClassPtr;
+    baseTemplate.derived      = nullptr;
+    baseTemplate.position     = {};
+    baseTemplate.is_dirty     = true;
+
+    manager.Entities.PushBack(baseTemplate);
+    Entity* basePtr = manager.Entities.Back();
+    Assert(basePtr != nullptr);
+
+    // 2. Allocate derived component memory in the typed arena
+    typed_entity_array& typedArray = manager.by_type[derivedClassPtr->kind];
+    Assert(typedArray.arena != nullptr);
+
+    void* rawMemory = ArenaPushSize(
+        typedArray.arena, 
+        derivedClassPtr->size_of, 
+        derivedClassPtr->alignment, 
+        false JULIET_DEBUG_PARAM(kEntity_type_names[derivedClassPtr->kind]));
+    Assert(rawMemory != nullptr);
+
+    // 3. Initialize derived component defaults via Class reflection stub
+    if (derivedClassPtr->default_init_fct != nullptr)
+    {
+        derivedClassPtr->default_init_fct(rawMemory);
+    }
+    else
+    {
+        MemZero(rawMemory, derivedClassPtr->size_of);
+    }
+
+    auto* derivedTemplate = reinterpret_cast<entity_template*>(rawMemory);
+
+    // 4. Establish mutual back-pointers
+    basePtr->derived      = rawMemory;
+    derivedTemplate->base = basePtr;
+
+    // 5. Update typed array tracking
+    if (typedArray.array == nullptr)
+    {
+        typedArray.array = derivedTemplate;
+    }
+    typedArray.count += 1;
+
+    return basePtr;
+}
+```
+
+### 3.3 Default Struct Initialization via `Class::default_init_fct`
+
+#### The Problem with Zero-Only Initialization
+If allocation only zeroes memory (`MemZero` / `0x00`), any C++ member variables with non-zero defaults (such as `index_t MeshInstance = indexMax;` or `float Density = 1.0f;`) are populated with `0`. During deserialization, if a `.jasset` file lacks that property (e.g. an older file version or an optional field), `SERIALIZE` leaves the field untouched, meaning it incorrectly remains `0` rather than its intended default sentinel value!
+
+#### The Solution: Compile-Time Default Stub in `DEFINE_ENTITY_VERSIONED`
+Every entity descriptor `Class` includes a function pointer:
+```cpp
+using default_init_fct_type = void (*)(void* payload);
+
+struct Class
+{
+    ...
+    default_init_fct_type default_init_fct = nullptr;
+};
+```
+
+When registering an entity type with `DEFINE_ENTITY_VERSIONED`, the macro automatically defines a tiny type-safe stub that aggregate value-initializes the struct:
+```cpp
+#define DEFINE_ENTITY_VERSIONED(entity, version, serialize_fct)                                                         \
+    inline void default_init_##entity(void* payload)                                                                    \
+    {                                                                                                                   \
+        *static_cast<entity*>(payload) = entity{};                                                                      \
+    }                                                                                                                   \
+    constexpr Class entityKind##entity = MakeClass(ConstString(#entity), (uint8)Entity_Type::entity, (version),         \
+                                                   &classKindEntity, sizeof(entity), alignof(entity),                   \
+                                                   (serialize_fct), default_init_##entity);                             \
+    Class*          entity::kind       = const_cast<Class*>(&entityKind##entity);
+```
+
+#### Architectural Advantages:
+1. **Zero Boilerplate**: Developers write member initializers once in the struct definition (`index_t MeshInstance = indexMax;`).
+2. **Type-Agnostic Core**: `AllocateEntity` does not need to know any C++ struct types; it unconditionally calls `derivedClassPtr->default_init_fct(rawMemory)`.
+3. **Robust Deserialization**: In `deserialize_entity_in_place`, newly allocated entities already hold their canonical C++ defaults. Any properties absent in the `.jasset` file naturally retain their correct initial values.
+4. **No Dynamic Heap / Placement-New**: `*static_cast<entity*>(payload) = entity{}` is pure aggregate value-assignment without `<new>` headers or exceptions.
+
+### 3.4 Bidirectional Pointer Wiring
+Notice the sequence:
+1. `manager.Entities.PushBack(baseTemplate)` places the struct at its final, fixed arena address.
+2. `base_ptr = manager.Entities.Back()` retrieves the persistent memory pointer.
+3. `derived_class_ptr->default_init_fct(raw_memory)` initializes canonical struct defaults.
+4. `derived_template->base = base_ptr` wires the derived back-pointer directly to this permanent location.
+5. `base_ptr->derived = raw_memory` wires the base forward-pointer to the arena-allocated derived struct.
+
+No stack copying occurs. Neither pointer is ever left dangling.
+
+### 3.5 Updating Type Counts and Array Cache
+`typed_entity_array` maintains:
+- `typedArray.count`: The exact count of active entities of this type.
+- `typedArray.array`: Pointer to the first element in the arena.
+
+When the first entity of a given type is allocated, `typedArray.array` is set to `derived_template`. Because the arena allocates sequentially, `typedArray.array[i]` can be indexed directly with stride `class_ptr->size_of` as long as memory remains contiguous.
+
+### 3.6 Refactoring `MakeEntity<EntityType>` Template
+With `AllocateEntity` handling memory allocation, default member initialization, and mutual pointer wiring, `MakeEntity` in [`Game/Entity/Entity.h`](file:///w:/Classified/Juliet/Game/Entity/Entity.h) becomes clean, safe, and stack-free:
+
+```cpp
+template <typename EntityType>
+    requires EntityConcept<EntityType>
+[[nodiscard]] EntityType* MakeEntity(EntityManager& manager, float x, float y, float z)
+{
+    Entity* base_ptr = AllocateEntity(manager, EntityType::kind);
+    Assert(base_ptr != nullptr);
+
+    base_ptr->ID         = EntityManager::ID++;
+    base_ptr->position.x = x;
+    base_ptr->position.y = y;
+    base_ptr->position.z = z;
+    base_ptr->position.w = 1.0f;
+
+    return static_cast<EntityType*>(base_ptr->derived);
+}
+```
+
+---
+
+## 4. In-Place Deserialization Pipeline
+
+### 4.1 Asset Format Specification (`.jasset`)
+To achieve robust version control and modular streaming, Juliet adopts a human-readable, Git-diffable **one-file-per-entity** disk format with extension `.jasset`.
+
+```ini
+; asset_type
+entity_instance
+; id
+0x0100000000000042
+; class
+Inert
+; version
+1
+; class_version
+1
+; position
+0.43 0.32 1.56
+; mesh_instance
+12
+```
+
+#### Important: No Header Structs for Derived Types
+- **Derived types NEVER require their own file header**: You do **not** write an `InertHeader`, `DoorHeader`, or `PlayerHeader`. Derived types only serialize their own member variables.
+- **Universal `; version` + optional `; class_version`**: Every `.jasset` file has a universal `; version` tag. For entity assets, `; version` governs base entity properties (`kEntityBaseVersion`), while an optional `; class_version` governs derived class properties (`Class::Version`). Non-entity assets like `WorldSettings.jasset` only have `; version`.
+- **No binary `EntityFileHeader` struct is needed**: Under the `; variable_name\nvalues` text format, there is no packed binary C-struct header at all. The common properties (`; id`, `; class`, `; version`, `; class_version`, `; position`) are standard text Key-Value nodes read by the exact same `Archive` parser.
+
+### 4.2 Eliminating Intermediate Stack Allocations
+Under the new pipeline:
+1. The `.jasset` text file is read into memory onto a `TempArena` via `LoadFile`.
+2. The property nodes are parsed into a `ParsedArchive` via `tokenize_archive(tempArena.Arena, fileBuffer, &ar.base)`.
+3. The engine reads `; class` (e.g. `"Inert"`) and resolves `Class* class_ptr = find_class_by_name(class_name)`.
+4. `AllocateEntity(manager, class_ptr)` is called immediately. Memory for both base and derived components is allocated in-place in their permanent engine arenas.
+5. `serialize(ar, NonNullPtr<Entity>(base_ptr))` is called. Base (`Entity::kind`) and derived (`base_ptr->derived_kind`) fields stream **directly into their permanent memory arenas** without temporary staging buffers or stack copies.
+
+### 4.3 Runtime Class Resolution
+To ensure fast and safe type lookup during file deserialization, Juliet provides two tiers of type resolution:
+
+1. **Low-Level Indexed Validation (`ResolveEntityClass`)**: An $O(1)$ array lookup into `kEntity_type_class_ptr[kind]` that validates the class pointer and verifies schema compatibility against `classPtr->CRC`. This is the core validation primitive used by binary streaming, network replication, and internal lookups.
+2. **High-Level Name Resolution (`find_class_by_name`)**: Bridges the human-readable text archive format (`; class\nInert`) to the entity class registry. It computes the `crc32` of the parsed class name and queries `ResolveEntityClass` across registered entity kinds.
+
+```cpp
+[[nodiscard]] const Class* ResolveEntityClass(uint8 kind, uint32 crc)
+{
+    if (kind >= ENTITY(Count))
+    {
+        return nullptr;
+    }
+
+    const Class* class_ptr = kEntity_type_class_ptr[kind];
+    if (class_ptr == nullptr)
+    {
+        return nullptr;
+    }
+
+    if (class_ptr->CRC != crc)
+    {
+        return nullptr;
+    }
+
+    return class_ptr;
+}
+
+[[nodiscard]] Class* find_class_by_name(String name)
+{
+    if (!IsValid(name))
+    {
+        return nullptr;
+    }
+
+    const uint32 name_crc = crc32(name.Str, name.Size);
+
+    for (uint8 kind = 0; kind < ENTITY(Count); ++kind)
+    {
+        const Class* class_ptr = ResolveEntityClass(kind, name_crc);
+        if (class_ptr != nullptr)
+        {
+            return const_cast<Class*>(class_ptr);
+        }
+    }
+
+    return nullptr;
+}
+```
+
+### 4.4 In-Place Deserialization Algorithm
+
+```
+---------------------------------------------------------------------------------------+
+|                       In-Place Deserialization Flowchart                              |
+---------------------------------------------------------------------------------------+
+|                                                                                       |
+|   1. LoadFile(scratch.Arena, filepath) into ByteBuffer                                |
+|              |                                                                        |
+|              v                                                                        |
+|   2. tokenize_archive(scratch.Arena, file_buffer, &ar.base)                            |
+|              |                                                                        |
+|              v                                                                        |
+|   3. Read "; class" & Resolve Class* via find_class_by_name(class_name)               |
+|              |                                                                        |
+|              v                                                                        |
+|   4. base_ptr = AllocateEntity(manager, class_ptr)                                    |
+|              |                                                                        |
+|              +--> [manager.Entities]: Allocates base Entity                           |
+|              +--> [manager.by_type[kind].arena]: Allocates derived struct             |
+|              +--> Mutual Back-Pointers Wired In-Place                                 |
+|              |                                                                        |
+|              v                                                                        |
+|   5. serialize(ar, NonNullPtr<Entity>(base_ptr))                                      |
+|              |                                                                        |
+|              +--> Streams Base Entity (Entity::kind, version, ID, position)           |
+|              +--> Streams Derived Component (base_ptr->derived_kind, class_version)   |
+|              |                                                                        |
+|              v                                                                        |
+|   6. Clear Dirty Flag: base_ptr->is_dirty = false                                     |
+|                                                                                       |
+---------------------------------------------------------------------------------------+
+```
+
+```cpp
+[[nodiscard]] Entity* deserialize_entity_in_place(EntityManager& manager, Archive& ar)
+{
+    Assert(ar.loading);
+
+    // 1. Read class name and resolve Class*
+    String class_name = {};
+    SERIALIZE(ar, class, class_name);
+    Class* class_ptr = find_class_by_name(class_name);
+    if (!class_ptr)
+    {
+        return nullptr;
+    }
+
+    // 2. Allocate persistent memory for base and derived components in their respective arenas
+    Entity* base_ptr = AllocateEntity(manager, class_ptr);
+    Assert(base_ptr != nullptr);
+
+    // 3. Serialize Base Entity and Derived in-place (loads ID and properties from disk)
+    serialize(ar, NonNullPtr<Entity>(base_ptr));
+
+    // 4. Advance generator counter to avoid collisions with loaded IDs
+    if (base_ptr->ID >= EntityManager::ID)
+    {
+        EntityManager::ID = base_ptr->ID + 1;
+    }
+
+    // Freshly loaded entity matches disk state exactly
+    base_ptr->is_dirty = false;
+
+    return base_ptr;
+}
+```
+
+---
+
+## 5. Entity Deletion Lifecycle & Disk Synchronization (Extracted for Rework)
+
+> [!WARNING]
+> **Status: Extracted for Rework**
+> The original swap-and-pop in-memory removal logic (`DestroyEntity`, `RemoveDerivedComponent`, and mutual back-pointer fixups) was determined to be overly complex and has been extracted to [`Game/Plans/Entity_Removal_Brainstorm.md`](file:///w:/Classified/Juliet/Game/Plans/Entity_Removal_Brainstorm.md) for further brainstorming and redesign.
+>
+> Simpler alternative architectures under consideration include:
+> - **Active / Tombstone Flag (`is_active` bool):** Retaining entities in-place without moving memory during frame simulation, eliminating pointer invalidation entirely.
+> - **Intrusive Free List:** Linking inactive slots via an intrusive linked list to find the first free slot in $O(1)$ without memory shifting.
+> - **Generational Handles / Slot Map:** Enabling safe, non-dangling entity references across systems.
+> - **Deferred Compaction:** Batch-compacting memory during level loads or scene transitions rather than per-frame swap-and-pop.
+
+---
+
+## 6. Dirty Tracking for Optimal Saves
+
+### 6.1 The Cost of Naive Monolithic & Full-Directory Writes
+In a level containing $10{,}000$ entities:
+- **Monolithic `world.bin` Save:** Modifying a single entity's $X$ coordinate requires re-serializing all $10{,}000$ entities and overwriting a multi-megabyte binary file. This introduces a huge Git diff and constant merge conflicts.
+- **Full-Directory `.jasset` Save:** Iterating through all $10{,}000$ entities and unconditionally writing $10{,}000$ `.jasset` files incurs massive OS file-system overhead (directory table locks, I/O bandwidth) and changes the file timestamps of every asset. Git reports thousands of modified files even when only one entity changed!
+
+### 6.2 The `is_dirty` Flag on `Entity`
+To solve this, `Entity` in [`Game/Entity/Entity.h`](file:///w:/Classified/Juliet/Game/Entity/Entity.h#L28-L36) is augmented with an explicit dirty flag:
+
+```cpp
+struct Entity final
+{
+    DECLARE_CLASS() // static Class* kind; (Entity's own Class descriptor)
+
+    EntityID    ID           = 0;
+    Class*      derived_kind = nullptr; // Pointer to derived class descriptor (e.g. Inert::kind)
+    DerivedType derived      = nullptr; // Pointer to derived component memory
+    Vector4     position     = {};
+    bool        is_dirty     = false;
+};
+```
+
+### 6.3 Granular State Transitions
+The `is_dirty` flag obeys a strict lifecycle state machine:
+
+```
+                  +-----------------------------------+
+                  |          Entity Created           |
+                  |     (AllocateEntity / Editor)     |
+                  +-----------------+-----------------+
+                                    |
+                                    v
+                            +---------------+
+                   +------->|is_dirty: TRUE |<-------+
+                   |        +-------+-------+        |
+                   |                |                |
+        Entity Mutated              |            SaveWorld
+    (Position, Component)           |            Completed
+                   |                v                |
+                   |        +---------------+        |
+                   +--------+is_dirty: FALSE+--------+
+                            +-------+-------+
+                                    ^
+                                    |
+                             Deserialization
+                            (LoadWorld / Asset)
+```
+
+1. **Entity Creation:** Newly spawned entities in the editor have `is_dirty = true`.
+2. **Property Mutation:** Any modification to `position` or derived component payload sets `entity->is_dirty = true`.
+3. **Successful Deserialization:** Entities loaded from disk initialize with `is_dirty = false`.
+4. **Successful Save:** Upon successfully writing an entity to its `.jasset` file, the engine resets `entity->is_dirty = false`.
+
+### 6.4 Version Control Benefits (Git Friendly Assets)
+By coupling the one-file-per-entity `.jasset` format with dirty tracking:
+- Only modified entities are touched on disk.
+- Git status displays only the exact `.jasset` files that were altered by the designer.
+- Team members can work concurrently in the same game scene without encountering binary merge conflicts.
+
+### 6.5 Editor Integration (`RenderWorldEditorUI` Hooks)
+In [`Game/Data/World.cpp`](file:///w:/Classified/Juliet/Game/Data/World.cpp#L291-L311), editor UI widgets automatically set the dirty flag upon receiving user input:
+
+```cpp
+float pos[4] = { ent.position.x, ent.position.y, ent.position.z, ent.position.w };
+if (ImGui::DragFloat3("Position", pos, 0.1f))
+{
+    ent.position.x = pos[0];
+    ent.position.y = pos[1];
+    ent.position.z = pos[2];
+    ent.is_dirty   = true; // Mark dirty for persistence
+    UpdateWorld(world);
+}
+```
+
+---
+
+## 7. Step-by-Step Implementation Roadmap
+
+### Phase 1: Data Structures & Header Definitions
+1. **Update `Class.h` & `Entity.h`:**
+   - Add `using default_init_fct_type = void (*)(void* payload);` and `default_init_fct` to `struct Class` and `MakeClass`.
+   - Update `DEFINE_ENTITY_VERSIONED` and `DEFINE_CLASS_VERSIONED` to define `default_init_##entity` and pass it to `MakeClass`.
+   - Add `bool is_dirty = false;` to `struct Entity`.
+   - Update `MakeEntity<EntityType>` to assign `base_ptr->ID = EntityManager::ID++;` and delegate allocation and defaults cleanly to `AllocateEntity`.
+   - Declare `[[nodiscard]] const Class* ResolveEntityClass(uint8 kind, uint32 crc);` and `[[nodiscard]] Class* find_class_by_name(String name);` in `Entity.h`.
+2. **Update `EntityManager.h`:**
+   - Declare `[[nodiscard]] Entity* AllocateEntity(EntityManager& manager, Class* class_ptr);`.
+   - *(Note: `DestroyEntity` and `RemoveDerivedComponent` deferred to `Entity_Removal_Brainstorm.md`)*
+3. **Update `World.h`:**
+   - Add `VectorArena<EntityID, 1024> PendingDeletions;` to `struct World`.
+   - Update `SaveWorld` and `LoadWorld` signatures to take directory paths.
+
+### Phase 2: Core Memory Allocation & Wiring in `EntityManager.cpp`
+1. Implement `AllocateEntity`:
+   - Enforce parameter assertions.
+   - Push to `manager.Entities` with `baseTemplate.ID = 0` (unassigned).
+   - Allocate block in `manager.by_type[kind].arena`.
+   - Call `derivedClassPtr->default_init_fct(rawMemory)` (or `MemZero` if null) to initialize struct defaults.
+   - Wire mutual pointers (`base->derived` and `derived->base`).
+   - Increment `typedArray.count` and initialize `typedArray.array`.
+2. *(Deferred for rework)* `DestroyEntity` & `RemoveDerivedComponent` (See [`Game/Plans/Entity_Removal_Brainstorm.md`](file:///w:/Classified/Juliet/Game/Plans/Entity_Removal_Brainstorm.md)).
+
+### Phase 3: In-Place Deserialization & Serialization Pipeline
+1. In `Entity.cpp`:
+   - Implement `ResolveEntityClass` and `find_class_by_name`.
+   - `serialize(Archive& ar, NonNullPtr<Entity> entity)` handles both base and derived class serialization.
+2. In `World.cpp`:
+   - Implement `serialize_entity_asset(Archive& ar, NonNullPtr<Entity> entity, String filepath)`.
+   - Implement `deserialize_entity_asset(EntityManager& manager, Archive& ar, String filepath)`.
+   - In `deserialize_entity_in_place`, advance `EntityManager::ID` past `base_ptr->ID` to prevent ID collisions.
+
+### Phase 4: World Save/Load Pipeline & Disk Deletion
+1. In `World.cpp`:
+   - Implement `ProcessPendingDeletions(World& world, NonNullPtr<Arena> scratchArena)`.
+   - Implement `SaveWorld(World& world, String worldDirectory)`:
+     - Process pending deletions.
+     - Iterate `manager.Entities`, skipping entities where `!entity.is_dirty`.
+     - Write dirty entities to `.jasset` files and clear `is_dirty`.
+   - Implement `LoadWorld(World& world, String worldDirectory)`:
+     - Enumerate `.jasset` files in directory.
+     - Call `deserialize_entity_asset` for each file.
+
+### Phase 5: Editor Integration
+1. In `RenderWorldEditorUI`:
+   - Hook `ImGui::DragFloat3` and property inspectors to set `is_dirty = true`.
+   - Hook "Add Entity" button to call `MakeEntity<Inert>(*world.EntityManager, 0.0f, 0.0f, 0.0f)`.
+   - Hook "Delete Entity" button to call `RemoveWorldEntity(world, selectedEntityId)`.
+
+---
+
+## 8. Unit Testing & Verification Plan
+
+### 8.1 Test Philosophy & Constraints
+Following Juliet coding guidelines:
+> "When creating a new system framework, make a unit test. To make the unit test we should not modify the framework code for special unit test case."
+
+Testing is isolated in [`Game/UnitTest/WorldUnitTest.cpp`](file:///w:/Classified/Juliet/Game/UnitTest/WorldUnitTest.cpp) and executed during engine initialization in debug builds.
+
+### 8.2 Comprehensive Test Suite (`WorldUnitTest.cpp`)
+The test suite validates every guarantee made in this specification:
+
+```cpp
+#include <UnitTest/WorldUnitTest.h>
+
+#if JULIET_DEBUG
+
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/serialization.h>
+#include <Core/HAL/Filesystem/Filesystem.h>
+#include <Core/HAL/IO/IOStream.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Core/Thread/ThreadContext.h>
+#include <Data/World.h>
+#include <Entity/Entity.h>
+#include <Entity/EntityManager.h>
+
+namespace UnitTest
+{
+    namespace
+    {
+        void TestEntityAllocationAndWiring()
+        {
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestEntityAllocationAndWiring...");
+
+            TempArena tempArena = scratch_begin(nullptr, 0);
+
+            World testWorld{};
+            InitWorld(&testWorld, tempArena.Arena);
+
+            InitEntityManager(&testWorld);
+            EntityManager& manager = *testWorld.EntityManager;
+
+            // 1. Allocate Inert Entity via AllocateEntity
+            Entity* base_entity = AllocateEntity(manager, Inert::kind);
+            Assert(base_entity != nullptr);
+            Assert(base_entity->ID == 0); // Pure memory allocator leaves ID unassigned (0) until MakeEntity or deserialization
+            base_entity->ID = EntityManager::ID++;
+            Assert(base_entity->ID > 0);
+            Assert(base_entity->derived_kind == Inert::kind);
+            Assert(base_entity->derived != nullptr);
+            Assert(base_entity->is_dirty == true);
+
+            // 2. Validate mutual back-pointer wiring
+            auto* derived = reinterpret_cast<entity_template*>(base_entity->derived);
+            Assert(derived->base == base_entity);
+
+            // 3. DownCast verification
+            Inert* inert = DownCast<Inert>(base_entity);
+            Assert(inert != nullptr);
+            Assert(inert->base == base_entity);
+
+            // 4. Validate typed array tracking
+            typed_entity_array& inert_array = manager.by_type[ENTITY(Inert)];
+            Assert(inert_array.count == 1);
+            Assert(inert_array.array == derived);
+
+            ShutdownEntityManager();
+            ShutdownWorld(&testWorld);
+
+            scratch_end(tempArena);
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestEntityAllocationAndWiring");
+        }
+
+        void TestInPlaceDeserialization()
+        {
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestInPlaceDeserialization...");
+
+            TempArena tempArena = scratch_begin(nullptr, 0);
+
+            World testWorld{};
+            InitWorld(&testWorld, tempArena.Arena);
+            InitEntityManager(&testWorld);
+            EntityManager& manager = *testWorld.EntityManager;
+
+            // 1. Create and populate entity
+            Inert* created_inert = MakeEntity<Inert>(manager, 12.5f, -44.0f, 108.2f);
+            Assert(created_inert != nullptr);
+            created_inert->MeshInstance = 42;
+
+            Entity*  original_base = created_inert->base;
+            EntityID original_id   = original_base->ID;
+
+            // 2. Serialize to text archive memory stream
+            MemoryStream mem_stream = MakeMemoryStream(tempArena.Arena);
+            Archive      save_ar{ .arena = tempArena.Arena, .loading = false, .stream = &mem_stream };
+            serialize(save_ar, NonNullPtr<Entity>(original_base));
+
+            // 3. Clear manager to simulate fresh load
+            ShutdownEntityManager();
+            InitEntityManager(&testWorld);
+            EntityManager& fresh_manager = *testWorld.EntityManager;
+
+            // 4. Tokenize and deserialize in-place
+            Archive load_ar{ .arena = tempArena.Arena, .loading = true };
+            tokenize_archive(tempArena.Arena, mem_stream.buffer, &load_ar.base);
+            Entity* loaded_base = deserialize_entity_in_place(fresh_manager, load_ar);
+
+            Assert(loaded_base != nullptr);
+            Assert(loaded_base->ID == original_id);
+            Assert(EntityManager::ID > original_id); // Counter was advanced past loaded ID to prevent collisions
+            Assert(loaded_base->position.x == 12.5f);
+            Assert(loaded_base->position.y == -44.0f);
+            Assert(loaded_base->position.z == 108.2f);
+            Assert(loaded_base->is_dirty == false);
+
+            Inert* loaded_inert = DownCast<Inert>(loaded_base);
+            Assert(loaded_inert != nullptr);
+            Assert(loaded_inert->base == loaded_base);
+            Assert(loaded_inert->MeshInstance == 42);
+
+            ShutdownEntityManager();
+            ShutdownWorld(&testWorld);
+
+            scratch_end(tempArena);
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestInPlaceDeserialization");
+        }
+
+        void TestDirtyTrackingLifecycle()
+        {
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestDirtyTrackingLifecycle...");
+
+            TempArena tempArena = scratch_begin(nullptr, 0);
+
+            World testWorld{};
+            InitWorld(&testWorld, tempArena.Arena);
+            InitEntityManager(&testWorld);
+            EntityManager& manager = *testWorld.EntityManager;
+
+            Entity* entity = AllocateEntity(manager, Inert::kind);
+            Assert(entity->is_dirty == true);
+
+            // Simulate save
+            entity->is_dirty = false;
+            Assert(entity->is_dirty == false);
+
+            // Simulate mutation
+            entity->position.x += 1.0f;
+            entity->is_dirty = true;
+            Assert(entity->is_dirty == true);
+
+            ShutdownEntityManager();
+            ShutdownWorld(&testWorld);
+
+            scratch_end(tempArena);
+            Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestDirtyTrackingLifecycle");
+        }
+    } // namespace
+
+    void WorldUnitTest()
+    {
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+        Log(LogLevel::Message, LogCategory::Game, "Starting Entity Allocation & Lifecycle Unit Tests");
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+
+        TestEntityAllocationAndWiring();
+        TestInPlaceDeserialization();
+        // TestSwapAndPopPointerFixup(); // Deferred to Entity_Removal_Brainstorm.md
+        TestDirtyTrackingLifecycle();
+
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+        Log(LogLevel::Message, LogCategory::Game, "All Entity Lifecycle Unit Tests PASSED Successfully");
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+    }
+} // namespace UnitTest
+
+#endif
@@ -0,0 +1,934 @@
+# Juliet Game Engine: Technical Specification & Implementation Plan
+# 04: Entity Templates ("Blueprints / Prefabs") & Delta Inheritance
+
+- **Document ID**: ENG-PLAN-04
+- **Component**: Game Architecture / Entity Component System / Asset Pipeline / Editor
+- **Author**: Senior Engine Architect
+- **Status**: Draft / Approved for Implementation
+- **Target Engine**: Juliet Engine (Milestone: 3D Platformer / World System)
+- **Target File**: `w:\Classified\Juliet\Game\Plans\04_Entity_Templates_And_Inheritance.md`
+
+---
+
+## 1. Executive Summary & Architecture Goals
+
+### 1.1 Motivation & Context
+As the Juliet engine evolves toward supporting complex interactive worlds, populating scenes by manually constructing raw entity memory from hardcoded values or monolithic binary streams (`world.bin`) creates severe scalability bottlenecks. Designers and environment artists require reusable entity archetypes—such as foliage, dynamic destructibles, hazards, enemies, and interactive props—that can be authored once and instantiated thousands of times with custom overrides.
+
+In modern commercial engines, this pattern is foundational:
+- **Unreal Engine**: Blueprint classes (`.uasset`) serve as class archetypes, instanced as Actors with per-instance component property overrides.
+- **Unity**: Prefabs (`.prefab`) serve as asset archetypes, instanced in scenes with explicit serialized property modification lists.
+
+In the **Juliet Game Engine**, this feature is formalized as **Entity Templates**.
+
+### 1.2 Architectural Goals
+1. **Unified File Format (`.jasset`)**:
+   Templates and world entity instances must share the exact same human-readable, version-control-friendly Key-Value (KV) file format. A template is simply an entity `.jasset` file located within `Assets/Templates/`, while a world entity is a `.jasset` file located within `Assets/Worlds/<WorldName>/Entities/` that references a parent template via metadata.
+2. **Zero Format Duplication**:
+   There must be no separate "prefab file format" versus "entity instance file format". The same serialization/deserialization code paths parse both archetypes and instances, completely eliminating format divergence, schema version desynchronization, and redundant parsing logic.
+3. **Delta Property Overrides (Sparse Inheritance)**:
+   Instances only serialize the fields that intentionally deviate from their template archetype. Any property omitted in the instance `.jasset` retains the exact bitwise value defined by the template archetype.
+4. **Zero Runtime Inheritance Overhead**:
+   No virtual table lookups, no runtime inheritance trees, and no pointer chasing at tick time. At instantiation time, the template archetype's memory footprint is blitted into contiguous engine arrays (`EntityManager::by_type`), and instance delta overrides are parsed directly into that memory block. Once instantiated, an entity created from a template executes with identical CPU cache locality and zero performance penalty compared to a hardcoded entity.
+5. **Arena-Centric Memory Model**:
+   All template assets are loaded into a dedicated, isolated `TemplateArena`. World entity instances allocate their runtime state out of `World::WorldArena` and `EntityManager::by_type[kind].arena`. Scratch computations during parsing utilize thread-local scratch arenas (`scratch_begin` / `scratch_end`). No heap allocation (`malloc`, `calloc`, `new`) is permitted.
+6. **Strict Engine Conformance**:
+   - Zero exceptions (`noexcept` by design).
+   - Strict warning compliance (`-Wall -Wextra -Werror` / `/W4 /WX`).
+   - Strict explicit casting (`static_cast`, `reinterpret_cast`; C-style casts strictly prohibited).
+   - Universal `[[nodiscard]]` on all value-returning queries and allocators.
+   - Consistent naming (`CamelCase` for types, functions, and member variables).
+   - Comprehensive precondition assertions via `Assert`.
+   - Mandatory curly braces `{}` across all control flow statements.
+
+---
+
+## 2. The Template Linking Mechanism
+
+### 2.1 File Format Specification (`.jasset`)
+All templates and entities in Juliet use the `.jasset` text format. The format consists of:
+- **Comment Lines**: Lines starting with `#` or `//` are treated as comments and ignored.
+- **Metadata Directives**: Lines starting with `; ` represent engine-level structural metadata (e.g., entity type, template references, versioning).
+- **Key-Value Pairs**: Key name followed by a colon and a space (`<Key>: <Value>`).
+
+```ini
+# ==============================================================================
+# Assets/Templates/RockLarge.jasset
+# Entity Archetype: Large Mossy Rock
+# ==============================================================================
+; entity_type: Inert
+
+Position: 0.0, 0.0, 0.0
+MeshAsset: Assets/Meshes/Rock_01.obj
+Scale: 1.0, 1.0, 1.0
+Mass: 250.0
+IsDestructible: true
+Health: 100.0
+```
+
+### 2.2 The `; template` Directive
+When an entity instance is authored for a world, it specifies its archetype via the `; template` directive:
+
+```ini
+# ==============================================================================
+# Assets/Worlds/Level01/Entities/RockLarge_042.jasset
+# Instance: Rock Large #042 in Level 01
+# ==============================================================================
+; template: Assets/Templates/RockLarge.jasset
+
+Position: 142.5, 12.0, -84.2
+Scale: 1.4, 1.4, 1.4
+Health: 50.0
+```
+
+Notice the power of sparse delta overrides in this format:
+- `Position` is set to the instance's unique world coordinates.
+- `Scale` is enlarged to $1.4\times$.
+- `Health` is damaged down to $50.0$.
+- Properties omitted—`MeshAsset`, `Mass`, and `IsDestructible`—are not duplicated in the file. They automatically inherit the authoritative values from `RockLarge.jasset`.
+
+### 2.3 Relative Path vs CRC Identifier
+To balance human-readability in source control with blazing runtime lookup speeds:
+- **Asset Authoring & Storage**: Files store canonical workspace-relative paths (e.g., `Assets/Templates/RockLarge.jasset`).
+- **Runtime Representation**: The engine computes a 32-bit CRC (`crc32`) of the normalized relative path string.
+  - Runtime lookup into `EntityTemplateCache` operates via `uint32 TemplateCrc`.
+  - In `JULIET_DEBUG` builds, the original `String TemplatePath` is retained within the cached struct for diagnostic logging, error messages, and inspector UI display.
+
+```cpp
+constexpr uint32 kInvalidTemplateCrc = 0;
+
+[[nodiscard]] inline uint32 HashTemplatePath(String path)
+{
+    Assert(IsValid(path));
+    return crc32(path.Str, path.Size);
+}
+```
+
+### 2.4 Standalone Entities vs Templated Instances
+The engine architecture seamlessly unifies two entity categories:
+
+| Entity Category | `; template` Directive Present? | Memory Initialization Source | Primary Use Case |
+| :--- | :--- | :--- | :--- |
+| **Standalone Entity** | **No** | Zero-initialized memory block (`ArenaPushStruct` / `MemSet`). All properties must be specified in the instance `.jasset`. | Unique, one-off actors (e.g., Level Script Trigger, Primary Player Spawn Marker, Boss Controller). |
+| **Templated Instance** | **Yes** | Blitted directly from `CachedTemplate::DefaultDerivedMemory`. Instance `.jasset` only specifies delta property overrides. | Reusable archetypes (e.g., environmental props, foliage, pickups, enemy minions, projectiles). |
+
+---
+
+## 3. In-Engine Template Caching
+
+### 3.1 Memory Layout & `TemplateArena` Isolation
+Reading and parsing text files from storage is orders of magnitude slower than memory copying. In a world containing 10,000 instances of `GrassClump` and 2,000 instances of `RockLarge`, disk I/O and text tokenization must occur **exactly once per archetype**.
+
+To achieve zero memory fragmentation and eliminate dynamic heap allocations:
+1. The engine instantiates an isolated `TemplateArena` at subsystem startup.
+2. When a template is requested, the system checks the `EntityTemplateCache`.
+3. If not cached, the template `.jasset` file is loaded from disk into temporary scratch memory, parsed, and baked into a contiguous binary archetype memory snapshot inside `TemplateArena`.
+4. The parsed archetype snapshot remains resident in `TemplateArena` for the lifetime of the application or world session.
+
+```
+---------------------------------------------------------------------------------+
+|                                 TemplateArena                                   |
+---------------------------------------------------------------------------------+
+|  [CachedTemplate #0]                                                            |
+|    - TemplateCrc: 0x9A4B12F0 ("Assets/Templates/RockLarge.jasset")             |
+|    - EntityKind: Pointer to Inert::Kind                                         |
+|    - DefaultBase: { ID=0, Kind=Inert::Kind, Derived=nullptr, X=0, Y=0, Z=0 }    |
+|    - DefaultDerivedMemory: [ sizeof(Inert) binary snapshot: MeshInstance=... ]  |
+---------------------------------------------------------------------------------+
+|  [CachedTemplate #1]                                                            |
+|    - TemplateCrc: 0x4D2E88C1 ("Assets/Templates/CoinPickup.jasset")            |
+|    - EntityKind: Pointer to Collectible::Kind                                   |
+|    - DefaultBase: { ID=0, Kind=Collectible::Kind, ... }                         |
+|    - DefaultDerivedMemory: [ sizeof(Collectible) binary snapshot: Value=100 ]   |
+---------------------------------------------------------------------------------+
+|  ... Free Arena Capacity for Additional Archetypes ...                          |
+---------------------------------------------------------------------------------+
+```
+
+### 3.2 Data Structures
+The template caching infrastructure is defined with explicit, strictly-typed C++ structures adhering to Juliet guidelines:
+
+```cpp
+#pragma once
+
+#include <Core/Common/CoreTypes.h>
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/NonNullPtr.h>
+#include <Core/Common/String.h>
+#include <Core/Container/Vector.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Engine/Class.h>
+#include <Entity/Entity.h>
+
+struct CachedTemplate
+{
+    uint32      TemplateCrc          = 0;
+    Class*      EntityKind           = nullptr;
+    Entity      DefaultBase          = {};
+    void*       DefaultDerivedMemory = nullptr;
+    size_t      DerivedMemorySize    = 0;
+
+#if JULIET_DEBUG
+    String      SourcePath           = {};
+#endif
+};
+
+constexpr size_t kMaxCachedTemplates = 1024;
+
+struct EntityTemplateCache
+{
+    Arena*                                  CacheArena = nullptr;
+    VectorArena<CachedTemplate, kMaxCachedTemplates> Templates;
+};
+
+// Subsystem API
+[[nodiscard]] EntityTemplateCache* InitEntityTemplateCache(NonNullPtr<Arena> parentArena);
+void                               ShutdownEntityTemplateCache(NonNullPtr<EntityTemplateCache> cache);
+[[nodiscard]] CachedTemplate*      GetOrLoadTemplate(NonNullPtr<EntityTemplateCache> cache, String relativePath);
+[[nodiscard]] CachedTemplate*      FindCachedTemplate(NonNullPtr<EntityTemplateCache> cache, uint32 templateCrc);
+void                               InvalidateTemplateCache(NonNullPtr<EntityTemplateCache> cache);
+```
+
+### 3.3 Loading Pipeline: Disk to Archetype Memory Snapshot
+When `GetOrLoadTemplate` is invoked with a relative path:
+1. **Hash & Probe**: Compute `crc32` of `relativePath`. Search `cache->Templates` for an existing entry. If found, immediately return the cached pointer ($O(1)$ amortized).
+2. **Scratch Allocation**: Open a scratch arena frame (`TempArena scratch = scratch_begin(nullptr, 0);`).
+3. **Disk I/O**: Resolve the path via `GetAssetPath(scratch.Arena, relativePath)` and load the entire file into a raw byte buffer via `LoadFile(scratch.Arena, fullPath)`.
+   - Precondition check: `Assert(fileBuffer.Data != nullptr);`
+4. **Header Parse**: Scan the file buffer for `; entity_type: <TypeName>`. Look up the corresponding `Class*` via the global entity registry (`kEntity_type_class_ptr`).
+5. **Archetype Memory Allocation**: Allocate `DefaultDerivedMemory` directly out of `cache->CacheArena`:
+   ```cpp
+   void* archetypeMem = ArenaPushSize(cache->CacheArena,
+                                      entityClass->size_of,
+                                      entityClass->alignment,
+                                      true JULIET_DEBUG_PARAM("CachedTemplateDerived"));
+   ```
+6. **Default Base Setup**: Initialize a local `Entity defaultBase`:
+   ```cpp
+   Entity defaultBase = {};
+   defaultBase.derived_kind = entityClass;
+   defaultBase.derived      = archetypeMem;
+   ```
+7. **Back-Pointer Linking**: Set `entity_template::base` in the archetype memory:
+   ```cpp
+   auto* archetypeTemplate = reinterpret_cast<entity_template*>(archetypeMem);
+   archetypeTemplate->base = &cachedEntry->DefaultBase;
+   ```
+8. **KV Property Parsing**: Parse all key-value pairs in the template `.jasset` file and write their deserialized values directly into `archetypeMem` and `defaultBase`.
+9. **Cache Insertion**: Store the fully baked `CachedTemplate` record in `cache->Templates`.
+10. **Scratch Release**: Release the temporary file buffer (`scratch_end(scratch);`).
+
+---
+
+## 4. Instantiation & Delta Property Overrides
+
+### 4.1 Memory Architecture: Base vs. Derived Entities
+In Juliet, an entity is split into two tightly coupled structures:
+1. **`Entity` (Base)**: Contains universal spatial and lifecycle fields:
+   ```cpp
+   struct Entity final
+   {
+       DECLARE_CLASS()
+
+       EntityID    ID           = 0;
+       Class*      derived_kind = nullptr;
+       DerivedType derived      = nullptr; // Points to the specialized struct
+       Vector4     position     = {};
+       bool        is_dirty     = false;
+   };
+   ```
+2. **`Derived` (Specialized Type)**: e.g., `Inert`, `Collectible`, `Player`. The first member is always `DECLARE_ENTITY()`, which expands to:
+   ```cpp
+   Entity* base;       // Back-pointer to the base Entity
+   DECLARE_CLASS()     // static Class* kind;
+   ```
+
+Because `DerivedType` stores a back-pointer (`base`) to `Entity`, **a shallow memory copy of an archetype invalidates this pointer**! The loading pipeline must explicitly restore this invariant.
+
+### 4.2 The 5-Step Instantiation Pipeline
+When an entity instance is spawned or deserialized from a `.jasset` file, the engine executes this strict 5-step sequence:
+
+```
+[ Step 1: Pre-allocate ]
+  - manager.Entities.PushBack(Entity{})
+  - ArenaPushSize(manager.by_type[Kind].arena)
+             |
+             v
+[ Step 2: Copy Archetype Memory ]
+  - MemCopy(instanceDerivedMem, template->DefaultDerivedMemory, size_of)
+  - instanceBase->X/Y/Z = template->DefaultBase.X/Y/Z
+             |
+             v
+[ Step 3: Fixup Base Back-Pointer ]  <--- CRITICAL ARCHITECTURAL STEP
+  - instanceDerived->Base = instanceBase
+  - instanceBase->Derived = instanceDerived
+             |
+             v
+[ Step 4: Parse Instance KV Delta ]
+  - Scan instance .jasset tokens
+  - Match each key to struct property offset
+  - Overwrite only specified properties
+             |
+             v
+[ Step 5: Finalize & Post-Init ]
+  - Assign Unique EntityID
+  - Register with Render/Physics systems
+```
+
+#### Step-by-Step Code Execution
+
+```cpp
+[[nodiscard]] Entity* InstantiateEntityFromTemplate(EntityManager& manager,
+                                                    NonNullPtr<const CachedTemplate> templateArchetype,
+                                                    NonNullPtr<Arena> scratchArena,
+                                                    String instanceKvContent)
+{
+    Assert(templateArchetype->EntityKind != nullptr);
+    Assert(templateArchetype->DefaultDerivedMemory != nullptr);
+
+    Class* entityKind = templateArchetype->EntityKind;
+    const size_t derivedSize = entityKind->size_of;
+    const size_t derivedAlign = entityKind->alignment;
+
+    // -------------------------------------------------------------------------
+    // STEP 1: Pre-allocate instance in EntityManager
+    // -------------------------------------------------------------------------
+    Entity baseEntity = {};
+    baseEntity.ID   = EntityManager::ID++;
+    baseEntity.Kind = entityKind;
+
+    // Push into flat base vector
+    manager.Entities.PushBack(baseEntity);
+    Entity* instanceBase = manager.Entities.Back();
+    Assert(instanceBase != nullptr);
+
+    // Allocate memory in the typed array arena
+    auto* instanceDerived = reinterpret_cast<entity_template*>(
+        ArenaPushSize(manager.by_type[entityKind->kind].arena,
+                      derivedSize,
+                      derivedAlign,
+                      false JULIET_DEBUG_PARAM(kEntity_type_names[entityKind->kind]))
+    );
+    Assert(instanceDerived != nullptr);
+
+    // Track array head if first element
+    if (manager.by_type[entityKind->kind].array == nullptr)
+    {
+        manager.by_type[entityKind->kind].array = instanceDerived;
+    }
+    manager.by_type[entityKind->kind].count += 1;
+
+    // -------------------------------------------------------------------------
+    // STEP 2: Copy cached template defaults into instance derived memory
+    // -------------------------------------------------------------------------
+    MemCopy(instanceDerived, templateArchetype->DefaultDerivedMemory, derivedSize);
+
+    // Inherit base spatial defaults
+    instanceBase->X = templateArchetype->DefaultBase.X;
+    instanceBase->Y = templateArchetype->DefaultBase.Y;
+    instanceBase->Z = templateArchetype->DefaultBase.Z;
+
+    // -------------------------------------------------------------------------
+    // STEP 3: Ensure derived back-pointer points to THIS instance's base
+    // -------------------------------------------------------------------------
+    instanceDerived->Base = instanceBase;
+    instanceBase->Derived = instanceDerived;
+
+    // -------------------------------------------------------------------------
+    // STEP 4: Parse instance .jasset KV nodes over the memory
+    // -------------------------------------------------------------------------
+    if (IsValid(instanceKvContent))
+    {
+        ApplyKvDeltaOverrides(instanceBase, instanceDerived, entityKind, instanceKvContent);
+    }
+
+    // -------------------------------------------------------------------------
+    // STEP 5: Post-Instantiation Initialization
+    // -------------------------------------------------------------------------
+    // If the entity is an Inert mesh, update its graphics transform
+    if (entityKind->kind == ENTITY(Inert))
+    {
+        auto* inert = reinterpret_cast<Inert*>(instanceDerived);
+        if (inert->MeshInstance != indexMax)
+        {
+            SetMeshInstanceTransform(inert->MeshInstance,
+                                     MatrixTranslation(instanceBase->X, instanceBase->Y, instanceBase->Z));
+        }
+    }
+
+    return instanceBase;
+}
+```
+
+### 4.3 Key-Value Parsing & Reflection Binding
+To apply delta overrides, the engine maps parsed string keys to memory offsets. Juliet utilizes lightweight property reflection metadata registered on each `Class`:
+
+```cpp
+enum class PropertyType : uint8
+{
+    Float,
+    Int32,
+    Bool,
+    Vector3,
+    MeshAsset,
+    String
+};
+
+struct PropertyDescriptor
+{
+    String       Name;
+    size_t       Offset;
+    PropertyType Type;
+    bool         IsBaseProperty; // True if located on Entity, false if on Derived
+};
+
+void ApplyKvDeltaOverrides(Entity* base, void* derived, Class* cls, String kvContent)
+{
+    Assert(base != nullptr);
+    Assert(derived != nullptr);
+    Assert(cls != nullptr);
+
+    TempArena scratch = scratch_begin(nullptr, 0);
+
+    KvParser parser = InitKvParser(kvContent);
+    KvPair pair = {};
+    while (NextKvPair(&parser, &pair))
+    {
+        // Directives like '; template' or '; entity_type' are skipped
+        if (pair.Key.Size > 0 && pair.Key.Str[0] == ';')
+        {
+            continue;
+        }
+
+        // Check base properties first
+        if (StringCompare(pair.Key, ConstString("Position")) == 0 || StringCompare(pair.Key, ConstString("position")) == 0)
+        {
+            Vector3 pos = ParseVector3(pair.Value);
+            base->position.x = pos.x;
+            base->position.y = pos.y;
+            base->position.z = pos.z;
+            continue;
+        }
+
+        // Look up property in Class reflection table
+        const PropertyDescriptor* prop = FindPropertyDescriptor(cls, pair.Key);
+        if (prop != nullptr)
+        {
+            void* targetField = static_cast<uint8*>(derived) + prop->Offset;
+            switch (prop->Type)
+            {
+                case PropertyType::Float:
+                {
+                    *reinterpret_cast<float*>(targetField) = ParseFloat(pair.Value);
+                    break;
+                }
+                case PropertyType::Int32:
+                {
+                    *reinterpret_cast<int32*>(targetField) = ParseInt32(pair.Value);
+                    break;
+                }
+                case PropertyType::Bool:
+                {
+                    *reinterpret_cast<bool*>(targetField) = ParseBool(pair.Value);
+                    break;
+                }
+                case PropertyType::MeshAsset:
+                {
+                    String meshPath = TrimWhitespace(pair.Value);
+                    MeshAssetID meshId = LoadMesh(meshPath);
+                    *reinterpret_cast<MeshAssetID*>(targetField) = meshId;
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+    scratch_end(scratch);
+}
+```
+
+---
+
+## 5. Editor Workflow & Operations (Romeo / ImGui)
+
+### 5.1 "Create Template from Entity" Workflow
+An artist or designer often crafts an intricate entity in the active level (configuring mesh, collider, and scale) and decides it should become a reusable archetype.
+
+#### Sequence Diagram / Workflow:
+1. **User Action**: Right-click an entity in the Romeo World Editor Outliner $\rightarrow$ Select *"Convert to Template..."*.
+2. **Modal Dialog**: The editor prompts for the template asset name (e.g., `SpikeTrap_Large`).
+3. **Sanitize World Transform**:
+   - The world position (`X, Y, Z`) is sanitized to origin (`0.0, 0.0, 0.0`) for the template asset.
+   - Rotations and local scale are preserved.
+4. **Serialize Archetype**:
+   - Write `Assets/Templates/SpikeTrap_Large.jasset` containing:
+     - `; entity_type: <KindName>`
+     - All authored property values.
+5. **Convert Live Instance**:
+   - The selected world entity is transformed into an instance of the newly created template.
+   - The entity is assigned the template CRC: `entity->TemplateCrc = crc32("Assets/Templates/SpikeTrap_Large.jasset")`.
+   - When the world is saved, this entity serializes as a sparse delta referencing the template!
+
+```cpp
+#if JULIET_EDITOR
+bool CreateTemplateFromEntity(World& world,
+                              size_t entityIndex,
+                              String templateName,
+                              NonNullPtr<Arena> scratchArena)
+{
+    auto& manager = *world.EntityManager;
+    Assert(entityIndex < manager.Entities.Size());
+
+    Entity* sourceEntity = &manager.Entities[entityIndex];
+    Class* entityKind = sourceEntity->derived_kind;
+    void* derivedMem = sourceEntity->derived;
+
+    // Format destination template path
+    String templatePath = Format(scratchArena, "Assets/Templates/{}.jasset", CStr(templateName));
+    String fullDiskPath = GetAssetPath(scratchArena, templatePath);
+
+    // Open IOStream for write
+    IOStream* fileStream = IOFromFile(scratchArena, fullDiskPath, ConstString("wb"));
+    if (fileStream == nullptr)
+    {
+        LogError(LogCategory::Game, "Failed to open file for template creation: %s", CStr(fullDiskPath));
+        return false;
+    }
+
+    // Write Header Directive
+    IOPrintf(fileStream, "; entity_type: %s\n\n", kEntity_type_names[entityKind->kind]);
+
+    // Write Origin Position
+    IOPrintf(fileStream, "Position: 0.0, 0.0, 0.0\n");
+
+    // Write Derived Properties via Reflection Table
+    SerializeDerivedPropertiesToKv(fileStream, entityKind, derivedMem);
+
+    IOClose(fileStream);
+
+    // Register with in-engine cache immediately
+    auto* templateCache = GetGameState()->TemplateCache;
+    if (templateCache != nullptr)
+    {
+        (void)GetOrLoadTemplate(templateCache, templatePath);
+    }
+
+    LogMessage(LogCategory::Game, "Successfully created template: %s", CStr(templatePath));
+    return true;
+}
+#endif
+```
+
+### 5.2 "Spawn Instance from Template" Workflow
+1. In the Romeo Content Browser, browse `Assets/Templates/`.
+2. Drag a `.jasset` template into the 3D viewport, or click *"Spawn Template"* in the World Editor toolbar.
+3. The viewport raycasts against the collision mesh/floor to compute `hitPosition`.
+4. The editor calls:
+   ```cpp
+   CachedTemplate* archetype = GetOrLoadTemplate(templateCache, templatePath);
+   Entity* newInstance = InstantiateEntityFromTemplate(manager, archetype, scratchArena, {});
+   newInstance->X = hitPosition.X;
+   newInstance->Y = hitPosition.Y;
+   newInstance->Z = hitPosition.Z;
+   ```
+5. The entity is immediately live, selectable, and rendered.
+
+### 5.3 Inspector Delta Highlighting & Property Diffing
+To make template inheritance intuitive, the inspector visually flags overridden properties:
+- **Default Property**: Rendered in standard gray text.
+- **Overridden Property**: Rendered in **bold bright cyan** with an undo/revert icon button `[R]`.
+
+```cpp
+#if JULIET_EDITOR
+void RenderEntityPropertyInspector(Entity* entity, CachedTemplate* archetype)
+{
+    Assert(entity != nullptr);
+    const bool isTemplated = (archetype != nullptr);
+
+    ImGui::Text("Entity ID: %llu", entity->ID);
+    if (isTemplated)
+    {
+        ImGui::TextColored(ImVec2(0.4f, 0.8f, 1.0f, 1.0f), "Template: %s", archetype->SourcePath.Str);
+        ImGui::SameLine();
+        if (ImGui::SmallButton("Revert All to Template"))
+        {
+            RevertEntityToTemplate(entity, archetype);
+        }
+        ImGui::Separator();
+    }
+
+    // Iterate through properties
+    Class* cls = entity->derived_kind;
+    for (size_t i = 0; i < cls->PropertyCount; ++i)
+    {
+        const PropertyDescriptor& prop = cls->Properties[i];
+        void* instanceField = static_cast<uint8*>(entity->derived) + prop.Offset;
+        void* templateField = isTemplated ? (static_cast<uint8*>(archetype->DefaultDerivedMemory) + prop.Offset) : nullptr;
+
+        const bool isOverridden = isTemplated && (MemCompare(instanceField, templateField, GetPropertySize(prop.Type)) != 0);
+
+        if (isOverridden)
+        {
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec2(0.2f, 1.0f, 1.0f, 1.0f));
+        }
+
+        // Render editor widget (DragFloat, InputText, etc.)
+        RenderPropertyWidget(prop, instanceField);
+
+        if (isOverridden)
+        {
+            ImGui::PopStyleColor();
+            ImGui::SameLine();
+            ImGui::PushID(static_cast<int>(i));
+            if (ImGui::SmallButton("R"))
+            {
+                // Revert this single property
+                MemCopy(instanceField, templateField, GetPropertySize(prop.Type));
+            }
+            ImGui::PopID();
+            if (ImGui::IsItemHovered())
+            {
+                ImGui::SetTooltip("Revert property to template default");
+            }
+        }
+    }
+}
+#endif
+```
+
+### 5.4 "Revert to Template" Mechanics
+Reverting an entire entity to its template archetype restores all properties while strictly preserving world positioning and the instance's unique `EntityID`:
+
+```cpp
+void RevertEntityToTemplate(NonNullPtr<Entity> instance, NonNullPtr<const CachedTemplate> archetype)
+{
+    Assert(instance->derived_kind == archetype->EntityKind);
+    Assert(archetype->DefaultDerivedMemory != nullptr);
+
+    void* derivedMem = instance->derived;
+    const size_t derivedSize = archetype->EntityKind->size_of;
+
+    // Preserve the current Base pointer
+    Entity* basePtr = instance.Get();
+
+    // 1. Re-copy the archetype defaults
+    MemCopy(derivedMem, archetype->DefaultDerivedMemory, derivedSize);
+
+    // 2. Re-establish the Base back-pointer
+    auto* templateDerived = reinterpret_cast<entity_template*>(derivedMem);
+    templateDerived->base = basePtr;
+
+    // 3. Mark visual / physics state as updated
+    if (instance->derived_kind->kind == ENTITY(Inert))
+    {
+        auto* inert = reinterpret_cast<Inert*>(derivedMem);
+        if (inert->MeshInstance != indexMax)
+        {
+            SetMeshInstanceTransform(inert->MeshInstance,
+                                     MatrixTranslation(basePtr->position.x, basePtr->position.y, basePtr->position.z));
+        }
+    }
+}
+```
+
+---
+
+## 6. Step-by-Step Implementation Roadmap
+
+```
+-----------------------------------------------------------------------------+
+| Phase 1: Core KV Parser & File Serialization Architecture                   |
+| - Fast, zero-allocation Key-Value streaming parser                          |
+| - Property reflection table integration on Class struct                     |
+-----------------------------------------------------------------------------+
+                                      |
+                                      v
+-----------------------------------------------------------------------------+
+| Phase 2: Template Cache Subsystem (`EntityTemplateCache`)                   |
+| - Dedicated TemplateArena initialization                                    |
+| - Archetype loading, CRC hashing, and resident memory snapshot baking       |
+-----------------------------------------------------------------------------+
+                                      |
+                                      v
+-----------------------------------------------------------------------------+
+| Phase 3: Instantiation & Delta Overrides in `EntityManager`                 |
+| - Implement 5-Step Instantiation Pipeline                                   |
+| - Derived back-pointer fixup validation                                     |
+| - Sparse delta serialization for world saving                               |
+-----------------------------------------------------------------------------+
+                                      |
+                                      v
+-----------------------------------------------------------------------------+
+| Phase 4: Romeo Editor UI & Inspector Workflow                               |
+| - Template browser window in ImGui                                          |
+| - "Create Template from Entity" context menu                                |
+| - Inspector delta highlighting and per-property "Revert" action             |
+-----------------------------------------------------------------------------+
+                                      |
+                                      v
+-----------------------------------------------------------------------------+
+| Phase 5: Production Verification & Non-Invasive Unit Testing Suite          |
+| - Comprehensive test cases for cache, delta inheritance, and memory safety  |
+-----------------------------------------------------------------------------+
+```
+
+### Detailed Milestone Tasks
+
+| Phase | Target Files | Objective / Deliverable | Success Criteria |
+| :--- | :--- | :--- | :--- |
+| **Phase 1** | `Juliet/include/Engine/KvParser.h`<br>`Juliet/src/Engine/KvParser.cpp`<br>`Juliet/include/Engine/Class.h` | Build a zero-allocation streaming Key-Value parser operating entirely over `String` slices and `Arena*`. Add property descriptor tables to `Class`. | Parses full `.jasset` buffer in $<50\mu\text{s}$ without dynamic allocations. Zero exceptions. |
+| **Phase 2** | `Game/Entity/TemplateCache.h`<br>`Game/Entity/TemplateCache.cpp` | Implement `EntityTemplateCache`, `CachedTemplate`, and on-demand disk loader backed by `TemplateArena`. | Repeated loads of same template return cached pointer in $O(1)$ time without disk reads. |
+| **Phase 3** | `Game/Entity/EntityManager.h`<br>`Game/Entity/EntityManager.cpp`<br>`Game/Data/World.cpp` | Implement `InstantiateEntityFromTemplate` using the 5-step pipeline. Update world save/load to serialize sparse deltas when `; template` is present. | Instantiated entities correctly retain archetype defaults while applying deltas. `Base` pointer is guaranteed valid. |
+| **Phase 4** | `Game/Data/World.cpp`<br>`Game/Debug/WorldEditorUI.cpp` | Add ImGui widgets for template authoring, template instantiation drag-and-drop, delta highlighting, and "Revert" actions. | Designer can convert an entity to a template and revert modified properties with instant visual update. |
+| **Phase 5** | `Game/UnitTest/TemplateUnitTest.h`<br>`Game/UnitTest/TemplateUnitTest.cpp` | Author non-invasive unit tests validating KV parsing, caching, delta override correctness, back-pointer fixup, and revert operations. | 100% test pass rate with zero memory leaks and all assertions satisfied under `/WX`. |
+
+---
+
+## 7. Production-Grade Unit Testing Plan
+
+### 7.1 Testing Philosophy & Non-Invasive Framework Rules
+In accordance with Juliet engine guidelines:
+- **No framework pollution**: Unit tests must not introduce test-only `#ifdef` branches or dummy parameters into production engine systems.
+- **Isolated test arenas**: All tests create their own temporary scratch arena or sub-arena and release it upon completion.
+- **Deterministic verification**: Every assumption (data alignment, pointer fixups, delta override values) is verified through explicit `Assert` statements.
+
+### 7.2 Header Specification (`Game/UnitTest/TemplateUnitTest.h`)
+
+```cpp
+#pragma once
+
+#include <Juliet.h>
+
+#if JULIET_DEBUG
+
+namespace UnitTest
+{
+    void RunTemplateAndInheritanceUnitTests();
+}
+
+#endif
+```
+
+### 7.3 Complete Unit Test Suite Implementation (`Game/UnitTest/TemplateUnitTest.cpp`)
+
+```cpp
+#include <UnitTest/TemplateUnitTest.h>
+
+#if JULIET_DEBUG
+
+#include <Core/Common/CoreUtils.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Core/Thread/ThreadContext.h>
+#include <Data/World.h>
+#include <Entity/Entity.h>
+#include <Entity/EntityManager.h>
+#include <Entity/TemplateCache.h>
+
+namespace UnitTest
+{
+    // =========================================================================
+    // Test 1: Key-Value Parser Verification
+    // =========================================================================
+    static void TestKvParser(NonNullPtr<Arena> testArena)
+    {
+        LogMessage(LogCategory::Game, "[UnitTest] Starting TestKvParser...");
+
+        const char* sampleKv =
+            "; entity_type: Inert\n"
+            "# This is a comment\n"
+            "Position: 10.5, -20.0, 30.25\n"
+            "Scale: 2.0, 2.0, 2.0\n"
+            "MeshAsset: Assets/Meshes/Cube.obj\n"
+            "IsActive: true\n";
+
+        KvParser parser = InitKvParser(WrapString(sampleKv));
+        KvPair pair = {};
+
+        // 1. Directive
+        Assert(NextKvPair(&parser, &pair));
+        Assert(StringCompare(pair.Key, ConstString("; entity_type")) == 0);
+        Assert(StringCompare(pair.Value, ConstString("Inert")) == 0);
+
+        // 2. Position
+        Assert(NextKvPair(&parser, &pair));
+        Assert(StringCompare(pair.Key, ConstString("Position")) == 0);
+        Vector3 pos = ParseVector3(pair.Value);
+        Assert(pos.X == 10.5f);
+        Assert(pos.Y == -20.0f);
+        Assert(pos.Z == 30.25f);
+
+        // 3. Scale
+        Assert(NextKvPair(&parser, &pair));
+        Assert(StringCompare(pair.Key, ConstString("Scale")) == 0);
+
+        // 4. MeshAsset
+        Assert(NextKvPair(&parser, &pair));
+        Assert(StringCompare(pair.Key, ConstString("MeshAsset")) == 0);
+        Assert(StringCompare(pair.Value, ConstString("Assets/Meshes/Cube.obj")) == 0);
+
+        // 5. IsActive
+        Assert(NextKvPair(&parser, &pair));
+        Assert(StringCompare(pair.Key, ConstString("IsActive")) == 0);
+        Assert(ParseBool(pair.Value) == true);
+
+        // End of stream
+        Assert(!NextKvPair(&parser, &pair));
+
+        LogMessage(LogCategory::Game, "[UnitTest] TestKvParser PASSED.");
+    }
+
+    // =========================================================================
+    // Test 2: Template Cache & Single-Load Invariant
+    // =========================================================================
+    static void TestTemplateCache(NonNullPtr<Arena> testArena)
+    {
+        LogMessage(LogCategory::Game, "[UnitTest] Starting TestTemplateCache...");
+
+        EntityTemplateCache* cache = InitEntityTemplateCache(testArena);
+        Assert(cache != nullptr);
+
+        String templatePath = ConstString("Assets/Templates/TestRock.jasset");
+
+        // First load: loads and caches
+        CachedTemplate* firstLoad = GetOrLoadTemplate(cache, templatePath);
+        Assert(firstLoad != nullptr);
+        Assert(firstLoad->TemplateCrc == HashTemplatePath(templatePath));
+        Assert(firstLoad->EntityKind == Inert::Kind);
+
+        // Second load: must return identical cached pointer without re-allocating
+        CachedTemplate* secondLoad = GetOrLoadTemplate(cache, templatePath);
+        Assert(secondLoad == firstLoad);
+
+        // Verify lookup by CRC
+        CachedTemplate* crcLookup = FindCachedTemplate(cache, firstLoad->TemplateCrc);
+        Assert(crcLookup == firstLoad);
+
+        ShutdownEntityTemplateCache(cache);
+        LogMessage(LogCategory::Game, "[UnitTest] TestTemplateCache PASSED.");
+    }
+
+    // =========================================================================
+    // Test 3: 5-Step Instantiation Pipeline & Derived Back-Pointer Fixup
+    // =========================================================================
+    static void TestInstantiationPipeline(NonNullPtr<Arena> testArena)
+    {
+        LogMessage(LogCategory::Game, "[UnitTest] Starting TestInstantiationPipeline...");
+
+        // Setup mock World and EntityManager
+        World world = {};
+        InitWorld(&world, testArena);
+        InitEntityManager(&world);
+        auto& manager = *world.EntityManager;
+
+        // Construct a synthetic template archetype
+        CachedTemplate mockTemplate = {};
+        mockTemplate.TemplateCrc = 0xABCD1234;
+        mockTemplate.EntityKind  = Inert::Kind;
+        mockTemplate.DefaultBase.X = 1.0f;
+        mockTemplate.DefaultBase.Y = 2.0f;
+        mockTemplate.DefaultBase.Z = 3.0f;
+
+        Inert defaultInert = {};
+        defaultInert.MeshInstance = 42; // Template default
+        mockTemplate.DefaultDerivedMemory = &defaultInert;
+        mockTemplate.DerivedMemorySize = sizeof(Inert);
+
+        // Delta content overrides Position and leaves MeshInstance unspecified
+        String instanceKv = ConstString("Position: 100.0, 200.0, 300.0\n");
+
+        Entity* instance = InstantiateEntityFromTemplate(manager, &mockTemplate, testArena, instanceKv);
+        Assert(instance != nullptr);
+
+        // Verify Step 1 & 2: Base spatial delta applied, non-overridden derived property retained
+        Assert(instance->position.x == 100.0f);
+        Assert(instance->position.y == 200.0f);
+        Assert(instance->position.z == 300.0f);
+
+        auto* inertDerived = DownCast<Inert>(instance);
+        Assert(inertDerived != nullptr);
+        Assert(inertDerived->MeshInstance == 42); // Retained from template!
+
+        // Verify Step 3: CRITICAL back-pointer fixup check
+        Assert(inertDerived->base == instance);
+        Assert(instance->derived == inertDerived);
+
+        ShutdownEntityManager();
+        ShutdownWorld(&world);
+
+        LogMessage(LogCategory::Game, "[UnitTest] TestInstantiationPipeline PASSED.");
+    }
+
+    // =========================================================================
+    // Test 4: Delta Override & Revert Functionality
+    // =========================================================================
+    static void TestDeltaOverrideAndRevert(NonNullPtr<Arena> testArena)
+    {
+        LogMessage(LogCategory::Game, "[UnitTest] Starting TestDeltaOverrideAndRevert...");
+
+        World world = {};
+        InitWorld(&world, testArena);
+        InitEntityManager(&world);
+        auto& manager = *world.EntityManager;
+
+        CachedTemplate mockTemplate = {};
+        mockTemplate.TemplateCrc = 0x11223344;
+        mockTemplate.EntityKind  = Inert::Kind;
+        mockTemplate.DefaultBase.X = 0.0f;
+        mockTemplate.DefaultBase.Y = 0.0f;
+        mockTemplate.DefaultBase.Z = 0.0f;
+
+        Inert defaultInert = {};
+        defaultInert.MeshInstance = 100;
+        mockTemplate.DefaultDerivedMemory = &defaultInert;
+        mockTemplate.DerivedMemorySize = sizeof(Inert);
+
+        // Instantiate with delta
+        String instanceKv = ConstString("MeshInstance: 999\nPosition: 5.0, 5.0, 5.0\n");
+        Entity* instance = InstantiateEntityFromTemplate(manager, &mockTemplate, testArena, instanceKv);
+
+        auto* inertDerived = DownCast<Inert>(instance);
+        Assert(inertDerived->MeshInstance == 999); // Delta applied
+
+        // Execute Revert to Template
+        RevertEntityToTemplate(instance, &mockTemplate);
+
+        // Verify property restored to template default
+        Assert(inertDerived->MeshInstance == 100);
+
+        // Verify world position is preserved across revert
+        Assert(instance->position.x == 5.0f);
+        Assert(instance->position.y == 5.0f);
+        Assert(instance->position.z == 5.0f);
+
+        // Verify back-pointer invariant preserved after revert
+        Assert(inertDerived->base == instance);
+
+        ShutdownEntityManager();
+        ShutdownWorld(&world);
+
+        LogMessage(LogCategory::Game, "[UnitTest] TestDeltaOverrideAndRevert PASSED.");
+    }
+
+    // =========================================================================
+    // Master Runner
+    // =========================================================================
+    void RunTemplateAndInheritanceUnitTests()
+    {
+        TempArena scratch = scratch_begin(nullptr, 0);
+
+        TestKvParser(scratch.Arena);
+        TestTemplateCache(scratch.Arena);
+        TestInstantiationPipeline(scratch.Arena);
+        TestDeltaOverrideAndRevert(scratch.Arena);
+
+        scratch_end(scratch);
+        LogMessage(LogCategory::Game, "[UnitTest] All Entity Template & Inheritance tests PASSED successfully.");
+    }
+}
+
+#endif
@@ -0,0 +1,273 @@
+# Entity Removal & Deletion Lifecycle (Brainstorm & Rework)
+
+> [!WARNING]
+> **Status: Needs Rework**
+> The entity deletion and removal logic below was extracted as-is from [`Game/Plans/02_Entity_Allocation_And_Lifecycle.md`](file:///w:/Classified/Juliet/Game/Plans/02_Entity_Allocation_And_Lifecycle.md) for future brainstorming.
+> The original swap-and-pop approach required complex mutual back-pointer fixups across both base and derived memory buffers.
+
+---
+
+## 1. Brainstorming Notes & Alternative Approaches
+
+The original design relied on `VectorArena::RemoveAtFast` (swap-and-pop) for both `Entities` and `by_type[kind].arena`. While this maintained dense contiguous memory, swapping arbitrary elements in memory invalidated pointers in both directions, requiring runtime pointer patching (`derived->Base = movedEntity; base->Derived = movedComponent`).
+
+### Ideas for Simpler & More Robust Alternatives:
+
+1. **Active Flag / Tombstone (`is_active` bool)**:
+   - Keep deleted entities in place rather than moving or swapping them.
+   - Simply toggle `entity->is_active = false;`.
+   - Iterators and simulation loops skip inactive entities (`if (!entity->is_active) continue;`).
+   - Pointers to entities and derived components remain stable for their entire lifetime.
+
+2. **Intrusive Free List for Slot Recycling**:
+   - Instead of shifting memory on deletion, vacant slots are linked into an intrusive free list (`first_free_index`).
+   - When an entity is destroyed:
+     - `entity->is_active = false;`
+     - Overwrite unused slot memory with `next_free_index`.
+   - When allocating a new entity:
+     - Check if `first_free_index != indexMax`.
+     - Pop from the free list in $O(1)$; otherwise push back to the end of the arena.
+   - Zero pointer invalidation, zero memmove/memcpy overhead during deletion.
+
+3. **Stable Generational Handles / Slot Map**:
+   - If external systems need references to entities that might be deleted, combine the free list with a generational counter to detect stale lookups safely.
+
+4. **Deferred Compaction / Garbage Collection**:
+   - If contiguous packing is strictly necessary for SIMD/cache optimization, defer compaction to a designated level load or scene transition rather than doing it per-frame on individual deletes.
+
+---
+
+## 2. Extracted Original Removal Logic (As-Is from Plan 2)
+
+### 2.1 In-Memory Removal vs. Immediate Disk Deletion Hazards
+In game development, deleting an entity in the editor or during gameplay must **never synchronously invoke disk deletion**:
+1. **Frame Rate Stutters:** Blocking on synchronous OS filesystem APIs (`DeleteFileA`) introduces multisecond frame freezes.
+2. **Transactional Safety:** If the editor crashes or the user exits without saving, disk modifications cannot be rolled back.
+3. **Undo/Redo Support:** An editor action stack must allow recovering deleted entities before changes are permanently committed to disk.
+
+Therefore, Juliet enforces a strict separation:
+- **Immediate in-memory destruction:** Releases the entity from active simulation and registers its identifier in `World::PendingDeletions`.
+- **Deferred disk deletion:** Executed strictly during explicit `SaveWorld` operations.
+
+### 2.2 Fast In-Memory Removal (`RemoveAtFast`) & Mutual Pointer Fixup
+`VectorArena::RemoveAtFast` utilizes swap-and-pop: the element at the target index is replaced by the last element in the vector, and `Count` is decremented.
+
+```cpp
+void RemoveAtFast(index_t index)
+{
+    Assert(Arena);
+    Assert(index < Count);
+    Assert(Count > 0);
+
+    Type* elementAdr = DataFirst + index;
+
+    if (DataLast != elementAdr)
+    {
+        Swap(DataLast, elementAdr);
+    }
+
+    --DataLast;
+    --Count;
+}
+```
+
+#### The Pointer Invalidation Problem:
+When `Entity A` (at `index`) is swapped with `Entity Z` (at `DataLast`), the physical address of `Entity Z` changes from `DataLast` to `elementAdr`.
+If `Entity Z` has a derived struct `derivedZ`, `derivedZ->Base` previously pointed to `DataLast`. After `RemoveAtFast`, `derivedZ->Base` points to garbage or the freed slot!
+
+#### The Pointer Fixup Protocol:
+To preserve the mutual back-pointer invariant, `DestroyEntity` explicitly fixes up the swapped entity's derived back-pointer:
+
+```cpp
+void DestroyEntity(EntityManager& manager, EntityID id)
+{
+    Entity* baseArray = manager.Entities.DataPtr();
+    size_t  count     = manager.Entities.Size();
+
+    size_t targetIndex = indexMax;
+    for (size_t i = 0; i < count; ++i)
+    {
+        if (baseArray[i].ID == id)
+        {
+            targetIndex = i;
+            break;
+        }
+    }
+
+    if (targetIndex == indexMax)
+    {
+        return;
+    }
+
+    Entity* targetEntity = &baseArray[targetIndex];
+    Class*  classPtr     = targetEntity->derived_kind;
+    Assert(classPtr != nullptr);
+
+    // 1. Remove derived component from typed array via swap-and-pop
+    RemoveDerivedComponent(manager, classPtr, targetEntity->derived);
+
+    // 2. Remove base entity via swap-and-pop in VectorArena
+    bool wasLast = (targetIndex == count - 1);
+    manager.Entities.RemoveAtFast(targetIndex);
+
+    // 3. Pointer fixup: If an element was swapped into targetIndex, fix its back-pointer!
+    if (!wasLast && targetIndex < manager.Entities.Size())
+    {
+        Entity* movedEntity = &manager.Entities[targetIndex];
+        auto*   derivedTemp = reinterpret_cast<entity_template*>(movedEntity->derived);
+        Assert(derivedTemp != nullptr);
+        derivedTemp->base = movedEntity;
+    }
+}
+```
+
+### 2.3 O(1) Component Removal in `typed_entity_array` via Swap-and-Pop
+To keep derived components packed contiguously for SIMD/cache iteration:
+1. Locate the component's index within `by_type[kind].arena`. Because components have uniform stride `classPtr->size_of`:
+   $$\text{componentIndex} = \frac{\text{reinterpret\_cast<uint8*>(derivedPtr)} - \text{reinterpret\_cast<uint8*>(typedArray.array)}}{\text{classPtr->size\_of}}$$
+2. If the component is not the last one in the typed arena:
+   - Copy the last component into the slot occupied by the deleted component.
+   - Update the moved component's `Base->Derived` pointer to point to its new slot.
+3. Decrement `typedArray.count`.
+4. Pop the arena allocation if it was the top of the stack, or decrement count to mark slot reclamation.
+
+```cpp
+void RemoveDerivedComponent(EntityManager& manager, Class* classPtr, DerivedType derivedPtr)
+{
+    Assert(classPtr != nullptr);
+    Assert(derivedPtr != nullptr);
+
+    typed_entity_array& typedArray = manager.by_type[classPtr->kind];
+    Assert(typedArray.count > 0);
+    Assert(typedArray.array != nullptr);
+
+    size_t stride     = classPtr->size_of;
+    auto*  targetByte = reinterpret_cast<uint8*>(derivedPtr);
+    auto*  firstByte  = reinterpret_cast<uint8*>(typedArray.array);
+
+    size_t componentIndex = static_cast<size_t>(targetByte - firstByte) / stride;
+    Assert(componentIndex < typedArray.count);
+
+    size_t lastIndex = typedArray.count - 1;
+    if (componentIndex != lastIndex)
+    {
+        uint8* lastByte = firstByte + (lastIndex * stride);
+        
+        // Copy last component data into target slot
+        MemCopy(targetByte, lastByte, stride);
+
+        // Fixup the base pointer of the moved component
+        auto* movedDerived = reinterpret_cast<entity_template*>(targetByte);
+        Assert(movedDerived->base != nullptr);
+        movedDerived->base->derived = targetByte;
+    }
+
+    typedArray.count -= 1;
+    if (typedArray.count == 0)
+    {
+        typedArray.array = nullptr;
+    }
+}
+```
+
+### 2.4 Tracking Deletions in `World::PendingDeletions`
+In `World.h`, the `World` struct is extended with a pending deletions container:
+
+```cpp
+struct World
+{
+    Arena*                       WorldArena    = nullptr;
+    EntityManager*               EntityManager = nullptr;
+    VectorArena<EntityID, 1024>  PendingDeletions;
+};
+```
+
+When an entity is deleted in the world:
+```cpp
+void RemoveWorldEntity(World& world, EntityID id)
+{
+    Assert(world.EntityManager != nullptr);
+
+    // Record pending disk deletion
+    world.PendingDeletions.PushBack(id);
+
+    // Destroy in memory immediately
+    DestroyEntity(*world.EntityManager, id);
+}
+```
+
+### 2.5 Disk File Cleanup during `SaveWorld`
+During `SaveWorld`, before saving modified entities, the engine iterates over `world.PendingDeletions` and removes their associated `.jasset` files:
+
+```cpp
+void ProcessPendingDeletions(World& world, NonNullPtr<Arena> scratchArena)
+{
+    for (size_t i = 0; i < world.PendingDeletions.Size(); ++i)
+    {
+        EntityID id = world.PendingDeletions[i];
+
+        // Format relative asset path: Assets/Entities/{ID}.jasset
+        char filenameBuffer[64];
+        juliet_snprintf(filenameBuffer, sizeof(filenameBuffer), "Entities/%llu.jasset", id);
+        
+        String assetPath = GetAssetPath(scratchArena, WrapString(filenameBuffer));
+
+        if (PlatformDeleteFile(assetPath))
+        {
+            Log(LogLevel::Message, LogCategory::Game, "Deleted entity asset: %s", CStr(assetPath));
+        }
+    }
+
+    world.PendingDeletions.Clear();
+}
+```
+
+### 2.6 Associated Swap-and-Pop Unit Test
+```cpp
+void TestSwapAndPopPointerFixup()
+{
+    Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestSwapAndPopPointerFixup...");
+
+    TempArena tempArena = scratch_begin(nullptr, 0);
+
+    World testWorld{};
+    InitWorld(&testWorld, tempArena.Arena);
+    InitEntityManager(&testWorld);
+    EntityManager& manager = *testWorld.EntityManager;
+
+    // Allocate 3 entities: E0, E1, E2
+    Inert* e0 = MakeEntity<Inert>(manager, 1.0f, 0.0f, 0.0f);
+    Inert* e1 = MakeEntity<Inert>(manager, 2.0f, 0.0f, 0.0f);
+    Inert* e2 = MakeEntity<Inert>(manager, 3.0f, 0.0f, 0.0f);
+
+    EntityID id0 = e0->base->ID;
+    EntityID id1 = e1->base->ID;
+    EntityID id2 = e2->base->ID;
+
+    Assert(manager.Entities.Size() == 3);
+
+    // Delete middle entity E1 (triggers swap with E2)
+    DestroyEntity(manager, id1);
+
+    Assert(manager.Entities.Size() == 2);
+
+    // Verify E2's mutual back-pointers are still completely intact
+    Entity* remaining0 = &manager.Entities[0];
+    Entity* remaining1 = &manager.Entities[1];
+
+    Assert(remaining0->ID == id0);
+    Assert(remaining1->ID == id2);
+
+    auto* derived0 = reinterpret_cast<entity_template*>(remaining0->derived);
+    auto* derived1 = reinterpret_cast<entity_template*>(remaining1->derived);
+
+    Assert(derived0->base == remaining0);
+    Assert(derived1->base == remaining1);
+
+    ShutdownEntityManager();
+    ShutdownWorld(&testWorld);
+
+    scratch_end(tempArena);
+    Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestSwapAndPopPointerFixup");
+}
+```
@@ -0,0 +1,154 @@
+#include <UnitTest/WorldUnitTest.h>
+
+#if JULIET_DEBUG
+
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/serialization.h>
+#include <Core/HAL/IO/IOStream.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Core/Thread/ThreadContext.h>
+#include <Data/World.h>
+#include <Entity/entity_types.h>
+
+namespace UnitTest
+{
+    internal void TestEntityAllocationAndWiring()
+    {
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestEntityAllocationAndWiring...");
+
+        TempArena tempArena = scratch_begin(nullptr, 0);
+
+        World testWorld{};
+        InitWorld(&testWorld, tempArena.Arena);
+
+        InitEntityManager(&testWorld);
+        EntityManager& manager = *testWorld.EntityManager;
+
+        // 1. Allocate Inert Entity via AllocateEntity
+        Entity* base_entity = allocate_entity(manager, Inert::kind);
+        Assert(base_entity != nullptr);
+        Assert(base_entity->ID == 0); // Pure memory allocator leaves ID unassigned (0) until MakeEntity or deserialization
+        base_entity->ID = ++EntityManager::ID;
+        Assert(base_entity->ID > 0);
+        Assert(base_entity->derived_kind == Inert::kind);
+        Assert(base_entity->derived != nullptr);
+        Assert(base_entity->is_dirty == true);
+
+        // 2. Validate mutual back-pointer wiring
+        auto* derived = reinterpret_cast<EntityTemplate*>(base_entity->derived);
+        Assert(derived->base == base_entity);
+
+        // 3. DownCast verification
+        Inert* inert = DownCast<Inert>(base_entity);
+        Assert(inert != nullptr);
+        Assert(inert->base == base_entity);
+
+        // 4. Validate typed array tracking
+        typed_entity_array& inert_array = manager.by_type[ENTITY(Inert)];
+        Assert(inert_array.count == 1);
+        Assert(inert_array.array == derived);
+
+        ShutdownEntityManager();
+        ShutdownWorld(&testWorld);
+
+        scratch_end(tempArena);
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestEntityAllocationAndWiring");
+    }
+
+    internal void TestInPlaceDeserialization()
+    {
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestInPlaceDeserialization...");
+        TempArena tempArena = scratch_begin(nullptr, 0);
+        World     testWorld{};
+        InitWorld(&testWorld, tempArena.Arena);
+        InitEntityManager(&testWorld);
+        EntityManager& manager = *testWorld.EntityManager;
+        // 1. In-memory .jasset text fixture (no streams or files needed)
+        String     asset_content = ConstString("; class\n"
+                                                   "Inert\n"
+                                                   "; version\n"
+                                                   "1\n"
+                                                   "; class_version\n"
+                                                   "1\n"
+                                                   "; id\n"
+                                                   "42\n"
+                                                   "; position\n"
+                                                   "12.5 -44.0 108.2 1.0\n"
+                                                   "; MeshInstance\n"
+                                                   "42\n");
+        ByteBuffer buffer        = { .Data = reinterpret_cast<Byte*>(asset_content.Str), .Size = asset_content.Size };
+        // 2. Tokenize into Archive
+        Archive load_ar = {};
+        load_ar.arena   = tempArena.Arena;
+        load_ar.loading = true;
+        load_ar.base    = tokenize_archive(tempArena.Arena, buffer);
+        // 3. Deserialize in-place
+        Entity* loaded_base = deserialize_entity(load_ar, manager);
+        // 4. Verify in-place allocations and values
+        Assert(loaded_base != nullptr);
+        Assert(loaded_base->ID == 42);
+        Assert(EntityManager::ID > 42); // Generator counter advanced past loaded ID
+        Assert(loaded_base->position.x == 12.5f);
+        Assert(loaded_base->position.y == -44.0f);
+        Assert(loaded_base->position.z == 108.2f);
+        Assert(loaded_base->is_dirty == false);
+        Inert* loaded_inert = DownCast<Inert>(loaded_base);
+        Assert(loaded_inert != nullptr);
+        Assert(loaded_inert->base == loaded_base);
+        Assert(loaded_inert->MeshInstance == 42);
+        ShutdownEntityManager();
+        ShutdownWorld(&testWorld);
+        scratch_end(tempArena);
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestInPlaceDeserialization");
+    }
+
+    internal void TestDirtyTrackingLifecycle()
+    {
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestDirtyTrackingLifecycle...");
+
+        TempArena tempArena = scratch_begin(nullptr, 0);
+
+        World testWorld{};
+        InitWorld(&testWorld, tempArena.Arena);
+        InitEntityManager(&testWorld);
+        EntityManager& manager = *testWorld.EntityManager;
+
+        Entity* entity = allocate_entity(manager, Inert::kind);
+        Assert(entity->is_dirty == true);
+
+        // Simulate save
+        entity->is_dirty = false;
+        Assert(entity->is_dirty == false);
+
+        // Simulate mutation
+        entity->position.x += 1.0f;
+        entity->is_dirty = true;
+        Assert(entity->is_dirty == true);
+
+        ShutdownEntityManager();
+        ShutdownWorld(&testWorld);
+
+        scratch_end(tempArena);
+        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestDirtyTrackingLifecycle");
+    }
+
+    void WorldUnitTest()
+    {
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+        Log(LogLevel::Message, LogCategory::Game, "Starting Entity Allocation & Lifecycle Unit Tests");
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+
+        TestEntityAllocationAndWiring();
+        TestInPlaceDeserialization();
+        // TestSwapAndPopPointerFixup(); // Deferred to Entity_Removal_Brainstorm.md
+        TestDirtyTrackingLifecycle();
+
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+        Log(LogLevel::Message, LogCategory::Game, "All Entity Lifecycle Unit Tests PASSED Successfully");
+        Log(LogLevel::Message, LogCategory::Game, "==================================================");
+    }
+} // namespace UnitTest
+
+#endif
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <Juliet.h>
+
+#if JULIET_DEBUG
+
+namespace UnitTest
+{
+    void WorldUnitTest();
+} // namespace UnitTest
+
+#endif
@@ -1,81 +1,172 @@
-#include <cstdio>
-#include <Windows.h> // TODO: remove because our dll should not be platform dependant
-#undef min
-#undef max
+#include <game.h>

+#include <Controller/DebugCameraController.h>
+#include <Core/Common/serialization.h>
 #include <Core/HAL/Filesystem/Filesystem.h>
+#include <Core/HAL/Keyboard/Keyboard.h>
 #include <Core/JulietInit.h>
 #include <Core/Logging/LogManager.h>
 #include <Core/Memory/MemoryArena.h>
+#include <Data/World.h>
 #include <Entity/Entity.h>
+#include <Entity/entity_types.h>
 #include <Entity/EntityManager.h>
+#include <Graphics/Camera.h>
+#include <Graphics/MeshRenderer.h>
+#include <imgui.h>

-// Test code
-namespace Game
+#if JULIET_DEBUG
+#include <Debug/DebugTopBar.h>
+#include <UnitTest/WorldUnitTest.h>
+#endif
+
+// namespace
+// {
+//     void serialize_test(Archive* ar, void* payload)
+//     {
+//         SerializedEntityTest* test = reinterpret_cast<SerializedEntityTest*>(payload);
+//         serialize_elem(ar, test->A);
+//     }
+// } // namespace
+//
+// DEFINE_ENTITY_SERIALIZED(SerializedEntityTest, serialize_test)
+
+namespace
 {
-    struct Door
-    {
-        DECLARE_ENTITY()
-        bool IsOpened;
-    };
-    DEFINE_ENTITY(Door);
+    GameState* gGameState = nullptr;
+}

-    struct Rock
-    {
-        DECLARE_ENTITY()
-        int Health;
-    };
-    DEFINE_ENTITY(Rock);
-
-} // namespace Game
-
-using namespace Juliet;
-
-extern "C" JULIET_API void GameInit(GameInitParams* params)
+GameState* GetGameState()
 {
-    // Example allocation in GameArena
-    struct GameState
-    {
-        float TotalTime;
-        int   Score;
-    };
-
-    auto* gameState      = ArenaPushStruct<GameState>(params->GameArena);
-    gameState->TotalTime = 0.0f;
-    gameState->Score     = 0;
-
-    printf("Game Arena Allocated: %p\n", static_cast<void*>(gameState));
-
-    using namespace Game;
-
-    // Entity Use case
-    InitEntityManager(params->GameArena);
-    auto& manager  = GetEntityManager();
-    Door* door     = MakeEntity<Door>(manager, 10.0f, 2.0f);
-    door->IsOpened = true;
-
-    Entity*                ent       = door->Base;
-    [[maybe_unused]] Door* stillDoor = DownCast<Door>(ent);
-    Assert(door == stillDoor);
-
-    Rock* rock   = MakeEntity<Rock>(manager, 1.f, 2.f);
-    rock->Health = 100;
-    Assert(door->Base != rock->Base);
-
-    printf("Door is %s\n", door->IsOpened ? "Opened" : "Closed");
-    printf("Rock has %d health points\n", rock->Health);
+    return gGameState;
 }

 extern "C" JULIET_API void __cdecl GameShutdown()
 {
    printf("Shutting down game...\n");

-    using namespace Game;
+    if (gGameState && gGameState->World)
+    {
+        ShutdownWorld(gGameState->World);
+    }

    ShutdownEntityManager();
 }

-extern "C" JULIET_API void __cdecl GameUpdate([[maybe_unused]] float deltaTime)
+extern "C" JULIET_API void __cdecl GameUpdate(GameData* params, [[maybe_unused]] float deltaTime)
 {
-    // printf("Updating game...\n");
+    gGameState = params->GameState;
+    if (!gGameState)
+    {
+        Arena* gameStateArena = ArenaAllocate({ .ReserveSize = Megabytes(1), .Name = "Game Total Arena" });
+        auto*  gameState      = ArenaPushStruct<GameState>(gameStateArena);
+        gGameState = params->GameState = gameState;
+        gameState->TotalArena          = gameStateArena;
+
+        gameState->TotalTime = 0.0f;
+        gameState->Score     = 0;
+
+        printf("Game Arena Allocated: %p\n", static_cast<void*>(gameState));
+
+        // Reserve cameras. Lets go with 4 for now
+        ReserveCamera(4);
+
+        // Bootstrap world
+        auto*  worldArena = ArenaAllocate({ .ReserveSize = Megabytes(1), .Name = "World Arena" });
+        World* world      = ArenaPushStruct<World>(worldArena JULIET_DEBUG_PARAM("World"));
+        gameState->World  = world;
+        InitWorld(gameState->World, worldArena);
+
+#if JULIET_DEBUG
+        UnitTest::WorldUnitTest();
+#endif
+
+        // Entity Use case
+        InitEntityManager(gameState->World);
+        auto& manager = GetEntityManager();
+
+        NonNullPtr mesh = MakeEntity<Inert>(manager, 1.f, 2.f, 0.f);
+
+        MeshAssetID    cubeAsset = GetCubePrimitiveMeshAssetID();
+        MeshInstanceID meshInst  = CreateMeshInstance(cubeAsset, 0, MatrixIdentity());
+        mesh->MeshInstance       = meshInst;
+
+        NonNullPtr mesh2 = MakeEntity<Inert>(manager, 4.f, 0.f, 2.f);
+
+        MeshInstanceID meshInst2 = CreateMeshInstance(cubeAsset, 0, MatrixIdentity());
+        mesh2->MeshInstance      = meshInst2;
+
+        // Summer at 2pm lighting
+        Vector3 sunDirection     = { -0.2f, -0.9f, -0.3f };
+        Vector3 sunColor         = { 1.0f, 0.95f, 0.85f };
+        float   ambientIntensity = 0.4f;
+        SetGlobalLight(sunDirection, sunColor, ambientIntensity);
+    }
+
+#if JULIET_DEBUG
+    DrawTopBar();
+#endif
+
+    GameMode previousFrameMode = gGameState->Mode;
+    if (IsKeyPressed(ScanCode::F1))
+    {
+        if (previousFrameMode == GameMode::Play)
+        {
+            gGameState->Mode = GameMode::Debug;
+        }
+        else if (previousFrameMode == GameMode::Debug)
+        {
+            gGameState->Mode = GameMode::Play;
+        }
+    }
+
+    if (gGameState->Mode == GameMode::Editor)
+    {
+        if (IsKeyPressed(ScanCode::F5))
+        {
+            gGameState->Mode = GameMode::Play;
+        }
+
+#if JULIET_EDITOR
+        RenderWorldEditorUI(*gGameState->World);
+#endif
+    }
+
+    if (gGameState->Mode == GameMode::Play)
+    {
+        if (IsKeyPressed(ScanCode::Escape))
+        {
+            gGameState->Mode = GameMode::Editor;
+        }
+
+        // update game
+    }
+
+    auto& manager = GetEntityManager();
+    UpdateEntityManager(manager);
+
+    if (gGameState->Mode == GameMode::Debug)
+    {
+        if (previousFrameMode == GameMode::Play)
+        {
+            ActivateDebugController();
+        }
+
+        if (IsKeyPressed(ScanCode::Escape))
+        {
+            gGameState->Mode = GameMode::Editor;
+        }
+
+        UpdateDebugController(deltaTime);
+
+#if JULIET_DEBUG
+        ImGui::Begin("Debug");
+        RenderImGuiDebugController(deltaTime);
+        ImGui::End();
+#endif
+    }
+    if (gGameState->Mode != GameMode::Debug && previousFrameMode == GameMode::Debug)
+    {
+        DeactivateDebugController();
+    }
 }
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <Core/Memory/MemoryArena.h>
+#include <Data/World.h>
+
+struct EntityManager;
+
+enum class GameMode
+{
+    Editor,
+    Play,
+    Debug
+};
+
+struct GameState
+{
+    Arena* TotalArena = nullptr;
+
+    World* World = nullptr;
+
+    GameMode Mode = GameMode::Editor;
+
+    float TotalTime = 0.0f;
+    int   Score     = 0;
+};
+
+[[nodiscard]] extern GameState* GetGameState();
@@ -1,48 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JulietApp", "JulietApp\JulietApp.vcxproj", "{1720427b-c8ba-3195-f931-e97f6d6125c1}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Juliet", "Juliet\Juliet.vcxproj", "{a93aa30f-8f29-02fe-57e2-cd3626948b68}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Game", "Game\Game.vcxproj", "{b568a67e-05a1-9907-ff4b-a129119528bd}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ImGui", "External\imgui\ImGui.vcxproj", "{652d3fea-b417-1d5e-9f79-3f32e9604ddc}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Profile|x64 = Profile|x64
-		Release|x64 = Release|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Debug|x64.ActiveCfg = Debug|x64
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Debug|x64.Build.0 = Debug|x64
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Profile|x64.ActiveCfg = Profile|x64
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Profile|x64.Build.0 = Profile|x64
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Release|x64.ActiveCfg = Release|x64
-		{1720427b-c8ba-3195-f931-e97f6d6125c1}.Release|x64.Build.0 = Release|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Debug|x64.ActiveCfg = Debug|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Debug|x64.Build.0 = Debug|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Profile|x64.ActiveCfg = Profile|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Profile|x64.Build.0 = Profile|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Release|x64.ActiveCfg = Release|x64
-		{a93aa30f-8f29-02fe-57e2-cd3626948b68}.Release|x64.Build.0 = Release|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Debug|x64.ActiveCfg = Debug|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Debug|x64.Build.0 = Debug|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Profile|x64.ActiveCfg = Profile|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Profile|x64.Build.0 = Profile|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Release|x64.ActiveCfg = Release|x64
-		{b568a67e-05a1-9907-ff4b-a129119528bd}.Release|x64.Build.0 = Release|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Debug|x64.ActiveCfg = Debug|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Debug|x64.Build.0 = Debug|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Profile|x64.ActiveCfg = Profile|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Profile|x64.Build.0 = Profile|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Release|x64.ActiveCfg = Release|x64
-		{652d3fea-b417-1d5e-9f79-3f32e9604ddc}.Release|x64.Build.0 = Release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
@@ -1,24 +0,0 @@
-// Juliet - Lib
-//------------------------------------------------------------------------------
-{
-    .ProjectName        = 'Juliet'
-    .ProjectPath        = 'Juliet'
-
-    // Library Configurations
-    //--------------------------------------------------------------------------
-    ForEach( .BuildConfigName in .BuildConfigs )
-    {
-        #if __WINDOWS__
-            .ProjectConfig              = [ Using( .'Project_x64_$BuildConfigName$' ) ]
-            ^ProjectConfigs             + .ProjectConfig
-        #endif
-    }
-
-    VCXProject( '$ProjectName$' )
-    {
-        .ProjectOutput              = '$ProjectPath$/$ProjectName$.vcxproj'
-        .ProjectBasePath            = '$ProjectPath$/'
-        .ProjectInputPaths          = .ProjectBasePath
-        .ProjectConfigs             = .ProjectConfigs
-    }
-}
@@ -1,267 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Profile|x64">
-      <Configuration>Profile</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{a93aa30f-8f29-02fe-57e2-cd3626948b68}</ProjectGuid>
-    <Keyword>MakeFileProj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Debug $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Debug $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Debug $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Debug\Juliet.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;DEBUG;JULIET_DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Debug\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Debug\Juliet\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Debug\</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Profile $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Profile $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Profile $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Profile\Juliet.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;RELEASE;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Profile\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Profile\Juliet\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Profile\</OutDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat Release $(SolutionName)</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Release $(SolutionName)</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cd $(SolutionDir) &amp; misc\build.bat -clean Release $(SolutionName)</NMakeCleanCommandLine>
-    <NMakeOutput>$(SolutionDir)bin\x64-Release\Juliet.exe</NMakeOutput>
-    <NMakeIncludeSearchPath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(NMakeIncludeSearchPath)</NMakeIncludeSearchPath>
-    <IncludePath>$(SolutionDir)Juliet\include;$(SolutionDir)Juliet\src;$(SolutionDir)Game;$(SolutionDir)External\imgui;$(SolutionDir)External\imgui\backends;$(IncludePath)</IncludePath>
-    <NMakePreprocessorDefinitions>JULIET_WIN32;UNICODE;_UNICODE;WIN32_LEAN_AND_MEAN;_CRT_SECURE_NO_WARNINGS;RELEASE;JULIET_EXPORT;$(NMakePreprocessorDefinitions)</NMakePreprocessorDefinitions>
-    <AdditionalOptions>/std:c++20</AdditionalOptions>
-    <LanguageStandard>stdcpp20</LanguageStandard>
-    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\x64-Release\</LocalDebuggerWorkingDirectory>
-    <IntDir>$(SolutionDir)Intermediate\x64-Release\Juliet\</IntDir>
-    <OutDir>$(SolutionDir)bin\x64-Release\</OutDir>
-  </PropertyGroup>
-  <ItemGroup>
-    <ClCompile Include="src\Core\Application\ApplicationManager.cpp" />
-    <ClCompile Include="src\Core\Common\CoreUtils.cpp" />
-    <ClCompile Include="src\Core\Common\String.cpp" />
-    <ClCompile Include="src\Core\Container\Vector.cpp" />
-    <ClCompile Include="src\Core\HAL\Display\Display.cpp" />
-    <ClCompile Include="src\Core\HAL\Display\Win32\Win32DisplayDevice.cpp" />
-    <ClCompile Include="src\Core\HAL\Display\Win32\Win32DisplayEvent.cpp" />
-    <ClCompile Include="src\Core\HAL\Display\Win32\Win32Window.cpp" />
-    <ClCompile Include="src\Core\HAL\DynLib\Win32\DynamicLibrary.cpp" />
-    <ClCompile Include="src\Core\HAL\Event\Keyboard.cpp" />
-    <ClCompile Include="src\Core\HAL\Event\KeyboardMapping.cpp" />
-    <ClCompile Include="src\Core\HAL\Event\Mouse.cpp" />
-    <ClCompile Include="src\Core\HAL\Event\SystemEvent.cpp" />
-    <ClCompile Include="src\Core\HAL\Event\WindowEvent.cpp" />
-    <ClCompile Include="src\Core\HAL\Filesystem\Filesystem.cpp" />
-    <ClCompile Include="src\Core\HAL\Filesystem\Win32\Win32Filesystem.cpp" />
-    <ClCompile Include="src\Core\HAL\IO\IOStream.cpp" />
-    <ClCompile Include="src\Core\HAL\IO\Win32\Win32IOStream.cpp" />
-    <ClCompile Include="src\Core\HAL\OS\OS.cpp" />
-    <ClCompile Include="src\Core\HAL\OS\Win32\Win32OS.cpp" />
-    <ClCompile Include="src\Core\HotReload\HotReload.cpp" />
-    <ClCompile Include="src\Core\HotReload\Win32\Win32HotReload.cpp" />
-    <ClCompile Include="src\Core\ImGui\ImGuiService.cpp" />
-    <ClCompile Include="src\Core\ImGui\ImGuiTests.cpp" />
-    <ClCompile Include="src\Core\Juliet.cpp" />
-    <ClCompile Include="src\Core\Logging\LogManager.cpp" />
-    <ClCompile Include="src\Core\Math\MathRound.cpp" />
-    <ClCompile Include="src\Core\Memory\Allocator.cpp" />
-    <ClCompile Include="src\Core\Memory\MemoryArena.cpp" />
-    <ClCompile Include="src\Core\Memory\MemoryArenaDebug.cpp" />
-    <ClCompile Include="src\Core\Memory\MemoryArenaTests.cpp" />
-    <ClCompile Include="src\Core\Memory\ScratchArena.cpp" />
-    <ClCompile Include="src\Core\Networking\NetworkPacket.cpp" />
-    <ClCompile Include="src\Core\Networking\Socket.cpp" />
-    <ClCompile Include="src\Core\Networking\TcpListener.cpp" />
-    <ClCompile Include="src\Core\Networking\TcpSocket.cpp" />
-    <ClCompile Include="src\Core\Networking\Win32\Win32SocketPlatformImpl.cpp" />
-    <ClCompile Include="src\Engine\Debug\MemoryDebugger.cpp" />
-    <ClCompile Include="src\Engine\Engine.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_property_format_table.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Buffer.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12CommandList.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Common.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12DescriptorHeap.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12GraphicsDevice.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12GraphicsPipeline.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12InternalTests.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12RenderPass.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Shader.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12SwapChain.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Synchronization.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Texture.cpp" />
-    <ClCompile Include="src\Graphics\D3D12\D3D12Utils.cpp" />
-    <ClCompile Include="src\Graphics\DebugDisplayRenderer.cpp" />
-    <ClCompile Include="src\Graphics\Graphics.cpp" />
-    <ClCompile Include="src\Graphics\ImGuiRenderer.cpp" />
-    <ClCompile Include="src\Graphics\Mesh.cpp" />
-    <ClCompile Include="src\Graphics\MeshRenderer.cpp" />
-    <ClCompile Include="src\Graphics\SkyboxRenderer.cpp" />
-    <ClCompile Include="src\UnitTest\Container\VectorUnitTest.cpp" />
-    <ClCompile Include="src\UnitTest\RunUnitTests.cpp" />
-    <ClInclude Include="include\Core\Application\ApplicationManager.h" />
-    <ClInclude Include="include\Core\Application\IApplication.h" />
-    <ClInclude Include="include\Core\Common\CoreTypes.h" />
-    <ClInclude Include="include\Core\Common\CoreUtils.h" />
-    <ClInclude Include="include\Core\Common\CRC32.h" />
-    <ClInclude Include="include\Core\Common\EnumUtils.h" />
-    <ClInclude Include="include\Core\Common\NonCopyable.h" />
-    <ClInclude Include="include\Core\Common\NonMovable.h" />
-    <ClInclude Include="include\Core\Common\NonNullPtr.h" />
-    <ClInclude Include="include\Core\Common\Singleton.h" />
-    <ClInclude Include="include\Core\Common\String.h" />
-    <ClInclude Include="include\Core\Container\Vector.h" />
-    <ClInclude Include="include\Core\HAL\Display\Display.h" />
-    <ClInclude Include="include\Core\HAL\DynLib\DynamicLibrary.h" />
-    <ClInclude Include="include\Core\HAL\Event\SystemEvent.h" />
-    <ClInclude Include="include\Core\HAL\Filesystem\Filesystem.h" />
-    <ClInclude Include="include\Core\HAL\IO\IOStream.h" />
-    <ClInclude Include="include\Core\HAL\Keyboard\Keyboard.h" />
-    <ClInclude Include="include\Core\HAL\Keyboard\KeyCode.h" />
-    <ClInclude Include="include\Core\HAL\Keyboard\ScanCode.h" />
-    <ClInclude Include="include\Core\HAL\Mouse\Mouse.h" />
-    <ClInclude Include="include\Core\HAL\OS\OS.h" />
-    <ClInclude Include="include\Core\HotReload\HotReload.h" />
-    <ClInclude Include="include\Core\ImGui\ImGuiService.h" />
-    <ClInclude Include="include\Core\ImGui\ImGuiTests.h" />
-    <ClInclude Include="include\Core\JulietInit.h" />
-    <ClInclude Include="include\Core\Logging\LogManager.h" />
-    <ClInclude Include="include\Core\Logging\LogTypes.h" />
-    <ClInclude Include="include\Core\Main.h" />
-    <ClInclude Include="include\Core\Math\MathUtils.h" />
-    <ClInclude Include="include\Core\Math\Matrix.h" />
-    <ClInclude Include="include\Core\Math\Shape.h" />
-    <ClInclude Include="include\Core\Math\Vector.h" />
-    <ClInclude Include="include\Core\Memory\Allocator.h" />
-    <ClInclude Include="include\Core\Memory\MemoryArena.h" />
-    <ClInclude Include="include\Core\Memory\MemoryArenaDebug.h" />
-    <ClInclude Include="include\Core\Memory\ScratchArena.h" />
-    <ClInclude Include="include\Core\Memory\Utils.h" />
-    <ClInclude Include="include\Core\Networking\IPAddress.h" />
-    <ClInclude Include="include\Core\Networking\NetworkPacket.h" />
-    <ClInclude Include="include\Core\Networking\Socket.h" />
-    <ClInclude Include="include\Core\Networking\SocketHandle.h" />
-    <ClInclude Include="include\Core\Networking\TcpListener.h" />
-    <ClInclude Include="include\Core\Networking\TcpSocket.h" />
-    <ClInclude Include="include\Core\Thread\Mutex.h" />
-    <ClInclude Include="include\Core\Thread\Thread.h" />
-    <ClInclude Include="include\Engine\Class.h" />
-    <ClInclude Include="include\Engine\Debug\MemoryDebugger.h" />
-    <ClInclude Include="include\Engine\Engine.h" />
-    <ClInclude Include="include\Graphics\Camera.h" />
-    <ClInclude Include="include\Graphics\Colors.h" />
-    <ClInclude Include="include\Graphics\DebugDisplay.h" />
-    <ClInclude Include="include\Graphics\Graphics.h" />
-    <ClInclude Include="include\Graphics\GraphicsBuffer.h" />
-    <ClInclude Include="include\Graphics\GraphicsConfig.h" />
-    <ClInclude Include="include\Graphics\GraphicsPipeline.h" />
-    <ClInclude Include="include\Graphics\ImGuiRenderer.h" />
-    <ClInclude Include="include\Graphics\Lighting.h" />
-    <ClInclude Include="include\Graphics\Mesh.h" />
-    <ClInclude Include="include\Graphics\MeshRenderer.h" />
-    <ClInclude Include="include\Graphics\PushConstants.h" />
-    <ClInclude Include="include\Graphics\RenderPass.h" />
-    <ClInclude Include="include\Graphics\Shader.h" />
-    <ClInclude Include="include\Graphics\SkyboxRenderer.h" />
-    <ClInclude Include="include\Graphics\Texture.h" />
-    <ClInclude Include="include\Graphics\VertexData.h" />
-    <ClInclude Include="include\Juliet.h" />
-    <ClInclude Include="src\Core\HAL\Display\DisplayDevice.h" />
-    <ClInclude Include="src\Core\HAL\Display\Display_Private.h" />
-    <ClInclude Include="src\Core\HAL\Display\Win32\Win32DisplayEvent.h" />
-    <ClInclude Include="src\Core\HAL\Display\Win32\Win32Window.h" />
-    <ClInclude Include="src\Core\HAL\Display\Window.h" />
-    <ClInclude Include="src\Core\HAL\Event\KeyboardMapping.h" />
-    <ClInclude Include="src\Core\HAL\Event\Keyboard_Private.h" />
-    <ClInclude Include="src\Core\HAL\Event\Mouse_Private.h" />
-    <ClInclude Include="src\Core\HAL\Event\Win32ScanCode.h" />
-    <ClInclude Include="src\Core\HAL\Event\WindowEvent.h" />
-    <ClInclude Include="src\Core\HAL\Filesystem\Filesystem_Platform.h" />
-    <ClInclude Include="src\Core\HAL\Filesystem\Filesystem_Private.h" />
-    <ClInclude Include="src\Core\HAL\IO\IOStream_Private.h" />
-    <ClInclude Include="src\Core\HAL\OS\OS_Private.h" />
-    <ClInclude Include="src\Core\HAL\Win32.h" />
-    <ClInclude Include="src\Core\Math\Math_Private.h" />
-    <ClInclude Include="src\Core\Networking\SocketPlatformImpl.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3d12.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3d12compatibility.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3d12sdklayers.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3d12shader.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3d12video.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dcommon.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_barriers.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_check_feature_support.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_core.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_default.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_pipeline_state_stream.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_property_format_table.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_render_pass.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_resource_helpers.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_root_signature.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\d3dx12\d3dx12_state_object.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\dxgiformat.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Buffer.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12CommandList.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Common.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12DescriptorHeap.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12GraphicsDevice.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12GraphicsPipeline.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Includes.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12InternalTests.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12RenderPass.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Shader.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12SwapChain.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Synchronization.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Texture.h" />
-    <ClInclude Include="src\Graphics\D3D12\D3D12Utils.h" />
-    <ClInclude Include="src\Graphics\GraphicsDevice.h" />
-    <ClInclude Include="src\UnitTest\VectorTestHelper.h" />
-    <ClInclude Include="src\Graphics\D3D12\AgilitySDK\D3D12TokenizedProgramFormat.hpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
@@ -228,6 +228,9 @@
    <ClCompile Include="src\Core\Networking\Win32\Win32SocketPlatformImpl.cpp">
      <Filter>src\Core\Networking\Win32</Filter>
    </ClCompile>
+    <ClCompile Include="src\Core\PCH.cpp">
+      <Filter>src\Core</Filter>
+    </ClCompile>
    <ClCompile Include="src\Engine\Debug\MemoryDebugger.cpp">
      <Filter>src\Engine\Debug</Filter>
    </ClCompile>
@@ -318,18 +321,9 @@
    <ClInclude Include="include\Core\Common\EnumUtils.h">
      <Filter>include\Core\Common</Filter>
    </ClInclude>
-    <ClInclude Include="include\Core\Common\NonCopyable.h">
-      <Filter>include\Core\Common</Filter>
-    </ClInclude>
-    <ClInclude Include="include\Core\Common\NonMovable.h">
-      <Filter>include\Core\Common</Filter>
-    </ClInclude>
    <ClInclude Include="include\Core\Common\NonNullPtr.h">
      <Filter>include\Core\Common</Filter>
    </ClInclude>
-    <ClInclude Include="include\Core\Common\Singleton.h">
-      <Filter>include\Core\Common</Filter>
-    </ClInclude>
    <ClInclude Include="include\Core\Common\String.h">
      <Filter>include\Core\Common</Filter>
    </ClInclude>
@@ -432,6 +426,9 @@
    <ClInclude Include="include\Core\Networking\TcpSocket.h">
      <Filter>include\Core\Networking</Filter>
    </ClInclude>
+    <ClInclude Include="include\Core\PCH.h">
+      <Filter>include\Core</Filter>
+    </ClInclude>
    <ClInclude Include="include\Core\Thread\Mutex.h">
      <Filter>include\Core\Thread</Filter>
    </ClInclude>
@@ -1,13 +1,9 @@
-#pragma once
+#pragma once

 #include <Core/Application/IApplication.h>
-#include <Core/Common/CoreTypes.h>
 #include <Juliet.h>

-namespace Juliet
-{
-    enum class JulietInit_Flags : uint8;
+enum class JulietInit_Flags : uint8;

-    struct Arena;
-    extern JULIET_API void StartApplication(IApplication& app, JulietInit_Flags flags);
-} // namespace Juliet
+struct Arena;
+extern JULIET_API void StartApplication(IApplication& app, JulietInit_Flags flags);
@@ -1,23 +1,22 @@
-#pragma once
+#pragma once

 #include <Core/Common/NonNullPtr.h>

-namespace Juliet
-{
-    struct RenderPass;
-    struct CommandList;
-    struct Texture;
-    struct ColorTargetInfo;
-    struct DepthStencilTargetInfo;
-    struct Arena;
+struct Camera;
+struct RenderPass;
+struct CommandList;
+struct Texture;
+struct ColorTargetInfo;
+struct DepthStencilTargetInfo;
+struct Arena;

-    class IApplication
-    {
+class IApplication
+{
  public:
    virtual ~IApplication()                    = default;
    virtual void Init(NonNullPtr<Arena> arena) = 0;
    virtual void Shutdown()                    = 0;
-        virtual void Update()                      = 0;
+    virtual void Update(float deltaTime)       = 0;
    virtual bool IsRunning()                   = 0;

    // Accessors for Engine Systems
@@ -25,10 +24,6 @@ namespace Juliet
    virtual struct GraphicsDevice* GetGraphicsDevice() = 0;

    // Render Lifecycle (Engine-Managed Render Loop)
-        virtual void                    OnPreRender(CommandList* cmd)                 = 0;
-        virtual void                    OnRender(RenderPass* pass, CommandList* cmd)  = 0;
    virtual ColorTargetInfo         GetColorTargetInfo(Texture* swapchainTexture) = 0;
    virtual DepthStencilTargetInfo* GetDepthTargetInfo()                          = 0;
-        virtual struct Camera           GetDebugCamera()                              = 0;
-    };
-} // namespace Juliet
+};
@@ -1,11 +1,11 @@
-#pragma once
+#pragma once
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/String.h>

 // From https://web.mit.edu/freebsd/head/sys/libkern/crc32.c

-namespace Juliet
+namespace details
 {
-    namespace details
-    {
    constexpr uint32_t crc32_tab[] = {
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
        0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
@@ -37,10 +37,11 @@ namespace Juliet
        0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
        0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
    };
-    }
+}

-    consteval uint32 crc32(const char* str, size_t length)
-    {
+constexpr uint32 crc32(const char* str, size_t length)
+{
+    Assert(str && length > 0);
    const char* p   = str;
    uint32_t    crc = ~0U;
    while (length--)
@@ -48,11 +49,14 @@ namespace Juliet
        crc = details::crc32_tab[(crc ^ static_cast<uint8>(*p++)) & 0xFF] ^ (crc >> 8);
    }
    return crc ^ ~0U;
-    }
+}

-    consteval uint32 operator""_crc32(const char* str, size_t length)
-    {
+constexpr uint32 crc32(String str)
+{
+    return crc32(str.Str, str.Size);
+}
+
+consteval uint32 operator""_crc32(const char* str, size_t length)
+{
    return crc32(str, length);
-    }
-
-} // namespace Juliet
+}
@@ -1,9 +1,5 @@
 #pragma once

-#include <cstddef>
-#include <cstdint>
-#include <limits>
-
 using uint8  = uint8_t;
 using uint16 = uint16_t;
 using uint32 = uint32_t;
@@ -45,5 +41,25 @@ constexpr int16 int16Max = MaxValueOf<int16>();
 constexpr int32 int32Max = MaxValueOf<int32>();
 constexpr int64 int64Max = MaxValueOf<int64>();

+constexpr index_t indexMax = MaxValueOf<index_t>();
+
+template <typename Type>
+consteval Type MinValueOf()
+{
+    return std::numeric_limits<Type>::lowest();
+}
+
+constexpr uint8  uint8Min  = MinValueOf<uint8>();
+constexpr uint16 uint16Min = MinValueOf<uint16>();
+constexpr uint32 uint32Min = MinValueOf<uint32>();
+constexpr uint64 uint64Min = MinValueOf<uint64>();
+
+constexpr int8  int8Min  = MinValueOf<int8>();
+constexpr int16 int16Min = MinValueOf<int16>();
+constexpr int32 int32Min = MinValueOf<int32>();
+constexpr int64 int64Min = MinValueOf<int64>();
+
+constexpr index_t indexMin = MinValueOf<index_t>();
+
 #define Kilobytes(value) value * 1024
 #define Megabytes(value) Kilobytes(value) * 1024
@@ -1,24 +1,15 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Juliet.h>

-#include <algorithm>
-#include <bit>
-#include <cassert>
-#include <concepts>
-#include <source_location>
-
-namespace Juliet
-{
-
 #define global static
+#define internal static

-    // 1. Stringify helpers
+// 1. Stringify helpers
 #define JULIET_STR(x) #x
 #define JULIET_TOSTRING(x) JULIET_STR(x)

-    // 2. Define the pragma operator based on compiler
+// 2. Define the pragma operator based on compiler
 #if defined(__clang__) || defined(__GNUC__)
 #define JULIET_PRAGMA(x) _Pragma(#x)
 #define JULIET_SUPPRESS_MSVC(id)
@@ -33,7 +24,7 @@ namespace Juliet
 #define JULIET_SUPPRESS_CLANG(str)
 #endif

-    // 3. The Agnostic "Push/Pop"
+// 3. The Agnostic "Push/Pop"
 #if defined(__clang__)
 #define JULIET_WARNING_PUSH JULIET_PRAGMA(clang diagnostic push)
 #define JULIET_WARNING_POP JULIET_PRAGMA(clang diagnostic pop)
@@ -46,10 +37,10 @@ namespace Juliet
 #endif

 #if defined(_MSC_VER)
-    // MSVC specific intrinsic
+// MSVC specific intrinsic
 #define JULIET_PLATFORM_BREAK() (__nop(), __debugbreak())
 #elif defined(__clang__) || defined(__GNUC__)
-    // Clang/GCC specific intrinsic
+// Clang/GCC specific intrinsic
 #define JULIET_PLATFORM_BREAK() __builtin_trap()
 #else
 #include <signal.h>
@@ -65,7 +56,7 @@ namespace Juliet
    {                                                                                                                  \
        if (!(expression)) [[unlikely]]                                                                                \
        {                                                                                                              \
-            Juliet::JulietAssert(#expression, message);                                                                \
+            JulietAssert(#expression, message);                                                                        \
        }                                                                                                              \
    }                                                                                                                  \
    JULIET_WARNING_POP                                                                                                 \
@@ -77,7 +68,7 @@ namespace Juliet
        long hr_val = (hr_expression);                                                                                 \
        if (hr_val < 0)                                                                                                \
        {                                                                                                              \
-            Juliet::JulietAssert(#hr_expression, message, std::source_location::current(), hr_val);                    \
+            JulietAssert(#hr_expression, message, std::source_location::current(), hr_val);                            \
        }                                                                                                              \
    }                                                                                                                  \
    while (0)
@@ -89,7 +80,7 @@ namespace Juliet
 #define Unimplemented()                                                                                                \
    do                                                                                                                 \
    {                                                                                                                  \
-        Juliet::JulietAssert("UNIMPLEMENTED", "This code path is not yet functional.");                                \
+        JulietAssert("UNIMPLEMENTED", "This code path is not yet functional.");                                        \
    }                                                                                                                  \
    while (0)

@@ -99,26 +90,26 @@ namespace Juliet
 #define Unimplemented() ((void)0)
 #endif

-    JULIET_API extern void JulietAssert(const char* expression, const char* message,
+JULIET_API extern void JulietAssert(const char* expression, const char* message,
                                    std::source_location location = std::source_location::current(), long handleResult = 0);

 #define ZeroStruct(structInstance) ZeroSize(sizeof(structInstance), &(structInstance))
 #define ZeroArray(array) ZeroSize(sizeof((array)), (array))
 #define ZeroDynArray(Count, Pointer) ZeroSize((Count) * sizeof((Pointer)[0]), Pointer)
-    inline void ZeroSize(size_t size, void* ptr)
-    {
+inline void ZeroSize(size_t size, void* ptr)
+{
    auto Byte = (uint8*)ptr;
    while (size--)
    {
        *Byte++ = 0;
    }
-    }
+}

 #define Restrict __restrict

-    template <class Function>
-    class DeferredFunction
-    {
+template <class Function>
+class DeferredFunction
+{
  public:
    explicit DeferredFunction(const Function& otherFct) noexcept
      : Callback(otherFct)
@@ -138,46 +129,46 @@ namespace Juliet

  private:
    Function Callback;
-    };
+};

-    template <class Function>
-    auto Defer(Function&& fct) noexcept
-    {
+template <class Function>
+auto Defer(Function&& fct) noexcept
+{
    return DeferredFunction<std::decay_t<Function>>{ std::forward<Function>(fct) };
-    }
+}

-    inline bool IsValid(ByteBuffer buffer)
-    {
+inline bool IsValid(ByteBuffer buffer)
+{
    return buffer.Size > 0 && buffer.Data;
-    }
+}

-    extern JULIET_API void Free(ByteBuffer& buffer);
+extern JULIET_API void Free(ByteBuffer& buffer);

-    template <std::integral T>
-    [[nodiscard]] constexpr T AlignPow2(T x, T alignment)
-    {
+template <std::integral T>
+[[nodiscard]] constexpr T AlignPow2(T x, T alignment)
+{
    // Safety Check:
    Assert(std::has_single_bit(static_cast<size_t>(alignment)));

    return (x + alignment - 1) & ~(alignment - 1);
-    }
+}

-    template <typename T>
-    inline void Swap(T* Restrict a, T* Restrict b)
-    {
+template <typename T>
+inline void Swap(T* Restrict a, T* Restrict b)
+{
    T temp = std::move(*a);
    *a     = std::move(*b);
    *b     = std::move(temp);
-    }
+}

-    // Move to another file dedicated to those
+// Move to another file dedicated to those
 #if defined(__clang__)
 #define COMPILER_CLANG 1
 #elif defined(_MSC_VER)
 #define COMPILER_MSVC 1
 #endif

-    // Undef anything not defined
+// Undef anything not defined
 #if !defined(COMPILER_CLANG)
 #define COMPILER_CLANG 0
 #endif
@@ -195,9 +186,9 @@ namespace Juliet
 #error AlignOf not defined for this compiler.
 #endif

-    template <typename T>
-    [[nodiscard]] constexpr const char* GetTypeName()
-    {
+template <typename T>
+[[nodiscard]] constexpr const char* GetTypeName()
+{
 #if COMPILER_CLANG
    return __PRETTY_FUNCTION__;
 #elif COMPILER_MSVC
@@ -207,5 +198,30 @@ namespace Juliet
 #else
    return "UnknownType";
 #endif
-    }
-} // namespace Juliet
+}
+
+inline uint16 safe_cast_uint16(uint32 value)
+{
+    Assert(value <= uint16Max);
+    uint16 result = (uint16)value;
+    return result;
+}
+
+const uint32 bitmask1  = 0b0000'0001;
+const uint32 bitmask2  = 0b0000'0011;
+const uint32 bitmask3  = 0b0000'0111;
+const uint32 bitmask4  = 0b0000'1111;
+const uint32 bitmask5  = 0b0001'1111;
+const uint32 bitmask6  = 0b0011'1111;
+const uint32 bitmask7  = 0b0111'1111;
+const uint32 bitmask8  = 0b1111'1111;
+const uint32 bitmask9  = 0x0000'01ff;
+const uint32 bitmask10 = 0x0000'03ff;
+const uint32 bitmask11 = 0x0000'07ff;
+const uint32 bitmask12 = 0x0000'0fff;
+const uint32 bitmask13 = 0x0000'1fff;
+const uint32 bitmask14 = 0x0000'3fff;
+const uint32 bitmask15 = 0x0000'7fff;
+const uint32 bitmask16 = 0x0000'ffff;
+// ...
+const uint32 bitmask32 = 0xffff'ffff;
@@ -1,91 +1,86 @@
-#pragma once
+#pragma once

-#include <type_traits>
+template <typename T>
+concept IsEnum = std::is_enum_v<T>;

-namespace Juliet
+template <IsEnum E>
+constexpr E operator~(E lhs) noexcept
 {
-    template <typename T>
-    concept IsEnum = std::is_enum_v<T>;
-
-    template <IsEnum E>
-    constexpr E operator~(E lhs) noexcept
-    {
    return static_cast<E>(~static_cast<std::underlying_type_t<E>>(lhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E operator|(E lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E operator|(E lhs, E rhs) noexcept
+{
    return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) | static_cast<std::underlying_type_t<E>>(rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E& operator|=(E& lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E& operator|=(E& lhs, E rhs) noexcept
+{
    return lhs = (lhs | rhs);
-    }
+}

-    template <IsEnum E>
-    constexpr E operator&(E lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E operator&(E lhs, E rhs) noexcept
+{
    return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) & static_cast<std::underlying_type_t<E>>(rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E& operator&=(E& lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E& operator&=(E& lhs, E rhs) noexcept
+{
    return lhs = (lhs & rhs);
-    }
+}

-    template <IsEnum E>
-    constexpr E operator^(E lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E operator^(E lhs, E rhs) noexcept
+{
    return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) ^ static_cast<std::underlying_type_t<E>>(rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E& operator^=(E& lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E& operator^=(E& lhs, E rhs) noexcept
+{
    return lhs = (lhs ^ rhs);
-    }
+}

-    template <IsEnum E>
-    constexpr std::underlying_type_t<E> operator-(E lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr std::underlying_type_t<E> operator-(E lhs, E rhs) noexcept
+{
    using T = std::underlying_type_t<E>;
    return static_cast<T>(static_cast<T>(lhs) - static_cast<T>(rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr std::underlying_type_t<E> operator+(E lhs, E rhs) noexcept
-    {
+template <IsEnum E>
+constexpr std::underlying_type_t<E> operator+(E lhs, E rhs) noexcept
+{
    using T = std::underlying_type_t<E>;
    return static_cast<T>(static_cast<T>(lhs) + static_cast<T>(rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E operator-(E lhs, std::underlying_type_t<E> rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E operator-(E lhs, std::underlying_type_t<E> rhs) noexcept
+{
    using T = std::underlying_type_t<E>;
    return static_cast<E>(static_cast<T>(static_cast<T>(lhs) - rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr E operator+(E lhs, std::underlying_type_t<E> rhs) noexcept
-    {
+template <IsEnum E>
+constexpr E operator+(E lhs, std::underlying_type_t<E> rhs) noexcept
+{
    using T = std::underlying_type_t<E>;
    return static_cast<E>(static_cast<T>(static_cast<T>(lhs) + rhs));
-    }
+}

-    template <IsEnum E>
-    constexpr std::underlying_type_t<E> ToUnderlying(E enm) noexcept
-    {
+template <IsEnum E>
+constexpr std::underlying_type_t<E> ToUnderlying(E enm) noexcept
+{
    return static_cast<std::underlying_type_t<E>>(enm);
-    }
+}

-    template <IsEnum E>
-    constexpr E ToEnum(std::underlying_type_t<E> value) noexcept
-    {
+template <IsEnum E>
+constexpr E ToEnum(std::underlying_type_t<E> value) noexcept
+{
    return static_cast<E>(value);
-    }
-} // namespace Juliet
+}
@@ -1,21 +1,18 @@
-#pragma once
+#pragma once

 #include <Core/Common/CoreUtils.h>
-#include <type_traits>

-namespace Juliet
+template <typename Type, typename OtherType>
+concept NonNullPtr_Convertible = std::is_convertible_v<OtherType*, Type*>;
+
+template <typename Type, typename OtherType>
+concept NonNullPtr_SameType = std::is_same_v<OtherType*, Type*>;
+
+template <typename Type>
+class NonNullPtr
 {
-    template <typename Type, typename OtherType>
-    concept NonNullPtr_Convertible = std::is_convertible_v<OtherType*, Type*>;
-
-    template <typename Type, typename OtherType>
-    concept NonNullPtr_SameType = std::is_same_v<OtherType*, Type*>;
-
-    template <typename Type>
-    class NonNullPtr
-    {
  public:
-        inline NonNullPtr(Type* ptr)
+    constexpr NonNullPtr(Type* ptr)
      : InternalPtr(ptr)
    {
        Assert(ptr, "Tried to initialize a NonNullPtr with a null pointer");
@@ -23,14 +20,14 @@ namespace Juliet

    template <typename OtherType>
        requires NonNullPtr_Convertible<OtherType*, Type*>
-        NonNullPtr(const NonNullPtr<OtherType>& otherPtr)
+    constexpr NonNullPtr(const NonNullPtr<OtherType>& otherPtr)
      : InternalPtr(otherPtr.Get())
    {
        Assert(InternalPtr, "Fatal Error: Assigned a non null ptr using another NonNullPtr but its was null.");
    }

    // Assignment
-        NonNullPtr& operator=(Type* ptr)
+    [[nodiscard]] constexpr NonNullPtr& operator=(Type* ptr)
    {
        Assert(ptr, "Tried to assign a null pointer to a NonNullPtr!");
        InternalPtr = ptr;
@@ -39,73 +36,75 @@ namespace Juliet

    template <typename OtherType>
        requires NonNullPtr_Convertible<OtherType*, Type*>
-        NonNullPtr& operator=(const NonNullPtr<OtherType>& otherPtr)
+    [[nodiscard]] constexpr NonNullPtr& operator=(const NonNullPtr<OtherType>& otherPtr)
    {
        InternalPtr = otherPtr.Get();
        return *this;
    }

    // Accessors
-        operator Type*() const
+    [[nodiscard]] constexpr operator Type*() const
    {
        Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
        return InternalPtr;
    }

-        Type* Get() const
+    [[nodiscard]] constexpr Type* Get() const
    {
        Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
        return InternalPtr;
    }

-        Type& operator*() const
+    [[nodiscard]] constexpr Type& operator*() const
    {
        Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
        return *InternalPtr;
    }

-        inline Type* operator->() const
+    [[nodiscard]] constexpr Type* operator->() const
    {
        Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
        return InternalPtr;
    }

    // Comparisons
-        bool operator==(const NonNullPtr& otherPtr) const { return InternalPtr == otherPtr.InternalPtr; }
+    [[nodiscard]] constexpr bool operator==(const NonNullPtr& otherPtr) const
+    {
+        return InternalPtr == otherPtr.InternalPtr;
+    }

    template <typename OtherType>
        requires NonNullPtr_SameType<Type, OtherType>
-        bool operator==(OtherType* otherRawPtr) const
+    [[nodiscard]] constexpr bool operator==(OtherType* otherRawPtr) const
    {
        return InternalPtr == otherRawPtr;
    }

    template <typename OtherType>
        requires NonNullPtr_SameType<Type, OtherType>
-        friend bool operator==(OtherType* otherRawPtr, const NonNullPtr& nonNullPtr)
+    [[nodiscard]] constexpr friend bool operator==(OtherType* otherRawPtr, const NonNullPtr& nonNullPtr)
    {
        return otherRawPtr == nonNullPtr.InternalPtr;
    }

    // Forbid assigning a nullptr at compile time
-        NonNullPtr(std::nullptr_t)
+    constexpr NonNullPtr(std::nullptr_t)
      : InternalPtr(nullptr)
    {
        static_assert(sizeof(Type) == 0, "Trying to initialize a NonNullPtr with a nullptr value");
    }

-        NonNullPtr& operator=(std::nullptr_t)
+    [[nodiscard]] constexpr NonNullPtr& operator=(std::nullptr_t)
    {
        static_assert(sizeof(Type) == 0, "Trying to assign a NonNullPtr with a nullptr value");
        return *this;
    }

-        explicit operator bool() const { return true; }
+    [[nodiscard]] constexpr explicit operator bool() const { return InternalPtr != nullptr; }

  private:
    Type* InternalPtr;
-    };
+};

-    template <typename T>
-    NonNullPtr(T*) -> NonNullPtr<T>;
-} // namespace Juliet
+template <typename T>
+NonNullPtr(T*) -> NonNullPtr<T>;
@@ -1,24 +1,31 @@
-#pragma once
+#pragma once

-#include <string.h>
 #include <Core/Common/NonNullPtr.h>
 #include <Core/Math/MathUtils.h>
 #include <Core/Memory/Utils.h>

-namespace Juliet
-{
-    struct Arena;
+#ifdef global
+#undef global
+#define RESTORE_GLOBAL
+#endif
+
+#ifdef RESTORE_GLOBAL
+#define global static
+#undef RESTORE_GLOBAL
+#endif
+
+struct Arena;

 #define ConstString(str) { const_cast<char*>((str)), sizeof(str) - 1 }
-#define CStr(str) ((str).Data)
+#define CStr(str) ((str).Str)
 #define InplaceString(name, size)                                                                                      \
    char name##_[size];                                                                                                \
    MemSet(name##_, 0, sizeof(uint32));                                                                                \
    String name = { name##_, 0 }

-    // Everything is Little Endian
-    enum class StringEncoding : uint8
-    {
+// Everything is Little Endian
+enum class StringEncoding : uint8
+{
    Unknown = 0,
    ASCII,
    LATIN1,
@@ -27,44 +34,43 @@ namespace Juliet
    UTF32,
    UCS2,
    UCS4,
-    };
+};

-    // Represents a UTF-8 String.
-    // Not null terminated.
-    struct String
-    {
-        char*  Data;
+// Represents a UTF-8 String.
+// Not null terminated.
+struct String8
+{
+    char*  Str;
    size_t Size;
-    };
+};
+using String = String8;

-    struct StringBuffer : String
-    {
+struct String16
+{
+    uint16* Str;
+    size_t  Size;
+};
+
+struct StringBuffer : String
+{
    size_t Capacity;
-    };
+};

-    struct StringListNode
-    {
-        StringListNode* Next;
-        String          Content;
-    };
+struct UnicodeDecode
+{
+    uint32 Increment;
+    uint32 Codepoint;
+};

-    struct StringList
-    {
-        StringListNode* First;
-        StringListNode* Last;
-        size_t          NodeCount;
-        size_t          Size;
-    };
+constexpr uint32 kInvalidUTF8 = 0xFFFD;

-    constexpr uint32 kInvalidUTF8 = 0xFFFD;
-
-    inline size_t StringLength(String str)
-    {
+inline size_t StringLength(String str)
+{
    return str.Size;
-    }
+}

-    inline size_t StringLength(const char* str)
-    {
+inline size_t StringLength(const char* str)
+{
    size_t length = 0;
    if (str)
    {
@@ -76,29 +82,29 @@ namespace Juliet
    }

    return length;
-    }
+}

-    inline bool IsValid(String str)
-    {
-        return str.Size > 0 && str.Data != nullptr && *str.Data;
-    }
+inline bool IsValid(String str)
+{
+    return str.Size > 0 && str.Str != nullptr && *str.Str;
+}

-    inline String WrapString(const char* str)
-    {
+inline String WrapString(const char* str)
+{
    String result = {};
-        result.Data   = const_cast<char*>(str);
+    result.Str    = const_cast<char*>(str);
    result.Size   = str ? strlen(str) : 0;
    return result;
-    }
+}

-    inline String FindChar(String str, char c)
-    {
+inline String FindChar(String str, char c)
+{
    String result = str;
    while (result.Size)
    {
-            if (*result.Data != c)
+        if (*result.Str != c)
        {
-                ++result.Data;
+            ++result.Str;
            --result.Size;
        }
        else
@@ -107,19 +113,19 @@ namespace Juliet
        }
    }
    return {};
-    }
+}

-    inline bool ContainsChar(String str, char c)
-    {
+inline bool ContainsChar(String str, char c)
+{
    return IsValid(FindChar(str, c));
-    }
+}

-    // Return:
-    // - < 0 if str1 < str2
-    // - = 0 : Both strings are equals
-    // - > 0 if str1 > str2
-    inline int32 StringCompare(String str1, String str2)
-    {
+// Return:
+// - < 0 if str1 < str2
+// - = 0 : Both strings are equals
+// - > 0 if str1 > str2
+inline int32 StringCompare(String str1, String str2)
+{
    size_t len1   = StringLength(str1);
    size_t len2   = StringLength(str2);
    size_t minLen = Min(len1, len2);
@@ -137,29 +143,40 @@ namespace Juliet
        return 0;
    }
    return result;
-    }
+}

-    JULIET_API uint32 StepUTF8(String& inStr);
-    JULIET_API String FindString(String strLeft, String strRight);
+JULIET_API uint32 StepUTF8(String& inStr);
+JULIET_API String FindString(String strLeft, String strRight);

-    // Case insensitive compare. Supports ASCII only
-    // TODO: Support UNICODE
-    extern JULIET_API int8 StringCompareCaseInsensitive(String str1, String str2);
+// Case insensitive compare. Supports ASCII only
+// TODO: Support UNICODE
+extern JULIET_API int8 StringCompareCaseInsensitive(String str1, String str2);

-    // Do not allocate anything, you must allocate your out buffer yourself
-    // TODO: Version taking arena that can allocate
-    // Do not take String type because we dont know the string encoding we are going from/to
-    // src and dst will be casted based on the encoding.
-    // size will correspond to the number of characters
-    // Will convert \0 character if present.
-    extern JULIET_API bool ConvertString(StringEncoding from, StringEncoding to, String src, StringBuffer& dst, bool nullTerminate);
-    extern JULIET_API bool ConvertString(String from, String to, String src, StringBuffer& dst, bool nullTerminate);
+// Do not allocate anything, you must allocate your out buffer yourself
+// TODO: Version taking arena that can allocate
+// Do not take String type because we dont know the string encoding we are going from/to
+// src and dst will be casted based on the encoding.
+// size will correspond to the number of characters
+// Will convert \0 character if present.
+extern JULIET_API bool ConvertString(StringEncoding from, StringEncoding to, String src, StringBuffer& dst, bool nullTerminate);
+extern JULIET_API bool ConvertString(String from, String to, String src, StringBuffer& dst, bool nullTerminate);

-    JULIET_API String StringCopy(NonNullPtr<Arena> arena, String str);
-} // namespace Juliet
+JULIET_API String   StringCopy(NonNullPtr<Arena> arena, String str);
+JULIET_API String16 str16_from_8(NonNullPtr<Arena> arena, String8 str);
+
+String trim_whitespace(String str);
+
+template <typename... Args>
+String Format(NonNullPtr<Arena> arena, const char* formatStr, Args&&... args)
+{
+    std::string result = std::vformat(formatStr, std::make_format_args(args...));
+    return StringCopy(arena, WrapString(result.c_str()));
+}
+
+#define juliet_snprintf snprintf

 #ifdef UNIT_TEST
-namespace Juliet::UnitTest
+namespace UnitTest
 {
    inline void TestFindChar()
    {
@@ -167,12 +184,12 @@ namespace Juliet::UnitTest
        String s2 = ConstString("abcdefabcdef");
        String s3 = ConstString("11111111111111111111");

-        Assert(FindChar(s1, 'x').Data == nullptr);
-        Assert(FindChar(s2, 'y').Data == nullptr);
-        Assert(FindChar(s2, 'a').Data - s2.Data == 0);
-        Assert(FindChar(s2, 'd').Data - s2.Data == 3);
-        Assert(FindChar(s2, 'f').Data - s2.Data == 5);
-        Assert(FindChar(s3, '1').Data - s3.Data == 0);
+        Assert(FindChar(s1, 'x').Str == nullptr);
+        Assert(FindChar(s2, 'y').Str == nullptr);
+        Assert(FindChar(s2, 'a').Str - s2.Str == 0);
+        Assert(FindChar(s2, 'd').Str - s2.Str == 3);
+        Assert(FindChar(s2, 'f').Str - s2.Str == 5);
+        Assert(FindChar(s3, '1').Str - s3.Str == 0);
    }
-} // namespace Juliet::UnitTest
+} // namespace UnitTest
 #endif
@@ -0,0 +1,126 @@
+#pragma once
+
+#include <Juliet.h>
+
+#include <Core/Common/String.h>
+#include <Core/HAL/IO/IOStream.h>
+
+// .jasset
+// AssetFile       ::= { CommentLine | EmptyLine | PropertyDeclaration } ;
+// CommentLine     ::= ( "#" | "//" ) { Character } LineEnding ;
+// EmptyLine       ::= { Whitespace } LineEnding ;
+// PropertyDeclaration ::= KeyHeader LineEnding ValueBlock ;
+// KeyHeader       ::= ";" { Whitespace } Identifier ;
+// ValueBlock      ::= { ValueLine LineEnding } ;
+// ValueLine       ::= { Whitespace } ValueString { Whitespace } ;
+// LineEnding      ::= "\r\n" | "\n" ;
+// Identifier      ::= [a-zA-Z_][a-zA-Z0-9_]* ;
+
+struct Vector4;
+struct IOStream;
+struct Arena;
+
+struct ArchivePropertyNode
+{
+    String key;
+    String value;
+    uint32 key_crc;
+    bool   consumed;
+};
+
+struct ParsedArchive
+{
+    ArchivePropertyNode* nodes          = nullptr;
+    uint32               property_count = 0;
+};
+
+struct Archive
+{
+    Arena*        arena;
+    bool          loading;
+    ParsedArchive base   = {};
+    IOStream*     stream = nullptr;
+
+    // to remove
+    void*   base_ptr = nullptr;
+    index_t offset   = 0;
+};
+
+JULIET_API void serialize(Archive& ar, void* data, size_t size);
+
+#define serialize_elem(ar, val) serialize((ar), &(val), sizeof(val))
+
+JULIET_API ParsedArchive        tokenize_archive(NonNullPtr<Arena> arena, ByteBuffer file_buffer);
+JULIET_API ArchivePropertyNode* find_property(NonNullPtr<ParsedArchive> archive, uint32 property_crc);
+JULIET_API void                 write_property_header(Archive& archive, String property_name);
+
+JULIET_API bool read_prop(Archive& ar, String value_raw, String& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, String value);
+JULIET_API bool read(const char* buffer, float& value, const char** end = nullptr);
+JULIET_API void write(NonNullPtr<IOStream> stream, float value);
+JULIET_API bool read(const char* buffer, int8& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, int8 value);
+JULIET_API bool read(const char* buffer, int16& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, int16 value);
+JULIET_API bool read(const char* buffer, int32& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, int32 value);
+JULIET_API bool read(const char* buffer, int64& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, int64 value);
+JULIET_API bool read(const char* buffer, uint8& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, uint8 value);
+JULIET_API bool read(const char* buffer, uint16& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, uint16 value);
+JULIET_API bool read(const char* buffer, uint32& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, uint32 value);
+JULIET_API bool read(const char* buffer, uint64& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, uint64 value);
+JULIET_API bool read(const char* buffer, bool& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, bool value);
+JULIET_API bool read(const char* buffer, Vector4& value);
+JULIET_API void write(NonNullPtr<IOStream> stream, Vector4 value);
+
+// For primitives not needing archive nor allocation
+template <typename Type>
+bool read_prop(Archive& /*ar*/, String value_raw, Type& value)
+{
+    char   buffer[64];
+    size_t cpy_size = Min(value_raw.Size, sizeof(buffer) - 1);
+    MemCopy(buffer, value_raw.Str, cpy_size);
+    buffer[cpy_size] = '\0';
+
+    return read(buffer, value);
+}
+
+#define SERIALIZE(ar, name, var) serialize((ar), ConstString(#name), #name##_crc32, (var))
+#define SERIALIZE_SIMPLE(ar, var) SERIALIZE(ar, var, var)
+
+template <typename Type>
+bool serialize(Archive& ar, String property_name, uint32 property_crc, Type& value)
+{
+    Assert(IsValid(property_name));
+
+    bool result = false;
+    if (ar.loading)
+    {
+        if (auto* prop = find_property(&ar.base, property_crc))
+        {
+            if (read_prop(ar, prop->value, value))
+            {
+                result = true;
+            }
+        }
+    }
+    else
+    {
+        // Save
+        write_property_header(ar, property_name);
+        write(ar.stream, value);
+        result = true;
+    }
+
+    return result;
+}
+
+#if JULIET_DEBUG
+JULIET_API void audit_unconsumed_properties(NonNullPtr<ParsedArchive> archive, String context_name);
+#endif
@@ -1,13 +1,11 @@
-#pragma once
+#pragma once

 #include <Core/Common/NonNullPtr.h>
 #include <Core/Memory/MemoryArena.h>

-namespace Juliet
+template <typename Type, size_t ReserveSize = 16>
+struct VectorArena
 {
-    template <typename Type, size_t ReserveSize = 16>
-    struct VectorArena
-    {
    void Create(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* name = nullptr))
    {
        Assert(!Arena);
@@ -33,6 +31,8 @@ namespace Juliet
    void Reserve(size_t newCapacity)
    {
        Assert(Arena);
+        Assert(newCapacity <= ReserveSize && "VectorArena capacity should be <= ReserveSize.");
+
        if (Data == nullptr)
        {
            Data     = ArenaPushArray<Type>(Arena, newCapacity JULIET_DEBUG_PARAM(Name));
@@ -40,7 +40,7 @@ namespace Juliet
        }
        else
        {
-                Assert(newCapacity <= Capacity && "VectorArena capacity exceeded! Reallocation is disabled.");
+            Unimplemented();
        }
    }

@@ -204,9 +204,8 @@ namespace Juliet
    size_t Count     = 0;
    size_t Capacity  = 0;
    JULIET_DEBUG_ONLY(const char* Name = "VectorArena";)
-    };
-    static_assert(std::is_standard_layout_v<VectorArena<int>>,
+};
+static_assert(std::is_standard_layout_v<VectorArena<int>>,
              "VectorArena must have a standard layout to remain POD-like.");
-    static_assert(std::is_trivially_copyable_v<VectorArena<int>>,
+static_assert(std::is_trivially_copyable_v<VectorArena<int>>,
              "VectorArena must be trivially copyable (no custom destructors/assignment).");
-} // namespace Juliet
@@ -1,21 +1,16 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Common/NonNullPtr.h>
 #include <Core/Common/String.h>
-#include <Juliet.h>

-namespace Juliet
-{
-    struct Window;
+struct Window;

-    using WindowID = uint8;
-    extern JULIET_API Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int flags = 0 /* unused */);
-    extern JULIET_API void DestroyPlatformWindow(NonNullPtr<Window> window);
+using WindowID = uint8;
+extern JULIET_API Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int flags = 0 /* unused */);
+extern JULIET_API void DestroyPlatformWindow(NonNullPtr<Window> window);

-    extern JULIET_API void ShowWindow(NonNullPtr<Window> window);
-    extern JULIET_API void HideWindow(NonNullPtr<Window> window);
+extern JULIET_API void ShowWindow(NonNullPtr<Window> window);
+extern JULIET_API void HideWindow(NonNullPtr<Window> window);

-    extern JULIET_API WindowID GetWindowID(NonNullPtr<Window> window);
-    extern JULIET_API void SetWindowTitle(NonNullPtr<Window> window, String title);
-} // namespace Juliet
+extern JULIET_API WindowID GetWindowID(NonNullPtr<Window> window);
+extern JULIET_API void     SetWindowTitle(NonNullPtr<Window> window, String title);
@@ -1,12 +1,9 @@
-#pragma once
+#pragma once

 #include <Core/Common/NonNullPtr.h>

-namespace Juliet
-{
-    struct DynamicLibrary;
+struct DynamicLibrary;

-    extern JULIET_API DynamicLibrary* LoadDynamicLibrary(const char* filename);
-    extern JULIET_API FunctionPtr     LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName);
-    extern JULIET_API void            UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib);
-} // namespace Juliet
+extern JULIET_API DynamicLibrary* LoadDynamicLibrary(const char* filename);
+extern JULIET_API FunctionPtr     LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName);
+extern JULIET_API void            UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib);
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once

 #include <Core/HAL/Display/Display.h>
 #include <Core/HAL/Keyboard/Keyboard.h>
@@ -9,10 +9,8 @@
 // Handles all events from systems handling the Hardware
 // Very inspired by SDL3

-namespace Juliet
+enum class EventType : uint32
 {
-    enum class EventType : uint32
-    {
    None  = 0,
    First = None,

@@ -44,28 +42,28 @@ namespace Juliet
    Mouse_End   = Mouse_ButtonReleased,

    Last // Get value from the previous one
-    };
+};

-    struct WindowEvent
-    {
+struct WindowEvent
+{
    WindowID AssociatedWindowID;
    uint32   DataPadding[2]; // TODO : define how much data param we need
-    };
+};

-    struct KeyboardEvent
-    {
+struct KeyboardEvent
+{
    KeyboardID AssociatedKeyboardID;
    WindowID   WindowID;
    Key        Key;
    KeyState   KeyState;
    KeyMod     KeyModeState;
-    };
+};

-    // =====================================================
-    // Mouse Events
-    // =====================================================
-    struct MouseMovementEvent
-    {
+// =====================================================
+// Mouse Events
+// =====================================================
+struct MouseMovementEvent
+{
    MouseID     AssociatedMouseID;
    WindowID    WindowID;
    float       X;
@@ -73,49 +71,50 @@ namespace Juliet
    float       X_Displacement;
    float       Y_Displacement;
    MouseButton ButtonState;
-    };
+};

-    struct MouseButtonEvent
-    {
+struct MouseButtonEvent
+{
    MouseID     AssociatedMouseID;
    WindowID    WindowID;
    float       X;
    float       Y;
    MouseButton ButtonState;
    bool        IsPressed : 1;
-    };
+};

-    // Tagged union representing ALL possible system events + a bit of data for custom event if needed
-    union AllSystemEventUnion
-    {
+// Tagged union representing ALL possible system events + a bit of data for custom event if needed
+union AllSystemEventUnion
+{
    WindowEvent        Window;
    KeyboardEvent      Keyboard;
    MouseMovementEvent MouseMovement;
    MouseButtonEvent   MouseButton;
    uint8              Padding[128]; // Make sure that the union is fixed in size and big enough on all platforms.
-    };
-    // Make sure we do not bust the union size
-    static_assert(sizeof(AllSystemEventUnion) == sizeof(((AllSystemEventUnion*)nullptr)->Padding));
+};
+// Make sure we do not bust the union size
+static_assert(sizeof(AllSystemEventUnion) == sizeof(((AllSystemEventUnion*)nullptr)->Padding));

-    struct SystemEvent
-    {
+struct SystemEvent
+{
    EventType           Type;
    uint64              Timestamp;
    AllSystemEventUnion Data;
-    };
+};

-    // Poll for any event, return false if no event is available.
-    // Equivalent to WaitEvent(event, 0);
-    // Will not block
-    extern JULIET_API bool GetEvent(SystemEvent& event);
+// Poll for any event, return false if no event is available.
+// Equivalent to WaitEvent(event, 0);
+// Will not block
+extern JULIET_API bool GetEvent(SystemEvent& event);

-    // TODO : use chrono to tag the timeout correctly with nanosec
-    // timeout == -1 means wait for any event before pursuing
-    // timeout == 0 means checking once for the frame and getting out
-    // timeout > 0 means wait until time is out
-    extern JULIET_API bool WaitEvent(SystemEvent& event, int32 timeoutInNS = -1);
+// TODO : use chrono to tag the timeout correctly with nanosec
+// timeout == -1 means wait for any event before pursuing
+// timeout == 0 means checking once for the frame and getting out
+// timeout > 0 means wait until time is out
+extern JULIET_API bool WaitEvent(SystemEvent& event, int32 timeoutInNS = -1);

-    // Add an event onto the event queue.
-    // TODO : support array of events
-    extern JULIET_API bool AddEvent(SystemEvent& event);
-} // namespace Juliet
+// Add an event onto the event queue.
+// TODO : support array of events
+extern JULIET_API bool AddEvent(SystemEvent& event);
+
+extern void Events_NewFrame(float deltaTime);
@@ -1,20 +1,17 @@
-#pragma once
+#pragma once

 #include <Core/Common/String.h>

-namespace Juliet
-{
-    // Returns the path to the application directory
-    [[nodiscard]] extern JULIET_API String GetBasePath();
+// Returns the path to the application directory
+[[nodiscard]] extern JULIET_API String GetBasePath();

-    // Returns the resolved base path to the compiled shaders directory.
-    // In dev, this resolves to ../../Assets/compiled/ relative to the exe.
-    // In shipping, this resolves to Assets/Shaders/ next to the exe.
-     [[nodiscard]] extern JULIET_API String GetAssetBasePath();
+// Returns the resolved base path to the compiled shaders directory.
+// In dev, this resolves to ../../Assets/compiled/ relative to the exe.
+// In shipping, this resolves to Assets/Shaders/ next to the exe.
+[[nodiscard]] extern JULIET_API String GetAssetBasePath();

-    // Builds a full path to an asset file given its filename (e.g. "Triangle.vert.dxil").
-    // The caller owns the returned buffer and must free it.
-    [[nodiscard]] extern JULIET_API String GetAssetPath(String filename);
+// Builds a full path to an asset file given its filename (e.g. "Triangle.vert.dxil").
+// The caller owns the returned buffer and must free it.
+[[nodiscard]] extern JULIET_API String GetAssetPath(NonNullPtr<Arena> arena, String filename);

-     [[nodiscard]]extern JULIET_API bool IsAbsolutePath(String path);
-} // namespace Juliet
+[[nodiscard]] extern JULIET_API bool IsAbsolutePath(String path);
@@ -1,40 +1,38 @@
-#pragma once
+#pragma once

 #include <Core/Common/NonNullPtr.h>
 #include <Core/Common/String.h>
 #include <Juliet.h>

-namespace Juliet
+// Opaque type
+struct IOStream;
+
+struct IOStreamDataPayload
 {
-    // Opaque type
-    struct IOStream;
+};

-    struct IOStreamDataPayload
-    {
-    };
-
-    enum class IOStreamStatus : uint8
-    {
+enum class IOStreamStatus : uint8
+{
    Ready,
    Error,
    EndOfFile,
    NotReady,
    ReadOnly,
    WriteOnly
-    };
+};

-    enum class IOStreamSeekPivot : uint8
-    {
+enum class IOStreamSeekPivot : uint8
+{
    Begin,
    Current,
    End,
    Count
-    };
+};

-    // IOStream can be opened on a file or memory, or anything else.
-    // Use the interface to make it transparent to the user.
-    struct IOStreamInterface
-    {
+// IOStream can be opened on a file or memory, or anything else.
+// Use the interface to make it transparent to the user.
+struct IOStreamInterface
+{
    uint32 Version;

    int64 (*Size)(NonNullPtr<IOStreamDataPayload> data);
@@ -45,25 +43,24 @@ namespace Juliet
    bool (*Flush)(NonNullPtr<IOStreamDataPayload> data, NonNullPtr<IOStreamStatus> status);

    bool (*Close)(NonNullPtr<IOStreamDataPayload> data);
-    };
+};

-    extern JULIET_API IOStream* IOFromFile(String filename, String mode);
+extern JULIET_API IOStream* IOFromFile(NonNullPtr<Arena> arena, String filename, String mode);

-    // Let you use an interface to open any io. Is used internally by IOFromFile
-    extern JULIET_API IOStream* IOFromInterface(NonNullPtr<const IOStreamInterface> streamInterface, NonNullPtr<IOStreamDataPayload> payload);
+// Let you use an interface to open any io. Is used internally by IOFromFile
+extern JULIET_API IOStream* IOFromInterface(NonNullPtr<Arena> arena, NonNullPtr<const IOStreamInterface> streamInterface,
+                                            NonNullPtr<IOStreamDataPayload> payload);

-    // Write formatted string into the stream.
-    extern JULIET_API size_t IOPrintf(NonNullPtr<IOStream> stream, _Printf_format_string_ const char* format, ...);
-    extern JULIET_API size_t IOWrite(NonNullPtr<IOStream> stream, ByteBuffer inBuffer);
+// Write formatted string into the stream.
+extern JULIET_API size_t IOPrintf(NonNullPtr<IOStream> stream, _Printf_format_string_ const char* format, ...);
+extern JULIET_API size_t IOWrite(NonNullPtr<IOStream> stream, ByteBuffer inBuffer);

-    extern JULIET_API size_t IORead(NonNullPtr<IOStream> stream, void* ptr, size_t size);
-    extern JULIET_API int64  IOSeek(NonNullPtr<IOStream> stream, int64 offset, IOStreamSeekPivot pivot);
+extern JULIET_API size_t IORead(NonNullPtr<IOStream> stream, void* ptr, size_t size);
+extern JULIET_API int64  IOSeek(NonNullPtr<IOStream> stream, int64 offset, IOStreamSeekPivot pivot);

-    extern JULIET_API int64 IOSize(NonNullPtr<IOStream> stream);
+extern JULIET_API int64 IOSize(NonNullPtr<IOStream> stream);

-    // TODO : Use memory arena because that Allocates
-    extern JULIET_API ByteBuffer LoadFile(String filename);
-    extern JULIET_API ByteBuffer LoadFile(NonNullPtr<IOStream> stream, bool closeStreamWhenDone);
+extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, String filename);
+extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, NonNullPtr<IOStream> stream, bool closeStreamWhenDone);

-    extern JULIET_API bool IOClose(NonNullPtr<IOStream> stream);
-} // namespace Juliet
+extern JULIET_API bool IOClose(NonNullPtr<IOStream> stream);
@@ -1,18 +1,14 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-
-namespace Juliet
+// Represents a Virtual Key corresponding to the Physical key, but localized using the keyboard layout
+// ScanCode reprensent US ASCII Keyboard
+// WASD Scan codes are ZQSD in KeyCode for French keyboard
+// We use the ASCII value of the generated character as value, when possible.
+// Keys that do not produce a character are converted to an abritrary value high enough to not conflict
+// Reference: https://www.asciitable.com/
+// Reference: https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa299374(v=vs.60)
+enum class KeyCode : uint32
 {
-    // Represents a Virtual Key corresponding to the Physical key, but localized using the keyboard layout
-    // ScanCode reprensent US ASCII Keyboard
-    // WASD Scan codes are ZQSD in KeyCode for French keyboard
-    // We use the ASCII value of the generated character as value, when possible.
-    // Keys that do not produce a character are converted to an abritrary value high enough to not conflict
-    // Reference: https://www.asciitable.com/
-    // Reference: https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa299374(v=vs.60)
-    enum class KeyCode : uint32
-    {
    Unknown          = 0x0,   // 0
    Unsupported      = 0x0,   // 0
    Return           = 0X0Du, // '\r'
@@ -169,10 +165,10 @@ namespace Juliet
    Media_Eject         = 0x4000010Eu,
    Media_PlayPause     = 0x4000010Fu,
    Media_Select        = 0x40000110u,
-    };
+};

-    enum class KeyMod : uint16
-    {
+enum class KeyMod : uint16
+{
    None           = 0b0,
    LeftShift      = 0b0000'0000'0001u,
    RightShift     = 0b0000'0000'0010u,
@@ -189,5 +185,4 @@ namespace Juliet
    Shift          = LeftShift | RightShift,
    Alt            = LeftAlt | RightAlt,
    OSCommand      = LeftOSCommand | RightOSCommand,
-    };
-} // namespace Juliet
+};
@@ -1,28 +1,32 @@
-#pragma once
+#pragma once

 #include <Core/HAL/Keyboard/KeyCode.h>
 #include <Core/HAL/Keyboard/ScanCode.h>
 #include <Juliet.h>

-namespace Juliet
-{
-    using KeyboardID = uint8;
+using KeyboardID = uint8;

-    enum class KeyState : bool
-    {
+enum class KeyPosition : bool
+{
    Up   = false,
    Down = true
-    };
+};

-    struct Key
-    {
+struct KeyState
+{
+    KeyPosition Position;
+    float       Time;
+};
+
+struct Key
+{
    ScanCode ScanCode;
    KeyCode  KeyCode;
    uint16   Raw;
-    };
+};

-    extern JULIET_API bool IsKeyDown(ScanCode scanCode);
+extern JULIET_API bool IsKeyDown(ScanCode scanCode);
+extern JULIET_API bool IsKeyPressed(ScanCode scanCode);

-    extern JULIET_API KeyMod  GetKeyModState();
-    extern JULIET_API KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState);
-} // namespace Juliet
+extern JULIET_API KeyMod  GetKeyModState();
+extern JULIET_API KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState);
@@ -1,15 +1,13 @@
-#pragma once
+#pragma once

-namespace Juliet
+// Follow the HID Usage page for USB
+// https://usb.org/sites/default/files/hut1_5.pdf
+// 0 to 256 Is dedicated to Keyboard Usage Page (0x07)
+// 257 to 286 Is dedicated to Consumer Usage Page (0xC)
+// 287 to 511 Is not implemented. Could be used for Mobile or Consoles
+// ScanCode reprensent Physical Keys and Buttons
+enum class ScanCode : uint16
 {
-    // Follow the HID Usage page for USB
-    // https://usb.org/sites/default/files/hut1_5.pdf
-    // 0 to 256 Is dedicated to Keyboard Usage Page (0x07)
-    // 257 to 286 Is dedicated to Consumer Usage Page (0xC)
-    // 287 to 511 Is not implemented. Could be used for Mobile or Consoles
-    // ScanCode reprensent Physical Keys and Buttons
-    enum class ScanCode : uint16
-    {
    Unknown     = 0,
    Unsupported = 0,

@@ -182,5 +180,4 @@ namespace Juliet
    Reserved = 287,

    Count = 512
-    };
-} // namespace Juliet
+};
@@ -1,27 +1,25 @@
-#pragma once
+#pragma once

-namespace Juliet
+using MouseID = uint8;
+
+enum class MouseButton : uint8
 {
-    using MouseID = uint8;
-
-    enum class MouseButton : uint8
-    {
    None    = 0,
    Left    = 1 << 0,
    Right   = 1 << 1,
    Middle  = 1 << 2,
    Button1 = 1 << 3,
    Button2 = 1 << 4,
-    };
+};

-    // TODO : Replace by Vector2f
-    struct MousePosition
-    {
+// TODO : Replace by Vector2f
+struct MousePosition
+{
    float X;
    float Y;
-    };
+};

-    extern bool          IsMouseButtonDown(MouseButton button);
-    extern MousePosition GetMousePosition();
-    extern MouseButton   GetMouseButtonState();
-} // namespace Juliet
+JULIET_API extern bool          IsMouseButtonDown(MouseButton button);
+JULIET_API extern MousePosition GetMousePosition();
+JULIET_API extern MousePosition GetMouseDelta();
+JULIET_API extern MouseButton   GetMouseButtonState();
@@ -1,13 +1,7 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-#include <Graphics/D3D12/D3D12Buffer.h>
-#include <Juliet.h>
-
-namespace Juliet
+namespace Memory
 {
-    namespace Memory
-    {
    Byte* OS_Reserve(size_t size);
    bool  OS_Commit(Byte* ptr, size_t size);
    void  OS_Release(Byte* ptr, size_t size);
@@ -30,13 +24,20 @@ namespace Juliet
        OS_Release(reinterpret_cast<Byte*>(ptr), size);
    }

-    } // namespace Memory
+} // namespace Memory

-    namespace Debug
-    {
+namespace Time
+{
+    uint64 Timestamp();
+    void   ComputeDeltaTime();
+    float  GetDeltaTime();
+    uint64 GetFrameNumber();
+} // namespace Time
+
+namespace Debug
+{
    JULIET_API bool IsDebuggerPresent();
-    } // namespace Debug
+} // namespace Debug

-    using EntryPointFunc = int (*)(int, wchar_t**);
-    JULIET_API int Bootstrap(EntryPointFunc entryPointFunc, int argc, wchar_t** argv);
-} // namespace Juliet
+using EntryPointFunc = int (*)(int, wchar_t**);
+JULIET_API int Bootstrap(EntryPointFunc entryPointFunc, int argc, wchar_t** argv);
@@ -1,16 +1,12 @@
-#pragma once
+#pragma once

 #include <Core/Common/String.h>

-namespace Juliet
+// Fwd Declare
+struct DynamicLibrary;
+
+struct HotReloadCode
 {
-    // Fwd Declare
-    struct DynamicLibrary;
-
-    struct HotReloadCode
-    {
-        Arena* Arena;
-
    String DLLFullPath;
    String LockFullPath;
    String TransientDLLName;
@@ -26,14 +22,14 @@ namespace Juliet
    uint32 UniqueID;

    bool IsValid : 1;
-    };
+};

-    extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename);
-    extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
+extern JULIET_API void InitHotReloadCode(NonNullPtr<Arena> arena, HotReloadCode& code, String dllName,
+                                         String transientDllName, String lockFilename);
+extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);

-    extern JULIET_API void LoadCode(HotReloadCode& code);
-    extern JULIET_API void UnloadCode(HotReloadCode& code);
+extern JULIET_API void LoadCode(HotReloadCode& code);
+extern JULIET_API void UnloadCode(HotReloadCode& code);

-    extern JULIET_API void ReloadCode(HotReloadCode& code);
-    extern JULIET_API bool ShouldReloadCode(const HotReloadCode& code);
-} // namespace Juliet
+extern JULIET_API void ReloadCode(HotReloadCode& code);
+extern JULIET_API bool ShouldReloadCode(const HotReloadCode& code);
@@ -1,19 +1,16 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Common/NonNullPtr.h>

 #ifdef JULIET_ENABLE_IMGUI

 struct ImGuiContext;

-namespace Juliet
-{
-    struct Window;
-    struct GraphicsDevice;
+struct Window;
+struct GraphicsDevice;

-    namespace ImGuiService
-    {
+namespace ImGuiService
+{
    JULIET_API void Initialize(NonNullPtr<Window> window);
    JULIET_API void Shutdown();

@@ -25,7 +22,6 @@ namespace Juliet

    // Run internal unit tests
    JULIET_API void RunTests();
-    } // namespace ImGuiService
-} // namespace Juliet
+} // namespace ImGuiService

 #endif // JULIET_ENABLE_IMGUI
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once

 #include <Core/Common/NonNullPtr.h>
 #include <Core/HAL/Display/Window.h>
@@ -6,7 +6,7 @@

 #include <Juliet.h>

-namespace Juliet::UnitTest
+namespace UnitTest
 {
    void TestImGui();
 }
@@ -1,26 +1,21 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-
-namespace Juliet
+enum class JulietInit_Flags : uint8
 {
-    enum class JulietInit_Flags : uint8
-    {
    None    = 0,
    Display = 1 << 0,
    Audio   = 1 << 1,
    Count   = Audio,
    All     = 0xFb
-    };
+};

-    struct Arena;
+struct Arena;

-    struct GameInitParams
-    {
-        Arena* GameArena;
+struct GameData
+{
+    struct GameState* GameState;
    Arena*            ScratchArena;
-    };
+};

-    void JulietInit(JulietInit_Flags flags);
-    void JulietShutdown();
-} // namespace Juliet
+void JulietInit(JulietInit_Flags flags);
+void JulietShutdown();
@@ -1,29 +1,24 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Common/NonNullPtr.h>
 #include <Core/Memory/MemoryArena.h>
-#include <Juliet.h>

 // TODO : Juliet strings
 // TODO Juliet Containers + Allocators...
 // TODO: Juliet chrono, because it prevents me from doing #define global static

-namespace Juliet
-{
-    enum class LogLevel : uint8;
-    enum class LogCategory : uint8;
+enum class LogLevel : uint8;
+enum class LogCategory : uint8;

-    extern void JULIET_API InitializeLogManager();
-    extern void JULIET_API ShutdownLogManager();
+extern void JULIET_API InitializeLogManager();
+extern void JULIET_API ShutdownLogManager();

-    extern void JULIET_API LogScopeBegin();
-    // TODO everything that happened in there to export them to file or something
-    extern void JULIET_API LogScopeEnd();
+extern void JULIET_API LogScopeBegin();
+// TODO everything that happened in there to export them to file or something
+extern void JULIET_API LogScopeEnd();

-    extern void JULIET_API Log(LogLevel level, LogCategory category, const char* fmt, ...);
-    extern void JULIET_API LogDebug(LogCategory category, const char* fmt, ...);
-    extern void JULIET_API LogMessage(LogCategory category, const char* fmt, ...);
-    extern void JULIET_API LogWarning(LogCategory category, const char* fmt, ...);
-    extern void JULIET_API LogError(LogCategory category, const char* fmt, ...);
-} // namespace Juliet
+extern void JULIET_API Log(LogLevel level, LogCategory category, const char* fmt, ...);
+extern void JULIET_API LogDebug(LogCategory category, const char* fmt, ...);
+extern void JULIET_API LogMessage(LogCategory category, const char* fmt, ...);
+extern void JULIET_API LogWarning(LogCategory category, const char* fmt, ...);
+extern void JULIET_API LogError(LogCategory category, const char* fmt, ...);
@@ -1,22 +1,19 @@
-#pragma once
+#pragma once

-namespace Juliet
+enum class LogLevel : uint8
 {
-    enum class LogLevel : uint8
-    {
    Debug   = 0,
    Message = 1,
    Warning = 2,
    Error   = 3,
-    };
+};

-    enum class LogCategory : uint8
-    {
+enum class LogCategory : uint8
+{
    Core       = 0,
    Graphics   = 1,
    Networking = 2,
    Engine     = 3,
    Tool       = 4,
    Game       = 5,
-    };
-} // namespace Juliet
+};
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once

 #include <Core/HAL/OS/OS.h>

@@ -12,12 +12,12 @@ extern int JulietMain(int, wchar_t**);
 #if UNICODE
 int wmain(int argc, wchar_t** argv)
 {
-    return Juliet::Bootstrap(JulietMain, argc, argv);
+    return Bootstrap(JulietMain, argc, argv);
 }
 #else
 int main(int argc, char** argv)
 {
-    return Juliet::Bootstrap(JulietMain, argc, argv);
+    return Bootstrap(JulietMain, argc, argv);
 }
 #endif

@@ -38,7 +38,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
    (void)szCmdLine;
    (void)sw;

-    return Juliet::Bootstrap(JulietMain, __argc, __wargv);
+    return Bootstrap(JulietMain, __argc, __wargv);
 }
 }
 #else
@@ -1,44 +1,39 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-#include <Juliet.h>
+extern JULIET_API float RoundF(float value);

-namespace Juliet
+inline int32 LRoundF(float value)
 {
-    extern JULIET_API float RoundF(float value);
-
-    inline int32 LRoundF(float value)
-    {
    return static_cast<int32>(RoundF(value));
-    }
+}

-    template <typename Type>
-    constexpr Type Min(Type lhs, Type rhs)
-    {
+template <typename Type>
+constexpr Type Min(Type lhs, Type rhs)
+{
    return rhs < lhs ? rhs : lhs;
-    }
+}

-    template <typename Type>
-    constexpr Type Max(Type lhs, Type rhs)
-    {
+template <typename Type>
+constexpr Type Max(Type lhs, Type rhs)
+{
    return lhs < rhs ? rhs : lhs;
-    }
+}

-    template <typename Type>
-    constexpr Type ClampTop(Type value, Type X)
-    {
+template <typename Type>
+constexpr Type ClampTop(Type value, Type X)
+{
    return Min(value, X);
-    }
+}

-    template <typename Type>
-    constexpr Type ClampBottom(Type value, Type X)
-    {
+template <typename Type>
+constexpr Type ClampBottom(Type value, Type X)
+{
    return Max(value, X);
-    }
+}

-    template <typename Type>
-    constexpr Type Clamp(Type val, Type min, Type max)
-    {
+template <typename Type>
+constexpr Type Clamp(Type val, Type min, Type max)
+{
    if (val < min)
    {
        return min;
@@ -48,5 +43,4 @@ namespace Juliet
        return max;
    }
    return val;
-    }
-} // namespace Juliet
+}
@@ -1,27 +1,25 @@
-#pragma once
+#pragma once

 #include <Core/Math/Vector.h>
 #include <math.h>

-namespace Juliet
+struct Matrix
 {
-    struct Matrix
-    {
    float m[4][4];
-    };
+};

-    [[nodiscard]] inline Matrix MatrixIdentity()
-    {
+[[nodiscard]] inline Matrix MatrixIdentity()
+{
    Matrix result = {};
    result.m[0][0] = 1.0f;
    result.m[1][1] = 1.0f;
    result.m[2][2] = 1.0f;
    result.m[3][3] = 1.0f;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix operator*(const Matrix& lhs, const Matrix& rhs)
-    {
+[[nodiscard]] inline Matrix operator*(const Matrix& lhs, const Matrix& rhs)
+{
    Matrix result = {};
    for (int i = 0; i < 4; ++i)
    {
@@ -34,28 +32,28 @@ namespace Juliet
        }
    }
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixTranslation(float x, float y, float z)
-    {
+[[nodiscard]] inline Matrix MatrixTranslation(float x, float y, float z)
+{
    Matrix result = MatrixIdentity();
    result.m[0][3] = x;
    result.m[1][3] = y;
    result.m[2][3] = z;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixScale(float x, float y, float z)
-    {
+[[nodiscard]] inline Matrix MatrixScale(float x, float y, float z)
+{
    Matrix result = MatrixIdentity();
    result.m[0][0] = x;
    result.m[1][1] = y;
    result.m[2][2] = z;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixRotationX(float radians)
-    {
+[[nodiscard]] inline Matrix MatrixRotationX(float radians)
+{
    float c = cosf(radians);
    float s = sinf(radians);
    Matrix result = MatrixIdentity();
@@ -64,10 +62,10 @@ namespace Juliet
    result.m[2][1] =  s;
    result.m[2][2] =  c;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixRotationY(float radians)
-    {
+[[nodiscard]] inline Matrix MatrixRotationY(float radians)
+{
    float c = cosf(radians);
    float s = sinf(radians);
    Matrix result = MatrixIdentity();
@@ -76,10 +74,10 @@ namespace Juliet
    result.m[2][0] = -s;
    result.m[2][2] =  c;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixRotationZ(float radians)
-    {
+[[nodiscard]] inline Matrix MatrixRotationZ(float radians)
+{
    float c = cosf(radians);
    float s = sinf(radians);
    Matrix result = MatrixIdentity();
@@ -88,22 +86,22 @@ namespace Juliet
    result.m[1][0] =  s;
    result.m[1][1] =  c;
    return result;
-    }
+}

-    inline void MatrixTranslate(Matrix& m, const Vector3& v)
-    {
+inline void MatrixTranslate(Matrix& m, const Vector3& v)
+{
    m.m[0][3] += v.x;
    m.m[1][3] += v.y;
    m.m[2][3] += v.z;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixRotation(float x, float y, float z)
-    {
+[[nodiscard]] inline Matrix MatrixRotation(float x, float y, float z)
+{
    return MatrixRotationX(x) * MatrixRotationY(y) * MatrixRotationZ(z);
-    }
+}

-    inline Matrix LookAt(const Vector3& eye, const Vector3& target, const Vector3& up)
-    {
+inline Matrix LookAt(const Vector3& eye, const Vector3& target, const Vector3& up)
+{
    // Left-Handed convention
    Vector3 zaxis = Normalize(target - eye); // Forward is +z
    Vector3 xaxis = Normalize(Cross(up, zaxis));
@@ -132,10 +130,10 @@ namespace Juliet
    result.m[3][3] = 1.0f;

    return result;
-    }
+}

-    inline Matrix PerspectiveFov(float fovY, float aspectRatio, float nearZ, float farZ)
-    {
+inline Matrix PerspectiveFov(float fovY, float aspectRatio, float nearZ, float farZ)
+{
    // Left-Handed Perspective
    float yScale = 1.0f / tanf(fovY * 0.5f);
    float xScale = yScale / aspectRatio;
@@ -148,10 +146,10 @@ namespace Juliet
    result.m[3][2]  = 1.0f;
    result.m[3][3]  = 0.0f;
    return result;
-    }
+}

-    [[nodiscard]] inline Matrix MatrixInverse(const Matrix& m)
-    {
+[[nodiscard]] inline Matrix MatrixInverse(const Matrix& m)
+{
    Matrix out = {};

    float m00 = m.m[0][0], m01 = m.m[0][1], m02 = m.m[0][2], m03 = m.m[0][3];
@@ -190,5 +188,4 @@ namespace Juliet
    }

    return out;
-    }
-} // namespace Juliet
+}
@@ -1,12 +1,9 @@
-#pragma once
+#pragma once

-namespace Juliet
+struct Rectangle
 {
-    struct Rectangle
-    {
    int32 X;
    int32 Y;
    int32 Width;
    int32 Height;
-    };
-} // namespace Juliet
+};
@@ -1,39 +1,38 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-#include <Juliet.h>
-#include <math.h>
-
-namespace Juliet
+struct Vector3
 {
-    struct Vector3
-    {
    float x, y, z;

    Vector3 operator+(const Vector3& rhs) const { return { x + rhs.x, y + rhs.y, z + rhs.z }; }
    Vector3 operator-(const Vector3& rhs) const { return { x - rhs.x, y - rhs.y, z - rhs.z }; }
    Vector3 operator*(float s) const { return { x * s, y * s, z * s }; }
-    };
+};

-    struct Vector4
-    {
-        float x, y, z, w;
-    };
+struct Vector4
+{
+    float x = 0.f;
+    float y = 0.f;
+    float z = 0.f;
+    float w = 0.f;
+};

-    inline Vector3 Normalize(const Vector3& v)
-    {
+inline Vector3 Normalize(const Vector3& v)
+{
    float len = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
    if (len > 0.0001f)
    {
        return { v.x / len, v.y / len, v.z / len };
    }
    return v;
-    }
+}

-    inline Vector3 Cross(const Vector3& a, const Vector3& b)
-    {
+inline Vector3 Cross(const Vector3& a, const Vector3& b)
+{
    return { a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x };
-    }
+}

-    inline float Dot(const Vector3& a, const Vector3& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
-} // namespace Juliet
+inline float Dot(const Vector3& a, const Vector3& b)
+{
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+}
@@ -1,33 +1,28 @@
-#pragma once
+#pragma once

 #include <Juliet.h>
 #include <Core/Common/CoreUtils.h>

-#include <cstdlib>
+// Uninitialized allocation
+JULIET_API void* Malloc(size_t elem_size);
+// Initialized to 0 allocation
+JULIET_API void* Calloc(size_t nb_elem, size_t elem_size);
+JULIET_API void* Realloc(void* memory, size_t newSize);

-namespace Juliet
+// Free
+template <typename Type>
+void Free(Type* memory)
 {
-    // Uninitialized allocation
-    JULIET_API void* Malloc(size_t elem_size);
-    // Initialized to 0 allocation
-    JULIET_API void* Calloc(size_t nb_elem, size_t elem_size);
-    JULIET_API void* Realloc(void* memory, size_t newSize);
-
-    // Free
-    template <typename Type>
-    void Free(Type* memory)
-    {
    Assert(memory);
    ::free(memory);
-    }
-    // Free and Set the ptr to nullptr
-    template <typename Type>
-    void SafeFree(Type*& memory)
-    {
+}
+// Free and Set the ptr to nullptr
+template <typename Type>
+void SafeFree(Type*& memory)
+{
    if (memory)
    {
        ::free(memory);
        memory = nullptr;
    }
-    }
-} // namespace Juliet
+}
@@ -1,31 +1,24 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Common/CoreUtils.h>
 #include <Core/Common/NonNullPtr.h>
 #include <Core/Common/String.h>
-#include <Juliet.h>
-
-namespace Juliet
-{
-    constexpr global uint64 g_Arena_Default_Reserve_Size = Megabytes(64);
-    constexpr global uint64 g_Arena_Default_Commit_Size  = Kilobytes(64);
-    constexpr global uint64 k_ArenaHeaderSize            = 128;
-
-    struct ArenaFreeNode
-    {
-        ArenaFreeNode* Next;
-        ArenaFreeNode* Previous;
-        index_t        Position;
-        size_t         Size;
-    };

 #if JULIET_DEBUG
-    struct ArenaDebugInfo;
+#include <Core/Memory/MemoryArenaDebug.h>
 #endif

-    struct Arena
-    {
+constexpr global uint64 g_Arena_Default_Reserve_Size = Megabytes(64);
+constexpr global uint64 g_Arena_Default_Commit_Size  = Kilobytes(64);
+constexpr global uint64 k_ArenaHeaderSize            = 128;
+
+#if JULIET_DEBUG
+struct ArenaDebugInfo;
+JULIET_API String FormatDebugTagV(const char* formatStr, std::format_args args);
+#endif
+
+struct Arena
+{
    Arena* Previous;
    Arena* Current;

@@ -41,67 +34,92 @@ namespace Juliet

    Arena* FreeBlockLast;

-        ArenaFreeNode* FreeNodes;
-
-        bool AllowRealloc : 1;
-
    JULIET_DEBUG_ONLY(uint16 LostNodeCount;)
    JULIET_DEBUG_ONLY(bool CanReserveMore : 1;)

    JULIET_DEBUG_ONLY(Arena* GlobalNext;)
    JULIET_DEBUG_ONLY(Arena* GlobalPrev;)
    JULIET_DEBUG_ONLY(ArenaDebugInfo* FirstDebugInfo;)
-        JULIET_DEBUG_ONLY(const char* Name;)
-    };
-    static_assert(sizeof(Arena) <= k_ArenaHeaderSize);
+    const char* Name;
+};
+static_assert(sizeof(Arena) <= k_ArenaHeaderSize);

-    struct TempArena
-    {
+struct TempArena
+{
    Arena*  Arena;
    index_t Position;
-    };
+};

-    struct ArenaParams
-    {
+struct ArenaParams
+{
    uint64 ReserveSize = g_Arena_Default_Reserve_Size;
    uint64 CommitSize  = g_Arena_Default_Commit_Size;

-        // True: All push will be 32 bytes minimum
-        bool AllowRealloc = false;
+    const char* Name;

    // When false, will assert if a new block is reserved.
    JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
-    };
+};

-    [[nodiscard]] JULIET_API Arena* ArenaAllocate(const ArenaParams& params   JULIET_DEBUG_ONLY(, const char* name),
+[[nodiscard]] JULIET_API Arena* ArenaAllocate(const ArenaParams&          params,
                                              const std::source_location& loc = std::source_location::current());
-    JULIET_API void                 ArenaRelease(NonNullPtr<Arena> arena);
+JULIET_API void                 ArenaRelease(NonNullPtr<Arena> arena);

-    // Raw Push, can be used but templated helpers exists below
-    // Raw Push, can be used but templated helpers exists below
-    [[nodiscard]] JULIET_API void* ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align,
-                                             bool shouldBeZeroed JULIET_DEBUG_ONLY(, const char* tag));
-    [[nodiscard]] JULIET_API void* ArenaReallocate(NonNullPtr<Arena> arena, void* oldPtr, size_t oldSize, size_t newSize,
-                                                   size_t align, bool shouldBeZeroed JULIET_DEBUG_ONLY(, const char* tag));
-    JULIET_API void                 ArenaPopTo(NonNullPtr<Arena> arena, size_t position);
-    JULIET_API void                 ArenaPop(NonNullPtr<Arena> arena, size_t amount);
-    JULIET_API void                 ArenaClear(NonNullPtr<Arena> arena);
-    [[nodiscard]] JULIET_API size_t ArenaPos(NonNullPtr<Arena> arena);
+// Raw Push, can be used but templated helpers exists below
+[[nodiscard]] JULIET_API void*  ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align,
+                                          bool shouldBeZeroed JULIET_DEBUG_PARAM(const char* tag));
+JULIET_API void                 ArenaPopTo(NonNullPtr<Arena> arena, size_t position);
+JULIET_API void                 ArenaPop(NonNullPtr<Arena> arena, size_t amount);
+JULIET_API void                 ArenaClear(NonNullPtr<Arena> arena);
+[[nodiscard]] JULIET_API size_t ArenaPos(NonNullPtr<Arena> arena);

-    template <typename Type>
-    [[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* tag = nullptr))
+#if JULIET_DEBUG
+template <typename FirstDebugArg, typename... DebugArgs>
+#endif
+[[nodiscard]] inline void* ArenaPushSize(NonNullPtr<Arena> arena, size_t size, size_t align,
+                                         bool shouldBeZeroed JULIET_DEBUG_PARAM(FirstDebugArg&& firstDebugArg, DebugArgs&&... debugArgs))
+{
+    return ArenaPush(arena, size, align,
+                     shouldBeZeroed JULIET_DEBUG_PARAM(
+                         [&]() -> const char*
                         {
+                             return Format(GetDebugInfoArena(), std::forward<FirstDebugArg>(firstDebugArg),
+                                           std::forward<DebugArgs>(debugArgs)...)
+                                 .Str;
+                         }()));
+}
+
+template <typename Type JULIET_DEBUG_ONLY(, typename... DebugArgs)>
+[[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
+{
    return static_cast<Type*>(
-            ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type), true JULIET_DEBUG_PARAM(tag ? tag : GetTypeName<Type>())));
-    }
-
-    template <typename Type>
-    [[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count JULIET_DEBUG_PARAM(const char* tag = nullptr))
+        ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type),
+                  true JULIET_DEBUG_PARAM(
+                      [&]() -> const char*
                      {
-        return static_cast<Type*>(ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)),
-                                            true JULIET_DEBUG_PARAM(tag ? tag : GetTypeName<Type>())));
+                          if constexpr (sizeof...(DebugArgs) > 0)
+                          {
+                              return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
                          }
+                          return GetTypeName<Type>();
+                      }())));
+}

-    TempArena ArenaTempBegin(NonNullPtr<Arena> arena);
-    void      ArenaTempEnd(TempArena temp);
-} // namespace Juliet
+template <typename Type, bool shouldZero = true JULIET_DEBUG_ONLY(, typename... DebugArgs)>
+[[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
+{
+    return static_cast<Type*>(
+        ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)),
+                  shouldZero JULIET_DEBUG_PARAM(
+                      [&]() -> const char*
+                      {
+                          if constexpr (sizeof...(DebugArgs) > 0)
+                          {
+                              return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
+                          }
+                          return GetTypeName<Type>();
+                      }())));
+}
+
+TempArena ArenaTempBegin(NonNullPtr<Arena> arena);
+void      ArenaTempEnd(TempArena temp);
@@ -1,50 +1,46 @@
-#pragma once
+#pragma once

-#include <Juliet.h>
-#include <Core/Common/CoreTypes.h>
-#include <Core/Common/String.h>
 #include <Core/Common/NonNullPtr.h>
+#include <Core/Common/String.h>

 #if JULIET_DEBUG

-namespace Juliet
-{
-    struct Arena;
-    struct MemoryBlock;
+struct Arena;
+struct MemoryBlock;

-    // Arena (Struct)
-    struct ArenaDebugInfo
-    {
+// Arena (Struct)
+struct ArenaDebugInfo
+{
    const char*     Tag;
    size_t          Offset;
    size_t          Size;
    ArenaDebugInfo* Next;
-    };
+};

-    // MemoryArena (Pool-based)
-    struct ArenaAllocation
-    {
+// MemoryArena (Pool-based)
+struct ArenaAllocation
+{
    size_t           Offset;
    size_t           Size;
    String           Tag;
    ArenaAllocation* Next;
-    };
+};

-    // Arena (Struct)
-    void            DebugRegisterArena(NonNullPtr<Arena> arena);
-    void            DebugUnregisterArena(NonNullPtr<Arena> arena);
-    void            DebugArenaSetDebugName(NonNullPtr<Arena> arena, const char* name);
-    bool            IsDebugInfoArena(const Arena* arena); // To prevent recursion
-    void            DebugArenaFreeBlock(Arena* block); // To clear all debug infos in a block
-    void            DebugArenaRemoveAllocation(Arena* block, size_t oldOffset);
-    void            DebugArenaPopTo(Arena* block, size_t newPosition);
-    void            DebugArenaAddDebugInfo(Arena* block, size_t size, size_t offset, const char* tag);
+// Arena (Struct)
+void DebugRegisterArena(NonNullPtr<Arena> arena);
+void DebugUnregisterArena(NonNullPtr<Arena> arena);
+void DebugArenaSetDebugName(NonNullPtr<Arena> arena, const char* name);
+bool IsDebugInfoArena(const Arena* arena); // To prevent recursion
+void DebugArenaFreeBlock(Arena* block);    // To clear all debug infos in a block
+void DebugArenaRemoveAllocation(Arena* block, size_t oldOffset);
+void DebugArenaPopTo(Arena* block, size_t newPosition);
+void DebugArenaAddDebugInfo(Arena* block, size_t size, size_t offset, const char* tag);

-    // MemoryArena (Pool-based)
-    void             DebugFreeArenaAllocations(MemoryBlock* blk);
-    void             DebugArenaAddAllocation(MemoryBlock* blk, size_t size, size_t offset, String tag);
-    void             DebugArenaRemoveLastAllocation(MemoryBlock* blk);
+// MemoryArena (Pool-based)
+void DebugFreeArenaAllocations(MemoryBlock* blk);
+void DebugArenaAddAllocation(MemoryBlock* blk, size_t size, size_t offset, String tag);
+void DebugArenaRemoveLastAllocation(MemoryBlock* blk);

-} // namespace Juliet
+JULIET_API Arena* GetDebugInfoArena();

 #endif
@@ -1,13 +1,9 @@
-#pragma once
-
-#include <Core/Common/CoreTypes.h>
+#pragma once

 #define ArraySize(array) (sizeof(array) / sizeof(array[0]))

-namespace Juliet
+inline int32 MemCompare(const void* leftValue, const void* rightValue, size_t size)
 {
-    inline int32 MemCompare(const void* leftValue, const void* rightValue, size_t size)
-    {
    auto left  = static_cast<const unsigned char*>(leftValue);
    auto right = static_cast<const unsigned char*>(rightValue);
    while (size && *left == *right)
@@ -17,36 +13,30 @@ namespace Juliet
        --size;
    }
    return size ? *left - *right : 0;
-    }
+}

-    // Single linked list
-    void SingleLinkedListPushNext(auto*& stackTop, auto* node)
-    {
+// Single linked list
+void SingleLinkedListPushNext(auto*& stackTop, auto* node)
+{
    node->Next = stackTop;
    stackTop   = node;
-    }
+}

-    void SingleLinkedListPushPrevious(auto*& stackTop, auto* node)
-    {
+void SingleLinkedListPushPrevious(auto*& stackTop, auto* node)
+{
    node->Previous = stackTop;
    stackTop       = node;
-    }
+}

-    void SingleLinkedListPopNext(auto*& stackTop)
-    {
+void SingleLinkedListPopNext(auto*& stackTop)
+{
    stackTop = stackTop->Next;
-    }
+}

-    template <typename SingleLinkedListType>
-    struct SingleLinkedListNode
-    {
-        SingleLinkedListType* Next;
-    };
-
-    // Double linked list
-    template <typename QueueType, typename QueueTypeNode>
-    void Enqueue(QueueType& queue, QueueTypeNode* node)
-    {
+// Double linked list
+template <typename QueueType, typename QueueTypeNode>
+void Enqueue(QueueType& queue, QueueTypeNode* node)
+{
    if (queue.First == nullptr)
    {
        queue.First = queue.Last = node;
@@ -59,13 +49,13 @@ namespace Juliet
    }

    queue.Nodecount += 1;
-    }
+}

-    template <typename QueueType>
-    struct QueueNode
-    {
+template <typename QueueType>
+struct QueueNode
+{
    QueueType* Next;
-    };
+};

 #define DECLARE_QUEUE(type)                                                                                            \
    struct type##Queue                                                                                                 \
@@ -76,14 +66,8 @@ namespace Juliet
        size_t Size;                                                                                                   \
    };

-#define SLLQueuePush(f, l, n) SLLQueuePush_NZ(0, f, l, n, next)
-
-#define SLLQueuePush_NZ(nil, f, l, n, next)                                                                            \
-    (CheckNil(nil, f) ? ((f) = (l) = (n), SetNil(nil, (n)->next)) : ((l)->next = (n), (l) = (n), SetNil(nil, (n)->next)))
-
 // TODO: homemade versions
 #define MemSet memset
 #define MemCopy memcpy

 #define MemoryZero(dst, size) MemSet(dst, 0, size)
-} // namespace Juliet
@@ -1,11 +1,6 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
-
-namespace Juliet
-{
-    // TODO : Do something better.
-    constexpr uint32 kLocalhost   = (127 << 3) | (0 << 2) | (0 << 1) | 1;
-    constexpr uint32 kAnyIp       = 0;
-    constexpr uint32 kBroadcastIp = (255 << 3) | (255 << 2) | (255 << 1) | 255;
-} // namespace Juliet
+// TODO : Do something better.
+constexpr uint32 kLocalhost   = (127 << 3) | (0 << 2) | (0 << 1) | 1;
+constexpr uint32 kAnyIp       = 0;
+constexpr uint32 kBroadcastIp = (255 << 3) | (255 << 2) | (255 << 1) | 255;
@@ -1,12 +1,9 @@
-#pragma once
+#pragma once

-#include <Core/Common/CoreTypes.h>
 #include <Core/Container/Vector.h>

-namespace Juliet
+class NetworkPacket
 {
-    class NetworkPacket
-    {
  public:
    NetworkPacket();
    NetworkPacket(Arena& arena);
@@ -32,5 +29,4 @@ namespace Juliet
  private:
    VectorArena<Byte, 4096> Data;
    size_t                  PartialSendIndex = 0;
-    };
-} // namespace Juliet
+};
@@ -1,11 +1,9 @@
-#pragma once
+#pragma once

 #include <Core/Networking/SocketHandle.h>

-namespace Juliet
+class Socket
 {
-    class Socket
-    {
  public:
    virtual ~Socket();

@@ -52,5 +50,4 @@ namespace Juliet
  private:
    SocketHandle Handle;
    Protocol     ProtocolType;
-    };
-} // namespace Juliet
+};
@@ -1,14 +1,11 @@
-#pragma once
+#pragma once

 #if JULIET_WIN32
 #include <basetsd.h>
 #endif

-namespace Juliet
-{
 #if JULIET_WIN32
-    using SocketHandle = UINT_PTR;
+using SocketHandle = UINT_PTR;
 #else
-    using SocketHandle = int;
+using SocketHandle = int;
 #endif
-} // namespace Juliet
@@ -1,13 +1,11 @@
-#pragma once
+#pragma once

 #include <Core/Networking/IPAddress.h>
 #include <Core/Networking/Socket.h>
 #include <Core/Networking/TcpSocket.h>

-namespace Juliet
+class TcpListener : public Socket
 {
-    class TcpListener : public Socket
-    {
  public:
    TcpListener();

@@ -17,5 +15,4 @@ namespace Juliet
    Status Listen(uint16 port, uint32 address = kAnyIp);
    Status Accept(TcpSocket& socket);
    void   Close();
-    };
-} // namespace Juliet
+};
@@ -1,13 +1,11 @@
-#pragma once
+#pragma once

 #include <Core/Networking/Socket.h>

-namespace Juliet
-{
-    class NetworkPacket;
+class NetworkPacket;

-    class TcpSocket : public Socket
-    {
+class TcpSocket : public Socket
+{
  public:
    TcpSocket();

@@ -20,5 +18,4 @@ namespace Juliet

  private:
    friend class TcpListener;
-    };
-} // namespace Juliet
+};
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <algorithm>
+#include <bit>
+#include <cassert>
+#include <cfloat>
+#include <chrono>
+#include <cinttypes>
+#include <cmath>
+#include <concepts>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <format>
+#include <forward_list>
+#include <ios>
+#include <iosfwd>
+#include <limits>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <source_location>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include <Juliet.h>
+
+#include <Core/Common/CoreTypes.h>
@@ -1,9 +1,4 @@
-#pragma once
+#pragma once

-#include <mutex>
-
-namespace Juliet
-{
-    using Mutex     = std::mutex;
-    using LockGuard = std::lock_guard<Mutex>;
-} // namespace Juliet
+using Mutex     = std::mutex;
+using LockGuard = std::lock_guard<Mutex>;
@@ -1,17 +1,16 @@
-#pragma once
+#pragma once

-#include <thread>
+#include <Core/Common/String.h>

-namespace Juliet
+uint32 thread_id();
+
+void set_thread_name(String name);
+
+// TODO : Proper wait
+inline void wait_ms(int milliseconds)
 {
-    using Thread = std::thread;
-
-    // TODO : Proper wait
-    inline void wait_ms(int milliseconds)
-    {
    clock_t start_time = clock();
    while (clock() < start_time + milliseconds)
    {
    }
-    }
-} // namespace Juliet
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <Core/Memory/MemoryArena.h>
+
+struct thread_context
+{
+    Arena* ScratchArenas[2];
+
+    char  ThreadName[64];
+    uint8 ThreadNameSize;
+};
+
+thread_context* thread_context_alloc();
+void            thread_context_release(NonNullPtr<thread_context> ctx);
+void            thread_context_select(NonNullPtr<thread_context> ctx);
+thread_context* thread_context_current();
+
+Arena*               thread_context_get_scratch(Arena** conflicts, size_t count);
+JULIET_API TempArena scratch_begin(Arena** conflicts, size_t count);
+JULIET_API void      scratch_end(TempArena scratch);
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <Core/Common/String.h>
+#include <Graphics/MeshRenderer.h>
+
+JULIET_API extern MeshAssetID LoadMesh(String filename);
@@ -1,33 +1,81 @@
 #pragma once

-#include <Core/Common/CRC32.h>
 #include <Juliet.h>

-namespace Juliet
+#include <Core/Common/CRC32.h>
+#include <Core/Common/String.h>
+
+struct Archive;
+
+using serialize_fct_type = void(Archive&, uint16 version, void* payload);
+using serialize_fct_ptr  = serialize_fct_type*;
+
+using initialize_fct_type = void(void* payload);
+using initialize_fct_ptr  = initialize_fct_type*;
+
+template <typename Type>
+void serialize_thunk(Archive& ar, uint16 version, void* payload)
+{
+    Assert(payload);
+    serialize(ar, version, *((Type*)payload));
+}
+
+template <typename Type>
+void initialize_thunk(void* payload)
+{
+    auto& typed_val = *(Type*)payload;
+    typed_val       = {};
+}
+
+struct Class
 {
-    struct Class
-    {
    uint32             CRC;
+    uint8              kind;
+    uint16             version;
+    const Class*       base_class;
+    initialize_fct_ptr initialize_fct;
+    serialize_fct_ptr  serialize_fct;
+    size_t             size_of;
+    size_t             alignment;
+
 #if JULIET_DEBUG
-        // TODO: string struct may be
-        const char* Name;
-        size_t      Name_Length;
+    String Name;
+#endif
+};
+
+#define DECLARE_CLASS() static Class* kind;
+
+#define DEFINE_CLASS_VERSIONED(cls, version, base_class)                                                               \
+    constexpr Class class_kind_##cls = MakeClass(ConstString(#cls), 0, (version), (base_class), sizeof(cls),           \
+                                                 alignof(cls), (&initialize_thunk<cls>), (&serialize_thunk<cls>));     \
+    Class*          cls::kind        = const_cast<Class*>(&class_kind_##cls);
+
+consteval Class MakeClass(String name, uint8 kind, uint16 version, const Class* base_class, size_t size, size_t align,
+                          initialize_fct_ptr init_fct, serialize_fct_ptr serde_fct)
+{
+    Class cls          = {};
+    cls.CRC            = crc32(name.Str, name.Size);
+    cls.kind           = kind;
+    cls.version        = version;
+    cls.base_class     = base_class;
+    cls.size_of        = size;
+    cls.alignment      = align;
+    cls.initialize_fct = init_fct;
+    cls.serialize_fct  = serde_fct;
+
+#if JULIET_DEBUG
+    cls.Name = name;
 #endif

-        consteval Class(const char* className, size_t name_length)
-        {
-            CRC = crc32(className, name_length);
-#if JULIET_DEBUG
-            // TODO: string struct may be
-            Name        = className;
-            Name_Length = name_length;
-#endif
-        }
-    };
+    return cls;
+}

-    template <typename type>
-    bool IsA(Class& cls)
-    {
-        return cls.CRC == type::StaticClass->CRC;
-    }
-} // namespace Juliet
+bool IsA(const Class& query, const Class* target);
+
+template <typename type>
+bool IsA(const Class& cls)
+{
+    return IsA(cls, type::kind);
+}
+
+JULIET_API void serialize(Archive& ar, NonNullPtr<const Class> cls, void* instance);
@@ -1,12 +1,12 @@
-#pragma once
+#pragma once

 #include <Juliet.h>

 #if JULIET_DEBUG

-namespace Juliet::Debug
+namespace Debug
 {
    JULIET_API void DebugDrawMemoryArena();
-} // namespace Juliet::Debug
+} // namespace Debug

 #endif
@@ -1,22 +1,22 @@
-#pragma once
+#pragma once

 #include <Core/Application/IApplication.h>

-namespace Juliet
-{
-    enum class JulietInit_Flags : uint8;
+enum class JulietInit_Flags : uint8;

-    struct Engine
-    {
+struct Engine
+{
    IApplication* Application   = nullptr;
    Arena*        PlatformArena = nullptr;
-    };
+    Arena*        AssetArena    = nullptr;
+};

-    void InitializeEngine(JulietInit_Flags flags);
-    void ShutdownEngine();
+void InitializeEngine(JulietInit_Flags flags);
+void ShutdownEngine();

-    void LoadApplication(IApplication& app);
-    void UnloadApplication();
+void LoadApplication(IApplication& app);
+void UnloadApplication();

-    void RunEngine();
-} // namespace Juliet
+void RunEngine();
+
+extern Arena* GetPlatformArena();
@@ -1,12 +1,11 @@
-#pragma once
+#pragma once

 #include <Core/Math/Matrix.h>
 #include <Juliet.h>

-namespace Juliet
+struct Camera
 {
-    struct Camera
-    {
+    index_t Index;
    Vector3 Position;
    Vector3 Target;
    Vector3 Up;
@@ -14,20 +13,23 @@ namespace Juliet
    float   AspectRatio;
    float   NearPlane;
    float   FarPlane;
-    };
+};

-    inline Matrix Camera_GetViewMatrix(const Camera& cam)
-    {
+inline Matrix Camera_GetViewMatrix(const Camera& cam)
+{
    return LookAt(cam.Position, cam.Target, cam.Up);
-    }
+}

-    inline Matrix Camera_GetProjectionMatrix(const Camera& cam)
-    {
+inline Matrix Camera_GetProjectionMatrix(const Camera& cam)
+{
    return PerspectiveFov(cam.FOV, cam.AspectRatio, cam.NearPlane, cam.FarPlane);
-    }
+}

-    inline Matrix Camera_GetViewProjectionMatrix(const Camera& cam)
-    {
+inline Matrix Camera_GetViewProjectionMatrix(const Camera& cam)
+{
    return Camera_GetProjectionMatrix(cam) * Camera_GetViewMatrix(cam);
-    }
-} // namespace Juliet
+}
+
+JULIET_API extern void    ReserveCamera(size_t amount);
+JULIET_API extern Camera* GetCurrentCamera();
+JULIET_API extern void    SetCurrentCamera(index_t index);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Patedam	58b79fb499	wip entity deserialization phase 1. Unit test not passing because of globals that assume only one entity manager / game state.	2026-09-10 22:50:18 -04:00
Patedam	615d36b09c	Serialization : started to unify how to allocate entity whether its from MakeEntity or during deserialization.	2026-09-08 23:24:48 -04:00
Patedam	3123d2f2e6	updating serialization tdd with latest changes	2026-09-07 20:05:17 -04:00
Patedam	b1de6ccc49	finishing first step of serialization : the basics	2026-09-07 19:42:15 -04:00
Patedam	a462575af4	ongoing refactor of serialization and various cleanup	2026-09-07 16:58:57 -04:00
Patedam	1a045c3578	updating coding guidelines + plan for full juliet serialization and entity system	2026-09-06 12:08:57 -04:00
Patedam	62e6284976	preparing serialization of entities	2026-09-06 12:08:31 -04:00
Patedam	d7825270ee	crc32: moving to constexpr to prepare for the juliet serializer	2026-09-06 12:04:13 -04:00
Patedam	cb615091ca	Improving entity manager and entity support for a simpler version, made some cleanup on the road to support serialization of world	2026-08-31 23:05:20 -04:00
Patedam	4180622d6a	Removing named namespace from code base.	2026-08-22 21:39:21 -04:00
Patedam	678795b793	calloc to arena	2026-08-16 22:44:52 -04:00
Patedam	4d803fdf77	conversion to arena, missing get asset filename	2026-08-16 22:37:31 -04:00
Patedam	a50e3c75cb	conversion to arena of filesystem	2026-08-16 22:30:40 -04:00
Patedam	262d91dd49	Various conversion to memory arena and misc clean up	2026-08-16 22:10:51 -04:00
Patedam	d1b7c5dbbe	Adding scratch arena for main thread (and any thread in the future) Added some function based on raddbg code for string conversion and more.	2026-08-16 18:06:46 -04:00
Patedam	3e7216f57d	Modified build system to detect pch changes *gemini	2026-08-16 13:13:51 -04:00
Patedam	5566f76a94	Cleaning game.cpp removing old test code. Created static mesh entity Created debug bar	2026-08-10 22:12:31 -04:00
Patedam	ee20c903b2	improved the shader of mesh renderer to make the global lighting better	2026-08-09 18:04:46 -04:00
Patedam	e14931b27b	Merge remote-tracking branch 'origin/main'	2026-08-09 18:00:16 -04:00
Patedam	5bc4375265	Added way to set global light from game. + Some clean up in the mesh renderer	2026-08-09 18:00:05 -04:00
Patedam	fb020d16e5	Some clean up in the mesh renderer	2026-08-09 17:59:37 -04:00
Patedam	73aa4a846b	Entity now can be linked to a mesh. Only support cube generated from code no light no nothing	2026-08-09 17:20:38 -04:00
Patedam	30ea435b87	First iteration of mesh assets	2026-08-09 16:43:35 -04:00
Patedam	697579e72f	Fixing adaptive incremental build. Moved more functions into engine.cpp	2026-08-09 15:48:53 -04:00
Patedam	7c18804df6	Fixing debug display with depth test enabled	2026-08-09 15:28:41 -04:00
Patedam	430cf35345	build fix update	2026-08-09 13:18:19 -04:00
Patedam	1a56c9e99c	Added a debug controller Made a default template for cameras. Added delta to mouse state so we can check delta for debug Camera.	2026-08-09 13:18:04 -04:00
Patedam	ae790f5a9e	moved delta time computation to the HAL	2026-08-09 11:32:06 -04:00
Patedam	d52c77a017	Support of IsKeyPressed that only trigger for the frame it is pressed on.	2026-08-09 11:23:56 -04:00
Patedam	681267f445	removing old vcxproj that was forgotten	2026-08-09 09:54:40 -04:00
Patedam	8582435f21	Shuffled stuff around to make it more efficient and remove redundancy	2026-08-08 23:28:36 -04:00
Patedam	ab158e8b3d	Merged all d3d12 files into one file	2026-08-08 23:06:29 -04:00
Patedam	403e70b14d	fixing random build issue	2026-08-08 18:39:17 -04:00
Patedam	9de4fb5689	renaiming display_private.h to display_cpp.h	2026-08-08 18:05:55 -04:00
Patedam	aa61f3e57c	fix intellisnse when generating project	2026-08-08 14:07:02 -04:00
Patedam	ba563ca642	moving project files into a separate folder. deleting remaining bff ignoring project files from git	2026-08-08 13:05:46 -04:00
Patedam	6c7b7c0124	Removing debug code (put in #if 0 for now) Added a very simple camera system.	2026-08-05 19:12:34 -04:00
Patedam	f122533f92	fixed build_game to use the adaptive build properly	2026-08-04 21:24:10 -04:00
Patedam	cb2114daca	Cleaned up build.bat to be more readable and easier to maintain	2026-08-04 21:18:05 -04:00
Patedam	3065441989	adaptive unity build	2026-08-04 20:53:14 -04:00
Patedam	5eb8fb7e9d	use pch on the project. Removed all include that are now not necessary	2026-08-04 19:31:31 -04:00
Patedam	aabe585696	Move shaders to arena. For now it will use the driver Arena. They should use an "asset" arena eventually	2026-08-03 20:00:36 -04:00
Patedam	e325668650	fixing build issues	2026-08-02 19:53:41 -04:00
Patedam	2d76955cfe	removing include	2026-08-02 19:46:40 -04:00
Patedam	40cb95bc40	fix generate to move imgui vc project out of imgui folder to stop confusing git	2026-08-02 19:46:08 -04:00
Patedam	00036950d6	Converted d3d12 buffers to arena. Using linked list as i'm not sure how many buffers i will use total	2026-08-02 19:33:20 -04:00
Patedam	5862843a40	Convert bunch of alloc into arena push. Made most of the array of pointer fixed size. Could use linked list if needed.	2026-08-02 18:28:51 -04:00
Patedam	0bb2d8d9dc	replaced alloca by temp arena	2026-08-01 19:49:03 -04:00
Patedam	9f6064995f	Reduced Imgui memory usage by implementing a free node list.	2026-08-01 19:16:02 -04:00
Patedam	7b21ca6b1d	Adapting arena push to support format as debug tag Changed some d3d12 to work better with arenas	2026-07-29 14:44:16 -04:00
Patedam	4dc14a04b3	removing useless "realloc" feature in memory arenas	2026-07-28 16:00:39 -04:00
Patedam	4081539ee4	Using memory arena in the game that supports hot reload	2026-07-28 15:44:41 -04:00