diff --git a/CLAUDE.md b/CLAUDE.md
index 22811a3..dfa3f71 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -103,39 +103,67 @@ The shader compilation system automatically discovers `.hlsl` files in `engine/*
 - Shader development: Add HLSL files to module `shaders/` directories, run `cookShaders.py`
 - Asset pipeline: Assets go in `projects/content/` and use `.cook` extensions for processed assets
 
-## Bug Tracking with git-bug
+## Issue Tracking with git-bug
 
-This project uses git-bug for distributed bug tracking. Bug data is stored directly in the git repository.
+This project uses git-bug for distributed issue tracking. Bug data is stored directly in the git repository. While named "git-bug", it can track all types of development work including bugs, features, tasks, and documentation.
 
 ### Common Commands
 
-- `git bug bug` - List all bugs
-- `git bug bug new -t "title" -m "message"` - Create a new bug with title and message
-- `git bug bug show <id>` - Display bug details
-- `git bug bug comment <id>` - Add a comment to a bug
-- `git bug bug status <id>` - Display bug status
-- `git bug bug label new <id> <label>` - Add a label to a bug
-- `git bug bug label rm <id> <label>` - Remove a label from a bug
-- `git bug bug label <id>` - Display labels for a bug
-- `git bug bug status:open` - List only open bugs
-- `git bug pull` - Pull bug updates from remote
-- `git bug push` - Push bug updates to remote
+- `git bug bug` - List all issues
+- `git bug bug new -t "title" -m "message"` - Create a new issue with title and message
+- `git bug bug show <id>` - Display issue details
+- `git bug bug comment <id>` - Add a comment to an issue
+- `git bug bug status <id>` - Display issue status
+- `git bug bug label new <id> <label>` - Add a label to an issue
+- `git bug bug label rm <id> <label>` - Remove a label from an issue
+- `git bug bug label <id>` - Display labels for an issue
+- `git bug bug status:open` - List only open issues
+- `git bug pull` - Pull issue updates from remote
+- `git bug push` - Push issue updates to remote
 
 ### Workflow
 
-- Bugs are stored in the repository and sync with `git bug pull`/`git bug push`
-- Bug IDs can be abbreviated to the first few characters
-- Use labels to categorize bugs by component (e.g., `core`, `rendering`, `physics`, `build-system`)
+- Issues are stored in the repository and sync with `git bug pull`/`git bug push`
+- Issue IDs can be abbreviated to the first few characters
+- Use labels to categorize issues by both type and component
 - Use `--non-interactive` flag for scripting
-- Keep bug descriptions factual - describe what happens, not speculation about why
+- Keep issue descriptions factual and clear
 
 ### Standard Labels
 
-Use these standard labels to categorize bugs:
+Use these standard labels to categorize issues:
 
-- **Component labels**: `core`, `rendering`, `physics`, `build-system`, `platform`, `assets`, `audio`, `ui`
-- **Type labels**:
+- **Component labels**: `core`, `rendering`, `physics`, `build-system`, `platform`, `assets`, `audio`, `ui`, `documentation`
+- **Issue type labels**:
+  - `bug` - Defects, errors, or incorrect behavior
+  - `feature` - New functionality to implement
+  - `enhancement` - Improvements to existing features
+  - `task` - General development work items
+  - `documentation` - Documentation improvements or additions
+  - `question` - Design decisions or technical discussions
+  - `refactoring` - Code cleanup and restructuring
+- **Problem type labels** (for bugs):
   - `memory` - Memory allocation, leaks, or performance issues
   - `threading` - Job system, parallelization, race conditions, or deadlocks
   - `crash` - Application crashes or critical failures
-  - `build` - Build system or compilation issues
\ No newline at end of file
+  - `build` - Build system or compilation issues
+
+### Examples
+
+```bash
+# Create a feature request
+git bug bug new -t "Add procedural terrain generation" -m "Implement heightmap-based terrain system"
+git bug bug label new <id> feature rendering
+
+# Create a task
+git bug bug new -t "Update to Zig 0.15" -m "Migrate codebase to latest Zig version"
+git bug bug label new <id> task build-system
+
+# Create a documentation issue
+git bug bug new -t "Document shader pipeline" -m "Add comprehensive guide for shader development workflow"
+git bug bug label new <id> documentation rendering
+
+# Create a bug report
+git bug bug new -t "Memory leak in asset loader" -m "Assets not freed when unloading scenes"
+git bug bug label new <id> bug assets memory
+```
\ No newline at end of file
diff --git a/depot/.gitignore b/depot/.gitignore
new file mode 100644
index 0000000..fd494e6
--- /dev/null
+++ b/depot/.gitignore
@@ -0,0 +1,2 @@
+.fontcache/
+Saved/
diff --git a/depot/build.zig b/depot/build.zig
index 6f53928..71ade37 100644
--- a/depot/build.zig
+++ b/depot/build.zig
@@ -12,24 +12,24 @@ pub fn build(b: *std.Build) void {
     });
 
     // blbuild.addDependencyInstalls(b, .ReleaseFast); //.ReleaseFast);
-    const exileMain = blbuild.program(.{
-        .name = "exileMain",
+    const zuck = blbuild.program(.{
+        .name = "zuck",
         .desc = "A tiny shooter made with this engine.",
-        .root_source_file = b.path("src/main.zig"),
+        .root_source_file = b.path("zuck/main.zig"),
     });
 
-    exileMain.setModuleEnabled("imgui", true);
-    exileMain.setModuleEnabled("audio", true);
-    exileMain.setModuleEnabled("physics", true);
-    exileMain.setModuleEnabled("ui", true);
-    exileMain.setModuleEnabled("sys", true);
-    exileMain.setModuleEnabled("net", true);
+    zuck.setModuleEnabled("imgui", true);
+    zuck.setModuleEnabled("audio", true);
+    zuck.setModuleEnabled("physics", true);
+    zuck.setModuleEnabled("ui", true);
+    zuck.setModuleEnabled("sys", true);
+    zuck.setModuleEnabled("net", true);
+    zuck.addExtraModule("gameExtras");
 
     {
-        const exileGame = exileMain.addDynamicModule("exileGame", b.path("src/exileGame.zig"));
-
-        _ = exileGame.compileInstall();
+        const zuckGame = zuck.addDynamicModule("zuckGame", b.path("zuck/game.zig"));
+        _ = zuckGame.compileInstall();
     }
 
-    _ = exileMain.compileInstall();
+    _ = zuck.compileInstall();
 }
diff --git a/depot/build.zig.zon b/depot/build.zig.zon
index 76e286b..d18e07f 100644
--- a/depot/build.zig.zon
+++ b/depot/build.zig.zon
@@ -18,9 +18,6 @@
         .SpirvReflect = .{ .path = "../lib/spirv-reflect-zig" },
 
         .gameExtras = .{.path = "../extras/gameExtras"},
-        .videoplayer = .{.path = "../extras/videoplayer"},
-        .doomplayer = .{.path = "../extras/doomplayer"},
-        .bsp = .{.path = "../extras/bsp"},
 
         .zphysics = .{.path = "../lib/zphysics"},
         .spng = .{ .path = "../lib/spng" },
@@ -34,4 +31,5 @@
     .paths = .{
         "",
     },
+    .fingerprint = 0x14099f73bcfb78d8,
 }
diff --git a/depot/content/_shaders/dxil/debug.frag.dxil b/depot/content/_shaders/dxil/debug.frag.dxil
new file mode 100644
index 0000000..d8cf8b2
Binary files /dev/null and b/depot/content/_shaders/dxil/debug.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/debug.vert.dxil b/depot/content/_shaders/dxil/debug.vert.dxil
new file mode 100644
index 0000000..89a9c46
Binary files /dev/null and b/depot/content/_shaders/dxil/debug.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/depthOnly.frag.dxil b/depot/content/_shaders/dxil/depthOnly.frag.dxil
new file mode 100644
index 0000000..b03e545
Binary files /dev/null and b/depot/content/_shaders/dxil/depthOnly.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/lit_mesh.frag.dxil b/depot/content/_shaders/dxil/lit_mesh.frag.dxil
new file mode 100644
index 0000000..e86567e
Binary files /dev/null and b/depot/content/_shaders/dxil/lit_mesh.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/meshes.vert.dxil b/depot/content/_shaders/dxil/meshes.vert.dxil
new file mode 100644
index 0000000..562754a
Binary files /dev/null and b/depot/content/_shaders/dxil/meshes.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/postProc.frag.dxil b/depot/content/_shaders/dxil/postProc.frag.dxil
new file mode 100644
index 0000000..c55772c
Binary files /dev/null and b/depot/content/_shaders/dxil/postProc.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/postProc.vert.dxil b/depot/content/_shaders/dxil/postProc.vert.dxil
new file mode 100644
index 0000000..ce70167
Binary files /dev/null and b/depot/content/_shaders/dxil/postProc.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/rect.frag.dxil b/depot/content/_shaders/dxil/rect.frag.dxil
new file mode 100644
index 0000000..768208b
Binary files /dev/null and b/depot/content/_shaders/dxil/rect.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/rect.vert.dxil b/depot/content/_shaders/dxil/rect.vert.dxil
new file mode 100644
index 0000000..a1d162e
Binary files /dev/null and b/depot/content/_shaders/dxil/rect.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/sample.frag.dxil b/depot/content/_shaders/dxil/sample.frag.dxil
new file mode 100644
index 0000000..6115e3a
Binary files /dev/null and b/depot/content/_shaders/dxil/sample.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/sample.vert.dxil b/depot/content/_shaders/dxil/sample.vert.dxil
new file mode 100644
index 0000000..fdabb15
Binary files /dev/null and b/depot/content/_shaders/dxil/sample.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/skybox.frag.dxil b/depot/content/_shaders/dxil/skybox.frag.dxil
new file mode 100644
index 0000000..f75744d
Binary files /dev/null and b/depot/content/_shaders/dxil/skybox.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/skybox.vert.dxil b/depot/content/_shaders/dxil/skybox.vert.dxil
new file mode 100644
index 0000000..280990d
Binary files /dev/null and b/depot/content/_shaders/dxil/skybox.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/ssao.frag.dxil b/depot/content/_shaders/dxil/ssao.frag.dxil
new file mode 100644
index 0000000..165af91
Binary files /dev/null and b/depot/content/_shaders/dxil/ssao.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/test.vert.dxil b/depot/content/_shaders/dxil/test.vert.dxil
new file mode 100644
index 0000000..a29b0fe
Binary files /dev/null and b/depot/content/_shaders/dxil/test.vert.dxil differ
diff --git a/depot/content/_shaders/dxil/text.frag.dxil b/depot/content/_shaders/dxil/text.frag.dxil
new file mode 100644
index 0000000..20db0d8
Binary files /dev/null and b/depot/content/_shaders/dxil/text.frag.dxil differ
diff --git a/depot/content/_shaders/dxil/text.vert.dxil b/depot/content/_shaders/dxil/text.vert.dxil
new file mode 100644
index 0000000..1ddba0c
Binary files /dev/null and b/depot/content/_shaders/dxil/text.vert.dxil differ
diff --git a/depot/content/_shaders/msl/debug.frag.msl b/depot/content/_shaders/msl/debug.frag.msl
new file mode 100644
index 0000000..929e58a
--- /dev/null
+++ b/depot/content/_shaders/msl/debug.frag.msl
@@ -0,0 +1,25 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+    float4 out_var_SV_Target1 [[color(1)]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]])
+{
+    main0_out out = {};
+    float4 _20 = float4(in.in_var_TEXCOORD0 * 4.0, 1.0);
+    out.out_var_SV_Target0 = _20;
+    out.out_var_SV_Target1 = _20;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/debug.vert.msl b/depot/content/_shaders/msl/debug.vert.msl
new file mode 100644
index 0000000..8dd4b36
--- /dev/null
+++ b/depot/content/_shaders/msl/debug.vert.msl
@@ -0,0 +1,40 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float4x4 Model;
+    float4 Color;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+struct type_Uniforms
+{
+    float4x4 ViewProjection;
+};
+
+struct main0_out
+{
+    float3 out_var_TEXCOORD0 [[user(locn0)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[attribute(0)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_Scene& scene [[buffer(1)]], uint gl_InstanceIndex [[instance_id]])
+{
+    main0_out out = {};
+    out.out_var_TEXCOORD0 = scene._m0[gl_InstanceIndex].Color.xyz;
+    out.gl_Position = Uniforms.ViewProjection * (scene._m0[gl_InstanceIndex].Model * float4(in.in_var_TEXCOORD0, 1.0));
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/depthOnly.frag.msl b/depot/content/_shaders/msl/depthOnly.frag.msl
new file mode 100644
index 0000000..e221fab
--- /dev/null
+++ b/depot/content/_shaders/msl/depthOnly.frag.msl
@@ -0,0 +1,17 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+fragment main0_out main0()
+{
+    main0_out out = {};
+    out.out_var_SV_Target0 = float4(1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/lit_mesh.frag.msl b/depot/content/_shaders/msl/lit_mesh.frag.msl
new file mode 100644
index 0000000..d8f157a
--- /dev/null
+++ b/depot/content/_shaders/msl/lit_mesh.frag.msl
@@ -0,0 +1,198 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct type_Uniforms
+{
+    float4 viewPos;
+    float4 lightPosition;
+    float4 directionalLight;
+    float4 directionalLightColor;
+    float2 screenSize;
+    float lightPower;
+    float time;
+};
+
+struct Scene
+{
+    float4x4 Model;
+    uint textureMode;
+    int animation;
+    uint flags;
+    float float0;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+constant float4 _92 = {};
+constant float3 _94 = {};
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+    float4 out_var_SV_Target1 [[color(1)]];
+    float4 out_var_SV_Target2 [[color(2)]];
+    float4 out_var_SV_Target3 [[color(3)]];
+};
+
+struct main0_in
+{
+    float2 in_var_TEXCOORD0 [[user(locn0)]];
+    float3 in_var_TEXCOORD1 [[user(locn1)]];
+    float3 in_var_TEXCOORD2 [[user(locn2)]];
+    float4 in_var_TEXCOORD3 [[user(locn3)]];
+    uint in_var_TEXCOORD4 [[user(locn4)]];
+    float3 in_var_TEXCOORD5 [[user(locn5)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_Scene& scene [[buffer(1)]], texture2d<float> Texture0 [[texture(0)]], texture2d<float> Texture1 [[texture(1)]], texture2d<float> Texture2 [[texture(2)]], texture2d<float> DirectionalShadowDepthMap [[texture(3)]], sampler Sampler0 [[sampler(0)]], sampler Sampler1 [[sampler(1)]], sampler Sampler2 [[sampler(2)]], sampler DirectionalShadowSampler [[sampler(3)]])
+{
+    main0_out out = {};
+    int _104 = int(scene._m0[in.in_var_TEXCOORD4].textureMode);
+    int _105 = _104 & 240;
+    float4 _139;
+    if (_105 == 16)
+    {
+        float3 _126 = float3(Texture0.sample(Sampler0, in.in_var_TEXCOORD0).x, Texture1.sample(Sampler1, in.in_var_TEXCOORD0).x, Texture2.sample(Sampler2, in.in_var_TEXCOORD0).x) + float3(-0.0625, -0.5, -0.5);
+        _139 = float4(dot(_126, float3(1.164000034332275390625, 0.0, 1.7929999828338623046875)), dot(_126, float3(1.164000034332275390625, -0.212999999523162841796875, -0.53299999237060546875)), dot(_126, float3(1.164000034332275390625, 2.111999988555908203125, 0.0)), 1.0);
+    }
+    else
+    {
+        float4 _138;
+        if (_105 == 0)
+        {
+            _138 = Texture0.sample(Sampler0, in.in_var_TEXCOORD0);
+        }
+        else
+        {
+            _138 = _92;
+        }
+        _139 = _138;
+    }
+    float4 _145;
+    if ((_104 & 1) == 1)
+    {
+        _145 = powr(_139, float4(2.2000000476837158203125));
+    }
+    else
+    {
+        _145 = _139;
+    }
+    if (_145.w < 0.00999999977648258209228515625)
+    {
+        discard_fragment();
+    }
+    float3 _155 = float3(0.800000011920928955078125, 0.800000011920928955078125, 0.5) * Uniforms.lightPower;
+    float3 _202;
+    do
+    {
+        float3 _159 = Uniforms.lightPosition.xyz - in.in_var_TEXCOORD1;
+        float _160 = length(_159);
+        float _161 = _160 * _160;
+        float _167;
+        if (_160 > 2.0)
+        {
+            _167 = 0.5 / _161;
+        }
+        else
+        {
+            _167 = 1.0 / _161;
+        }
+        float _172;
+        if (_160 > 4.0)
+        {
+            _172 = _167 * 0.5;
+        }
+        else
+        {
+            _172 = _167;
+        }
+        float _174 = (_160 > 15.0) ? 0.0 : _172;
+        float _176 = (_174 > 1.0) ? 1.0 : _174;
+        if (length(in.in_var_TEXCOORD2) < 0.100000001490116119384765625)
+        {
+            _202 = (in.in_var_TEXCOORD1 * _155) * _176;
+            break;
+        }
+        float3 _183 = fast::normalize(_159);
+        _202 = ((_155 * precise::max(dot(_183, in.in_var_TEXCOORD2), 0.0)) * _176) + (((_155 * powr(precise::max(dot(in.in_var_TEXCOORD2, fast::normalize(_183 + fast::normalize(in.in_var_TEXCOORD1 - Uniforms.viewPos.xyz))), 0.0), 30.0)) * 2.0) * _176);
+        break;
+    } while(false);
+    float3 _219 = ((in.in_var_TEXCOORD3.xyz / float3(in.in_var_TEXCOORD3.w)) * 0.5) + float3(0.5);
+    float3 _221;
+    _221.x = _219.x;
+    float2 _222 = _221.xy;
+    _222.y = -_219.y;
+    float _229;
+    int _232;
+    int _234;
+    _229 = 0.0;
+    _232 = 0;
+    _234 = -2;
+    float _230;
+    int _233;
+    for (; _234 <= 2; _229 = _230, _232 = _233, _234++)
+    {
+        _233 = _232;
+        _230 = _229;
+        for (int _243 = -2; _243 <= 2; )
+        {
+            _233++;
+            _230 += float((in.in_var_TEXCOORD3.z - 0.0030000000260770320892333984375) > DirectionalShadowDepthMap.sample(DirectionalShadowSampler, (_222 + float2(float(_243) * 0.000244140625, float(_234) * 0.000244140625))).x);
+            _243++;
+            continue;
+        }
+    }
+    float3 _272;
+    if ((_104 & 2) > 0)
+    {
+        _272 = powr(_145.xyz, float3(0.4545454680919647216796875));
+    }
+    else
+    {
+        _272 = _145.xyz * ((float3(0.100000001490116119384765625) + _202) + ((Uniforms.directionalLightColor.xyz * precise::max(dot(Uniforms.directionalLight.xyz, in.in_var_TEXCOORD2), 0.0)) * (1.0 - (_229 / float(_232)))));
+    }
+    float4 _289;
+    if (_272.x > 1.0)
+    {
+        float4 _288 = float4(0.0);
+        _288.x = _272.x;
+        _289 = _288;
+    }
+    else
+    {
+        _289 = float4(0.0);
+    }
+    float4 _294;
+    if (_272.y > 1.0)
+    {
+        float4 _293 = _289;
+        _293.y = _272.y;
+        _294 = _293;
+    }
+    else
+    {
+        _294 = _289;
+    }
+    float4 _299;
+    if (_272.z > 1.0)
+    {
+        float4 _298 = _294;
+        _298.z = _272.z;
+        _299 = _298;
+    }
+    else
+    {
+        _299 = _294;
+    }
+    out.out_var_SV_Target0 = float4(_272, _145.w);
+    out.out_var_SV_Target1 = _299;
+    out.out_var_SV_Target2 = float4(in.in_var_TEXCOORD1, 1.0);
+    out.out_var_SV_Target3 = float4(in.in_var_TEXCOORD5, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/meshes.vert.msl b/depot/content/_shaders/msl/meshes.vert.msl
new file mode 100644
index 0000000..1cf9fc6
--- /dev/null
+++ b/depot/content/_shaders/msl/meshes.vert.msl
@@ -0,0 +1,119 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float4x4 Model;
+    uint textureMode;
+    int animation;
+    uint flags;
+    float float0;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+struct BoneTransform
+{
+    float4x4 final;
+};
+
+struct type_StructuredBuffer_BoneTransform
+{
+    BoneTransform _m0[1];
+};
+
+struct type_Uniforms
+{
+    float4x4 ViewProjection;
+    float4x4 NoTranslateView;
+    float4x4 ViewTransform;
+    float4x4 ShadowMapProjection;
+    float4 cameraPosition;
+    float time;
+};
+
+struct main0_out
+{
+    float2 out_var_TEXCOORD0 [[user(locn0)]];
+    float3 out_var_TEXCOORD1 [[user(locn1)]];
+    float3 out_var_TEXCOORD2 [[user(locn2)]];
+    float4 out_var_TEXCOORD3 [[user(locn3)]];
+    uint out_var_TEXCOORD4 [[user(locn4)]];
+    float3 out_var_TEXCOORD5 [[user(locn5)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[attribute(0)]];
+    float3 in_var_TEXCOORD1 [[attribute(1)]];
+    float2 in_var_TEXCOORD3 [[attribute(3)]];
+    uint in_var_TEXCOORD4 [[attribute(4)]];
+    uint in_var_TEXCOORD5 [[attribute(5)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_Scene& scene [[buffer(1)]], const device type_StructuredBuffer_BoneTransform& animationBuffer [[buffer(2)]], uint gl_InstanceIndex [[instance_id]])
+{
+    main0_out out = {};
+    float3 _111;
+    if (scene._m0[gl_InstanceIndex].animation != (-1))
+    {
+        float3 _83;
+        _83 = float3(0.0);
+        for (int _86 = 0; _86 < 4; )
+        {
+            uint _92 = (8u * uint(_86)) & 31u;
+            _83 += ((animationBuffer._m0[uint(scene._m0[gl_InstanceIndex].animation) + ((in.in_var_TEXCOORD4 >> _92) & 255u)].final * float4(in.in_var_TEXCOORD0, 1.0)).xyz * (float((in.in_var_TEXCOORD5 >> _92) & 255u) * 0.0039215688593685626983642578125));
+            _86++;
+            continue;
+        }
+        _111 = _83;
+    }
+    else
+    {
+        _111 = in.in_var_TEXCOORD0;
+    }
+    float4 _115 = float4(_111, 1.0);
+    float3 _207;
+    float3 _208;
+    float3 _209;
+    float4 _210;
+    float4 _211;
+    if (int(scene._m0[gl_InstanceIndex].flags & 4u) > 0)
+    {
+        float3 _127 = (scene._m0[gl_InstanceIndex].Model * float4(0.0, 0.0, 0.0, 1.0)).xyz;
+        float3 _132 = fast::normalize(Uniforms.cameraPosition.xyz - _127);
+        float3 _134 = fast::normalize(cross(float3(0.0, 1.0, 0.0), _132));
+        float4 _152 = float4((_127 + ((_134 * (-in.in_var_TEXCOORD0.x)) * scene._m0[gl_InstanceIndex].float0)) + ((cross(_132, _134) * in.in_var_TEXCOORD0.y) * scene._m0[gl_InstanceIndex].float0), 1.0);
+        _207 = _152.xyz;
+        _208 = _132;
+        _209 = float3(0.0, 0.0, 1.0);
+        _210 = Uniforms.ViewProjection * _152;
+        _211 = _152;
+    }
+    else
+    {
+        float4 _159 = scene._m0[gl_InstanceIndex].Model * _115;
+        float4x4 _194 = float4x4(float4(fast::normalize(float3(scene._m0[gl_InstanceIndex].Model[0][0], scene._m0[gl_InstanceIndex].Model[1][0], scene._m0[gl_InstanceIndex].Model[2][0])), 0.0), float4(fast::normalize(float3(scene._m0[gl_InstanceIndex].Model[0][1], scene._m0[gl_InstanceIndex].Model[1][1], scene._m0[gl_InstanceIndex].Model[2][1])), 0.0), float4(fast::normalize(float3(scene._m0[gl_InstanceIndex].Model[0][2], scene._m0[gl_InstanceIndex].Model[1][2], scene._m0[gl_InstanceIndex].Model[2][2])), 0.0), float4(0.0, 0.0, 0.0, 1.0));
+        float4 _198 = float4(in.in_var_TEXCOORD1, 1.0);
+        _207 = _159.xyz;
+        _208 = fast::normalize(_198 * _194).xyz;
+        _209 = (_198 * (_194 * transpose(Uniforms.NoTranslateView))).xyz;
+        _210 = Uniforms.ViewProjection * (scene._m0[gl_InstanceIndex].Model * _115);
+        _211 = _159;
+    }
+    out.out_var_TEXCOORD0 = in.in_var_TEXCOORD3;
+    out.out_var_TEXCOORD1 = _207;
+    out.out_var_TEXCOORD2 = _208;
+    out.out_var_TEXCOORD3 = Uniforms.ShadowMapProjection * _211;
+    out.out_var_TEXCOORD4 = gl_InstanceIndex;
+    out.out_var_TEXCOORD5 = _209;
+    out.gl_Position = _210;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/postProc.frag.msl b/depot/content/_shaders/msl/postProc.frag.msl
new file mode 100644
index 0000000..1c59719
--- /dev/null
+++ b/depot/content/_shaders/msl/postProc.frag.msl
@@ -0,0 +1,59 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 in_var_TEXCOORD0 [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], texture2d<float> ColorTexture [[texture(0)]], texture2d<float> EmissiveTexture [[texture(1)]], texture2d<float> SsaoTexture [[texture(2)]], sampler Sampler0 [[sampler(0)]], sampler Sampler1 [[sampler(1)]], sampler Sampler2 [[sampler(2)]])
+{
+    main0_out out = {};
+    float2 _51 = in.in_var_TEXCOORD0;
+    _51.y = (_51.y * (-1.0)) + 1.0;
+    float4 _59 = ColorTexture.sample(Sampler0, _51);
+    float3 _60 = _59.xyz;
+    float3 _74;
+    int _77;
+    _74 = EmissiveTexture.sample(Sampler1, _51).xyz * 0.2270270287990570068359375;
+    _77 = 0;
+    float3 _75;
+    for (; _77 < 5; _74 = _75, _77++)
+    {
+        _75 = _74;
+        for (int _85 = 0; _85 < 5; )
+        {
+            float2 _93 = float2(float(_77) - 2.5, float(_85)) * float2(0.001953125);
+            _75 = (_75 + (EmissiveTexture.sample(Sampler1, (_51 + _93)).xyz * float3(0.039999999105930328369140625))) + (EmissiveTexture.sample(Sampler1, (_51 - _93)).xyz * float3(0.039999999105930328369140625));
+            _85++;
+            continue;
+        }
+    }
+    float3 _109;
+    int _112;
+    _109 = float3(0.0);
+    _112 = 0;
+    float3 _110;
+    for (; _112 < 5; _109 = _110, _112++)
+    {
+        _110 = _109;
+        for (int _120 = 0; _120 < 5; )
+        {
+            float2 _128 = float2(float(_112) - 2.5, float(_120)) * float2(0.0009765625);
+            _110 = (_110 + (SsaoTexture.sample(Sampler2, (_51 + _128)).xyz * float3(0.0199999995529651641845703125))) + (SsaoTexture.sample(Sampler2, (_51 - _128)).xyz * float3(0.0199999995529651641845703125));
+            _120++;
+            continue;
+        }
+    }
+    float3 _142 = ((powr((_60 * (float3(1.0) + (_60 * float3(0.00999999977648258209228515625)))) / (float3(1.0) + _60), float3(0.4545454680919647216796875)) + (_74 * 0.0500000007450580596923828125)) * 1.0) * _109;
+    out.out_var_SV_Target0 = float4(((_142.x * (1.0 + (9.9999999747524270787835121154785e-07 * EmissiveTexture.sample(Sampler1, _51).x))) * (1.0 + (9.9999999747524270787835121154785e-07 * ColorTexture.sample(Sampler0, _51).x))) * (1.0 + (9.9999999747524270787835121154785e-07 * SsaoTexture.sample(Sampler2, _51).x)), _142.yz, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/postProc.vert.msl b/depot/content/_shaders/msl/postProc.vert.msl
new file mode 100644
index 0000000..ecdc597
--- /dev/null
+++ b/depot/content/_shaders/msl/postProc.vert.msl
@@ -0,0 +1,25 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float2 out_var_TEXCOORD0 [[user(locn0)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[attribute(0)]];
+    float2 in_var_TEXCOORD3 [[attribute(3)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]])
+{
+    main0_out out = {};
+    out.out_var_TEXCOORD0 = in.in_var_TEXCOORD3;
+    out.gl_Position = float4(in.in_var_TEXCOORD0, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/rect.frag.msl b/depot/content/_shaders/msl/rect.frag.msl
new file mode 100644
index 0000000..497baf5
--- /dev/null
+++ b/depot/content/_shaders/msl/rect.frag.msl
@@ -0,0 +1,259 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float2 imagePosition;
+    float2 _imageSize;
+    float2 anchorPoint;
+    float2 scale;
+    float alpha;
+    float borderWidth;
+    uint flags;
+    float4 baseColor;
+    float4 rounding;
+    float4 edgeColor;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+struct main0_in
+{
+    float4 in_var_TEXCOORD0 [[user(locn0)]];
+    float2 in_var_TEXCOORD1 [[user(locn1)]];
+    float2 in_var_TEXCOORD2 [[user(locn2)]];
+    uint in_var_TEXCOORD3 [[user(locn3)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_Scene& scene [[buffer(0)]], texture2d<float> Texture0 [[texture(0)]], sampler Sampler0 [[sampler(0)]])
+{
+    main0_out out = {};
+    bool _71 = in.in_var_TEXCOORD2.x < scene._m0[in.in_var_TEXCOORD3].rounding.x;
+    bool _78;
+    if (_71)
+    {
+        _78 = in.in_var_TEXCOORD2.y < scene._m0[in.in_var_TEXCOORD3].rounding.y;
+    }
+    else
+    {
+        _78 = false;
+    }
+    float _95;
+    float3 _96;
+    if (_78)
+    {
+        float _82 = distance(in.in_var_TEXCOORD2, float2(scene._m0[in.in_var_TEXCOORD3].rounding.x));
+        float _93;
+        float3 _94;
+        if (_82 > scene._m0[in.in_var_TEXCOORD3].rounding.x)
+        {
+            discard_fragment();
+        }
+        else
+        {
+            if (abs(_82 - scene._m0[in.in_var_TEXCOORD3].rounding.x) < 1.0)
+            {
+                _93 = scene._m0[in.in_var_TEXCOORD3].edgeColor.w;
+                _94 = scene._m0[in.in_var_TEXCOORD3].edgeColor.xyz;
+            }
+            else
+            {
+                _93 = scene._m0[in.in_var_TEXCOORD3].alpha;
+                _94 = in.in_var_TEXCOORD0.xyz;
+            }
+        }
+        _95 = _93;
+        _96 = _94;
+    }
+    else
+    {
+        _95 = scene._m0[in.in_var_TEXCOORD3].alpha;
+        _96 = in.in_var_TEXCOORD0.xyz;
+    }
+    float _99 = scene._m0[in.in_var_TEXCOORD3]._imageSize.x - scene._m0[in.in_var_TEXCOORD3].rounding.y;
+    bool _106;
+    if (in.in_var_TEXCOORD2.x > _99)
+    {
+        _106 = in.in_var_TEXCOORD2.y < scene._m0[in.in_var_TEXCOORD3].rounding.y;
+    }
+    else
+    {
+        _106 = false;
+    }
+    float _123;
+    float3 _124;
+    if (_106)
+    {
+        float _110 = distance(in.in_var_TEXCOORD2, float2(_99, scene._m0[in.in_var_TEXCOORD3].rounding.y));
+        float _121;
+        float3 _122;
+        if (_110 > scene._m0[in.in_var_TEXCOORD3].rounding.y)
+        {
+            discard_fragment();
+        }
+        else
+        {
+            if (abs(_110 - scene._m0[in.in_var_TEXCOORD3].rounding.y) < 1.0)
+            {
+                _121 = scene._m0[in.in_var_TEXCOORD3].edgeColor.w;
+                _122 = scene._m0[in.in_var_TEXCOORD3].edgeColor.xyz;
+            }
+            else
+            {
+                _121 = _95;
+                _122 = _96;
+            }
+        }
+        _123 = _121;
+        _124 = _122;
+    }
+    else
+    {
+        _123 = _95;
+        _124 = _96;
+    }
+    bool _132;
+    if (_71)
+    {
+        _132 = in.in_var_TEXCOORD2.y > (scene._m0[in.in_var_TEXCOORD3]._imageSize.y - scene._m0[in.in_var_TEXCOORD3].rounding.y);
+    }
+    else
+    {
+        _132 = false;
+    }
+    float _151;
+    float3 _152;
+    if (_132)
+    {
+        float _138 = distance(in.in_var_TEXCOORD2, float2(scene._m0[in.in_var_TEXCOORD3].rounding.x, scene._m0[in.in_var_TEXCOORD3]._imageSize.y - scene._m0[in.in_var_TEXCOORD3].rounding.y));
+        float _149;
+        float3 _150;
+        if (_138 > scene._m0[in.in_var_TEXCOORD3].rounding.y)
+        {
+            discard_fragment();
+        }
+        else
+        {
+            if (abs(_138 - scene._m0[in.in_var_TEXCOORD3].rounding.y) < 1.0)
+            {
+                _149 = scene._m0[in.in_var_TEXCOORD3].edgeColor.w;
+                _150 = scene._m0[in.in_var_TEXCOORD3].edgeColor.xyz;
+            }
+            else
+            {
+                _149 = _123;
+                _150 = _124;
+            }
+        }
+        _151 = _149;
+        _152 = _150;
+    }
+    else
+    {
+        _151 = _123;
+        _152 = _124;
+    }
+    bool _163;
+    if (in.in_var_TEXCOORD2.x > (scene._m0[in.in_var_TEXCOORD3]._imageSize.x - scene._m0[in.in_var_TEXCOORD3].rounding.w))
+    {
+        _163 = (scene._m0[in.in_var_TEXCOORD3]._imageSize.y - in.in_var_TEXCOORD2.y) < scene._m0[in.in_var_TEXCOORD3].rounding.w;
+    }
+    else
+    {
+        _163 = false;
+    }
+    float _183;
+    float3 _184;
+    if (_163)
+    {
+        float _170 = distance(in.in_var_TEXCOORD2, float2(scene._m0[in.in_var_TEXCOORD3]._imageSize.x - scene._m0[in.in_var_TEXCOORD3].rounding.x, scene._m0[in.in_var_TEXCOORD3]._imageSize.y - scene._m0[in.in_var_TEXCOORD3].rounding.y));
+        float _181;
+        float3 _182;
+        if (_170 > scene._m0[in.in_var_TEXCOORD3].rounding.y)
+        {
+            discard_fragment();
+        }
+        else
+        {
+            if (abs(_170 - scene._m0[in.in_var_TEXCOORD3].rounding.y) < 1.0)
+            {
+                _181 = scene._m0[in.in_var_TEXCOORD3].edgeColor.w;
+                _182 = scene._m0[in.in_var_TEXCOORD3].edgeColor.xyz;
+            }
+            else
+            {
+                _181 = _151;
+                _182 = _152;
+            }
+        }
+        _183 = _181;
+        _184 = _182;
+    }
+    else
+    {
+        _183 = _151;
+        _184 = _152;
+    }
+    bool _191;
+    if (!(in.in_var_TEXCOORD2.x < scene._m0[in.in_var_TEXCOORD3].borderWidth))
+    {
+        _191 = in.in_var_TEXCOORD2.x > (scene._m0[in.in_var_TEXCOORD3]._imageSize.x - scene._m0[in.in_var_TEXCOORD3].borderWidth);
+    }
+    else
+    {
+        _191 = true;
+    }
+    bool _198;
+    if (!_191)
+    {
+        _198 = in.in_var_TEXCOORD2.y < scene._m0[in.in_var_TEXCOORD3].borderWidth;
+    }
+    else
+    {
+        _198 = true;
+    }
+    bool _207;
+    if (!_198)
+    {
+        _207 = in.in_var_TEXCOORD2.y > (scene._m0[in.in_var_TEXCOORD3]._imageSize.y - scene._m0[in.in_var_TEXCOORD3].borderWidth);
+    }
+    else
+    {
+        _207 = true;
+    }
+    float _212;
+    float3 _213;
+    if (_207)
+    {
+        _212 = scene._m0[in.in_var_TEXCOORD3].edgeColor.w;
+        _213 = scene._m0[in.in_var_TEXCOORD3].edgeColor.xyz;
+    }
+    else
+    {
+        _212 = _183;
+        _213 = _184;
+    }
+    float4 _238;
+    if ((scene._m0[in.in_var_TEXCOORD3].flags & 1u) > 0u)
+    {
+        float4 _227 = Texture0.sample(Sampler0, float2(in.in_var_TEXCOORD1.x, 1.0 - in.in_var_TEXCOORD1.y));
+        _238 = float4(_227.xyz, _227.w * _212);
+    }
+    else
+    {
+        _238 = float4(_213, _212);
+    }
+    out.out_var_SV_Target0 = _238;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/rect.vert.msl b/depot/content/_shaders/msl/rect.vert.msl
new file mode 100644
index 0000000..477773d
--- /dev/null
+++ b/depot/content/_shaders/msl/rect.vert.msl
@@ -0,0 +1,62 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float2 imagePosition;
+    float2 _imageSize;
+    float2 anchorPoint;
+    float2 scale;
+    float alpha;
+    float borderWidth;
+    uint flags;
+    float4 baseColor;
+    float4 rounding;
+    float4 edgeColor;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+struct type_Uniforms
+{
+    float2 Extents;
+};
+
+struct main0_out
+{
+    float4 out_var_TEXCOORD0 [[user(locn0)]];
+    float2 out_var_TEXCOORD1 [[user(locn1)]];
+    float2 out_var_TEXCOORD2 [[user(locn2)]];
+    uint out_var_TEXCOORD3 [[user(locn3)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[attribute(0)]];
+    float2 in_var_TEXCOORD3 [[attribute(3)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_Scene& scene [[buffer(1)]], uint gl_InstanceIndex [[instance_id]])
+{
+    main0_out out = {};
+    float2 _63 = scene._m0[gl_InstanceIndex]._imageSize / Uniforms.Extents;
+    float2 _69 = (((scene._m0[gl_InstanceIndex].imagePosition / Uniforms.Extents) * 2.0) - float2(1.0)) - ((scene._m0[gl_InstanceIndex].anchorPoint * _63) * scene._m0[gl_InstanceIndex].scale);
+    float _85 = _69.y + ((in.in_var_TEXCOORD0.y * _63.y) * scene._m0[gl_InstanceIndex].scale.y);
+    float4 _88 = float4(_69.x + ((in.in_var_TEXCOORD0.x * _63.x) * scene._m0[gl_InstanceIndex].scale.x), _85, in.in_var_TEXCOORD0.z, 1.0);
+    _88.y = -_85;
+    float2 _100 = ((in.in_var_TEXCOORD0.xy - scene._m0[gl_InstanceIndex].anchorPoint) * float2(0.5)) * scene._m0[gl_InstanceIndex]._imageSize;
+    _100.y = scene._m0[gl_InstanceIndex]._imageSize.y - _100.y;
+    out.out_var_TEXCOORD0 = scene._m0[gl_InstanceIndex].baseColor;
+    out.out_var_TEXCOORD1 = float2(1.0 - in.in_var_TEXCOORD3.x, in.in_var_TEXCOORD3.y);
+    out.out_var_TEXCOORD2 = _100;
+    out.out_var_TEXCOORD3 = gl_InstanceIndex;
+    out.gl_Position = _88;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/sample.frag.msl b/depot/content/_shaders/msl/sample.frag.msl
new file mode 100644
index 0000000..e9e2dad
--- /dev/null
+++ b/depot/content/_shaders/msl/sample.frag.msl
@@ -0,0 +1,22 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+struct main0_in
+{
+    float4 in_var_TEXCOORD0 [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]])
+{
+    main0_out out = {};
+    out.out_var_SV_Target0 = in.in_var_TEXCOORD0;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/sample.vert.msl b/depot/content/_shaders/msl/sample.vert.msl
new file mode 100644
index 0000000..15b45b2
--- /dev/null
+++ b/depot/content/_shaders/msl/sample.vert.msl
@@ -0,0 +1,66 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float3 color;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+constant float2 _31 = {};
+constant float4 _32 = {};
+
+struct main0_out
+{
+    float4 out_var_TEXCOORD0 [[user(locn0)]];
+    float4 gl_Position [[position]];
+};
+
+vertex main0_out main0(const device type_StructuredBuffer_Scene& test [[buffer(0)]], uint gl_VertexIndex [[vertex_id]])
+{
+    main0_out out = {};
+    float4 _71;
+    float2 _72;
+    if (gl_VertexIndex == 0u)
+    {
+        _71 = float4(test._m0[0u].color, 1.0);
+        _72 = float2(-1.0);
+    }
+    else
+    {
+        float4 _69;
+        float2 _70;
+        if (gl_VertexIndex == 1u)
+        {
+            _69 = float4(test._m0[1u].color, 1.0);
+            _70 = float2(1.0, -1.0);
+        }
+        else
+        {
+            bool _57 = gl_VertexIndex == 2u;
+            float4 _66;
+            if (_57)
+            {
+                _66 = float4(test._m0[2u].color, 1.0);
+            }
+            else
+            {
+                _66 = _32;
+            }
+            _69 = _66;
+            _70 = select(_31, float2(0.0, 1.0), bool2(_57));
+        }
+        _71 = _69;
+        _72 = _70;
+    }
+    out.out_var_TEXCOORD0 = _71;
+    out.gl_Position = float4(_72, 0.0, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/skybox.frag.msl b/depot/content/_shaders/msl/skybox.frag.msl
new file mode 100644
index 0000000..1abee72
--- /dev/null
+++ b/depot/content/_shaders/msl/skybox.frag.msl
@@ -0,0 +1,32 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct type_Uniforms
+{
+    float brightnessFactor;
+};
+
+constant float4 _28 = {};
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+    float4 out_var_SV_Target1 [[color(1)]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], texturecube<float> SkyboxTexture [[texture(0)]], sampler SkyboxSampler [[sampler(0)]])
+{
+    main0_out out = {};
+    float4 _38 = SkyboxTexture.sample(SkyboxSampler, in.in_var_TEXCOORD0) * Uniforms.brightnessFactor;
+    out.out_var_SV_Target0 = _38;
+    out.out_var_SV_Target1 = select(_28, _38, bool4(length(_38) > 1.0));
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/skybox.vert.msl b/depot/content/_shaders/msl/skybox.vert.msl
new file mode 100644
index 0000000..63e7121
--- /dev/null
+++ b/depot/content/_shaders/msl/skybox.vert.msl
@@ -0,0 +1,29 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct type_Uniforms
+{
+    float4x4 ViewProjection;
+};
+
+struct main0_out
+{
+    float3 out_var_TEXCOORD0 [[user(locn0)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float3 in_var_TEXCOORD0 [[attribute(0)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]])
+{
+    main0_out out = {};
+    out.out_var_TEXCOORD0 = in.in_var_TEXCOORD0;
+    out.gl_Position = Uniforms.ViewProjection * float4(in.in_var_TEXCOORD0, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/ssao.frag.msl b/depot/content/_shaders/msl/ssao.frag.msl
new file mode 100644
index 0000000..0b8c1d0
--- /dev/null
+++ b/depot/content/_shaders/msl/ssao.frag.msl
@@ -0,0 +1,124 @@
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#pragma clang diagnostic ignored "-Wmissing-braces"
+
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+template<typename T, size_t Num>
+struct spvUnsafeArray
+{
+    T elements[Num ? Num : 1];
+    
+    thread T& operator [] (size_t pos) thread
+    {
+        return elements[pos];
+    }
+    constexpr const thread T& operator [] (size_t pos) const thread
+    {
+        return elements[pos];
+    }
+    
+    device T& operator [] (size_t pos) device
+    {
+        return elements[pos];
+    }
+    constexpr const device T& operator [] (size_t pos) const device
+    {
+        return elements[pos];
+    }
+    
+    constexpr const constant T& operator [] (size_t pos) const constant
+    {
+        return elements[pos];
+    }
+    
+    threadgroup T& operator [] (size_t pos) threadgroup
+    {
+        return elements[pos];
+    }
+    constexpr const threadgroup T& operator [] (size_t pos) const threadgroup
+    {
+        return elements[pos];
+    }
+};
+
+struct type_Uniforms
+{
+    float4x4 View;
+    float4x4 ViewProjection;
+    float4x4 Projection;
+    float2 extents;
+    float radius;
+    float bias0;
+    int numSamples;
+};
+
+constant spvUnsafeArray<float3, 64> _314 = spvUnsafeArray<float3, 64>({ float3(0.0), float3(0.00039307403494603931903839111328125, 0.00020744701032526791095733642578125, 0.02340200729668140411376953125), float3(-0.001318361726589500904083251953125, -0.001457856036722660064697265625, 0.01546739041805267333984375), float3(0.0003496186691336333751678466796875, 8.4181214333511888980865478515625e-05, 0.058608897030353546142578125), float3(-0.0005043491837568581104278564453125, -0.00383304059505462646484375, 0.02929248847067356109619140625), float3(-0.00241771643050014972686767578125, 0.0057135238312184810638427734375, 0.01733645610511302947998046875), float3(-0.0007101023220457136631011962890625, 0.000413290224969387054443359375, 0.0375200845301151275634765625), float3(1.5587833331665024161338806152344e-05, -0.00011572847870411351323127746582031, 0.073567919433116912841796875), float3(0.00334032182581722736358642578125, -0.0051653436385095119476318359375, 0.050431825220584869384765625), float3(-0.0063966461457312107086181640625, 0.01290071941912174224853515625, 0.00147703452967107295989990234375), float3(0.007907788269221782684326171875, -0.0049759554676711559295654296875, 0.001991991885006427764892578125), float3(-0.0003332807100377976894378662109375, -0.00100087863393127918243408203125, 0.001031001214869320392608642578125), float3(0.00011193146201549097895622253417969, 0.00036116360570304095745086669921875, 0.010905899107456207275390625), float3(-0.00385366589762270450592041015625, -0.004629385657608509063720703125, 0.027080766856670379638671875), float3(-0.0055218120105564594268798828125, 0.0163907893002033233642578125, 0.0033264369703829288482666015625), float3(-0.00297828204929828643798828125, -0.00340225151740014553070068359375, 0.009606515057384967803955078125), float3(0.0005643319454975426197052001953125, -0.00123721174895763397216796875, 0.01142332889139652252197265625), float3(0.0042646829970180988311767578125, 0.001690786913968622684478759765625, 0.00338359293527901172637939453125), float3(0.028113491833209991455078125, -0.01881640218198299407958984375, 0.0140878893435001373291015625), float3(-0.03022454865276813507080078125, -0.000894616474397480487823486328125, 0.0849911272525787353515625), float3(-0.01961914263665676116943359375, -0.0350324176251888275146484375, 0.014081305824220180511474609375), float3(0.015496986918151378631591796875, -0.010903127491474151611328125, 0.00180752319283783435821533203125), float3(0.0196535401046276092529296875, 0.01710924692451953887939453125, 0.0142847932875156402587890625), float3(-0.02892612479627132415771484375, 0.00322483875788748264312744140625, 0.06573773920536041259765625), float3(-0.0016983882524073123931884765625, 0.0004074592725373804569244384765625, 0.00372933782637119293212890625), float3(-0.0335367508232593536376953125, 0.0591063164174556732177734375, 0.01477129198610782623291015625), float3(0.01729742996394634246826171875, 0.02095410041511058807373046875, 0.061427496373653411865234375), float3(-0.0362440533936023712158203125, -0.01097334362566471099853515625, 0.052580632269382476806640625), float3(-0.010873113758862018585205078125, 0.071666888892650604248046875, 0.07090236246585845947265625), float3(0.0404303781688213348388671875, -0.0758908092975616455078125, 0.066407024860382080078125), float3(0.006424785591661930084228515625, -0.00888848863542079925537109375, 0.00571323931217193603515625), float3(-0.0424978695809841156005859375, 0.122786454856395721435546875, 0.03013108484447002410888671875), float3(-0.012614764273166656494140625, -0.01173587143421173095703125, 0.0161450766026973724365234375), float3(0.02246730588376522064208984375, -0.023659668862819671630859375, 0.01735904999077320098876953125), float3(0.0280994363129138946533203125, -0.0286351330578327178955078125, 0.0076164784841239452362060546875), float3(0.0701790750026702880859375, -0.1532168686389923095703125, 0.0887149870395660400390625), float3(0.0073889424093067646026611328125, 0.152280390262603759765625, 0.00664083100855350494384765625), float3(0.07831905782222747802734375, -0.072104983031749725341796875, 0.094614334404468536376953125), float3(0.03289596736431121826171875, -0.0408993400633335113525390625, 0.040609411895275115966796875), float3(-0.141404449939727783203125, 0.17826557159423828125, 0.067046172916889190673828125), float3(0.108955644071102142333984375, 0.1114947497844696044921875, 0.21018303930759429931640625), float3(0.02759261615574359893798828125, 0.0139005817472934722900390625, 0.036677159368991851806640625), float3(0.05564410984516143798828125, -0.099730752408504486083984375, 0.113144241273403167724609375), float3(-0.0315654389560222625732421875, -0.22426509857177734375, 0.23739193379878997802734375), float3(-0.0474216155707836151123046875, 0.00566783733665943145751953125, 0.1736856400966644287109375), float3(0.088452465832233428955078125, 0.096331931650638580322265625, 0.083578832447528839111328125), float3(-0.0036428333260118961334228515625, 0.010955554433166980743408203125, 0.00330849713645875453948974609375), float3(-0.1911892592906951904296875, -0.18971312046051025390625, 0.1564487516880035400390625), float3(0.034361146390438079833984375, 0.0655452907085418701171875, 0.0308254323899745941162109375), float3(0.371889293193817138671875, 0.0229042805731296539306640625, 0.2982411682605743408203125), float3(-0.014679887332022190093994140625, 0.01349230110645294189453125, 0.00740495882928371429443359375), float3(-0.00653826631605625152587890625, -0.0058869807980954647064208984375, 0.005725885741412639617919921875), float3(-0.2333120405673980712890625, -0.35499393939971923828125, 0.03432808816432952880859375), float3(0.0411357469856739044189453125, -0.023320116102695465087890625, 0.01891444809734821319580078125), float3(-0.0945928990840911865234375, 0.02529100514948368072509765625, 0.092956520617008209228515625), float3(-0.0317381806671619415283203125, 0.226026356220245361328125, 0.2367977797985076904296875), float3(-0.3801217377185821533203125, 0.2481244504451751708984375, 0.47917068004608154296875), float3(0.13565014302730560302734375, 0.13791494071483612060546875, 0.4077457487583160400390625), float3(0.523879945278167724609375, -0.388758122920989990234375, 0.24387760460376739501953125), float3(-0.0520826168358325958251953125, -0.118409633636474609375, 0.095709107816219329833984375), float3(0.122609488666057586669921875, -0.4220634996891021728515625, 0.178109467029571533203125), float3(-0.2801954448223114013671875, -0.520291268825531005859375, 0.26809024810791015625), float3(-0.3271856009960174560546875, 0.23393590748310089111328125, 0.098123751580715179443359375), float3(0.3826406896114349365234375, 0.08367092907428741455078125, 0.257561206817626953125) });
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 in_var_TEXCOORD0 [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], texture2d<float> PositionTexture [[texture(0)]], texture2d<float> NormalTexture [[texture(1)]], texture2d<float> NoiseTexture [[texture(2)]], sampler Sampler0 [[sampler(0)]], sampler Sampler1 [[sampler(1)]], sampler Sampler2 [[sampler(2)]])
+{
+    main0_out out = {};
+    float2 _318 = in.in_var_TEXCOORD0;
+    float4 _425;
+    do
+    {
+        _318.y = (_318.y * (-1.0)) + 1.0;
+        float4 _330 = PositionTexture.sample(Sampler0, _318);
+        float4 _331 = Uniforms.View * _330;
+        float3 _332 = _331.xyz;
+        float _333 = _331.z;
+        if (_333 < 0.00999999977648258209228515625)
+        {
+            _425 = float4(1.0);
+            break;
+        }
+        float4 _340 = NormalTexture.sample(Sampler1, _318);
+        float3 _341 = _340.xyz;
+        float4 _346 = NoiseTexture.sample(Sampler2, (_318 * float2(320.0, 180.0)));
+        float3 _348 = fast::normalize(_346.xyz);
+        float3 _352 = fast::normalize(_348 - (_341 * dot(_348, _341)));
+        float3x3 _355 = transpose(float3x3(_352, cross(_341, _352), _341));
+        float _357;
+        _357 = 0.0;
+        float _358;
+        for (int _360 = 0; _360 < Uniforms.numSamples; _357 = _358, _360++)
+        {
+            float3 _374 = _332 + (((_314[_360] + float3(0.0, 0.0, 0.0500000007450580596923828125)) * _355) * Uniforms.radius);
+            float _377 = _374.z;
+            float4 _381 = Uniforms.Projection * float4(_374.xy, _377, 1.0);
+            float3 _388 = ((_381.xyz / float3(_381.w)).xyz * 0.5) + float3(0.5);
+            float4 _389 = float4(_388.x, _388.y, _388.z, _381.w);
+            _389.y = (_388.y * (-1.0)) + 1.0;
+            float4 _396 = PositionTexture.sample(Sampler0, _389.xy);
+            float4 _397 = Uniforms.View * _396;
+            float _398 = _397.z;
+            float _409 = _357 + (float(_398 <= (_377 - Uniforms.bias0)) * smoothstep(0.0, 1.0, Uniforms.radius / abs(_333 - _398)));
+            if (_377 > 30.0)
+            {
+                _358 = _409 * precise::max(0.0, 1.0 - ((_377 - 30.0) * 0.0033333334140479564666748046875));
+            }
+            else
+            {
+                _358 = _409;
+            }
+        }
+        float _420 = 1.0 - (_357 / float(Uniforms.numSamples));
+        _425 = float4(_420) + float4(_420 * 9.9999997473787516355514526367188e-06);
+        break;
+    } while(false);
+    out.out_var_SV_Target0 = _425;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/test.vert.msl b/depot/content/_shaders/msl/test.vert.msl
new file mode 100644
index 0000000..564cda3
--- /dev/null
+++ b/depot/content/_shaders/msl/test.vert.msl
@@ -0,0 +1,66 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct Scene
+{
+    float4 color;
+};
+
+struct type_StructuredBuffer_Scene
+{
+    Scene _m0[1];
+};
+
+constant float2 _30 = {};
+constant float4 _31 = {};
+
+struct main0_out
+{
+    float4 out_var_TEXCOORD0 [[user(locn0)]];
+    float4 gl_Position [[position]];
+};
+
+vertex main0_out main0(const device type_StructuredBuffer_Scene& test [[buffer(0)]], uint gl_VertexIndex [[vertex_id]])
+{
+    main0_out out = {};
+    float4 _58;
+    float2 _59;
+    if (gl_VertexIndex == 0u)
+    {
+        _58 = test._m0[0u].color;
+        _59 = float2(-1.0);
+    }
+    else
+    {
+        float4 _56;
+        float2 _57;
+        if (gl_VertexIndex == 1u)
+        {
+            _56 = test._m0[1u].color;
+            _57 = float2(1.0, -1.0);
+        }
+        else
+        {
+            bool _48 = gl_VertexIndex == 2u;
+            float4 _53;
+            if (_48)
+            {
+                _53 = test._m0[2u].color;
+            }
+            else
+            {
+                _53 = _31;
+            }
+            _56 = _53;
+            _57 = select(_30, float2(0.0, 1.0), bool2(_48));
+        }
+        _58 = _56;
+        _59 = _57;
+    }
+    out.out_var_TEXCOORD0 = _58;
+    out.gl_Position = float4(_59, 0.0, 1.0);
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/text.frag.msl b/depot/content/_shaders/msl/text.frag.msl
new file mode 100644
index 0000000..68cc8e9
--- /dev/null
+++ b/depot/content/_shaders/msl/text.frag.msl
@@ -0,0 +1,102 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct FontInfo
+{
+    float2 position;
+    float2 size;
+    uint isSdf;
+    uint pad0;
+};
+
+struct type_StructuredBuffer_FontInfo
+{
+    FontInfo _m0[1];
+};
+
+struct main0_out
+{
+    float4 out_var_SV_Target0 [[color(0)]];
+};
+
+struct main0_in
+{
+    uint in_var_TEXCOORD0 [[user(locn0)]];
+    float2 in_var_TEXCOORD1 [[user(locn1)]];
+    float2 in_var_TEXCOORD2 [[user(locn2)]];
+    uint in_var_TEXCOORD3 [[user(locn3)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], const device type_StructuredBuffer_FontInfo& fontBuffer [[buffer(0)]], texture2d<float> Texture0 [[texture(0)]], sampler Sampler0 [[sampler(0)]])
+{
+    main0_out out = {};
+    float4 _67 = Texture0.sample(Sampler0, in.in_var_TEXCOORD1);
+    bool _104;
+    do
+    {
+        bool _85;
+        if (in.in_var_TEXCOORD2.x >= fontBuffer._m0[in.in_var_TEXCOORD3].position.x)
+        {
+            _85 = in.in_var_TEXCOORD2.x <= (fontBuffer._m0[in.in_var_TEXCOORD3].position.x + fontBuffer._m0[in.in_var_TEXCOORD3].size.x);
+        }
+        else
+        {
+            _85 = false;
+        }
+        bool _92;
+        if (_85)
+        {
+            _92 = in.in_var_TEXCOORD2.y >= fontBuffer._m0[in.in_var_TEXCOORD3].position.y;
+        }
+        else
+        {
+            _92 = false;
+        }
+        bool _101;
+        if (_92)
+        {
+            _101 = in.in_var_TEXCOORD2.y <= (fontBuffer._m0[in.in_var_TEXCOORD3].position.y + fontBuffer._m0[in.in_var_TEXCOORD3].size.y);
+        }
+        else
+        {
+            _101 = false;
+        }
+        if (_101)
+        {
+            _104 = true;
+            break;
+        }
+        _104 = false;
+        break;
+    } while(false);
+    if (!_104)
+    {
+        discard_fragment();
+    }
+    float _110 = float(in.in_var_TEXCOORD0 & 255u) * 0.0039215688593685626983642578125;
+    float _114 = float((in.in_var_TEXCOORD0 >> 8u) & 255u) * 0.0039215688593685626983642578125;
+    float _118 = float((in.in_var_TEXCOORD0 >> 16u) & 255u) * 0.0039215688593685626983642578125;
+    float _122 = float((in.in_var_TEXCOORD0 >> 24u) & 255u) * 0.0039215688593685626983642578125;
+    float4 _187;
+    if (fontBuffer._m0[in.in_var_TEXCOORD3].isSdf == 1u)
+    {
+        float _128 = _67.x;
+        float _129 = fwidth(_128);
+        float _130 = 0.529411792755126953125 - _129;
+        float _131 = 0.529411792755126953125 + _129;
+        float2 _137 = (dfdx(in.in_var_TEXCOORD1) + dfdy(in.in_var_TEXCOORD1)) * 0.3540000021457672119140625;
+        float4 _144 = float4(in.in_var_TEXCOORD1 - _137, in.in_var_TEXCOORD1 + _137);
+        float4 _176 = float4(_110, _114, _118, ((fast::clamp(smoothstep(_130, _131, _128), 0.0, 1.0) + (0.5 * (((fast::clamp(smoothstep(_130, _131, Texture0.sample(Sampler0, _144.xy).x), 0.0, 1.0) + fast::clamp(smoothstep(_130, _131, Texture0.sample(Sampler0, _144.zw).x), 0.0, 1.0)) + fast::clamp(smoothstep(_130, _131, Texture0.sample(Sampler0, _144.xw).x), 0.0, 1.0)) + fast::clamp(smoothstep(_130, _131, Texture0.sample(Sampler0, _144.zy).x), 0.0, 1.0)))) * 0.3333333432674407958984375) * _122);
+        float3 _178 = powr(_176.xyz, float3(2.2000000476837158203125));
+        _187 = float4(_178.x, _178.y, _178.z, _176.w);
+    }
+    else
+    {
+        _187 = float4(_110, _114, _118, powr(_67.x / dot(float4(_110, _114, _118, _122).xyz, float3(0.2125999927520751953125, 0.715200006961822509765625, 0.072200000286102294921875)), 0.4545454680919647216796875) * _122);
+    }
+    out.out_var_SV_Target0 = _187;
+    return out;
+}
+
diff --git a/depot/content/_shaders/msl/text.vert.msl b/depot/content/_shaders/msl/text.vert.msl
new file mode 100644
index 0000000..fdb1abb
--- /dev/null
+++ b/depot/content/_shaders/msl/text.vert.msl
@@ -0,0 +1,54 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct FontInfo
+{
+    float2 position;
+    float2 size;
+    uint isSdf;
+    uint pad0;
+};
+
+struct type_StructuredBuffer_FontInfo
+{
+    FontInfo _m0[1];
+};
+
+struct type_Uniforms
+{
+    float2 Extents;
+};
+
+struct main0_out
+{
+    uint out_var_TEXCOORD0 [[user(locn0)]];
+    float2 out_var_TEXCOORD1 [[user(locn1)]];
+    float2 out_var_TEXCOORD2 [[user(locn2)]];
+    uint out_var_TEXCOORD3 [[user(locn3)]];
+    float4 gl_Position [[position]];
+};
+
+struct main0_in
+{
+    float2 in_var_TEXCOORD0 [[attribute(0)]];
+    float2 in_var_TEXCOORD1 [[attribute(1)]];
+    uint in_var_TEXCOORD2 [[attribute(2)]];
+};
+
+vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]], const device type_StructuredBuffer_FontInfo& fontBuffer [[buffer(1)]], uint gl_InstanceIndex [[instance_id]])
+{
+    main0_out out = {};
+    float2 _46 = in.in_var_TEXCOORD0 + fontBuffer._m0[gl_InstanceIndex].position;
+    float2 _51 = ((_46 / Uniforms.Extents) * 2.0) + float2(-1.0);
+    float4 _54 = float4(_51, 0.0, 1.0);
+    _54.y = -_51.y;
+    out.out_var_TEXCOORD0 = in.in_var_TEXCOORD2;
+    out.out_var_TEXCOORD1 = in.in_var_TEXCOORD1;
+    out.out_var_TEXCOORD2 = _46;
+    out.out_var_TEXCOORD3 = gl_InstanceIndex;
+    out.gl_Position = _54;
+    return out;
+}
+
diff --git a/depot/content/_shaders/spv/debug.frag.spv b/depot/content/_shaders/spv/debug.frag.spv
new file mode 100644
index 0000000..103f69a
Binary files /dev/null and b/depot/content/_shaders/spv/debug.frag.spv differ
diff --git a/depot/content/_shaders/spv/debug.vert.spv b/depot/content/_shaders/spv/debug.vert.spv
new file mode 100644
index 0000000..16f3db5
Binary files /dev/null and b/depot/content/_shaders/spv/debug.vert.spv differ
diff --git a/depot/content/_shaders/spv/depthOnly.frag.spv b/depot/content/_shaders/spv/depthOnly.frag.spv
new file mode 100644
index 0000000..7e413c3
Binary files /dev/null and b/depot/content/_shaders/spv/depthOnly.frag.spv differ
diff --git a/depot/content/_shaders/spv/lit_mesh.frag.spv b/depot/content/_shaders/spv/lit_mesh.frag.spv
new file mode 100644
index 0000000..4b7c049
Binary files /dev/null and b/depot/content/_shaders/spv/lit_mesh.frag.spv differ
diff --git a/depot/content/_shaders/spv/meshes.vert.spv b/depot/content/_shaders/spv/meshes.vert.spv
new file mode 100644
index 0000000..7c3da46
Binary files /dev/null and b/depot/content/_shaders/spv/meshes.vert.spv differ
diff --git a/depot/content/_shaders/spv/postProc.frag.spv b/depot/content/_shaders/spv/postProc.frag.spv
new file mode 100644
index 0000000..1fa98d9
Binary files /dev/null and b/depot/content/_shaders/spv/postProc.frag.spv differ
diff --git a/depot/content/_shaders/spv/postProc.vert.spv b/depot/content/_shaders/spv/postProc.vert.spv
new file mode 100644
index 0000000..30bf6db
Binary files /dev/null and b/depot/content/_shaders/spv/postProc.vert.spv differ
diff --git a/depot/content/_shaders/spv/rect.frag.spv b/depot/content/_shaders/spv/rect.frag.spv
new file mode 100644
index 0000000..f89070b
Binary files /dev/null and b/depot/content/_shaders/spv/rect.frag.spv differ
diff --git a/depot/content/_shaders/spv/rect.vert.spv b/depot/content/_shaders/spv/rect.vert.spv
new file mode 100644
index 0000000..0839336
Binary files /dev/null and b/depot/content/_shaders/spv/rect.vert.spv differ
diff --git a/depot/content/_shaders/spv/sample.frag.spv b/depot/content/_shaders/spv/sample.frag.spv
new file mode 100644
index 0000000..5f4c638
Binary files /dev/null and b/depot/content/_shaders/spv/sample.frag.spv differ
diff --git a/depot/content/_shaders/spv/sample.vert.spv b/depot/content/_shaders/spv/sample.vert.spv
new file mode 100644
index 0000000..8e1453e
Binary files /dev/null and b/depot/content/_shaders/spv/sample.vert.spv differ
diff --git a/depot/content/_shaders/spv/skybox.frag.spv b/depot/content/_shaders/spv/skybox.frag.spv
new file mode 100644
index 0000000..f33fd3d
Binary files /dev/null and b/depot/content/_shaders/spv/skybox.frag.spv differ
diff --git a/depot/content/_shaders/spv/skybox.vert.spv b/depot/content/_shaders/spv/skybox.vert.spv
new file mode 100644
index 0000000..ca2947a
Binary files /dev/null and b/depot/content/_shaders/spv/skybox.vert.spv differ
diff --git a/depot/content/_shaders/spv/ssao.frag.spv b/depot/content/_shaders/spv/ssao.frag.spv
new file mode 100644
index 0000000..a5ed705
Binary files /dev/null and b/depot/content/_shaders/spv/ssao.frag.spv differ
diff --git a/depot/content/_shaders/spv/test.vert.spv b/depot/content/_shaders/spv/test.vert.spv
new file mode 100644
index 0000000..203031d
Binary files /dev/null and b/depot/content/_shaders/spv/test.vert.spv differ
diff --git a/depot/content/_shaders/spv/text.frag.spv b/depot/content/_shaders/spv/text.frag.spv
new file mode 100644
index 0000000..d6e6ee2
Binary files /dev/null and b/depot/content/_shaders/spv/text.frag.spv differ
diff --git a/depot/content/_shaders/spv/text.vert.spv b/depot/content/_shaders/spv/text.vert.spv
new file mode 100644
index 0000000..337854b
Binary files /dev/null and b/depot/content/_shaders/spv/text.vert.spv differ
diff --git a/depot/zuck/actors/ZuckPlayer.zig b/depot/zuck/actors/ZuckPlayer.zig
new file mode 100644
index 0000000..242697e
--- /dev/null
+++ b/depot/zuck/actors/ZuckPlayer.zig
@@ -0,0 +1,53 @@
+pub const BoxObject = struct {
+    playing: bool = false,
+
+    pub fn create(allocator: std.mem.Allocator, entity: core.Entity, params: core.SpawnParameters) !*@This() {
+        const position = params.posRot.position;
+
+        const box2 = entity;
+        const scene = box2.addComponent(core.Scene).?;
+
+        const mesh = box2.addComponent(rend.MeshComponent).?;
+        mesh.setMesh("m_crate");
+        mesh.setTexture("t_crate");
+
+        scene.setPosition(position);
+        scene.setScaleV(params.posRot.scale);
+        scene.setMobility(.moveable);
+
+        const collider = box2.addComponent(physics.PhysicsCollider).?;
+        try collider.setupByShapeName(core.MakeName("ph_small_box"), .{
+            .motion_type = .dynamic,
+            .object_layer = physics.ObjectLayers.moving,
+            .friction = 0.8,
+            .mass_properties_override = .{ .mass = 12 },
+            .override_mass_properties = .calc_inertia,
+        });
+
+        return try allocator.create(@This());
+    }
+
+    pub fn createSmoky(allocator: std.mem.Allocator, entity: core.Entity, params: core.SpawnParameters) !*@This() {
+        const rv = try create(allocator, entity, params);
+
+        const particle = entity.addComponent(rend.ParticleEmitter).?;
+        particle.start();
+        particle.gravity = .{ .y = 1.0 };
+        particle.particleVelocity = .{ .min = 0.6, .max = 1.2 };
+        particle.particleLife = .{ .min = 5, .max = 6 };
+        var name = core.MakeName("t_pixelSmoke");
+        particle.texture = rend.getTexture(&name).?;
+
+        return rv;
+    }
+
+    pub fn destroy(self: *@This(), alloc: std.mem.Allocator) void {
+        alloc.destroy(self);
+    }
+};
+
+const std = @import("std");
+const Backlog = @import("Backlog");
+const core = Backlog.core;
+const rend = Backlog.rend;
+const physics = Backlog.physics;
diff --git a/depot/zuck/game.zig b/depot/zuck/game.zig
new file mode 100644
index 0000000..368aa6b
--- /dev/null
+++ b/depot/zuck/game.zig
@@ -0,0 +1,37 @@
+const backlog = @import("backlog");
+const core = backlog.core;
+const imgui = backlog.imgui;
+const physics = backlog.physics;
+const rend = backlog.rend;
+const ig = imgui.api;
+const sys = backlog.sys;
+const ui = backlog.ui;
+const net = backlog.net;
+const audio = backlog.audio;
+const platform = backlog.platform;
+
+pub export fn shutdown_module() void {}
+pub export fn startup_module(p_allocator: *anyopaque, p_a: ?*anyopaque) bool {
+    const allocator = core.modulePreamble(p_allocator, p_a) catch return false;
+    _ = allocator;
+    imgui.setupFromModule();
+    platform.setupFromModule();
+    sys.setupFromModule();
+    rend.setupFromModule();
+    backlog.physics.setupFromModule();
+
+    start_module(core.startup_getArgs(p_a.?)) catch return false;
+
+    return true;
+}
+
+pub fn start_module(args: core.ModuleLoaderArgs) !void {
+    _ = args;
+    core.PatchOrCreateObject(ZuckGame, .{});
+    // core.PatchOrCreateObject(ZuckEditor, .{});
+}
+
+const ZuckGame = @import("games/ZuckGame.zig");
+const ZuckEditor = @import("games/ZuckEditor.zig");
+
+const ZuckPlayer = @import("actors/ZuckPlayer.zig");
diff --git a/depot/zuck/games/ZuckEditor.zig b/depot/zuck/games/ZuckEditor.zig
new file mode 100644
index 0000000..48cd04c
--- /dev/null
+++ b/depot/zuck/games/ZuckEditor.zig
@@ -0,0 +1,29 @@
+pub var NeonObjectTable = core.EngineObjectVTable.from(@This(), "zuck.game.Editor");
+
+allocator: std.mem.Allocator = undefined,
+
+pub const Slack = core.SlackStruct(@This(), 8192);
+
+pub fn create(allocator: std.mem.Allocator) !*@This() {
+    const self = try Slack.create(allocator);
+    self.* = .{
+        .allocator = allocator,
+    };
+
+    return self;
+}
+
+pub fn tick(self: *@This(), dt: f64) void {
+    _ = self;
+    _ = dt;
+}
+
+pub fn destroy(self: *@This()) void {
+    self.allocator.destroy(Slack.fromPtr(self));
+}
+
+const backlog = @import("backlog");
+const std = @import("std");
+const extras = @import("gameExtras");
+
+const core = backlog.core;
diff --git a/depot/zuck/games/ZuckGame.zig b/depot/zuck/games/ZuckGame.zig
new file mode 100644
index 0000000..6004b68
--- /dev/null
+++ b/depot/zuck/games/ZuckGame.zig
@@ -0,0 +1,29 @@
+pub var NeonObjectTable = core.EngineObjectVTable.from(@This(), "zuck.game.Root");
+
+allocator: std.mem.Allocator = undefined,
+
+pub const Slack = core.SlackStruct(@This(), 1024);
+
+pub fn create(allocator: std.mem.Allocator) !*@This() {
+    const self = try Slack.create(allocator);
+    self.* = .{
+        .allocator = allocator,
+    };
+
+    return self;
+}
+
+pub fn tick(self: *@This(), dt: f64) void {
+    _ = self;
+    _ = dt;
+}
+
+pub fn destroy(self: *@This()) void {
+    self.allocator.destroy(Slack.fromPtr(self));
+}
+
+const backlog = @import("backlog");
+const std = @import("std");
+const extras = @import("gameExtras");
+
+const core = backlog.core;
diff --git a/depot/shooterGame/main.zig b/depot/zuck/main.zig
similarity index 100%
rename from depot/shooterGame/main.zig
rename to depot/zuck/main.zig
diff --git a/engine/core/src/inputs/inputStack.zig b/engine/core/src/inputs/inputStack.zig
index fb53849..76ad037 100644
--- a/engine/core/src/inputs/inputStack.zig
+++ b/engine/core/src/inputs/inputStack.zig
@@ -111,6 +111,7 @@ fn BindingData(Func: type) type {
 pub const ActionBinding = struct {
     data: BindingData(ActionFunc),
     keys: std.ArrayListUnmanaged(ActionBindingKey) = .{},
+    layer: ?*BindingLayer = null,
 
     // pub const Listener = struct {
     //     id: u32,
diff --git a/lib/sdl3/build.zig b/lib/sdl3/build.zig
index 543018a..cbcb6d1 100644
--- a/lib/sdl3/build.zig
+++ b/lib/sdl3/build.zig
@@ -108,6 +108,20 @@ pub fn build(b: *std.Build) void {
         }),
     });
 
+    const hello_window = b.step("hello-window", "test window");
+    const hello_window_exe = b.addExecutable(.{
+        .name = "hello-window",
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/samples/hello-window.zig"),
+            .link_libc = true,
+        }),
+    });
+
+    hello_window.dependOn(&hello_window_exe.step);
+    hello_window_exe.root_module.addImport("sdl3", mod);
+
     tests.root_module.addImport("sdl3", mod);
 
     const vertexDefinitions = addShaderDefinition(b, ".", target, optimize, "hello-triangle.vert", b.path("content/hello-triangle.vert.json"));
@@ -119,6 +133,7 @@ pub fn build(b: *std.Build) void {
     const runArtifact2 = b.addRunArtifact(tests2);
     test_step2.dependOn(&runArtifact2.step);
 
+    b.installArtifact(hello_window_exe);
     b.installArtifact(sdl3_lib);
     b.installArtifact(tests);
     b.installArtifact(tests2);
diff --git a/lib/sdl3/src/samples/hello-window.zig b/lib/sdl3/src/samples/hello-window.zig
new file mode 100644
index 0000000..f0b3c1d
--- /dev/null
+++ b/lib/sdl3/src/samples/hello-window.zig
@@ -0,0 +1,103 @@
+allocator: std.mem.Allocator,
+
+timer: std.time.Timer,
+// fillPipeline: *sdl3.GpuGraphicsPipeline = undefined,
+// linePipeline: *sdl3.GpuGraphicsPipeline = undefined,
+// viewport: sdl3.GpuViewport = undefined,
+running: bool = true,
+window: *sdl3.Window = undefined,
+
+totalTime: f64 = 0.0,
+
+var stdout_buffer: [1024]u8 = undefined;
+
+pub fn print(comptime fmt: []const u8, args: anytype) void {
+    var stdout = std.fs.File.stdout().writer(&stdout_buffer);
+    stdout.interface.print(">>> " ++ fmt ++ "\n", args) catch return;
+    stdout.interface.flush() catch return;
+}
+
+pub fn create(allocator: std.mem.Allocator) !*@This() {
+    const self = try allocator.create(@This());
+    self.* = .{
+        .allocator = allocator,
+        .timer = try std.time.Timer.start(),
+    };
+
+    return self;
+}
+
+pub fn frameStamp(self: *@This()) f64 {
+    return @as(f64, @floatFromInt(self.timer.read())) / 1000 / 1000 / 1000;
+}
+
+pub fn startContext(self: *@This()) !void {
+    try sdl3.init(.{
+        .video = true,
+        .gamepad = true,
+    });
+
+    self.window = sdl3.c.SDL_CreateWindow("hello-world", 640, 480, 0).?;
+}
+
+pub fn loadFileAlloc(filename: []const u8, comptime alignment: ?std.mem.Alignment, allocator: std.mem.Allocator) ![]u8 {
+    var file = try std.fs.cwd().openFile(filename, .{});
+    defer file.close();
+    const filesize = (try file.stat()).size + 1; // add null byte
+    const buffer: []u8 = try allocator.alignedAlloc(u8, alignment, filesize);
+    errdefer allocator.free(buffer);
+    std.mem.copyForwards(u8, buffer, try file.readToEndAlloc(allocator, buffer.len - 1));
+    buffer[buffer.len - 1] = 0;
+    return buffer;
+}
+
+pub fn loop(self: *@This()) !void {
+    print("loop started\n", .{});
+    try self.startContext();
+    while (self.running) {
+        const dt = @as(f64, @floatFromInt(self.timer.lap())) / 1000 / 1000 / 1000;
+        self.update(dt);
+    }
+}
+
+fn update(self: *@This(), dt: f64) void {
+    while (sdl3.pollEvent()) |event| {
+        switch (event.type) {
+            sdl_event.quit => {
+                self.running = false;
+            },
+            sdl_event.key_down => {
+                const key = event.key.scancode;
+                if (key == @intFromEnum(sdl3.Scancode.escape)) {
+                    self.running = false;
+                }
+            },
+            else => {},
+        }
+    }
+
+    self.draw(dt);
+    print("frametime {d:.3}ms (fps: {d:.1})\r", .{ dt * 1000, 1 / dt });
+}
+
+pub fn draw(self: *@This(), dt: f64) void {
+    self.totalTime += dt;
+}
+
+pub fn destroy(self: *@This()) void {
+    sdl3.c.SDL_DestroyWindow(self.window);
+
+    self.allocator.destroy(self);
+}
+
+pub fn main() !void {
+    std.debug.print("lmao?\n", .{});
+    print("hello world... n", .{});
+    const app = try create(std.heap.c_allocator);
+    try app.loop();
+    defer app.destroy();
+}
+
+const sdl3 = @import("sdl3");
+const sdl_event = sdl3.events;
+const std = @import("std");
diff --git a/projects/headless/main.zig b/projects/headless/main.zig
index 45a1f1d..184462d 100644
--- a/projects/headless/main.zig
+++ b/projects/headless/main.zig
@@ -29,7 +29,7 @@ pub fn tick(self: *@This(), dt: f64) void {
     core.parallelJob(UpdateWorldTransformsJob{}, false, 1) catch unreachable;
 
     // wait 10 ms
-    while (core.getEngineTime() - start < 0.010) { }
+    while (core.getEngineTime() - start < 0.010) {}
 
     if (self.timeLeft < 0)
         core.exitNow();
@@ -158,7 +158,8 @@ pub fn testThing(self: *@This()) !void {
 
     for (0..workerCount) |i| {
         const name = try std.fmt.allocPrintSentinel(std.heap.c_allocator, "MultiJob{d}", .{i}, 0);
-        try core.dispatchJob(MultiJob{ .threadName = name, .threadId = @intCast(i), .threadCount = workerCount });
+        _ = name;
+        // try core.dispatchJob(MultiJob{ .threadName = name, .threadId = @intCast(i), .threadCount = workerCount });
     }
 
     // workerCountHint=0
diff --git a/projects/sampleGame/externGame/externGame.zig b/projects/sampleGame/externGame/externGame.zig
index dbf73a2..59bd2ea 100644
--- a/projects/sampleGame/externGame/externGame.zig
+++ b/projects/sampleGame/externGame/externGame.zig
@@ -1,3 +1,4 @@
+pub export fn shutdown_module() void {}
 pub export fn startup_module(p_allocator: *anyopaque, p_a: ?*anyopaque) bool {
     const allocator = core.modulePreamble(p_allocator, p_a) catch return false;
     _ = allocator;
@@ -6,8 +7,6 @@ pub export fn startup_module(p_allocator: *anyopaque, p_a: ?*anyopaque) bool {
     sys.setupFromModule();
     rend.setupFromModule();
     backlog.physics.setupFromModule();
-    // backlog.net.setupFromModule();
-    // TODO backlog.setupFromModule
 
     core.engine_logs("creating externgame");
     start_module(core.startup_getArgs(p_a.?)) catch return false;
@@ -152,10 +151,10 @@ pub const ExternGameObject = struct {
         }
 
         // change this into a parallel for
-        for (0..1) |i| {
+        for (0..4000) |i| {
             _ = try core.get(core.GameObjectSystem).spawnObject(BoxObject, "Box", .{
                 .posRot = .{
-                    .position = .{ .x = core.itof32((i % 10)) * 2, .y = 15.0, .z = core.itof32(@divFloor(i, 10) * 2) },
+                    .position = .{ .x = core.itof32((i % 100)) * 2, .y = 15.0, .z = core.itof32(@divFloor(i, 100) * 2) },
                 },
             });
         }
@@ -690,8 +689,6 @@ pub const ExternGameObject = struct {
     }
 };
 
-pub export fn shutdown_module() void {}
-
 const std = @import("std");
 const backlog = @import("backlog");
 const core = backlog.core;