diff --git a/.gitmodules b/.gitmodules
index 25caf7aec1..c2b5f02c63 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,12 @@
 [submodule "Kha"]
 	path = Kha
 	url = https://github.com/armory3d/Kha
+
+[submodule "lib/libdragon"]
+	path = lib/libdragon
+	url = https://github.com/DragonMinded/libdragon.git
+	branch = preview
+
+[submodule "lib/tiny3d"]
+	path = lib/tiny3d
+	url = https://github.com/HailToDodongo/tiny3d.git
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 6778ea66a8..2295e84898 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -5,4 +5,4 @@
 	"[python]": {
 		"editor.insertSpaces": true
 	}
-}
+}
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/Makefile.j2 b/armorcore/Deployment/n64/Makefile.j2
new file mode 100644
index 0000000000..3d18c4533f
--- /dev/null
+++ b/armorcore/Deployment/n64/Makefile.j2
@@ -0,0 +1,75 @@
+BUILD_DIR=build
+
+T3D_INST={tiny3d_path}
+
+include $(N64_INST)/include/n64.mk
+include $(T3D_INST)/t3d.mk
+
+GAME_TITLE := {game_title}
+ROM_NAME := {game_title}
+
+N64_CFLAGS += -std=gnu2x
+
+src = \
+    src/main.c \
+    src/engine.c \
+    src/renderer.c \
+    src/system/signal.c \
+	src/data/models.c \
+    src/data/scenes.c \
+	src/data/traits.c \
+	src/events/trait_events.c \
+	src/iron/object/transform.c \
+	src/iron/object/object.c \
+	src/iron/system/input.c \
+{scene_files}
+
+# Physics sources (conditionally included)
+{physics_sources}
+
+# UI sources (conditionally included)
+{koui_sources}
+
+assets_png = $(wildcard assets/*.png)
+assets_gltf = $(wildcard assets/*.gltf)
+assets_ttf = $(wildcard assets/*.ttf)
+assets_conv = $(addprefix filesystem/,$(notdir $(assets_png:%.png=%.sprite))) \
+			  $(addprefix filesystem/,$(notdir $(assets_ttf:%.ttf=%.font64))) \
+			  $(addprefix filesystem/,$(notdir $(assets_gltf:%.gltf=%.t3dm)))
+
+all: $(ROM_NAME).z64
+
+filesystem/%.sprite: assets/%.png
+	@mkdir -p $(dir $@)
+	@echo "    [SPRITE] $@"
+	$(N64_MKSPRITE) $(MKSPRITE_FLAGS) -o filesystem "$<"
+
+filesystem/%.font64: assets/%.ttf
+	@mkdir -p $(dir $@)
+	@echo "    [FONT] $@"
+	$(N64_MKFONT) $(MKFONT_FLAGS) -o filesystem "$<"
+
+filesystem/%.t3dm: assets/%.gltf
+	@mkdir -p $(dir $@)
+	@echo "    [T3D-MODEL] $@"
+	$(T3D_GLTF_TO_3D) "$<" $@
+	$(N64_BINDIR)/mkasset -c 2 -o filesystem $@
+
+$(BUILD_DIR)/$(ROM_NAME).dfs: $(assets_conv)
+$(BUILD_DIR)/$(ROM_NAME).elf: $(src:%.c=$(BUILD_DIR)/%.o)
+
+$(ROM_NAME).z64: N64_ROM_TITLE=$(GAME_TITLE)
+$(ROM_NAME).z64: $(BUILD_DIR)/$(ROM_NAME).dfs
+
+clean:
+	rm -rf $(BUILD_DIR) *.z64
+	rm -rf filesystem
+
+build_lib:
+	rm -rf $(BUILD_DIR) *.z64
+	make -C $(T3D_INST)
+	make all
+
+-include $(wildcard $(BUILD_DIR)/*.d)
+
+.PHONY: all clean
diff --git a/armorcore/Deployment/.keepme b/armorcore/Deployment/n64/docs/.keepme
similarity index 100%
rename from armorcore/Deployment/.keepme
rename to armorcore/Deployment/n64/docs/.keepme
diff --git a/armorcore/Deployment/n64/src/data/fonts.c.j2 b/armorcore/Deployment/n64/src/data/fonts.c.j2
new file mode 100644
index 0000000000..926f363b7c
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/fonts.c.j2
@@ -0,0 +1,61 @@
+#include <libdragon.h>
+#include "fonts.h"
+
+// Font paths (converted from .ttf to .font64 by Makefile)
+static const char *FONT_PATHS[FONT_COUNT] = {{
+{font_paths}
+}};
+
+// rdpq font IDs start at 2 (1 is reserved for libdragon debug font)
+#define FONT_ID_BASE 2
+
+typedef struct {{
+    rdpq_font_t *font;
+    uint8_t loaded;
+}} FontEntry;
+
+static FontEntry g_fonts[FONT_COUNT];
+
+void fonts_init(void)
+{{
+    for (uint8_t i = 0; i < FONT_COUNT; i++) {{
+        g_fonts[i].font = NULL;
+        g_fonts[i].loaded = 0;
+    }}
+}}
+
+void fonts_shutdown(void)
+{{
+    for (uint8_t i = 0; i < FONT_COUNT; i++) {{
+        if (g_fonts[i].loaded) {{
+            if (g_fonts[i].font) {{
+                rdpq_font_free(g_fonts[i].font);
+                g_fonts[i].font = NULL;
+            }}
+            g_fonts[i].loaded = 0;
+        }}
+    }}
+}}
+
+rdpq_font_t *fonts_get(FontId id)
+{{
+    if (id >= FONT_COUNT) {{
+        return NULL;
+    }}
+
+    FontEntry *e = &g_fonts[id];
+    if (!e->loaded) {{
+        const char *path = FONT_PATHS[id];
+        e->font = rdpq_font_load(path);
+        if (e->font) {{
+            rdpq_text_register_font(FONT_ID_BASE + id, e->font);
+            e->loaded = 1;
+        }}
+    }}
+    return e->font;
+}}
+
+uint8_t fonts_get_rdpq_id(FontId id)
+{{
+    return FONT_ID_BASE + id;
+}}
diff --git a/armorcore/Deployment/n64/src/data/fonts.h.j2 b/armorcore/Deployment/n64/src/data/fonts.h.j2
new file mode 100644
index 0000000000..533f761bd9
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/fonts.h.j2
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <libdragon.h>
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+typedef enum {{
+{font_enum_entries}
+    FONT_COUNT = {font_count}
+}} FontId;
+
+void fonts_init(void);
+void fonts_shutdown(void);
+
+rdpq_font_t *fonts_get(FontId id);
+uint8_t fonts_get_rdpq_id(FontId id);
+
+#ifdef __cplusplus
+}}
+#endif
diff --git a/armorcore/Deployment/n64/src/data/models.c.j2 b/armorcore/Deployment/n64/src/data/models.c.j2
new file mode 100644
index 0000000000..e26c1ba8de
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/models.c.j2
@@ -0,0 +1,129 @@
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmodel.h>
+
+#include "models.h"
+
+static const char *MODEL_PATHS[MODEL_COUNT] = {{
+{mesh_paths}
+}};
+
+typedef struct {{
+    T3DModel *model;
+    rspq_block_t *dpl;
+    uint16_t ref_count;  // Reference count for shared models
+    uint8_t loaded;
+}} ModelEntry;
+
+static ModelEntry g_models[MODEL_COUNT];
+
+void models_init(void)
+{{
+    for (uint8_t i = 0; i < MODEL_COUNT; i++) {{
+        g_models[i].model = NULL;
+		g_models[i].dpl = NULL;
+        g_models[i].ref_count = 0;
+        g_models[i].loaded = 0;
+    }}
+}}
+
+void models_shutdown(void)
+{{
+    for (uint8_t i = 0; i < MODEL_COUNT; i++) {{
+        if (g_models[i].loaded) {{
+            if (g_models[i].model) {{
+                t3d_model_free(g_models[i].model);
+                g_models[i].model = NULL;
+            }}
+            if (g_models[i].dpl) {{
+                rspq_block_free(g_models[i].dpl);
+                g_models[i].dpl = NULL;
+            }}
+            g_models[i].ref_count = 0;
+            g_models[i].loaded = 0;
+        }}
+    }}
+}}
+
+T3DModel *models_get(ModelId id)
+{{
+    if (id < 0 || id >= MODEL_COUNT) {{
+        return NULL;
+    }}
+
+    ModelEntry *e = &g_models[id];
+    if (!e->loaded) {{
+        const char *path = MODEL_PATHS[id];
+        e->model = t3d_model_load(path);
+        if (!e->model) {{
+            debugf("Failed to load model: %s\n", path);
+            return NULL;
+        }}
+		rspq_block_begin();
+		t3d_model_draw(e->model);
+		e->dpl = rspq_block_end();
+		e->loaded = 1;
+    }}
+    e->ref_count++;  // Increment reference count
+    return e->model;
+}}
+
+rspq_block_t *models_get_dpl(ModelId id)
+{{
+    return g_models[id].dpl;
+}}
+
+// Release a reference to a model
+void models_release(ModelId id)
+{{
+    if (id < 0 || id >= MODEL_COUNT) {{
+        return;
+    }}
+    ModelEntry *e = &g_models[id];
+    if (e->ref_count > 0) {{
+        e->ref_count--;
+    }}
+}}
+
+// Unload a model and free its resources.
+// Note: Models are cached by default for performance. Call this explicitly
+// when transitioning between scenes that use different model sets, or when
+// memory pressure requires freeing unused models.
+void models_unload(ModelId id)
+{{
+    if (id < 0 || id >= MODEL_COUNT) {{
+        return;
+    }}
+
+    ModelEntry *e = &g_models[id];
+    if (e->loaded) {{
+        if (e->model) {{
+            t3d_model_free(e->model);
+            e->model = NULL;
+        }}
+        if (e->dpl) {{
+            rspq_block_free(e->dpl);
+            e->dpl = NULL;
+        }}
+        e->ref_count = 0;
+        e->loaded = 0;
+    }}
+}}
+
+// Unload only models with zero references (safe after scene transition)
+void models_unload_unused(void)
+{{
+    for (uint8_t i = 0; i < MODEL_COUNT; i++) {{
+        if (g_models[i].loaded && g_models[i].ref_count == 0) {{
+            models_unload(i);
+        }}
+    }}
+}}
+
+// Unload all models to free memory (useful before scene transitions)
+void models_unload_all(void)
+{{
+    for (uint8_t i = 0; i < MODEL_COUNT; i++) {{
+        models_unload(i);
+    }}
+}}
diff --git a/armorcore/Deployment/n64/src/data/models.h.j2 b/armorcore/Deployment/n64/src/data/models.h.j2
new file mode 100644
index 0000000000..c50b802779
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/models.h.j2
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <t3d/t3dmodel.h>
+#include <rspq.h>
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+typedef enum {{
+{model_enum_entries}
+    MODEL_COUNT = {model_count}
+}} ModelId;
+
+void models_init(void);
+void models_shutdown(void);
+
+T3DModel *models_get(ModelId id);
+rspq_block_t *models_get_dpl(ModelId id);
+
+void models_release(ModelId id);          // Release a reference to a model
+void models_unload(ModelId id);           // Force unload a model
+void models_unload_unused(void);          // Unload models with zero references
+void models_unload_all(void);             // Unload all models to free memory
+
+#ifdef __cplusplus
+}}
+#endif
diff --git a/armorcore/Deployment/n64/src/data/scenes.c.j2 b/armorcore/Deployment/n64/src/data/scenes.c.j2
new file mode 100644
index 0000000000..24818d218f
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/scenes.c.j2
@@ -0,0 +1,396 @@
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmodel.h>
+#include <string.h>
+
+#include "../types.h"
+#include "../engine.h"
+#include "../renderer.h"
+#include "scenes.h"
+
+#if ENGINE_ENABLE_PHYSICS
+#include "../oimo/physics.h"
+#endif
+
+static ArmScene g_scenes[SCENE_COUNT];
+static SceneId g_current_scene = SCENE_COUNT;
+static SceneId g_pending_scene = SCENE_COUNT;
+
+void scene_init(SceneId id)
+{{
+    if (id >= SCENE_COUNT) return;
+    g_current_scene = id;
+
+    switch (id) {{
+{scene_init_switch_cases}
+		default: break;
+    }}
+	scene_on_ready(id);
+}}
+
+void scene_on_ready(SceneId id)
+{{
+	ArmScene *s = &g_scenes[id];
+
+	for (uint8_t i = 0; i < s->trait_count; i++) {{
+		if (s->traits[i].on_ready) s->traits[i].on_ready(s, s->traits[i].data);
+	}}
+	if (s->cameras) {{
+		for (uint8_t i = 0; i < s->camera_count; i++) {{
+			for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+				if (s->cameras[i].traits[t].on_ready) s->cameras[i].traits[t].on_ready(&s->cameras[i], s->cameras[i].traits[t].data);
+			}}
+		}}
+	}}
+	if (s->lights) {{
+		for (uint8_t i = 0; i < s->light_count; i++) {{
+			for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+				if (s->lights[i].traits[t].on_ready) s->lights[i].traits[t].on_ready(&s->lights[i], s->lights[i].traits[t].data);
+			}}
+		}}
+	}}
+	if (s->objects) {{
+		for (uint16_t i = 0; i < s->object_count; i++) {{
+			if (s->objects[i].is_removed) continue;
+			for (uint8_t t = 0; t < s->objects[i].trait_count; t++) {{
+				if (s->objects[i].traits[t].on_ready) s->objects[i].traits[t].on_ready(&s->objects[i], s->objects[i].traits[t].data);
+			}}
+		}}
+	}}
+}}
+
+void scene_on_fixed_update(SceneId id, float dt)
+{{
+	ArmScene *s = &g_scenes[id];
+
+	// Scene-level traits
+	for (uint8_t i = 0; i < s->trait_count; i++) {{
+		if (s->traits[i].on_fixed_update) s->traits[i].on_fixed_update(s, dt, s->traits[i].data);
+	}}
+
+	// Cameras (usually 1, direct iteration is fine)
+	if (s->cameras) {{
+		for (uint8_t i = 0; i < s->camera_count; i++) {{
+			if (!(s->cameras[i].lifecycle_flags & ARM_LIFECYCLE_FIXED_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+				if (s->cameras[i].traits[t].on_fixed_update) s->cameras[i].traits[t].on_fixed_update(&s->cameras[i], dt, s->cameras[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Lights (usually few, direct iteration is fine)
+	if (s->lights) {{
+		for (uint8_t i = 0; i < s->light_count; i++) {{
+			if (!(s->lights[i].lifecycle_flags & ARM_LIFECYCLE_FIXED_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+				if (s->lights[i].traits[t].on_fixed_update) s->lights[i].traits[t].on_fixed_update(&s->lights[i], dt, s->lights[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Objects - use active list for O(active) instead of O(total)
+	if (s->active_objects && s->active_trait_count > 0) {{
+		for (uint16_t i = 0; i < s->active_trait_count; i++) {{
+			ArmObject *obj = &s->objects[s->active_objects[i]];
+			if (obj->is_removed || !(obj->lifecycle_flags & ARM_LIFECYCLE_FIXED_UPDATE)) continue;
+			for (uint8_t t = 0; t < obj->trait_count; t++) {{
+				if (obj->traits[t].on_fixed_update) obj->traits[t].on_fixed_update(obj, dt, obj->traits[t].data);
+			}}
+		}}
+	}}
+}}
+
+void scene_sync_physics(SceneId id)
+{{
+#if ENGINE_ENABLE_PHYSICS
+	ArmScene *s = &g_scenes[id];
+	if (s->objects) {{
+		for (uint16_t i = 0; i < s->object_count; i++) {{
+			if (s->objects[i].is_removed) continue;
+			physics_sync_object(&s->objects[i]);
+		}}
+	}}
+#else
+	(void)id;
+#endif
+}}
+
+void scene_on_update(SceneId id, float dt)
+{{
+	ArmScene *s = &g_scenes[id];
+
+	// Scene-level traits
+	for (uint8_t i = 0; i < s->trait_count; i++) {{
+		if (s->traits[i].on_update) s->traits[i].on_update(s, dt, s->traits[i].data);
+	}}
+
+	// Cameras
+	if (s->cameras) {{
+		for (uint8_t i = 0; i < s->camera_count; i++) {{
+			if (!(s->cameras[i].lifecycle_flags & ARM_LIFECYCLE_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+				if (s->cameras[i].traits[t].on_update) s->cameras[i].traits[t].on_update(&s->cameras[i], dt, s->cameras[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Lights
+	if (s->lights) {{
+		for (uint8_t i = 0; i < s->light_count; i++) {{
+			if (!(s->lights[i].lifecycle_flags & ARM_LIFECYCLE_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+				if (s->lights[i].traits[t].on_update) s->lights[i].traits[t].on_update(&s->lights[i], dt, s->lights[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Objects - use active list
+	if (s->active_objects && s->active_trait_count > 0) {{
+		for (uint16_t i = 0; i < s->active_trait_count; i++) {{
+			ArmObject *obj = &s->objects[s->active_objects[i]];
+			if (obj->is_removed || !(obj->lifecycle_flags & ARM_LIFECYCLE_UPDATE)) continue;
+			for (uint8_t t = 0; t < obj->trait_count; t++) {{
+				if (obj->traits[t].on_update) obj->traits[t].on_update(obj, dt, obj->traits[t].data);
+			}}
+		}}
+	}}
+}}
+
+void scene_on_late_update(SceneId id, float dt)
+{{
+	ArmScene *s = &g_scenes[id];
+
+	// Scene-level traits
+	for (uint8_t i = 0; i < s->trait_count; i++) {{
+		if (s->traits[i].on_late_update) s->traits[i].on_late_update(s, dt, s->traits[i].data);
+	}}
+
+	// Cameras
+	if (s->cameras) {{
+		for (uint8_t i = 0; i < s->camera_count; i++) {{
+			if (!(s->cameras[i].lifecycle_flags & ARM_LIFECYCLE_LATE_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+				if (s->cameras[i].traits[t].on_late_update) s->cameras[i].traits[t].on_late_update(&s->cameras[i], dt, s->cameras[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Lights
+	if (s->lights) {{
+		for (uint8_t i = 0; i < s->light_count; i++) {{
+			if (!(s->lights[i].lifecycle_flags & ARM_LIFECYCLE_LATE_UPDATE)) continue;
+			for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+				if (s->lights[i].traits[t].on_late_update) s->lights[i].traits[t].on_late_update(&s->lights[i], dt, s->lights[i].traits[t].data);
+			}}
+		}}
+	}}
+
+	// Objects - use active list
+	if (s->active_objects && s->active_trait_count > 0) {{
+		for (uint16_t i = 0; i < s->active_trait_count; i++) {{
+			ArmObject *obj = &s->objects[s->active_objects[i]];
+			if (obj->is_removed || !(obj->lifecycle_flags & ARM_LIFECYCLE_LATE_UPDATE)) continue;
+			for (uint8_t t = 0; t < obj->trait_count; t++) {{
+				if (obj->traits[t].on_late_update) obj->traits[t].on_late_update(obj, dt, obj->traits[t].data);
+			}}
+		}}
+	}}
+}}
+
+void scene_on_remove(SceneId id)
+{{
+	ArmScene *s = &g_scenes[id];
+
+	for (uint8_t i = 0; i < s->trait_count; i++) {{
+		if (s->traits[i].on_remove) s->traits[i].on_remove(s, s->traits[i].data);
+	}}
+	if (s->cameras) {{
+		for (uint8_t i = 0; i < s->camera_count; i++) {{
+			for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+				if (s->cameras[i].traits[t].on_remove) s->cameras[i].traits[t].on_remove(&s->cameras[i], s->cameras[i].traits[t].data);
+			}}
+		}}
+	}}
+	if (s->lights) {{
+		for (uint8_t i = 0; i < s->light_count; i++) {{
+			for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+				if (s->lights[i].traits[t].on_remove) s->lights[i].traits[t].on_remove(&s->lights[i], s->lights[i].traits[t].data);
+			}}
+		}}
+	}}
+	if (s->objects) {{
+		for (uint16_t i = 0; i < s->object_count; i++) {{
+			for (uint8_t t = 0; t < s->objects[i].trait_count; t++) {{
+				if (s->objects[i].traits[t].on_remove) s->objects[i].traits[t].on_remove(&s->objects[i], s->objects[i].traits[t].data);
+			}}
+		}}
+	}}
+}}
+
+void scene_clear(SceneId id)
+{{
+    if (id >= SCENE_COUNT) return;
+
+    ArmScene *s = &g_scenes[id];
+    scene_on_remove(id);
+
+    // Free static display list
+    renderer_free_static_dpl(s);
+
+    // Free object resources
+    if (s->objects != NULL) {{
+        for (uint16_t i = 0; i < s->object_count; i++) {{
+#if ENGINE_ENABLE_PHYSICS
+            if (s->objects[i].rigid_body) physics_remove_body(&s->objects[i]);
+#endif
+            if (s->objects[i].model_mat) {{ free_uncached(s->objects[i].model_mat); s->objects[i].model_mat = NULL; }}
+            // Free trait data (malloc'd) before freeing traits array
+            if (s->objects[i].traits) {{
+                for (uint8_t t = 0; t < s->objects[i].trait_count; t++) {{
+                    if (s->objects[i].traits[t].data) {{ free(s->objects[i].traits[t].data); s->objects[i].traits[t].data = NULL; }}
+                }}
+                free(s->objects[i].traits);
+                s->objects[i].traits = NULL;
+            }}
+            s->objects[i].dpl = NULL;
+            s->objects[i].trait_count = 0;
+        }}
+    }}
+
+    // Free camera trait data
+    if (s->cameras != NULL) {{
+        for (uint8_t i = 0; i < s->camera_count; i++) {{
+            if (s->cameras[i].traits) {{
+                for (uint8_t t = 0; t < s->cameras[i].trait_count; t++) {{
+                    if (s->cameras[i].traits[t].data) {{ free(s->cameras[i].traits[t].data); s->cameras[i].traits[t].data = NULL; }}
+                }}
+                free(s->cameras[i].traits);
+                s->cameras[i].traits = NULL;
+            }}
+            s->cameras[i].trait_count = 0;
+        }}
+    }}
+
+    // Free light trait data
+    if (s->lights != NULL) {{
+        for (uint8_t i = 0; i < s->light_count; i++) {{
+            if (s->lights[i].traits) {{
+                for (uint8_t t = 0; t < s->lights[i].trait_count; t++) {{
+                    if (s->lights[i].traits[t].data) {{ free(s->lights[i].traits[t].data); s->lights[i].traits[t].data = NULL; }}
+                }}
+                free(s->lights[i].traits);
+                s->lights[i].traits = NULL;
+            }}
+            s->lights[i].trait_count = 0;
+        }}
+    }}
+
+    // Free scene-level trait data (note: scene_traits array itself is static, don't free it)
+    if (s->traits != NULL) {{
+        for (uint8_t i = 0; i < s->trait_count; i++) {{
+            if (s->traits[i].data) {{ free(s->traits[i].data); s->traits[i].data = NULL; }}
+        }}
+        // Don't free s->traits - it's a static array
+        s->traits = NULL;
+    }}
+
+	s->world.clear_color[0] = s->world.clear_color[1] = s->world.clear_color[2] = 0;
+	s->world.clear_color[3] = 0xFF;
+	s->world.ambient_color[0] = s->world.ambient_color[1] = s->world.ambient_color[2] = 0;
+	s->world.ambient_color[3] = 0xFF;
+	s->cameras = NULL;
+	s->camera_count = 0;
+	s->active_camera_id = 0;
+	s->lights = NULL;
+	s->light_count = 0;
+	s->objects = NULL;
+	s->object_count = 0;
+	s->active_count = 0;
+	s->free_list = NULL;
+	s->free_count = 0;
+	s->free_capacity = 0;
+	s->active_objects = NULL;
+	s->active_trait_count = 0;
+    s->trait_count = 0;
+    s->lifecycle_flags = 0;
+}}
+
+ArmScene *scene_get(SceneId id)
+{{
+    if (id >= SCENE_COUNT) return NULL;
+    return &g_scenes[id];
+}}
+
+// Scene name to ID lookup table
+static const struct {{ const char *name; SceneId id; }} g_scene_names[] = {{
+{scene_name_entries}
+}};
+
+SceneId scene_get_id_by_name(const char *name)
+{{
+    if (name == NULL) return SCENE_COUNT;
+    for (int i = 0; i < {scene_count}; i++) {{
+        if (strcmp(g_scene_names[i].name, name) == 0) {{
+            return g_scene_names[i].id;
+        }}
+    }}
+    return SCENE_COUNT; // Not found
+}}
+
+SceneId scene_get_current_id(void) {{ return g_current_scene; }}
+SceneId scene_get_pending(void) {{ return g_pending_scene; }}
+void scene_switch_to(SceneId id) {{ g_pending_scene = id; }}
+void scene_clear_pending(void) {{ g_pending_scene = SCENE_COUNT; }}
+
+// =============================================================================
+// Object Pool Management
+// =============================================================================
+
+void scene_recycle_object(SceneId id, ArmObject *obj)
+{{
+    if (id >= SCENE_COUNT) return;
+    ArmScene *s = &g_scenes[id];
+
+    if (!obj || !s->free_list) return;
+
+    // Find object index in the array
+    ptrdiff_t idx = obj - s->objects;
+    if (idx < 0 || idx >= s->object_count) return;
+
+    // Add to free list if there's room
+    if (s->free_count < s->free_capacity) {{
+        s->free_list[s->free_count++] = (uint16_t)idx;
+        s->active_count--;
+    }}
+}}
+
+ArmObject *scene_alloc_object(SceneId id)
+{{
+    if (id >= SCENE_COUNT) return NULL;
+    ArmScene *s = &g_scenes[id];
+
+    if (!s->free_list || s->free_count == 0) {{
+        debugf("Scene: object pool exhausted\\n");
+        return NULL;
+    }}
+
+    // Pop from free list (LIFO for cache locality)
+    uint16_t idx = s->free_list[--s->free_count];
+    ArmObject *obj = &s->objects[idx];
+
+    // Reset object to clean state
+    memset(obj, 0, sizeof(ArmObject));
+    obj->visible = true;
+    obj->transform.scale = (T3DVec3){{{{1.0f, 1.0f, 1.0f}}}};
+    obj->transform.rot = (T3DQuat){{{{0.0f, 0.0f, 0.0f, 1.0f}}}};
+    obj->transform.dirty = TRANSFORM_DIRTY_FRAMES;
+
+    s->active_count++;
+    return obj;
+}}
+
+uint16_t scene_get_active_count(SceneId id)
+{{
+    if (id >= SCENE_COUNT) return 0;
+    return g_scenes[id].active_count;
+}}
diff --git a/armorcore/Deployment/n64/src/data/scenes.h.j2 b/armorcore/Deployment/n64/src/data/scenes.h.j2
new file mode 100644
index 0000000000..32b7f55f16
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/scenes.h.j2
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "../types.h"
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+typedef enum SceneId {{
+{scene_enum_entries}
+    SCENE_COUNT = {scene_count}
+}} SceneId;
+
+{scene_declarations}
+
+void scene_init(SceneId id);
+void scene_on_ready(SceneId id);
+void scene_on_fixed_update(SceneId id, float dt);
+void scene_on_update(SceneId id, float dt);
+void scene_on_late_update(SceneId id, float dt);
+void scene_on_remove(SceneId id);
+void scene_clear(SceneId id);
+
+void scene_sync_physics(SceneId id);
+
+void scene_switch_to(SceneId id);
+SceneId scene_get_id_by_name(const char *name);
+SceneId scene_get_current_id(void);
+SceneId scene_get_pending(void);
+void scene_clear_pending(void);
+
+ArmScene *scene_get(SceneId id);
+
+// Object pool management
+// Recycle a removed object's slot back to the pool for reuse
+void scene_recycle_object(SceneId id, ArmObject *obj);
+
+// Allocate an object slot from the pool (returns NULL if pool exhausted)
+ArmObject *scene_alloc_object(SceneId id);
+
+// Get count of active (non-removed) objects
+uint16_t scene_get_active_count(SceneId id);
+
+#ifdef __cplusplus
+}}
+#endif
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/data/traits.c.j2 b/armorcore/Deployment/n64/src/data/traits.c.j2
new file mode 100644
index 0000000000..b23c9258fe
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/traits.c.j2
@@ -0,0 +1,24 @@
+#include "traits.h"
+#include "scenes.h"
+#include "../types.h"
+#include "../engine.h"
+#include "../utils.h"
+#include "../events/trait_events.h"
+#include "../iron/object/transform.h"
+#include "../iron/object/object.h"
+#include "../iron/system/input.h"
+#include <math.h>
+
+#if ENGINE_ENABLE_PHYSICS
+#include "../events/physics_events.h"
+#include "../oimo/physics.h"
+#endif
+
+#if ENGINE_ENABLE_UI
+#include "../koui/koui.h"
+#endif
+
+// Global signals (shared across traits)
+{global_signals}
+
+{trait_implementations}
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/data/traits.h.j2 b/armorcore/Deployment/n64/src/data/traits.h.j2
new file mode 100644
index 0000000000..cfa822d1fa
--- /dev/null
+++ b/armorcore/Deployment/n64/src/data/traits.h.j2
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "scenes.h"
+#include "../types.h"
+#include "../engine.h"
+#include "../events/trait_events.h"
+#include "../iron/system/input.h"
+
+#if ENGINE_ENABLE_UI
+#include "../koui/koui.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+// Trait data structures (for per-instance data)
+{trait_data_structs}
+
+// Trait function declarations
+{trait_declarations}
+
+// Event handler declarations
+{event_handler_declarations}
+
+#ifdef __cplusplus
+}}
+#endif
diff --git a/armorcore/Deployment/n64/src/engine.c b/armorcore/Deployment/n64/src/engine.c
new file mode 100644
index 0000000000..719c10b6c5
--- /dev/null
+++ b/armorcore/Deployment/n64/src/engine.c
@@ -0,0 +1,45 @@
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmodel.h>
+
+#include "types.h"
+#include "engine.h"
+#include "data/models.h"
+#include "iron/system/input.h"
+#if ENGINE_ENABLE_PHYSICS
+#include "oimo/physics.h"
+#endif
+
+void engine_init(void)
+{
+    debug_init_isviewer();
+    debug_init_usblog();
+
+    asset_init_compression(2);
+    dfs_init(DFS_DEFAULT_LOCATION);
+
+    display_init(RESOLUTION_320x240, DEPTH_16_BPP, FB_COUNT, GAMMA_NONE, FILTERS_RESAMPLE_ANTIALIAS);
+
+    rdpq_init();
+#ifdef ARM_DEBUG_HUD
+	rdpq_debug_start();
+#endif
+    t3d_init((T3DInitParams){});
+    rdpq_text_register_font(FONT_BUILTIN_DEBUG_MONO, rdpq_font_load_builtin(FONT_BUILTIN_DEBUG_MONO));
+
+    input_init();
+    models_init();
+
+#if ENGINE_ENABLE_PHYSICS
+    physics_init();
+#endif
+}
+
+void engine_shutdown(void)
+{
+#if ENGINE_ENABLE_PHYSICS
+    physics_shutdown();
+#endif
+    models_shutdown();
+    t3d_destroy();
+}
diff --git a/armorcore/Deployment/n64/src/engine.h.j2 b/armorcore/Deployment/n64/src/engine.h.j2
new file mode 100644
index 0000000000..19b189c5dd
--- /dev/null
+++ b/armorcore/Deployment/n64/src/engine.h.j2
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmodel.h>
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+#define ENGINE_ENABLE_PHYSICS {enable_physics}
+#define ENGINE_ENABLE_PHYSICS_DEBUG {enable_physics_debug}
+#define ENGINE_ENABLE_UI {enable_ui}
+
+void engine_init(void);
+void engine_shutdown(void);
+
+#ifdef __cplusplus
+}}
+#endif
diff --git a/armorcore/Deployment/n64/src/events/physics_events.c b/armorcore/Deployment/n64/src/events/physics_events.c
new file mode 100644
index 0000000000..fac3c6aca2
--- /dev/null
+++ b/armorcore/Deployment/n64/src/events/physics_events.c
@@ -0,0 +1,157 @@
+// physics_events.c - Per-object physics contact event subscriptions
+#include "physics_events.h"
+#include "../oimo/physics.h"
+#include <string.h>
+
+// Static storage for body contact subscriptions
+static BodyContactSubs g_body_subs[MAX_CONTACT_BODIES];
+static int g_body_sub_count = 0;
+
+void physics_contact_init(void)
+{
+    memset(g_body_subs, 0, sizeof(g_body_subs));
+    g_body_sub_count = 0;
+}
+
+void physics_contact_clear(void)
+{
+    memset(g_body_subs, 0, sizeof(g_body_subs));
+    g_body_sub_count = 0;
+}
+
+// Find or create subscription slot for a rigid body
+static BodyContactSubs* find_or_create_body_subs(OimoRigidBody* rb)
+{
+    // Find existing
+    for (int i = 0; i < g_body_sub_count; i++) {
+        if (g_body_subs[i].rb == rb) {
+            return &g_body_subs[i];
+        }
+    }
+    // Create new if space available
+    if (g_body_sub_count >= MAX_CONTACT_BODIES) {
+        return NULL;
+    }
+    BodyContactSubs* slot = &g_body_subs[g_body_sub_count++];
+    slot->rb = rb;
+    slot->count = 0;
+    return slot;
+}
+
+// Find subscription slot for a rigid body
+static BodyContactSubs* find_body_subs(OimoRigidBody* rb)
+{
+    for (int i = 0; i < g_body_sub_count; i++) {
+        if (g_body_subs[i].rb == rb) {
+            return &g_body_subs[i];
+        }
+    }
+    return NULL;
+}
+
+void physics_contact_subscribe(OimoRigidBody* rb, PhysicsContactHandler handler, void* obj, void* data)
+{
+    if (!rb || !handler) return;
+
+    BodyContactSubs* subs = find_or_create_body_subs(rb);
+    if (!subs || subs->count >= MAX_CONTACT_SUBSCRIBERS) return;
+
+    subs->subs[subs->count].handler = handler;
+    subs->subs[subs->count].obj = obj;
+    subs->subs[subs->count].data = data;
+    subs->count++;
+}
+
+void physics_contact_unsubscribe(OimoRigidBody* rb, PhysicsContactHandler handler, void* obj)
+{
+    if (!rb || !handler) return;
+
+    BodyContactSubs* subs = find_body_subs(rb);
+    if (!subs) return;
+
+    // Find and remove matching subscription
+    for (int i = 0; i < subs->count; ) {
+        if (subs->subs[i].handler == handler && subs->subs[i].obj == obj) {
+            // Shift remaining elements
+            for (int j = i; j < subs->count - 1; j++) {
+                subs->subs[j] = subs->subs[j + 1];
+            }
+            subs->count--;
+        } else {
+            i++;
+        }
+    }
+}
+
+void physics_contact_unsubscribe_all(void* obj)
+{
+    for (int b = 0; b < g_body_sub_count; b++) {
+        BodyContactSubs* subs = &g_body_subs[b];
+        for (int i = 0; i < subs->count; ) {
+            if (subs->subs[i].obj == obj) {
+                // Shift remaining elements
+                for (int j = i; j < subs->count - 1; j++) {
+                    subs->subs[j] = subs->subs[j + 1];
+                }
+                subs->count--;
+            } else {
+                i++;
+            }
+        }
+    }
+}
+
+void physics_contact_dispatch(void)
+{
+    // Fast path: skip entirely if no bodies have contact subscriptions
+    if (g_body_sub_count == 0) return;
+
+    // Called after physics step
+    // Iterate all touching contacts and dispatch to subscribed handlers
+    OimoWorld* world = physics_get_world();
+    if (!world) return;
+
+    OimoContact* contact = world->_contactManager._contactList;
+    while (contact != NULL) {
+        // Only process touching contacts
+        if (contact->_touching) {
+            // Get both bodies' ArmObject pointers
+            OimoRigidBody* rb1 = contact->_b1;
+            OimoRigidBody* rb2 = contact->_b2;
+
+            // Early exit: check if either body has subscribers before getting objects
+            BodyContactSubs* subs1 = find_body_subs(rb1);
+            BodyContactSubs* subs2 = find_body_subs(rb2);
+
+            // Skip this contact if neither body has subscribers
+            if (!subs1 && !subs2) {
+                contact = contact->_next;
+                continue;
+            }
+
+            ArmObject* obj1 = (ArmObject*)rb1->userData;
+            ArmObject* obj2 = (ArmObject*)rb2->userData;
+
+            // Skip if either object has been marked for removal
+            if (!obj1 || !obj2 || obj1->is_removed || obj2->is_removed) {
+                contact = contact->_next;
+                continue;
+            }
+
+            // Dispatch to body1's subscribers with body2 as "other"
+            if (subs1) {
+                for (int i = 0; i < subs1->count; i++) {
+                    subs1->subs[i].handler(subs1->subs[i].obj, subs1->subs[i].data, obj2);
+                }
+            }
+
+            // Dispatch to body2's subscribers with body1 as "other"
+            if (subs2) {
+                for (int i = 0; i < subs2->count; i++) {
+                    subs2->subs[i].handler(subs2->subs[i].obj, subs2->subs[i].data, obj1);
+                }
+            }
+        }
+        contact = contact->_next;
+    }
+}
diff --git a/armorcore/Deployment/n64/src/events/physics_events.h.j2 b/armorcore/Deployment/n64/src/events/physics_events.h.j2
new file mode 100644
index 0000000000..51d345cea2
--- /dev/null
+++ b/armorcore/Deployment/n64/src/events/physics_events.h.j2
@@ -0,0 +1,74 @@
+// physics_events.h - Per-object physics contact event subscriptions
+#pragma once
+
+#include "../types.h"
+#include "../oimo/oimo.h"
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+/**
+ * Physics Contact Event System
+ *
+ * Similar to trait_events for input, but for physics contacts.
+ * Traits can subscribe to contact notifications for specific rigid bodies.
+ *
+ * Usage:
+ *   physics_contact_subscribe(rb, handler, obj, data);  // In on_ready
+ *   physics_contact_unsubscribe(rb, handler, obj);      // In on_remove
+ *   physics_contact_dispatch();                         // Called by physics_step
+ */
+
+// Maximum contact subscriptions per rigid body
+#define MAX_CONTACT_SUBSCRIBERS {max_contact_subscribers}
+
+// Maximum rigid bodies with contact subscriptions
+#define MAX_CONTACT_BODIES {max_contact_bodies}
+
+// Contact handler signature: (obj, data, other_obj)
+// - obj: the object this trait is attached to
+// - data: trait data pointer
+// - other_obj: the object we collided with
+typedef void (*PhysicsContactHandler)(void* obj, void* data, ArmObject* other);
+
+// Subscription entry
+typedef struct {{
+    PhysicsContactHandler handler;
+    void* obj;
+    void* data;
+}} PhysicsContactSub;
+
+// Per-body subscriptions
+typedef struct {{
+    OimoRigidBody* rb;
+    PhysicsContactSub subs[MAX_CONTACT_SUBSCRIBERS];
+    uint8_t count;
+}} BodyContactSubs;
+
+// Initialize contact event system
+void physics_contact_init(void);
+
+// Clear all subscriptions (call on scene change)
+void physics_contact_clear(void);
+
+// Subscribe to contact events for a rigid body
+// handler: function to call on contact
+// obj: object pointer (usually the ArmObject with this rigid body)
+// data: trait data pointer
+void physics_contact_subscribe(OimoRigidBody* rb, PhysicsContactHandler handler, void* obj, void* data);
+
+// Unsubscribe from contact events
+// Matches by rb + handler + obj (same as subscribe)
+void physics_contact_unsubscribe(OimoRigidBody* rb, PhysicsContactHandler handler, void* obj);
+
+// Unsubscribe all handlers for an object (call when trait is removed)
+void physics_contact_unsubscribe_all(void* obj);
+
+// Dispatch contact events for all touching bodies
+// Called internally by physics_step after world simulation
+void physics_contact_dispatch(void);
+
+#ifdef __cplusplus
+}}
+#endif
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/events/trait_events.c b/armorcore/Deployment/n64/src/events/trait_events.c
new file mode 100644
index 0000000000..9f6497689e
--- /dev/null
+++ b/armorcore/Deployment/n64/src/events/trait_events.c
@@ -0,0 +1,171 @@
+#include "trait_events.h"
+#include "../iron/system/input.h"
+#include <string.h>
+
+static TraitEventState g_events;
+
+void trait_events_init(void)
+{
+    memset(&g_events, 0, sizeof(g_events));
+}
+
+void trait_events_clear(void)
+{
+    memset(&g_events, 0, sizeof(g_events));
+}
+
+void trait_events_subscribe_started(N64Button btn, TraitEventHandler handler, void* obj, void* data)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    if (subs->started_count >= MAX_BUTTON_SUBSCRIBERS) return;
+
+    subs->started[subs->started_count].handler = handler;
+    subs->started[subs->started_count].obj = obj;
+    subs->started[subs->started_count].data = data;
+    subs->started_count++;
+
+    // Set bitmask flag for fast dispatch
+    g_events.has_started_subs |= (1 << btn);
+}
+
+void trait_events_subscribe_released(N64Button btn, TraitEventHandler handler, void* obj, void* data)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    if (subs->released_count >= MAX_BUTTON_SUBSCRIBERS) return;
+
+    subs->released[subs->released_count].handler = handler;
+    subs->released[subs->released_count].obj = obj;
+    subs->released[subs->released_count].data = data;
+    subs->released_count++;
+
+    // Set bitmask flag for fast dispatch
+    g_events.has_released_subs |= (1 << btn);
+}
+
+void trait_events_subscribe_down(N64Button btn, TraitEventHandler handler, void* obj, void* data)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    if (subs->down_count >= MAX_BUTTON_SUBSCRIBERS) return;
+
+    subs->down[subs->down_count].handler = handler;
+    subs->down[subs->down_count].obj = obj;
+    subs->down[subs->down_count].data = data;
+    subs->down_count++;
+
+    // Set bitmask flag for fast dispatch
+    g_events.has_down_subs |= (1 << btn);
+}
+
+// Helper to remove subscription from an array by object pointer
+static void remove_sub_by_obj(TraitEventSub* subs, uint8_t* count, void* obj)
+{
+    for (int i = 0; i < *count; ) {
+        if (subs[i].obj == obj) {
+            // Shift remaining elements down
+            for (int j = i; j < *count - 1; j++) {
+                subs[j] = subs[j + 1];
+            }
+            (*count)--;
+        } else {
+            i++;
+        }
+    }
+}
+
+// Helper to update bitmask after unsubscribe
+static void update_bitmask(uint16_t* mask, int btn, uint8_t count)
+{
+    if (count == 0) {
+        *mask &= ~(1 << btn);
+    }
+}
+
+void trait_events_unsubscribe_started(N64Button btn, void* obj)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    remove_sub_by_obj(subs->started, &subs->started_count, obj);
+    update_bitmask(&g_events.has_started_subs, btn, subs->started_count);
+}
+
+void trait_events_unsubscribe_released(N64Button btn, void* obj)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    remove_sub_by_obj(subs->released, &subs->released_count, obj);
+    update_bitmask(&g_events.has_released_subs, btn, subs->released_count);
+}
+
+void trait_events_unsubscribe_down(N64Button btn, void* obj)
+{
+    if (btn >= N64_BTN_COUNT) return;
+    ButtonEventSubs* subs = &g_events.buttons[btn];
+    remove_sub_by_obj(subs->down, &subs->down_count, obj);
+    update_bitmask(&g_events.has_down_subs, btn, subs->down_count);
+}
+
+void trait_events_unsubscribe_all(void* obj)
+{
+    for (int btn = 0; btn < N64_BTN_COUNT; btn++) {
+        ButtonEventSubs* subs = &g_events.buttons[btn];
+        remove_sub_by_obj(subs->started, &subs->started_count, obj);
+        remove_sub_by_obj(subs->released, &subs->released_count, obj);
+        remove_sub_by_obj(subs->down, &subs->down_count, obj);
+        update_bitmask(&g_events.has_started_subs, btn, subs->started_count);
+        update_bitmask(&g_events.has_released_subs, btn, subs->released_count);
+        update_bitmask(&g_events.has_down_subs, btn, subs->down_count);
+    }
+}
+
+void trait_events_dispatch(float dt)
+{
+    // Fast path: skip entirely if no subscribers at all
+    if (g_events.has_started_subs == 0 &&
+        g_events.has_released_subs == 0 &&
+        g_events.has_down_subs == 0) {
+        return;
+    }
+
+    for (int btn = 0; btn < N64_BTN_COUNT; btn++) {
+        uint16_t btn_mask = (1 << btn);
+
+        // Dispatch "started" events - skip if no subscribers for this button
+        if ((g_events.has_started_subs & btn_mask) && input_started((N64Button)btn)) {
+            ButtonEventSubs* subs = &g_events.buttons[btn];
+            for (uint8_t i = 0; i < subs->started_count; i++) {
+                subs->started[i].handler(
+                    subs->started[i].obj,
+                    subs->started[i].data,
+                    dt
+                );
+            }
+        }
+
+        // Dispatch "released" events - skip if no subscribers for this button
+        if ((g_events.has_released_subs & btn_mask) && input_released((N64Button)btn)) {
+            ButtonEventSubs* subs = &g_events.buttons[btn];
+            for (uint8_t i = 0; i < subs->released_count; i++) {
+                subs->released[i].handler(
+                    subs->released[i].obj,
+                    subs->released[i].data,
+                    dt
+                );
+            }
+        }
+
+        // Dispatch "down" events - skip if no subscribers for this button
+        if ((g_events.has_down_subs & btn_mask) && input_down((N64Button)btn)) {
+            ButtonEventSubs* subs = &g_events.buttons[btn];
+            for (uint8_t i = 0; i < subs->down_count; i++) {
+                subs->down[i].handler(
+                    subs->down[i].obj,
+                    subs->down[i].data,
+                    dt
+                );
+            }
+        }
+    }
+}
diff --git a/armorcore/Deployment/n64/src/events/trait_events.h.j2 b/armorcore/Deployment/n64/src/events/trait_events.h.j2
new file mode 100644
index 0000000000..0bfafd98eb
--- /dev/null
+++ b/armorcore/Deployment/n64/src/events/trait_events.h.j2
@@ -0,0 +1,78 @@
+#pragma once
+
+#include "../types.h"
+#include "../iron/system/input.h"
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+/**
+ * Event-driven trait system.
+ *
+ * Instead of checking input inside on_update, traits register handlers
+ * for specific button events. The engine polls input once and dispatches
+ * to all registered handlers.
+ *
+ * Event types:
+ *   - btn_<button>_started  - Button just pressed this frame
+ *   - btn_<button>_released - Button just released this frame
+ *   - btn_<button>_down     - Button held down
+ *
+ * Performance: Uses bitmask to skip buttons with no subscribers.
+ */
+
+// Maximum traits that can subscribe to a single button event
+#define MAX_BUTTON_SUBSCRIBERS {max_button_subscribers}
+
+// Event handler function signature: (obj, data, dt)
+typedef void (*TraitEventHandler)(void* obj, void* data, float dt);
+
+// Subscription entry: links a handler to an object/data pair
+typedef struct {{
+    TraitEventHandler handler;
+    void* obj;
+    void* data;
+}} TraitEventSub;
+
+// Per-button event subscriptions
+typedef struct {{
+    TraitEventSub started[MAX_BUTTON_SUBSCRIBERS];
+    TraitEventSub released[MAX_BUTTON_SUBSCRIBERS];
+    TraitEventSub down[MAX_BUTTON_SUBSCRIBERS];
+    uint8_t started_count;
+    uint8_t released_count;
+    uint8_t down_count;
+}} ButtonEventSubs;
+
+// Global event state
+typedef struct {{
+    ButtonEventSubs buttons[N64_BTN_COUNT];
+    uint16_t has_started_subs;   // Bitmask: which buttons have started subscribers
+    uint16_t has_released_subs;  // Bitmask: which buttons have released subscribers
+    uint16_t has_down_subs;      // Bitmask: which buttons have down subscribers
+}} TraitEventState;
+
+// Initialize event system (call once at startup)
+void trait_events_init(void);
+
+// Clear all subscriptions (call on scene change)
+void trait_events_clear(void);
+
+// Subscribe to button events
+void trait_events_subscribe_started(N64Button btn, TraitEventHandler handler, void* obj, void* data);
+void trait_events_subscribe_released(N64Button btn, TraitEventHandler handler, void* obj, void* data);
+void trait_events_subscribe_down(N64Button btn, TraitEventHandler handler, void* obj, void* data);
+
+// Unsubscribe from button events (by object pointer)
+void trait_events_unsubscribe_started(N64Button btn, void* obj);
+void trait_events_unsubscribe_released(N64Button btn, void* obj);
+void trait_events_unsubscribe_down(N64Button btn, void* obj);
+void trait_events_unsubscribe_all(void* obj);  // Remove all subscriptions for an object
+
+// Dispatch all button events (call once per frame after input_poll)
+void trait_events_dispatch(float dt);
+
+#ifdef __cplusplus
+}}
+#endif
diff --git a/armorcore/Deployment/n64/src/iron/object/object.c b/armorcore/Deployment/n64/src/iron/object/object.c
new file mode 100644
index 0000000000..7184e633d9
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/object/object.c
@@ -0,0 +1,82 @@
+// object.c - Object lifecycle management
+#include "object.h"
+#include "../../engine.h"
+#include "../../data/scenes.h"
+
+#if ENGINE_ENABLE_PHYSICS
+#include "../../events/physics_events.h"
+#include "../../oimo/physics.h"
+#endif
+
+// Deferred removal queue - objects are marked for removal but physics cleanup
+// is deferred until safe (after contact dispatch completes)
+#define MAX_PENDING_REMOVALS 32
+
+typedef struct {
+    ArmObject* obj;
+    SceneId scene_id;
+    bool recycle;  // Whether to recycle the slot back to pool
+} PendingRemoval;
+
+static PendingRemoval g_pending_removals[MAX_PENDING_REMOVALS];
+static uint8_t g_pending_count = 0;
+
+static void object_remove_internal(ArmObject* obj, SceneId scene_id, bool recycle)
+{
+    if (!obj || obj->is_removed) return;
+
+    // Mark as removed immediately - prevents further trait callbacks and rendering
+    obj->is_removed = true;
+    obj->visible = false;
+
+    // Call all trait on_remove callbacks
+    for (int i = 0; i < obj->trait_count; i++) {
+        if (obj->traits[i].on_remove) {
+            obj->traits[i].on_remove(obj, obj->traits[i].data);
+        }
+    }
+
+    // Clear traits
+    obj->trait_count = 0;
+
+    // Queue for deferred cleanup
+    if (g_pending_count < MAX_PENDING_REMOVALS) {
+        g_pending_removals[g_pending_count].obj = obj;
+        g_pending_removals[g_pending_count].scene_id = scene_id;
+        g_pending_removals[g_pending_count].recycle = recycle;
+        g_pending_count++;
+    }
+}
+
+void object_remove(ArmObject* obj)
+{
+    object_remove_internal(obj, scene_get_current_id(), false);
+}
+
+void object_remove_and_recycle(ArmObject* obj, SceneId scene_id)
+{
+    object_remove_internal(obj, scene_id, true);
+}
+
+void object_process_removals(void)
+{
+    for (uint8_t i = 0; i < g_pending_count; i++) {
+        PendingRemoval* pr = &g_pending_removals[i];
+        ArmObject* obj = pr->obj;
+
+        if (!obj) continue;
+
+#if ENGINE_ENABLE_PHYSICS
+        if (obj->rigid_body) {
+            physics_contact_unsubscribe_all(obj);
+            physics_remove_body(obj);
+        }
+#endif
+
+        // Recycle the slot back to the pool if requested
+        if (pr->recycle && pr->scene_id < SCENE_COUNT) {
+            scene_recycle_object(pr->scene_id, obj);
+        }
+    }
+    g_pending_count = 0;
+}
diff --git a/armorcore/Deployment/n64/src/iron/object/object.h b/armorcore/Deployment/n64/src/iron/object/object.h
new file mode 100644
index 0000000000..087983adf2
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/object/object.h
@@ -0,0 +1,40 @@
+// object.h - Object lifecycle management
+#pragma once
+
+#include "../../types.h"
+#include "../../data/scenes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Remove an object from the scene.
+ * - Queues the object for deferred removal (safe during physics callbacks)
+ * - Immediately hides the object
+ * - Actual cleanup happens in object_process_removals()
+ *
+ * Safe to call multiple times. Memory cleanup happens during scene_clear().
+ */
+void object_remove(ArmObject* obj);
+
+/**
+ * Remove an object and recycle its slot back to the pool.
+ * Use this version when you want the slot to be available for scene_alloc_object().
+ */
+void object_remove_and_recycle(ArmObject* obj, SceneId scene_id);
+
+/**
+ * Process all queued object removals.
+ * Call this after physics_update() / physics_contact_dispatch().
+ * - Calls all trait on_remove callbacks
+ * - Unsubscribes from physics contact events
+ * - Removes physics bodies
+ */
+void object_process_removals(void);
+
+// Future: light_remove, camera_remove
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/iron/object/transform.c b/armorcore/Deployment/n64/src/iron/object/transform.c
new file mode 100644
index 0000000000..f3291b0f89
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/object/transform.c
@@ -0,0 +1,115 @@
+#include "transform.h"
+#include "../../types.h"
+#include <t3d/t3dmath.h>
+#include <fmath.h>
+
+void it_translate(ArmTransform *t, float x, float y, float z)
+{
+	t->loc.x += x;
+	t->loc.y += y;
+	t->loc.z += z;
+	t->dirty = FB_COUNT;
+}
+
+void it_move(ArmTransform *t, float dx, float dy, float dz, float scale)
+{
+	t->loc.x += dx * scale;
+	t->loc.y += dy * scale;
+	t->loc.z += dz * scale;
+	t->dirty = FB_COUNT;
+}
+
+void it_rotate_axis(ArmTransform *t, float ax, float ay, float az, float angle)
+{
+	float axis[3] = {ax, ay, az};
+	t3d_quat_rotate_euler(&t->rot, axis, angle);
+	t->dirty = FB_COUNT;
+}
+
+void it_rotate_axis_global(ArmTransform *t, float ax, float ay, float az, float angle)
+{
+	fm_vec3_t axis = {{ax, ay, az}};
+	fm_quat_t axis_rot;
+	fm_quat_from_axis_angle(&axis_rot, &axis, angle);
+
+	fm_quat_t current = t->rot;
+	fm_quat_mul(&t->rot, &axis_rot, &current);
+
+	t->dirty = FB_COUNT;
+}
+
+void it_set_loc(ArmTransform *t, float x, float y, float z)
+{
+	t->loc.x = x;
+	t->loc.y = y;
+	t->loc.z = z;
+	t->dirty = FB_COUNT;
+}
+
+void it_set_rot(ArmTransform *t, float x, float y, float z, float w)
+{
+	t->rot.x = x;
+	t->rot.y = y;
+	t->rot.z = z;
+	t->rot.w = w;
+	t->dirty = FB_COUNT;
+}
+
+void it_set_rot_euler(ArmTransform *t, float x, float y, float z)
+{
+	// Convert Euler angles (radians) to quaternion
+	// Use libdragon's fm_sincosf for ~16x speedup over sinf/cosf
+	float sx, cx, sy, cy, sz, cz;
+	fm_sincosf(x * 0.5f, &sx, &cx);
+	fm_sincosf(y * 0.5f, &sy, &cy);
+	fm_sincosf(z * 0.5f, &sz, &cz);
+
+	t->rot.w = cx * cy * cz + sx * sy * sz;
+	t->rot.x = sx * cy * cz - cx * sy * sz;
+	t->rot.y = cx * sy * cz + sx * cy * sz;
+	t->rot.z = cx * cy * sz - sx * sy * cz;
+	t->dirty = FB_COUNT;
+}
+
+void it_set_scale(ArmTransform *t, float x, float y, float z)
+{
+	t->scale.x = x;
+	t->scale.y = y;
+	t->scale.z = z;
+	t->dirty = FB_COUNT;
+}
+
+void it_reset(ArmTransform *t)
+{
+	t->loc.v[0] = 0.0f; t->loc.v[1] = 0.0f; t->loc.v[2] = 0.0f;
+	t->rot.x = 0.0f; t->rot.y = 0.0f; t->rot.z = 0.0f; t->rot.w = 1.0f;
+	t->scale.v[0] = 1.0f; t->scale.v[1] = 1.0f; t->scale.v[2] = 1.0f;
+	t->dirty = FB_COUNT;
+}
+
+void it_look(const ArmTransform *t, T3DVec3 *out)
+{
+	// Forward direction from quaternion (local +Y rotated by quaternion)
+	const T3DQuat *q = &t->rot;
+	out->v[0] = 2.0f * (q->x * q->y + q->w * q->z);
+	out->v[1] = 1.0f - 2.0f * (q->x * q->x + q->z * q->z);
+	out->v[2] = 2.0f * (q->y * q->z - q->w * q->x);
+}
+
+void it_right(const ArmTransform *t, T3DVec3 *out)
+{
+	// Right direction from quaternion (local +X rotated by quaternion)
+	const T3DQuat *q = &t->rot;
+	out->v[0] = 1.0f - 2.0f * (q->y * q->y + q->z * q->z);
+	out->v[1] = 2.0f * (q->x * q->y - q->w * q->z);
+	out->v[2] = 2.0f * (q->x * q->z + q->w * q->y);
+}
+
+void it_up(const ArmTransform *t, T3DVec3 *out)
+{
+	// Up direction from quaternion (local +Z rotated by quaternion)
+	const T3DQuat *q = &t->rot;
+	out->v[0] = 2.0f * (q->x * q->z - q->w * q->y);
+	out->v[1] = 2.0f * (q->y * q->z + q->w * q->x);
+	out->v[2] = 1.0f - 2.0f * (q->x * q->x + q->y * q->y);
+}
diff --git a/armorcore/Deployment/n64/src/iron/object/transform.h b/armorcore/Deployment/n64/src/iron/object/transform.h
new file mode 100644
index 0000000000..bf79e9c27f
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/object/transform.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "../../types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Transform manipulation
+void it_translate(ArmTransform *t, float x, float y, float z);
+void it_move(ArmTransform *t, float dx, float dy, float dz, float scale);
+void it_rotate_axis(ArmTransform *t, float ax, float ay, float az, float angle);
+void it_rotate_axis_global(ArmTransform *t, float ax, float ay, float az, float angle);
+
+// Setters
+void it_set_loc(ArmTransform *t, float x, float y, float z);
+void it_set_rot(ArmTransform *t, float x, float y, float z, float w);
+void it_set_rot_euler(ArmTransform *t, float x, float y, float z);
+void it_set_scale(ArmTransform *t, float x, float y, float z);
+void it_reset(ArmTransform *t);
+
+// Direction vectors (returns in provided out vector)
+void it_look(const ArmTransform *t, T3DVec3 *out);
+void it_right(const ArmTransform *t, T3DVec3 *out);
+void it_up(const ArmTransform *t, T3DVec3 *out);
+
+// World position getters
+static inline float it_world_x(const ArmTransform *t) { return t->loc.x; }
+static inline float it_world_y(const ArmTransform *t) { return t->loc.y; }
+static inline float it_world_z(const ArmTransform *t) { return t->loc.z; }
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/iron/system/input.c b/armorcore/Deployment/n64/src/iron/system/input.c
new file mode 100644
index 0000000000..8133545e1d
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/system/input.c
@@ -0,0 +1,73 @@
+#include "input.h"
+#include <libdragon.h>
+
+#define STICK_MAX 85.0f
+
+static joypad_inputs_t current_inputs;
+static joypad_buttons_t pressed_buttons;
+static joypad_buttons_t released_buttons;
+
+void input_init(void)
+{
+    joypad_init();
+}
+
+void input_poll(void)
+{
+    joypad_poll();
+    current_inputs = joypad_get_inputs(JOYPAD_PORT_1);
+    pressed_buttons = joypad_get_buttons_pressed(JOYPAD_PORT_1);
+    released_buttons = joypad_get_buttons_released(JOYPAD_PORT_1);
+}
+
+static bool get_button(joypad_buttons_t buttons, N64Button btn)
+{
+    switch (btn) {
+        case N64_BTN_A:      return buttons.a;
+        case N64_BTN_B:      return buttons.b;
+        case N64_BTN_Z:      return buttons.z;
+        case N64_BTN_START:  return buttons.start;
+        case N64_BTN_DUP:    return buttons.d_up;
+        case N64_BTN_DDOWN:  return buttons.d_down;
+        case N64_BTN_DLEFT:  return buttons.d_left;
+        case N64_BTN_DRIGHT: return buttons.d_right;
+        case N64_BTN_L:      return buttons.l;
+        case N64_BTN_R:      return buttons.r;
+        case N64_BTN_CUP:    return buttons.c_up;
+        case N64_BTN_CDOWN:  return buttons.c_down;
+        case N64_BTN_CLEFT:  return buttons.c_left;
+        case N64_BTN_CRIGHT: return buttons.c_right;
+        default:             return false;
+    }
+}
+
+bool input_started(N64Button btn)
+{
+    return get_button(pressed_buttons, btn);
+}
+
+bool input_down(N64Button btn)
+{
+    return get_button(current_inputs.btn, btn);
+}
+
+bool input_released(N64Button btn)
+{
+    return get_button(released_buttons, btn);
+}
+
+float input_stick_x(void)
+{
+    float val = (float)current_inputs.stick_x / STICK_MAX;
+    if (val > 1.0f) val = 1.0f;
+    if (val < -1.0f) val = -1.0f;
+    return val;
+}
+
+float input_stick_y(void)
+{
+    float val = (float)current_inputs.stick_y / STICK_MAX;
+    if (val > 1.0f) val = 1.0f;
+    if (val < -1.0f) val = -1.0f;
+    return val;
+}
diff --git a/armorcore/Deployment/n64/src/iron/system/input.h b/armorcore/Deployment/n64/src/iron/system/input.h
new file mode 100644
index 0000000000..da17d8aee4
--- /dev/null
+++ b/armorcore/Deployment/n64/src/iron/system/input.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    N64_BTN_A = 0,
+    N64_BTN_B,
+    N64_BTN_Z,
+    N64_BTN_START,
+    N64_BTN_DUP,
+    N64_BTN_DDOWN,
+    N64_BTN_DLEFT,
+    N64_BTN_DRIGHT,
+    N64_BTN_L,
+    N64_BTN_R,
+    N64_BTN_CUP,
+    N64_BTN_CDOWN,
+    N64_BTN_CLEFT,
+    N64_BTN_CRIGHT,
+    N64_BTN_COUNT
+} N64Button;
+
+void input_init(void);
+void input_poll(void);
+
+bool input_started(N64Button btn);
+bool input_down(N64Button btn);
+bool input_released(N64Button btn);
+
+float input_stick_x(void);
+float input_stick_y(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/koui/koui.c b/armorcore/Deployment/n64/src/koui/koui.c
new file mode 100644
index 0000000000..62b1d1a9d0
--- /dev/null
+++ b/armorcore/Deployment/n64/src/koui/koui.c
@@ -0,0 +1,137 @@
+#include "koui.h"
+#include "../data/fonts.h"
+#include <libdragon.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Static label pool - avoids malloc() in hot paths
+static KouiLabel g_label_pool[KOUI_MAX_LABELS];
+static uint8_t g_label_pool_used = 0;
+
+// Render list - pointers to labels that should be rendered
+static KouiLabel* g_render_list[KOUI_MAX_LABELS];
+static uint8_t g_render_count = 0;
+
+// Default font ID for rendering
+static uint8_t g_default_font_rdpq_id = 0;
+static bool g_initialized = false;
+
+void koui_init(void)
+{
+    if (g_initialized) return;
+    g_initialized = true;
+
+    g_label_pool_used = 0;
+    g_render_count = 0;
+    memset(g_label_pool, 0, sizeof(g_label_pool));
+    memset(g_render_list, 0, sizeof(g_render_list));
+
+    // Get the first font (index 0) as default for Koui labels
+    rdpq_font_t *font = fonts_get(0);
+    if (font) {
+        g_default_font_rdpq_id = fonts_get_rdpq_id(0);
+        // Set default style 0 to white - this avoids per-frame color setting
+        rdpq_font_style(font, 0, &(rdpq_fontstyle_t){
+            .color = RGBA32(255, 255, 255, 255)
+        });
+    }
+}
+
+KouiLabel* koui_create_label(const char *text)
+{
+    // Allocate from static pool - no malloc!
+    if (g_label_pool_used >= KOUI_MAX_LABELS) return NULL;
+    KouiLabel *label = &g_label_pool[g_label_pool_used++];
+
+    // Copy text into label's own buffer
+    if (text) {
+        strncpy(label->text, text, KOUI_LABEL_TEXT_SIZE - 1);
+        label->text[KOUI_LABEL_TEXT_SIZE - 1] = '\0';
+    } else {
+        label->text[0] = '\0';
+    }
+    label->pos_x = 0;
+    label->pos_y = 0;
+    label->font_id = g_default_font_rdpq_id;
+    label->visible = true;
+
+    return label;
+}
+
+void koui_add_label(KouiLabel *label)
+{
+    if (!label || g_render_count >= KOUI_MAX_LABELS) return;
+
+    // Check if already in render list
+    for (uint8_t i = 0; i < g_render_count; i++) {
+        if (g_render_list[i] == label) return;
+    }
+
+    g_render_list[g_render_count++] = label;
+}
+
+void koui_remove_label(KouiLabel *label)
+{
+    if (!label) return;
+
+    // Find in render list
+    for (uint8_t i = 0; i < g_render_count; i++) {
+        if (g_render_list[i] == label) {
+            // Shift remaining down
+            for (uint8_t j = i; j < g_render_count - 1; j++) {
+                g_render_list[j] = g_render_list[j + 1];
+            }
+            g_render_count--;
+            break;
+        }
+    }
+
+    // Note: Label stays in pool until scene reset (no free needed)
+}
+
+void koui_clear(void)
+{
+    // Reset label pool and render list (call on scene change)
+    g_label_pool_used = 0;
+    g_render_count = 0;
+    memset(g_label_pool, 0, sizeof(g_label_pool));
+    memset(g_render_list, 0, sizeof(g_render_list));
+}
+
+void koui_label_set_position(KouiLabel *label, int16_t x, int16_t y)
+{
+    if (label) {
+        label->pos_x = x;
+        label->pos_y = y;
+    }
+}
+
+void koui_label_set_text(KouiLabel *label, const char *text)
+{
+    if (label && text) {
+        strncpy(label->text, text, KOUI_LABEL_TEXT_SIZE - 1);
+        label->text[KOUI_LABEL_TEXT_SIZE - 1] = '\0';
+    }
+}
+
+void koui_render(void)
+{
+    // Early exit if nothing to render
+    if (g_render_count == 0 || g_default_font_rdpq_id == 0) return;
+
+    // Sync pipeline before switching from 3D to 2D mode
+    rdpq_sync_pipe();
+
+    // Begin 2D text rendering mode
+    rdpq_set_mode_standard();
+    rdpq_mode_combiner(RDPQ_COMBINER_TEX_FLAT);
+    rdpq_mode_blender(RDPQ_BLENDER_MULTIPLY);
+
+    // Render all visible labels in render list
+    for (uint8_t i = 0; i < g_render_count; i++) {
+        KouiLabel *label = g_render_list[i];
+        if (!label || !label->visible) continue;
+
+        rdpq_text_print(NULL, label->font_id, label->pos_x, label->pos_y + 15, label->text);
+    }
+}
diff --git a/armorcore/Deployment/n64/src/koui/koui.h b/armorcore/Deployment/n64/src/koui/koui.h
new file mode 100644
index 0000000000..768085cb8a
--- /dev/null
+++ b/armorcore/Deployment/n64/src/koui/koui.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Max UI elements
+#ifndef KOUI_MAX_LABELS
+#define KOUI_MAX_LABELS 32
+#endif
+
+// Max text length for labels
+#ifndef KOUI_LABEL_TEXT_SIZE
+#define KOUI_LABEL_TEXT_SIZE 64
+#endif
+
+// Label element
+typedef struct {
+    int16_t pos_x, pos_y;
+    char text[KOUI_LABEL_TEXT_SIZE];  // Owned buffer, not pointer
+    uint8_t font_id;
+    bool visible;
+} KouiLabel;
+
+// Initialize Koui UI system
+void koui_init(void);
+
+// Clear all labels and reset pool (call on scene change)
+void koui_clear(void);
+
+// Label management
+KouiLabel* koui_create_label(const char *text);  // Create label (not added to scene)
+void koui_add_label(KouiLabel *label);            // Add label to render list
+void koui_remove_label(KouiLabel *label);         // Remove label from render list
+void koui_label_set_position(KouiLabel *label, int16_t x, int16_t y);
+void koui_label_set_text(KouiLabel *label, const char *text);  // Set label text (copies string)
+
+// Render all UI elements (call after 3D rendering, before display_show)
+void koui_render(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/main.c.j2 b/armorcore/Deployment/n64/src/main.c.j2
new file mode 100644
index 0000000000..538c98a967
--- /dev/null
+++ b/armorcore/Deployment/n64/src/main.c.j2
@@ -0,0 +1,120 @@
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmath.h>
+
+#include "types.h"
+#include "engine.h"
+#include "renderer.h"
+#include "data/scenes.h"
+#include "data/models.h"
+#include "events/trait_events.h"
+#include "iron/system/input.h"
+#if ENGINE_ENABLE_PHYSICS
+#include "oimo/physics.h"
+#if ENGINE_ENABLE_PHYSICS_DEBUG
+#include "oimo/debug/physics_debug.h"
+#endif
+#endif
+#if ENGINE_ENABLE_UI
+#include "data/fonts.h"
+#include "koui/koui.h"
+#endif
+
+#define FIXED_TIMESTEP ({fixed_timestep}f)
+
+// Build static display list after this many frames (for triple-buffering)
+#define STATIC_DPL_BUILD_FRAME (FB_COUNT + 1)
+
+static float get_time_s(void)
+{{
+    return (float)((double)get_ticks_ms() / 1000.0);
+}}
+
+int main(void)
+{{
+    engine_init();
+    trait_events_init();
+#if ENGINE_ENABLE_PHYSICS && ENGINE_ENABLE_PHYSICS_DEBUG
+    physics_debug_init();
+    physics_debug_set_mode({physics_debug_mode});
+    physics_debug_enable(true);
+#endif
+#if ENGINE_ENABLE_UI
+    fonts_init();
+    koui_init();
+#endif
+
+    T3DViewport viewport = t3d_viewport_create_buffered(FB_COUNT);
+
+    SceneId current_scene = {initial_scene_id};
+    scene_init(current_scene);
+
+    float last_time = get_time_s();
+    float fixed_time = 0.0f;
+    uint8_t frame_count = 0;  // Track frames for static DPL building
+
+    for (;;) {{
+        float now = get_time_s();
+        float dt = now - last_time;
+        last_time = now;
+
+        input_poll();
+        trait_events_dispatch(dt);
+
+        ArmScene *scene = scene_get(current_scene);
+
+        fixed_time += dt;
+        while (fixed_time >= FIXED_TIMESTEP) {{
+#if ENGINE_ENABLE_PHYSICS
+            physics_step(FIXED_TIMESTEP);
+            scene_sync_physics(current_scene);
+#endif
+            scene_on_fixed_update(current_scene, FIXED_TIMESTEP);
+            fixed_time -= FIXED_TIMESTEP;
+        }}
+
+        scene_on_update(current_scene, dt);
+        scene_on_late_update(current_scene, dt);
+
+        SceneId pending = scene_get_pending();
+        if (pending < SCENE_COUNT) {{
+            scene_clear_pending();
+            scene_clear(current_scene);
+#if ENGINE_ENABLE_UI
+            koui_clear();
+#endif
+            trait_events_clear();
+#if ENGINE_ENABLE_PHYSICS
+            physics_reset();
+#endif
+            // Free all models to reclaim memory before loading new scene
+            models_unload_all();
+            fixed_time = 0.0f;
+            frame_count = 0;  // Reset frame counter for new scene
+            current_scene = pending;
+            scene_init(current_scene);
+            scene = scene_get(current_scene);
+        }}
+
+        renderer_begin_frame(&viewport, scene);
+        renderer_draw_scene(&viewport, scene);
+#if ENGINE_ENABLE_UI
+        koui_render();
+#endif
+        renderer_end_frame(&viewport);
+
+        // Build static display list after initial frames (matrices computed for all buffers)
+        if (frame_count == STATIC_DPL_BUILD_FRAME) {{
+            renderer_build_static_dpl(scene);
+        }}
+        if (frame_count <= STATIC_DPL_BUILD_FRAME) {{
+            frame_count++;
+        }}
+    }}
+
+#if ENGINE_ENABLE_UI
+    fonts_shutdown();
+#endif
+    engine_shutdown();
+    return 0;
+}}
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase.h
new file mode 100644
index 0000000000..18d7af6c4b
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase.h
@@ -0,0 +1,275 @@
+#pragma once
+
+#include "broadphase_type.h"
+#include "proxy.h"
+#include "proxy_pair.h"
+#include "../geometry/aabb.h"
+#include "../../common/vec3.h"
+#include "../../common/math_util.h"
+
+#define OIMO_MAX_PROXIES 128
+#define OIMO_MAX_PROXY_PAIRS 256
+
+typedef void (*OimoBroadPhaseProxyCallback)(OimoProxy* proxy, void* userData);
+
+typedef struct OimoBroadPhase {
+    int _type;
+    int _numProxies;
+    OimoProxy* _proxyList;
+    OimoProxy* _proxyListLast;
+    OimoProxyPair* _proxyPairList;
+    int _incremental;
+    int _testCount;
+    OimoProxyPair* _proxyPairPool;
+    int _idCount;
+    OimoProxy _proxyStorage[OIMO_MAX_PROXIES];
+    OimoProxyPair _pairStorage[OIMO_MAX_PROXY_PAIRS];
+    int _proxyStorageUsed;
+    int _pairStorageUsed;
+} OimoBroadPhase;
+
+static inline void oimo_broadphase_list_push(OimoBroadPhase* bp, OimoProxy* p) {
+    if (bp->_proxyListLast != NULL) {
+        bp->_proxyListLast->_next = p;
+        p->_prev = bp->_proxyListLast;
+        p->_next = NULL;
+        bp->_proxyListLast = p;
+    } else {
+        bp->_proxyList = p;
+        bp->_proxyListLast = p;
+        p->_prev = NULL;
+        p->_next = NULL;
+    }
+}
+
+static inline void oimo_broadphase_list_remove(OimoBroadPhase* bp, OimoProxy* p) {
+    OimoProxy* prev = p->_prev;
+    OimoProxy* next = p->_next;
+
+    if (prev != NULL) {
+        prev->_next = next;
+    } else {
+        bp->_proxyList = next;
+    }
+
+    if (next != NULL) {
+        next->_prev = prev;
+    } else {
+        bp->_proxyListLast = prev;
+    }
+
+    p->_prev = NULL;
+    p->_next = NULL;
+}
+
+static inline OimoProxyPair* oimo_broadphase_pick_pair(OimoBroadPhase* bp) {
+    OimoProxyPair* pp;
+
+    if (bp->_proxyPairPool != NULL) {
+        // Reuse from pool
+        pp = bp->_proxyPairPool;
+        bp->_proxyPairPool = pp->_next;
+    } else {
+        // Allocate from storage
+        if (bp->_pairStorageUsed < OIMO_MAX_PROXY_PAIRS) {
+            pp = &bp->_pairStorage[bp->_pairStorageUsed++];
+            oimo_proxy_pair_init(pp);
+        } else {
+            // Out of pairs - should not happen in normal usage
+            return NULL;
+        }
+    }
+
+    return pp;
+}
+
+static inline void oimo_broadphase_pick_and_push_pair(OimoBroadPhase* bp, OimoProxy* p1, OimoProxy* p2) {
+    OimoProxyPair* pp = oimo_broadphase_pick_pair(bp);
+    if (pp == NULL) return;
+
+    // Add to front of list: M.singleList_addFirst(_proxyPairList, _next, pp)
+    pp->_next = bp->_proxyPairList;
+    bp->_proxyPairList = pp;
+
+    pp->_p1 = p1;
+    pp->_p2 = p2;
+}
+
+static inline int oimo_broadphase_is_overlapping(const OimoProxy* p1, const OimoProxy* p2);
+static inline void oimo_broadphase_add_proxy(OimoBroadPhase* bp, OimoProxy* p);
+static inline void oimo_broadphase_remove_proxy(OimoBroadPhase* bp, OimoProxy* p);
+static inline void oimo_broadphase_pool_pairs(OimoBroadPhase* bp) {
+    OimoProxyPair* p = bp->_proxyPairList;
+
+    if (p != NULL) {
+        // Clear pair references and find end of list
+        OimoProxyPair* last = p;
+        while (1) {
+            p->_p1 = NULL;
+            p->_p2 = NULL;
+            if (p->_next == NULL) {
+                last = p;
+                break;
+            }
+            p = p->_next;
+        }
+
+        // Move entire list to pool
+        last->_next = bp->_proxyPairPool;
+        bp->_proxyPairPool = bp->_proxyPairList;
+        bp->_proxyPairList = NULL;
+    }
+}
+
+// O(n²) brute-force pair collection
+static inline void oimo_broadphase_collect_pairs_bruteforce(OimoBroadPhase* bp) {
+    // Return previous pairs to pool
+    oimo_broadphase_pool_pairs(bp);
+
+    bp->_testCount = 0;
+
+    // Brute-force all pairs
+    OimoProxy* p1 = bp->_proxyList;
+    while (p1 != NULL) {
+        OimoProxy* p2 = p1->_next;
+        while (p2 != NULL) {
+            bp->_testCount++;
+            if (oimo_broadphase_is_overlapping(p1, p2)) {
+                oimo_broadphase_pick_and_push_pair(bp, p1, p2);
+            }
+            p2 = p2->_next;
+        }
+        p1 = p1->_next;
+    }
+}
+
+static inline void oimo_broadphase_collect_pairs(OimoBroadPhase* bp) {
+    oimo_broadphase_collect_pairs_bruteforce(bp);
+}
+
+static inline void oimo_broadphase_init(OimoBroadPhase* bp, int type) {
+    bp->_type = type;
+    bp->_numProxies = 0;
+    bp->_proxyList = NULL;
+    bp->_proxyListLast = NULL;
+    bp->_proxyPairList = NULL;
+    bp->_incremental = 0;
+    bp->_testCount = 0;
+    bp->_proxyPairPool = NULL;
+    bp->_idCount = 0;
+    bp->_proxyStorageUsed = 0;
+    bp->_pairStorageUsed = 0;
+}
+
+static inline OimoProxy* oimo_broadphase_create_proxy(OimoBroadPhase* bp, void* userData, const OimoAabb* aabb) {
+    if (bp->_proxyStorageUsed >= OIMO_MAX_PROXIES) {
+        return NULL;  // Out of proxy storage
+    }
+
+    OimoProxy* p = &bp->_proxyStorage[bp->_proxyStorageUsed++];
+    oimo_proxy_init(p, userData, bp->_idCount++);
+
+    // Set AABB
+    p->_aabbMin = aabb->min;
+    p->_aabbMax = aabb->max;
+
+    // Add to broadphase
+    oimo_broadphase_add_proxy(bp, p);
+
+    return p;
+}
+
+static inline void oimo_broadphase_destroy_proxy(OimoBroadPhase* bp, OimoProxy* p) {
+    oimo_broadphase_remove_proxy(bp, p);
+}
+
+static inline void oimo_broadphase_add_proxy(OimoBroadPhase* bp, OimoProxy* p) {
+    bp->_numProxies++;
+    oimo_broadphase_list_push(bp, p);
+}
+
+static inline void oimo_broadphase_remove_proxy(OimoBroadPhase* bp, OimoProxy* p) {
+    bp->_numProxies--;
+    oimo_broadphase_list_remove(bp, p);
+}
+
+static inline int oimo_broadphase_is_overlapping(const OimoProxy* p1, const OimoProxy* p2) {
+    return (p1->_aabbMin.x <= p2->_aabbMax.x && p1->_aabbMax.x >= p2->_aabbMin.x) &&
+           (p1->_aabbMin.y <= p2->_aabbMax.y && p1->_aabbMax.y >= p2->_aabbMin.y) &&
+           (p1->_aabbMin.z <= p2->_aabbMax.z && p1->_aabbMax.z >= p2->_aabbMin.z);
+}
+
+static inline OimoProxyPair* oimo_broadphase_get_proxy_pair_list(const OimoBroadPhase* bp) {
+    return bp->_proxyPairList;
+}
+
+static inline int oimo_broadphase_is_incremental(const OimoBroadPhase* bp) {
+    return bp->_incremental;
+}
+
+static inline int oimo_broadphase_get_test_count(const OimoBroadPhase* bp) {
+    return bp->_testCount;
+}
+
+// AABB-segment intersection using SAT (6 axes)
+static inline int oimo_aabb_segment_test(
+    const OimoVec3* aabbMin,
+    const OimoVec3* aabbMax,
+    const OimoVec3* begin,
+    const OimoVec3* end
+) {
+    OimoScalar x1 = begin->x, y1 = begin->y, z1 = begin->z;
+    OimoScalar x2 = end->x, y2 = end->y, z2 = end->z;
+
+    // Segment bounding box
+    OimoScalar sminx = oimo_min(x1, x2);
+    OimoScalar sminy = oimo_min(y1, y2);
+    OimoScalar sminz = oimo_min(z1, z2);
+    OimoScalar smaxx = oimo_max(x1, x2);
+    OimoScalar smaxy = oimo_max(y1, y2);
+    OimoScalar smaxz = oimo_max(z1, z2);
+
+    OimoScalar pminx = aabbMin->x, pminy = aabbMin->y, pminz = aabbMin->z;
+    OimoScalar pmaxx = aabbMax->x, pmaxy = aabbMax->y, pmaxz = aabbMax->z;
+
+    // Test axes (1,0,0), (0,1,0), (0,0,1)
+    if (pminx > smaxx || pmaxx < sminx ||
+        pminy > smaxy || pmaxy < sminy ||
+        pminz > smaxz || pmaxz < sminz) {
+        return 0;
+    }
+
+    // Segment direction
+    OimoScalar dx = x2 - x1;
+    OimoScalar dy = y2 - y1;
+    OimoScalar dz = z2 - z1;
+    OimoScalar adx = oimo_abs(dx);
+    OimoScalar ady = oimo_abs(dy);
+    OimoScalar adz = oimo_abs(dz);
+
+    // AABB half-extents and center
+    OimoScalar pextx = (pmaxx - pminx) * 0.5f;
+    OimoScalar pexty = (pmaxy - pminy) * 0.5f;
+    OimoScalar pextz = (pmaxz - pminz) * 0.5f;
+    OimoScalar pcntx = (pmaxx + pminx) * 0.5f;
+    OimoScalar pcnty = (pmaxy + pminy) * 0.5f;
+    OimoScalar pcntz = (pmaxz + pminz) * 0.5f;
+
+    // Vector from AABB center to segment start
+    OimoScalar cpx = x1 - pcntx;
+    OimoScalar cpy = y1 - pcnty;
+    OimoScalar cpz = z1 - pcntz;
+
+    // Test cross product axes:
+    // axis4: d × (1,0,0) = (0, dz, -dy)
+    // axis5: d × (0,1,0) = (-dz, 0, dx)
+    // axis6: d × (0,0,1) = (dy, -dx, 0)
+    if (oimo_abs(cpy * dz - cpz * dy) - (pexty * adz + pextz * ady) > 0 ||
+        oimo_abs(cpz * dx - cpx * dz) - (pextz * adx + pextx * adz) > 0 ||
+        oimo_abs(cpx * dy - cpy * dx) - (pextx * ady + pexty * adx) > 0) {
+        return 0;
+    }
+
+    return 1;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase_type.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase_type.h
new file mode 100644
index 0000000000..870953afb2
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/broadphase_type.h
@@ -0,0 +1,4 @@
+#pragma once
+
+#define OIMO_BROADPHASE_BRUTE_FORCE 1
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/bruteforce_broadphase.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/bruteforce_broadphase.h
new file mode 100644
index 0000000000..8177114458
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/bruteforce_broadphase.h
@@ -0,0 +1,100 @@
+#pragma once
+
+#include "broadphase.h"
+
+static inline void oimo_bruteforce_broadphase_init(OimoBroadPhase* bp) {
+    oimo_broadphase_init(bp, OIMO_BROADPHASE_BRUTE_FORCE);
+    bp->_incremental = 0;  // Brute force is not incremental
+}
+
+static inline int oimo_bruteforce_overlap(const OimoProxy* p1, const OimoProxy* p2) {
+    // M.aabb_overlap(p1._aabbMin, p1._aabbMax, p2._aabbMin, p2._aabbMax)
+    return (p1->_aabbMin.x <= p2->_aabbMax.x && p1->_aabbMax.x >= p2->_aabbMin.x) &&
+           (p1->_aabbMin.y <= p2->_aabbMax.y && p1->_aabbMax.y >= p2->_aabbMin.y) &&
+           (p1->_aabbMin.z <= p2->_aabbMax.z && p1->_aabbMax.z >= p2->_aabbMin.z);
+}
+
+static inline OimoProxy* oimo_bruteforce_create_proxy(OimoBroadPhase* bp, void* userData, const OimoAabb* aabb) {
+    // Allocate proxy from storage
+    if (bp->_proxyStorageUsed >= OIMO_MAX_PROXIES) {
+        return NULL;  // Out of proxies
+    }
+
+    OimoProxy* proxy = &bp->_proxyStorage[bp->_proxyStorageUsed++];
+    oimo_proxy_init(proxy, userData, bp->_idCount++);
+
+    oimo_broadphase_add_proxy(bp, proxy);
+    oimo_proxy_set_aabb(proxy, aabb);
+
+    return proxy;
+}
+
+static inline void oimo_bruteforce_destroy_proxy(OimoBroadPhase* bp, OimoProxy* proxy) {
+    oimo_broadphase_remove_proxy(bp, proxy);
+    proxy->userData = NULL;
+}
+
+static inline void oimo_bruteforce_move_proxy(OimoBroadPhase* bp, OimoProxy* proxy, const OimoAabb* aabb, const OimoVec3* displacement) {
+    (void)bp;           // Unused in brute force
+    (void)displacement; // Unused in brute force (no predictive expansion)
+    oimo_proxy_set_aabb(proxy, aabb);
+}
+
+static inline void oimo_bruteforce_collect_pairs(OimoBroadPhase* bp) {
+    // Return previous pairs to pool
+    oimo_broadphase_pool_pairs(bp);
+
+    bp->_testCount = 0;
+
+    // Iterate: p1 from first to second-to-last
+    OimoProxy* p1 = bp->_proxyList;
+    while (p1 != NULL) {
+        // p2 from p1->next to last
+        OimoProxy* p2 = p1->_next;
+        while (p2 != NULL) {
+            bp->_testCount++;
+
+            if (oimo_bruteforce_overlap(p1, p2)) {
+                oimo_broadphase_pick_and_push_pair(bp, p1, p2);
+            }
+
+            p2 = p2->_next;
+        }
+        p1 = p1->_next;
+    }
+}
+
+static inline void oimo_bruteforce_ray_cast(
+    OimoBroadPhase* bp,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    OimoBroadPhaseProxyCallback callback,
+    void* callbackUserData
+) {
+    OimoProxy* p = bp->_proxyList;
+    while (p != NULL) {
+        if (oimo_aabb_segment_test(&p->_aabbMin, &p->_aabbMax, begin, end)) {
+            callback(p, callbackUserData);
+        }
+        p = p->_next;
+    }
+}
+
+static inline void oimo_bruteforce_aabb_test(
+    OimoBroadPhase* bp,
+    const OimoAabb* aabb,
+    OimoBroadPhaseProxyCallback callback,
+    void* callbackUserData
+) {
+    OimoProxy* p = bp->_proxyList;
+    while (p != NULL) {
+        // M.aabb_overlap(aabb._min, aabb._max, p._aabbMin, p._aabbMax)
+        if ((aabb->min.x <= p->_aabbMax.x && aabb->max.x >= p->_aabbMin.x) &&
+            (aabb->min.y <= p->_aabbMax.y && aabb->max.y >= p->_aabbMin.y) &&
+            (aabb->min.z <= p->_aabbMax.z && aabb->max.z >= p->_aabbMin.z)) {
+            callback(p, callbackUserData);
+        }
+        p = p->_next;
+    }
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/bvh.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/bvh.h
new file mode 100644
index 0000000000..c8ef8ee869
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/bvh.h
@@ -0,0 +1,283 @@
+#pragma once
+
+// bvh.h - Simple BVH for static mesh triangle queries (N64 optimized)
+
+#include "../geometry/aabb.h"
+#include "../../common/vec3.h"
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Maximum triangles in a static mesh (N64 memory constraint)
+#define OIMO_BVH_MAX_TRIANGLES 256
+
+// Maximum depth of BVH tree (log2(256) + some margin)
+#define OIMO_BVH_MAX_DEPTH 12
+
+// Maximum triangles per leaf before splitting
+#define OIMO_BVH_LEAF_THRESHOLD 4
+
+// BVH Node - compact for N64
+// If left_child == -1, it's a leaf node
+typedef struct OimoBvhNode {
+    OimoAabb aabb;           // Node bounding box
+    int16_t left_child;      // Index of left child (-1 if leaf)
+    int16_t right_child;     // Index of right child
+    int16_t first_triangle;  // First index into sorted_indices array (for leaves)
+    int16_t triangle_count;  // Number of triangles (for leaves)
+} OimoBvhNode;
+
+// BVH Tree for static mesh
+typedef struct OimoBvhTree {
+    OimoBvhNode* nodes;      // Node array (allocated)
+    int16_t* sorted_indices; // Sorted triangle indices for leaf nodes
+    int16_t node_count;      // Number of nodes used
+    int16_t max_nodes;       // Maximum nodes allocated
+    int16_t root;            // Root node index
+    int16_t triangle_count;  // Total triangles
+} OimoBvhTree;
+
+// Triangle data for building BVH
+typedef struct OimoBvhTriangle {
+    OimoVec3 centroid;       // Triangle center (for partitioning)
+    OimoAabb aabb;           // Triangle AABB
+    int16_t original_index;  // Original triangle index in mesh
+} OimoBvhTriangle;
+
+// Query result - indices of triangles that overlap query AABB
+typedef struct OimoBvhQueryResult {
+    int16_t triangles[OIMO_BVH_MAX_TRIANGLES];
+    int16_t count;
+} OimoBvhQueryResult;
+
+// Initialize BVH tree (allocate memory)
+static inline bool oimo_bvh_tree_init(OimoBvhTree* tree, int max_triangles) {
+    // Estimate max nodes: worst case is 2*n-1 for n leaves
+    tree->max_nodes = (int16_t)(max_triangles * 2);
+    tree->nodes = (OimoBvhNode*)malloc(sizeof(OimoBvhNode) * tree->max_nodes);
+    if (!tree->nodes) return false;
+    tree->sorted_indices = (int16_t*)malloc(sizeof(int16_t) * max_triangles);
+    if (!tree->sorted_indices) {
+        free(tree->nodes);
+        tree->nodes = NULL;
+        return false;
+    }
+    tree->node_count = 0;
+    tree->root = -1;
+    tree->triangle_count = 0;
+    return true;
+}
+
+// Free BVH tree
+static inline void oimo_bvh_tree_free(OimoBvhTree* tree) {
+    if (tree->nodes) {
+        free(tree->nodes);
+        tree->nodes = NULL;
+    }
+    if (tree->sorted_indices) {
+        free(tree->sorted_indices);
+        tree->sorted_indices = NULL;
+    }
+    tree->node_count = 0;
+    tree->root = -1;
+    tree->triangle_count = 0;
+}
+
+// Allocate a new node
+static inline int16_t oimo_bvh_alloc_node(OimoBvhTree* tree) {
+    if (tree->node_count >= tree->max_nodes) return -1;
+    int16_t idx = tree->node_count++;
+    OimoBvhNode* node = &tree->nodes[idx];
+    node->left_child = -1;
+    node->right_child = -1;
+    node->first_triangle = 0;
+    node->triangle_count = 0;
+    oimo_aabb_init(&node->aabb);
+    return idx;
+}
+
+// Compute AABB enclosing all triangles in range
+static inline void oimo_bvh_compute_bounds(
+    const OimoBvhTriangle* triangles,
+    const int16_t* indices,
+    int count,
+    OimoAabb* out_aabb
+) {
+    oimo_aabb_init(out_aabb);
+    for (int i = 0; i < count; i++) {
+        const OimoBvhTriangle* tri = &triangles[indices[i]];
+        oimo_aabb_merge(out_aabb, out_aabb, &tri->aabb);
+    }
+}
+
+// Partition triangles along the longest axis (simple median split)
+static inline int oimo_bvh_partition(
+    OimoBvhTriangle* triangles,
+    int16_t* indices,
+    int count,
+    int axis
+) {
+    if (count <= 1) return 0;
+
+    // Find median value along axis
+    float min_val = 1e30f, max_val = -1e30f;
+    for (int i = 0; i < count; i++) {
+        float val;
+        switch (axis) {
+            case 0: val = triangles[indices[i]].centroid.x; break;
+            case 1: val = triangles[indices[i]].centroid.y; break;
+            default: val = triangles[indices[i]].centroid.z; break;
+        }
+        if (val < min_val) min_val = val;
+        if (val > max_val) max_val = val;
+    }
+    float mid = (min_val + max_val) * 0.5f;
+
+    // Partition around median
+    int left = 0;
+    int right = count - 1;
+    while (left <= right) {
+        float left_val;
+        switch (axis) {
+            case 0: left_val = triangles[indices[left]].centroid.x; break;
+            case 1: left_val = triangles[indices[left]].centroid.y; break;
+            default: left_val = triangles[indices[left]].centroid.z; break;
+        }
+
+        if (left_val < mid) {
+            left++;
+        } else {
+            // Swap
+            int16_t tmp = indices[left];
+            indices[left] = indices[right];
+            indices[right] = tmp;
+            right--;
+        }
+    }
+
+    // Ensure we don't have empty partitions
+    if (left == 0) left = 1;
+    if (left == count) left = count - 1;
+
+    return left;
+}
+
+// Build BVH recursively - returns node index
+// sorted_pos tracks current position in sorted_indices array
+static inline int16_t oimo_bvh_build_recursive(
+    OimoBvhTree* tree,
+    OimoBvhTriangle* triangles,
+    int16_t* indices,
+    int count,
+    int depth,
+    int16_t* sorted_pos
+) {
+    if (count == 0 || depth > OIMO_BVH_MAX_DEPTH) return -1;
+
+    int16_t node_idx = oimo_bvh_alloc_node(tree);
+    if (node_idx < 0) return -1;
+
+    OimoBvhNode* node = &tree->nodes[node_idx];
+    oimo_bvh_compute_bounds(triangles, indices, count, &node->aabb);
+
+    // Make leaf if few enough triangles
+    if (count <= OIMO_BVH_LEAF_THRESHOLD) {
+        node->left_child = -1;
+        node->right_child = -1;
+        node->first_triangle = *sorted_pos;
+        node->triangle_count = (int16_t)count;
+        // Copy triangle indices to sorted array
+        for (int i = 0; i < count; i++) {
+            tree->sorted_indices[(*sorted_pos)++] = triangles[indices[i]].original_index;
+        }
+        return node_idx;
+    }
+
+    // Find longest axis
+    OimoVec3 size = oimo_vec3_sub(node->aabb.max, node->aabb.min);
+    int axis = 0;
+    if (size.y > size.x) axis = 1;
+    if (size.z > (axis == 0 ? size.x : size.y)) axis = 2;
+
+    // Partition
+    int mid = oimo_bvh_partition(triangles, indices, count, axis);
+
+    // Build children
+    node->left_child = oimo_bvh_build_recursive(tree, triangles, indices, mid, depth + 1, sorted_pos);
+    node->right_child = oimo_bvh_build_recursive(tree, triangles, indices + mid, count - mid, depth + 1, sorted_pos);
+
+    return node_idx;
+}
+
+// Build BVH from triangle data
+static inline bool oimo_bvh_tree_build(
+    OimoBvhTree* tree,
+    OimoBvhTriangle* triangles,
+    int triangle_count
+) {
+    if (triangle_count == 0 || triangle_count > OIMO_BVH_MAX_TRIANGLES) return false;
+
+    tree->triangle_count = (int16_t)triangle_count;
+
+    // Create index array
+    int16_t* indices = (int16_t*)malloc(sizeof(int16_t) * triangle_count);
+    if (!indices) return false;
+
+    for (int i = 0; i < triangle_count; i++) {
+        indices[i] = (int16_t)i;
+        triangles[i].original_index = (int16_t)i;
+    }
+
+    // Build tree
+    int16_t sorted_pos = 0;
+    tree->root = oimo_bvh_build_recursive(tree, triangles, indices, triangle_count, 0, &sorted_pos);
+
+    free(indices);
+    return tree->root >= 0;
+}
+
+// Query BVH for triangles overlapping an AABB
+static inline void oimo_bvh_query_recursive(
+    const OimoBvhTree* tree,
+    int16_t node_idx,
+    const OimoAabb* query_aabb,
+    OimoBvhQueryResult* result
+) {
+    if (node_idx < 0 || result->count >= OIMO_BVH_MAX_TRIANGLES) return;
+
+    const OimoBvhNode* node = &tree->nodes[node_idx];
+
+    // Check if query overlaps this node
+    if (!oimo_aabb_overlap(&node->aabb, query_aabb)) return;
+
+    // Leaf node - add triangles from sorted_indices
+    if (node->left_child < 0) {
+        for (int i = 0; i < node->triangle_count && result->count < OIMO_BVH_MAX_TRIANGLES; i++) {
+            int16_t tri_idx = tree->sorted_indices[node->first_triangle + i];
+            result->triangles[result->count++] = tri_idx;
+        }
+        return;
+    }
+
+    // Internal node - recurse
+    oimo_bvh_query_recursive(tree, node->left_child, query_aabb, result);
+    oimo_bvh_query_recursive(tree, node->right_child, query_aabb, result);
+}
+
+// Query BVH for triangles overlapping an AABB
+static inline void oimo_bvh_query(
+    const OimoBvhTree* tree,
+    const OimoAabb* query_aabb,
+    OimoBvhQueryResult* result
+) {
+    result->count = 0;
+    oimo_bvh_query_recursive(tree, tree->root, query_aabb, result);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy.h
new file mode 100644
index 0000000000..c275d8c544
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "../geometry/aabb.h"
+#include "../../common/vec3.h"
+
+// Forward declaration
+struct OimoShape;
+
+typedef struct OimoProxy {
+    struct OimoProxy* _prev;    // Previous proxy in list
+    struct OimoProxy* _next;    // Next proxy in list
+
+    // Fattened AABB (stored as min/max vectors like OimoPhysics)
+    OimoVec3 _aabbMin;
+    OimoVec3 _aabbMax;
+
+    int _id;                    // Unique proxy ID
+
+        void* userData;
+} OimoProxy;
+
+static inline void oimo_proxy_init(OimoProxy* proxy, void* userData, int id) {
+    proxy->userData = userData;
+    proxy->_id = id;
+    proxy->_prev = NULL;
+    proxy->_next = NULL;
+    proxy->_aabbMin = oimo_vec3_zero();
+    proxy->_aabbMax = oimo_vec3_zero();
+}
+
+static inline void oimo_proxy_set_aabb(OimoProxy* proxy, const OimoAabb* aabb) {
+    proxy->_aabbMin = aabb->min;
+    proxy->_aabbMax = aabb->max;
+}
+
+static inline int oimo_proxy_get_id(const OimoProxy* proxy) {
+    return proxy->_id;
+}
+
+static inline OimoAabb oimo_proxy_get_fat_aabb(const OimoProxy* proxy) {
+    OimoAabb aabb;
+    aabb.min = proxy->_aabbMin;
+    aabb.max = proxy->_aabbMax;
+    return aabb;
+}
+
+static inline void oimo_proxy_get_fat_aabb_to(const OimoProxy* proxy, OimoAabb* aabb) {
+    aabb->min = proxy->_aabbMin;
+    aabb->max = proxy->_aabbMax;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy_pair.h b/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy_pair.h
new file mode 100644
index 0000000000..39d7f28874
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/broadphase/proxy_pair.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "proxy.h"
+
+typedef struct OimoProxyPair {
+    struct OimoProxyPair* _next;    // Next pair in linked list
+
+    OimoProxy* _p1;                  // First proxy
+    OimoProxy* _p2;                  // Second proxy
+} OimoProxyPair;
+
+static inline void oimo_proxy_pair_init(OimoProxyPair* pair) {
+    pair->_next = NULL;
+    pair->_p1 = NULL;
+    pair->_p2 = NULL;
+}
+
+static inline OimoProxy* oimo_proxy_pair_get_proxy1(const OimoProxyPair* pair) {
+    return pair->_p1;
+}
+
+static inline OimoProxy* oimo_proxy_pair_get_proxy2(const OimoProxyPair* pair) {
+    return pair->_p2;
+}
+
+static inline OimoProxyPair* oimo_proxy_pair_get_next(const OimoProxyPair* pair) {
+    return pair->_next;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/aabb.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/aabb.h
new file mode 100644
index 0000000000..c884ae8410
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/aabb.h
@@ -0,0 +1,271 @@
+#pragma once
+
+#include "../../common/setting.h"
+#include "../../common/vec3.h"
+
+typedef struct OimoAabb {
+    OimoVec3 min;  // Minimum corner
+    OimoVec3 max;  // Maximum corner
+} OimoAabb;
+
+// Create empty AABB (both corners at zero)
+static inline OimoAabb oimo_aabb_zero(void) {
+    OimoAabb aabb;
+    aabb.min = oimo_vec3_zero();
+    aabb.max = oimo_vec3_zero();
+    return aabb;
+}
+
+// Create AABB from min/max corners
+static inline OimoAabb oimo_aabb(const OimoVec3* min, const OimoVec3* max) {
+    OimoAabb aabb;
+    aabb.min = oimo_vec3_copy(min);
+    aabb.max = oimo_vec3_copy(max);
+    return aabb;
+}
+
+// Create AABB from center and half-extents
+static inline OimoAabb oimo_aabb_from_center_extents(const OimoVec3* center, const OimoVec3* half_extents) {
+    OimoAabb aabb;
+    oimo_vec3_sub_to(&aabb.min, center, half_extents);
+    oimo_vec3_add_to(&aabb.max, center, half_extents);
+    return aabb;
+}
+
+// Copy AABB
+static inline OimoAabb oimo_aabb_copy(const OimoAabb* aabb) {
+    OimoAabb result;
+    result.min = oimo_vec3_copy(&aabb->min);
+    result.max = oimo_vec3_copy(&aabb->max);
+    return result;
+}
+
+// Get center of AABB: (min + max) / 2
+static inline OimoVec3 oimo_aabb_get_center(const OimoAabb* aabb) {
+    OimoVec3 center = oimo_vec3_add(aabb->min, aabb->max);
+    return oimo_vec3_scale(center, 0.5f);
+}
+
+// Get half-extents of AABB: (max - min) / 2
+static inline OimoVec3 oimo_aabb_get_extents(const OimoAabb* aabb) {
+    OimoVec3 extents = oimo_vec3_sub(aabb->max, aabb->min);
+    return oimo_vec3_scale(extents, 0.5f);
+}
+
+// Get size (full extents) of AABB: max - min
+static inline OimoVec3 oimo_aabb_get_size(const OimoAabb* aabb) {
+    return oimo_vec3_sub(aabb->max, aabb->min);
+}
+
+// Get surface area: 2 * (w*h + h*d + d*w)
+static inline OimoScalar oimo_aabb_get_surface_area(const OimoAabb* aabb) {
+    OimoVec3 size = oimo_aabb_get_size(aabb);
+    return 2.0f * (size.x * size.y + size.y * size.z + size.z * size.x);
+}
+
+// Get volume: w * h * d
+static inline OimoScalar oimo_aabb_get_volume(const OimoAabb* aabb) {
+    OimoVec3 size = oimo_aabb_get_size(aabb);
+    return size.x * size.y * size.z;
+}
+
+// Set min corner
+static inline void oimo_aabb_set_min(OimoAabb* aabb, const OimoVec3* min) {
+    oimo_vec3_copy_to(&aabb->min, min);
+}
+
+// Set max corner
+static inline void oimo_aabb_set_max(OimoAabb* aabb, const OimoVec3* max) {
+    oimo_vec3_copy_to(&aabb->max, max);
+}
+
+// Set both corners
+static inline void oimo_aabb_set(OimoAabb* aabb, const OimoVec3* min, const OimoVec3* max) {
+    oimo_vec3_copy_to(&aabb->min, min);
+    oimo_vec3_copy_to(&aabb->max, max);
+}
+
+// Copy from another AABB
+static inline void oimo_aabb_copy_to(OimoAabb* dst, const OimoAabb* src) {
+    oimo_vec3_copy_to(&dst->min, &src->min);
+    oimo_vec3_copy_to(&dst->max, &src->max);
+}
+
+// Check if two AABBs overlap
+static inline int oimo_aabb_overlap(const OimoAabb* a, const OimoAabb* b) {
+    // AABBs overlap if they overlap on all three axes
+    return (a->min.x <= b->max.x && a->max.x >= b->min.x) &&
+           (a->min.y <= b->max.y && a->max.y >= b->min.y) &&
+           (a->min.z <= b->max.z && a->max.z >= b->min.z);
+}
+
+// Check if point is inside AABB
+static inline int oimo_aabb_contains_point(const OimoAabb* aabb, const OimoVec3* point) {
+    return (point->x >= aabb->min.x && point->x <= aabb->max.x) &&
+           (point->y >= aabb->min.y && point->y <= aabb->max.y) &&
+           (point->z >= aabb->min.z && point->z <= aabb->max.z);
+}
+
+// Check if AABB a contains AABB b entirely
+static inline int oimo_aabb_contains(const OimoAabb* a, const OimoAabb* b) {
+    return (a->min.x <= b->min.x && a->max.x >= b->max.x) &&
+           (a->min.y <= b->min.y && a->max.y >= b->max.y) &&
+           (a->min.z <= b->min.z && a->max.z >= b->max.z);
+}
+
+// Combine two AABBs into one that contains both
+static inline OimoAabb oimo_aabb_combine(const OimoAabb* a, const OimoAabb* b) {
+    OimoAabb result;
+    result.min.x = oimo_min(a->min.x, b->min.x);
+    result.min.y = oimo_min(a->min.y, b->min.y);
+    result.min.z = oimo_min(a->min.z, b->min.z);
+    result.max.x = oimo_max(a->max.x, b->max.x);
+    result.max.y = oimo_max(a->max.y, b->max.y);
+    result.max.z = oimo_max(a->max.z, b->max.z);
+    return result;
+}
+
+// Combine AABB b into a (modify a in-place)
+static inline void oimo_aabb_combine_eq(OimoAabb* a, const OimoAabb* b) {
+    a->min.x = oimo_min(a->min.x, b->min.x);
+    a->min.y = oimo_min(a->min.y, b->min.y);
+    a->min.z = oimo_min(a->min.z, b->min.z);
+    a->max.x = oimo_max(a->max.x, b->max.x);
+    a->max.y = oimo_max(a->max.y, b->max.y);
+    a->max.z = oimo_max(a->max.z, b->max.z);
+}
+
+// Expand AABB to include point
+static inline void oimo_aabb_include_point(OimoAabb* aabb, const OimoVec3* point) {
+    aabb->min.x = oimo_min(aabb->min.x, point->x);
+    aabb->min.y = oimo_min(aabb->min.y, point->y);
+    aabb->min.z = oimo_min(aabb->min.z, point->z);
+    aabb->max.x = oimo_max(aabb->max.x, point->x);
+    aabb->max.y = oimo_max(aabb->max.y, point->y);
+    aabb->max.z = oimo_max(aabb->max.z, point->z);
+}
+
+// Get intersection of two AABBs (result may be invalid if they don't overlap)
+static inline OimoAabb oimo_aabb_intersection(const OimoAabb* a, const OimoAabb* b) {
+    OimoAabb result;
+    result.min.x = oimo_max(a->min.x, b->min.x);
+    result.min.y = oimo_max(a->min.y, b->min.y);
+    result.min.z = oimo_max(a->min.z, b->min.z);
+    result.max.x = oimo_min(a->max.x, b->max.x);
+    result.max.y = oimo_min(a->max.y, b->max.y);
+    result.max.z = oimo_min(a->max.z, b->max.z);
+    return result;
+}
+
+// Check if intersection is valid (min <= max on all axes)
+static inline int oimo_aabb_is_valid(const OimoAabb* aabb) {
+    return (aabb->min.x <= aabb->max.x) &&
+           (aabb->min.y <= aabb->max.y) &&
+           (aabb->min.z <= aabb->max.z);
+}
+
+// Expand AABB by margin on all sides
+static inline OimoAabb oimo_aabb_expand(const OimoAabb* aabb, OimoScalar margin) {
+    OimoAabb result;
+    result.min.x = aabb->min.x - margin;
+    result.min.y = aabb->min.y - margin;
+    result.min.z = aabb->min.z - margin;
+    result.max.x = aabb->max.x + margin;
+    result.max.y = aabb->max.y + margin;
+    result.max.z = aabb->max.z + margin;
+    return result;
+}
+
+// Expand AABB in-place
+static inline void oimo_aabb_expand_eq(OimoAabb* aabb, OimoScalar margin) {
+    aabb->min.x -= margin;
+    aabb->min.y -= margin;
+    aabb->min.z -= margin;
+    aabb->max.x += margin;
+    aabb->max.y += margin;
+    aabb->max.z += margin;
+}
+
+// Ray-AABB intersection test
+// Returns 1 if ray intersects, 0 otherwise
+// t_near and t_far are set to the intersection parameters (0 <= t_near <= t_far <= 1 for hit)
+static inline int oimo_aabb_ray_cast(
+    const OimoAabb* aabb,
+    const OimoVec3* ray_origin,
+    const OimoVec3* ray_dir,    // Direction (end - origin)
+    OimoScalar* t_near,
+    OimoScalar* t_far
+) {
+    OimoScalar tmin = 0.0f;
+    OimoScalar tmax = 1.0f;
+
+    // X axis
+    if (oimo_abs(ray_dir->x) < OIMO_EPSILON) {
+        if (ray_origin->x < aabb->min.x || ray_origin->x > aabb->max.x) {
+            return 0;
+        }
+    } else {
+        OimoScalar inv_d = 1.0f / ray_dir->x;
+        OimoScalar t1 = (aabb->min.x - ray_origin->x) * inv_d;
+        OimoScalar t2 = (aabb->max.x - ray_origin->x) * inv_d;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > tmin) tmin = t1;
+        if (t2 < tmax) tmax = t2;
+        if (tmin > tmax) return 0;
+    }
+
+    // Y axis
+    if (oimo_abs(ray_dir->y) < OIMO_EPSILON) {
+        if (ray_origin->y < aabb->min.y || ray_origin->y > aabb->max.y) {
+            return 0;
+        }
+    } else {
+        OimoScalar inv_d = 1.0f / ray_dir->y;
+        OimoScalar t1 = (aabb->min.y - ray_origin->y) * inv_d;
+        OimoScalar t2 = (aabb->max.y - ray_origin->y) * inv_d;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > tmin) tmin = t1;
+        if (t2 < tmax) tmax = t2;
+        if (tmin > tmax) return 0;
+    }
+
+    // Z axis
+    if (oimo_abs(ray_dir->z) < OIMO_EPSILON) {
+        if (ray_origin->z < aabb->min.z || ray_origin->z > aabb->max.z) {
+            return 0;
+        }
+    } else {
+        OimoScalar inv_d = 1.0f / ray_dir->z;
+        OimoScalar t1 = (aabb->min.z - ray_origin->z) * inv_d;
+        OimoScalar t2 = (aabb->max.z - ray_origin->z) * inv_d;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > tmin) tmin = t1;
+        if (t2 < tmax) tmax = t2;
+        if (tmin > tmax) return 0;
+    }
+
+    *t_near = tmin;
+    *t_far = tmax;
+    return 1;
+}
+
+// Initialize AABB to "empty" state (inverted bounds for expansion)
+static inline void oimo_aabb_init(OimoAabb* aabb) {
+    aabb->min.x = 1e30f;
+    aabb->min.y = 1e30f;
+    aabb->min.z = 1e30f;
+    aabb->max.x = -1e30f;
+    aabb->max.y = -1e30f;
+    aabb->max.z = -1e30f;
+}
+
+// Merge AABB b into result (result = union of result and b)
+static inline void oimo_aabb_merge(OimoAabb* result, const OimoAabb* a, const OimoAabb* b) {
+    result->min.x = oimo_min(a->min.x, b->min.x);
+    result->min.y = oimo_min(a->min.y, b->min.y);
+    result->min.z = oimo_min(a->min.z, b->min.z);
+    result->max.x = oimo_max(a->max.x, b->max.x);
+    result->max.y = oimo_max(a->max.y, b->max.y);
+    result->max.z = oimo_max(a->max.z, b->max.z);
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/box_geometry.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/box_geometry.h
new file mode 100644
index 0000000000..ae0df06538
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/box_geometry.h
@@ -0,0 +1,287 @@
+#pragma once
+
+#include "../../common/setting.h"
+#include "../../common/math_util.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/transform.h"
+#include "geometry_type.h"
+#include "aabb.h"
+#include "geometry.h"
+
+typedef struct OimoBoxGeometry {
+    OimoGeometry base;
+    OimoVec3 half_extents;
+} OimoBoxGeometry;
+
+static inline void oimo_box_geometry_init(OimoBoxGeometry* box, const OimoVec3* half_extents) {
+    oimo_geometry_init(&box->base, OIMO_GEOMETRY_BOX);
+    box->half_extents = oimo_vec3_copy(half_extents);
+
+    OimoScalar w = half_extents->x;
+    OimoScalar h = half_extents->y;
+    OimoScalar d = half_extents->z;
+
+    // Compute volume: V = 8 * w * h * d
+    box->base.volume = 8.0f * w * h * d;
+
+    // Compute inertia coefficient: I/m for a box
+    // Ixx/m = (1/3) * (h^2 + d^2)
+    // Iyy/m = (1/3) * (w^2 + d^2)
+    // Izz/m = (1/3) * (w^2 + h^2)
+    OimoScalar w2 = w * w;
+    OimoScalar h2 = h * h;
+    OimoScalar d2 = d * d;
+
+    box->base.inertia_coeff = oimo_mat3(
+        (1.0f / 3.0f) * (h2 + d2), 0, 0,
+        0, (1.0f / 3.0f) * (w2 + d2), 0,
+        0, 0, (1.0f / 3.0f) * (w2 + h2)
+    );
+}
+
+// Initialize box geometry with components
+static inline void oimo_box_geometry_init3(OimoBoxGeometry* box, OimoScalar hw, OimoScalar hh, OimoScalar hd) {
+    OimoVec3 half_ext = oimo_vec3(hw, hh, hd);
+    oimo_box_geometry_init(box, &half_ext);
+}
+
+// Create box geometry (returns by value)
+static inline OimoBoxGeometry oimo_box_geometry(const OimoVec3* half_extents) {
+    OimoBoxGeometry box;
+    oimo_box_geometry_init(&box, half_extents);
+    return box;
+}
+
+// Create box geometry with components
+static inline OimoBoxGeometry oimo_box_geometry3(OimoScalar hw, OimoScalar hh, OimoScalar hd) {
+    OimoVec3 half_ext = oimo_vec3(hw, hh, hd);
+    return oimo_box_geometry(&half_ext);
+}
+
+// Get half-extents
+static inline OimoVec3 oimo_box_geometry_get_half_extents(const OimoBoxGeometry* box) {
+    return oimo_vec3_copy(&box->half_extents);
+}
+
+// Get width (full width = 2 * half_extents.x)
+static inline OimoScalar oimo_box_geometry_get_width(const OimoBoxGeometry* box) {
+    return 2.0f * box->half_extents.x;
+}
+
+// Get height (full height = 2 * half_extents.y)
+static inline OimoScalar oimo_box_geometry_get_height(const OimoBoxGeometry* box) {
+    return 2.0f * box->half_extents.y;
+}
+
+// Get depth (full depth = 2 * half_extents.z)
+static inline OimoScalar oimo_box_geometry_get_depth(const OimoBoxGeometry* box) {
+    return 2.0f * box->half_extents.z;
+}
+
+// Set half-extents and update mass properties
+static inline void oimo_box_geometry_set_half_extents(OimoBoxGeometry* box, const OimoVec3* half_extents) {
+    box->half_extents = oimo_vec3_copy(half_extents);
+
+    OimoScalar w = half_extents->x;
+    OimoScalar h = half_extents->y;
+    OimoScalar d = half_extents->z;
+
+    // Update volume
+    box->base.volume = 8.0f * w * h * d;
+
+    // Update inertia coefficient
+    OimoScalar w2 = w * w;
+    OimoScalar h2 = h * h;
+    OimoScalar d2 = d * d;
+
+    box->base.inertia_coeff = oimo_mat3(
+        (1.0f / 3.0f) * (h2 + d2), 0, 0,
+        0, (1.0f / 3.0f) * (w2 + d2), 0,
+        0, 0, (1.0f / 3.0f) * (w2 + h2)
+    );
+}
+
+// Compute AABB for box at given transform
+static inline void oimo_box_geometry_compute_aabb(
+    const OimoBoxGeometry* box,
+    OimoAabb* aabb,
+    const OimoTransform* tf
+) {
+    // Transform each half-axis and take absolute values
+    OimoVec3 half_x = oimo_vec3(box->half_extents.x, 0, 0);
+    OimoVec3 half_y = oimo_vec3(0, box->half_extents.y, 0);
+    OimoVec3 half_z = oimo_vec3(0, 0, box->half_extents.z);
+
+    // Rotate each half-axis
+    OimoVec3 tfx = oimo_mat3_mul_vec3(&tf->rotation, half_x);
+    OimoVec3 tfy = oimo_mat3_mul_vec3(&tf->rotation, half_y);
+    OimoVec3 tfz = oimo_mat3_mul_vec3(&tf->rotation, half_z);
+
+    // Take absolute values
+    tfx.x = oimo_abs(tfx.x); tfx.y = oimo_abs(tfx.y); tfx.z = oimo_abs(tfx.z);
+    tfy.x = oimo_abs(tfy.x); tfy.y = oimo_abs(tfy.y); tfy.z = oimo_abs(tfy.z);
+    tfz.x = oimo_abs(tfz.x); tfz.y = oimo_abs(tfz.y); tfz.z = oimo_abs(tfz.z);
+
+    // Sum up the contributions
+    OimoVec3 extent;
+    extent.x = tfx.x + tfy.x + tfz.x;
+    extent.y = tfx.y + tfy.y + tfz.y;
+    extent.z = tfx.z + tfy.z + tfz.z;
+
+    // AABB = position ± extent
+    aabb->min = oimo_vec3_sub(tf->position, extent);
+    aabb->max = oimo_vec3_add(tf->position, extent);
+}
+
+// Ray cast against box in local coordinates (slab method)
+static inline int oimo_box_geometry_ray_cast_local(
+    const OimoBoxGeometry* box,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    OimoRayCastHit* hit
+) {
+    OimoScalar p1x = begin->x, p1y = begin->y, p1z = begin->z;
+    OimoScalar p2x = end->x, p2y = end->y, p2z = end->z;
+    OimoScalar hw = box->half_extents.x;
+    OimoScalar hh = box->half_extents.y;
+    OimoScalar hd = box->half_extents.z;
+
+    OimoScalar dx = p2x - p1x;
+    OimoScalar dy = p2y - p1y;
+    OimoScalar dz = p2z - p1z;
+
+    OimoScalar tminx = 0, tminy = 0, tminz = 0;
+    OimoScalar tmaxx = 1, tmaxy = 1, tmaxz = 1;
+
+    // X axis slab
+    if (dx > -OIMO_EPSILON && dx < OIMO_EPSILON) {
+        if (p1x <= -hw || p1x >= hw) return 0;
+    } else {
+        OimoScalar inv_dx = 1.0f / dx;
+        OimoScalar t1 = (-hw - p1x) * inv_dx;
+        OimoScalar t2 = (hw - p1x) * inv_dx;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > 0) tminx = t1;
+        if (t2 < 1) tmaxx = t2;
+    }
+
+    // Y axis slab
+    if (dy > -OIMO_EPSILON && dy < OIMO_EPSILON) {
+        if (p1y <= -hh || p1y >= hh) return 0;
+    } else {
+        OimoScalar inv_dy = 1.0f / dy;
+        OimoScalar t1 = (-hh - p1y) * inv_dy;
+        OimoScalar t2 = (hh - p1y) * inv_dy;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > 0) tminy = t1;
+        if (t2 < 1) tmaxy = t2;
+    }
+
+    // Z axis slab
+    if (dz > -OIMO_EPSILON && dz < OIMO_EPSILON) {
+        if (p1z <= -hd || p1z >= hd) return 0;
+    } else {
+        OimoScalar inv_dz = 1.0f / dz;
+        OimoScalar t1 = (-hd - p1z) * inv_dz;
+        OimoScalar t2 = (hd - p1z) * inv_dz;
+        if (t1 > t2) { OimoScalar tmp = t1; t1 = t2; t2 = tmp; }
+        if (t1 > 0) tminz = t1;
+        if (t2 < 1) tmaxz = t2;
+    }
+
+    // Check for no intersection
+    if (tminx >= 1 || tminy >= 1 || tminz >= 1 ||
+        tmaxx <= 0 || tmaxy <= 0 || tmaxz <= 0) return 0;
+
+    // Find the actual intersection interval
+    OimoScalar tmin = tminx;
+    OimoScalar tmax = tmaxx;
+    int hit_axis = 0;  // 0=X, 1=Y, 2=Z
+
+    if (tminy > tmin) { tmin = tminy; hit_axis = 1; }
+    if (tminz > tmin) { tmin = tminz; hit_axis = 2; }
+    if (tmaxy < tmax) tmax = tmaxy;
+    if (tmaxz < tmax) tmax = tmaxz;
+
+    // No valid intersection
+    if (tmin > tmax) return 0;
+    if (tmin <= OIMO_EPSILON) return 0;  // Ray starts inside
+
+    // Compute hit position
+    hit->position.x = p1x + dx * tmin;
+    hit->position.y = p1y + dy * tmin;
+    hit->position.z = p1z + dz * tmin;
+    hit->fraction = tmin;
+
+    // Compute hit normal based on which face was hit
+    switch (hit_axis) {
+        case 0:  // X face
+            hit->normal = oimo_vec3(dx > 0 ? -1.0f : 1.0f, 0, 0);
+            break;
+        case 1:  // Y face
+            hit->normal = oimo_vec3(0, dy > 0 ? -1.0f : 1.0f, 0);
+            break;
+        case 2:  // Z face
+            hit->normal = oimo_vec3(0, 0, dz > 0 ? -1.0f : 1.0f);
+            break;
+    }
+
+    return 1;
+}
+
+// Ray cast against box at given transform (world coordinates)
+static inline int oimo_box_geometry_ray_cast(
+    const OimoBoxGeometry* box,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    const OimoTransform* tf,
+    OimoRayCastHit* hit
+) {
+    // Transform ray to local space
+    OimoVec3 local_begin = oimo_transform_inv_point(tf, begin);
+    OimoVec3 local_end = oimo_transform_inv_point(tf, end);
+
+    // Perform ray cast in local space
+    if (!oimo_box_geometry_ray_cast_local(box, &local_begin, &local_end, hit)) {
+        return 0;
+    }
+
+    // Transform result back to world space
+    hit->position = oimo_transform_point(tf, &hit->position);
+    hit->normal = oimo_transform_vector(tf, &hit->normal);
+
+    return 1;
+}
+
+// Compute local supporting vertex in given direction
+static inline OimoVec3 oimo_box_geometry_support_local(
+    const OimoBoxGeometry* box,
+    const OimoVec3* dir
+) {
+    return oimo_vec3(
+        dir->x > 0 ? box->half_extents.x : -box->half_extents.x,
+        dir->y > 0 ? box->half_extents.y : -box->half_extents.y,
+        dir->z > 0 ? box->half_extents.z : -box->half_extents.z
+    );
+}
+
+// Get box vertex by index (0-7)
+// Vertices are ordered: (-,-,-), (+,-,-), (-,+,-), (+,+,-), (-,-,+), (+,-,+), (-,+,+), (+,+,+)
+static inline OimoVec3 oimo_box_geometry_get_vertex(const OimoBoxGeometry* box, int index) {
+    OimoScalar sx = (index & 1) ? box->half_extents.x : -box->half_extents.x;
+    OimoScalar sy = (index & 2) ? box->half_extents.y : -box->half_extents.y;
+    OimoScalar sz = (index & 4) ? box->half_extents.z : -box->half_extents.z;
+    return oimo_vec3(sx, sy, sz);
+}
+
+// Get box vertex transformed by given transform
+static inline OimoVec3 oimo_box_geometry_get_vertex_world(
+    const OimoBoxGeometry* box,
+    int index,
+    const OimoTransform* tf
+) {
+    OimoVec3 local = oimo_box_geometry_get_vertex(box, index);
+    return oimo_transform_point(tf, &local);
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/capsule_geometry.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/capsule_geometry.h
new file mode 100644
index 0000000000..9f08e9c686
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/capsule_geometry.h
@@ -0,0 +1,247 @@
+#pragma once
+
+#include "../../common/setting.h"
+#include "../../common/math_util.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/transform.h"
+#include "geometry_type.h"
+#include "aabb.h"
+#include "geometry.h"
+
+// Capsule geometry: a cylinder with hemispherical caps
+// Aligned along Y axis by default (same as OimoPhysics)
+typedef struct OimoCapsuleGeometry {
+    OimoGeometry base;
+    OimoScalar radius;
+    OimoScalar halfHeight;  // Half of the cylinder portion (not including caps)
+} OimoCapsuleGeometry;
+
+static inline void oimo_capsule_geometry_init(OimoCapsuleGeometry* capsule, OimoScalar radius, OimoScalar halfHeight) {
+    oimo_geometry_init(&capsule->base, OIMO_GEOMETRY_CAPSULE);
+    capsule->radius = radius;
+    capsule->halfHeight = halfHeight;
+
+    OimoScalar r = radius;
+    OimoScalar hh = halfHeight;
+    OimoScalar r2 = r * r;
+    OimoScalar hh2 = hh * hh;
+
+    // Volume calculation (matches OimoPhysics exactly)
+    // cylinderVolume = 2*PI * r^2 * halfHeight
+    // sphereVolume = (4/3) * PI * r^3
+    OimoScalar cylinderVolume = OIMO_TWO_PI * r2 * hh;
+    OimoScalar sphereVolume = OIMO_PI * r2 * r * (4.0f / 3.0f);
+    capsule->base.volume = cylinderVolume + sphereVolume;
+
+    // Inertia coefficient calculation (matches OimoPhysics)
+    // These are I/m values (inertia divided by mass)
+    OimoScalar invVolume = (oimo_abs(capsule->base.volume) <= OIMO_EPSILON) ? 0.0f : (1.0f / capsule->base.volume);
+
+    // Iyy: rotation around the capsule's long axis (Y)
+    OimoScalar inertiaY = invVolume * (
+        cylinderVolume * r2 * 0.5f +
+        sphereVolume * r2 * 0.4f
+    );
+
+    // Ixx = Izz: rotation perpendicular to the capsule's long axis
+    OimoScalar inertiaXZ = invVolume * (
+        cylinderVolume * (r2 * 0.25f + hh2 / 3.0f) +
+        sphereVolume * (r2 * 0.4f + hh * r * 0.75f + hh2)
+    );
+
+    capsule->base.inertia_coeff = oimo_mat3(
+        inertiaXZ, 0, 0,
+        0, inertiaY, 0,
+        0, 0, inertiaXZ
+    );
+}
+
+// Create capsule geometry (returns by value)
+static inline OimoCapsuleGeometry oimo_capsule_geometry(OimoScalar radius, OimoScalar halfHeight) {
+    OimoCapsuleGeometry capsule;
+    oimo_capsule_geometry_init(&capsule, radius, halfHeight);
+    return capsule;
+}
+
+// Get radius
+static inline OimoScalar oimo_capsule_geometry_get_radius(const OimoCapsuleGeometry* capsule) {
+    return capsule->radius;
+}
+
+// Get half height
+static inline OimoScalar oimo_capsule_geometry_get_half_height(const OimoCapsuleGeometry* capsule) {
+    return capsule->halfHeight;
+}
+
+// Get total height (cylinder + 2*radius for caps)
+static inline OimoScalar oimo_capsule_geometry_get_total_height(const OimoCapsuleGeometry* capsule) {
+    return 2.0f * (capsule->halfHeight + capsule->radius);
+}
+
+// Compute AABB for capsule at given transform (matches OimoPhysics)
+static inline void oimo_capsule_geometry_compute_aabb(
+    const OimoCapsuleGeometry* capsule,
+    OimoAabb* aabb,
+    const OimoTransform* tf
+) {
+    OimoScalar r = capsule->radius;
+    OimoScalar hh = capsule->halfHeight;
+
+    // Get Y axis from rotation matrix and scale by halfHeight
+    OimoVec3 axis;
+    axis.x = tf->rotation.e01 * hh;
+    axis.y = tf->rotation.e11 * hh;
+    axis.z = tf->rotation.e21 * hh;
+
+    // Take absolute values
+    OimoScalar ax = oimo_abs(axis.x);
+    OimoScalar ay = oimo_abs(axis.y);
+    OimoScalar az = oimo_abs(axis.z);
+
+    // AABB = position ± (abs(axis) + radius)
+    aabb->min.x = tf->position.x - ax - r;
+    aabb->min.y = tf->position.y - ay - r;
+    aabb->min.z = tf->position.z - az - r;
+    aabb->max.x = tf->position.x + ax + r;
+    aabb->max.y = tf->position.y + ay + r;
+    aabb->max.z = tf->position.z + az + r;
+}
+
+// Compute local supporting vertex for GJK (matches OimoPhysics)
+static inline void oimo_capsule_geometry_compute_local_supporting_vertex(
+    const OimoCapsuleGeometry* capsule,
+    const OimoVec3* dir,
+    OimoVec3* out
+) {
+    // Return the center of the hemisphere in the direction of dir
+    if (dir->y > 0) {
+        out->x = 0;
+        out->y = capsule->halfHeight;
+        out->z = 0;
+    } else {
+        out->x = 0;
+        out->y = -capsule->halfHeight;
+        out->z = 0;
+    }
+}
+
+// Ray cast against capsule (matches OimoPhysics algorithm)
+static inline int oimo_capsule_geometry_ray_cast(
+    const OimoCapsuleGeometry* capsule,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    const OimoTransform* tf,
+    OimoRayCastHit* hit
+) {
+    // Transform ray to local space
+    OimoVec3 localBegin = oimo_transform_inv_point(tf, begin);
+    OimoVec3 localEnd = oimo_transform_inv_point(tf, end);
+
+    OimoScalar p1x = localBegin.x;
+    OimoScalar p1y = localBegin.y;
+    OimoScalar p1z = localBegin.z;
+    OimoScalar p2x = localEnd.x;
+    OimoScalar p2y = localEnd.y;
+    OimoScalar p2z = localEnd.z;
+
+    OimoScalar halfH = capsule->halfHeight;
+    OimoScalar r = capsule->radius;
+
+    OimoScalar dx = p2x - p1x;
+    OimoScalar dy = p2y - p1y;
+    OimoScalar dz = p2z - p1z;
+
+    // Test against infinite cylinder in XZ plane
+    OimoScalar tminxz = 0;
+    OimoScalar tmaxxz = 1;
+
+    OimoScalar a = dx * dx + dz * dz;
+    OimoScalar b = p1x * dx + p1z * dz;
+    OimoScalar c = (p1x * p1x + p1z * p1z) - r * r;
+    OimoScalar D = b * b - a * c;
+
+    if (D < 0) return 0;
+
+    if (a > 0) {
+        OimoScalar sqrtD = oimo_sqrt(D);
+        tminxz = (-b - sqrtD) / a;
+        tmaxxz = (-b + sqrtD) / a;
+        if (tminxz >= 1 || tmaxxz <= 0) return 0;
+    } else {
+        if (c >= 0) return 0;
+        tminxz = 0;
+        tmaxxz = 1;
+    }
+
+    OimoScalar crossY = p1y + dy * tminxz;
+
+    // Check if we hit the cylindrical part
+    if (crossY > -halfH && crossY < halfH) {
+        if (tminxz > 0) {
+            // Hit the cylinder side
+            hit->fraction = tminxz;
+            hit->position.x = p1x + dx * tminxz;
+            hit->position.y = crossY;
+            hit->position.z = p1z + dz * tminxz;
+
+            // Normal is perpendicular to Y axis
+            OimoScalar nx = hit->position.x;
+            OimoScalar nz = hit->position.z;
+            OimoScalar invLen = 1.0f / oimo_sqrt(nx * nx + nz * nz);
+            hit->normal.x = nx * invLen;
+            hit->normal.y = 0;
+            hit->normal.z = nz * invLen;
+
+            // Transform back to world space
+            hit->position = oimo_transform_point(tf, &hit->position);
+            hit->normal = oimo_mat3_mul_vec3(&tf->rotation, hit->normal);
+
+            return 1;
+        }
+        return 0;
+    }
+
+    // Test against hemisphere caps
+    OimoScalar sphereY = crossY < 0 ? -halfH : halfH;
+    OimoScalar spx = 0, spy = sphereY, spz = 0;  // Sphere center
+
+    OimoScalar ox = p1x - spx;
+    OimoScalar oy = p1y - spy;
+    OimoScalar oz = p1z - spz;
+
+    a = dx * dx + dy * dy + dz * dz;
+    b = ox * dx + oy * dy + oz * dz;
+    c = ox * ox + oy * oy + oz * oz - r * r;
+
+    D = b * b - a * c;
+    if (D < 0) return 0;
+
+    OimoScalar t = (-b - oimo_sqrt(D)) / a;
+    if (t < 0 || t > 1) return 0;
+
+    hit->fraction = t;
+    hit->position.x = p1x + dx * t;
+    hit->position.y = p1y + dy * t;
+    hit->position.z = p1z + dz * t;
+
+    // Normal points from sphere center to hit point
+    hit->normal.x = hit->position.x - spx;
+    hit->normal.y = hit->position.y - spy;
+    hit->normal.z = hit->position.z - spz;
+    OimoScalar invLen = 1.0f / oimo_sqrt(
+        hit->normal.x * hit->normal.x +
+        hit->normal.y * hit->normal.y +
+        hit->normal.z * hit->normal.z
+    );
+    hit->normal.x *= invLen;
+    hit->normal.y *= invLen;
+    hit->normal.z *= invLen;
+
+    // Transform back to world space
+    hit->position = oimo_transform_point(tf, &hit->position);
+    hit->normal = oimo_mat3_mul_vec3(&tf->rotation, hit->normal);
+
+    return 1;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.c b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.c
new file mode 100644
index 0000000000..4e28b73739
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.c
@@ -0,0 +1,88 @@
+/**
+ * OimoPhysics N64 Port - Geometry Implementation
+ *
+ * Implementation of generic dispatch functions for geometry operations.
+ */
+
+#include "geometry.h"
+#include "sphere_geometry.h"
+#include "box_geometry.h"
+#include "capsule_geometry.h"
+#include "static_mesh_geometry.h"
+
+// ============================================================================
+// Generic AABB Computation
+// ============================================================================
+
+void oimo_geometry_compute_aabb(const OimoGeometry* geom, OimoAabb* aabb, const OimoTransform* tf) {
+    switch (geom->type) {
+        case OIMO_GEOMETRY_SPHERE:
+            oimo_sphere_geometry_compute_aabb(
+                (const OimoSphereGeometry*)geom, aabb, tf);
+            break;
+
+        case OIMO_GEOMETRY_BOX:
+            oimo_box_geometry_compute_aabb(
+                (const OimoBoxGeometry*)geom, aabb, tf);
+            break;
+
+        case OIMO_GEOMETRY_CAPSULE:
+            oimo_capsule_geometry_compute_aabb(
+                (const OimoCapsuleGeometry*)geom, aabb, tf);
+            break;
+
+        case OIMO_GEOMETRY_STATIC_MESH:
+            oimo_static_mesh_compute_aabb(
+                (const OimoStaticMeshGeometry*)geom, aabb, tf);
+            break;
+
+        default:
+            // Unknown geometry type - create zero AABB at position
+            aabb->min = oimo_vec3_copy(&tf->position);
+            aabb->max = oimo_vec3_copy(&tf->position);
+            break;
+    }
+}
+
+// ============================================================================
+// Generic Ray Casting
+// ============================================================================
+
+int oimo_geometry_ray_cast(
+    const OimoGeometry* geom,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    const OimoTransform* tf,
+    OimoRayCastHit* hit
+) {
+    switch (geom->type) {
+        case OIMO_GEOMETRY_SPHERE:
+            return oimo_sphere_geometry_ray_cast(
+                (const OimoSphereGeometry*)geom, begin, end, tf, hit);
+
+        case OIMO_GEOMETRY_BOX:
+            return oimo_box_geometry_ray_cast(
+                (const OimoBoxGeometry*)geom, begin, end, tf, hit);
+
+        case OIMO_GEOMETRY_CAPSULE:
+            return oimo_capsule_geometry_ray_cast(
+                (const OimoCapsuleGeometry*)geom, begin, end, tf, hit);
+
+        case OIMO_GEOMETRY_STATIC_MESH: {
+            // Transform ray to local space
+            OimoVec3 local_begin = oimo_transform_inv_point(tf, begin);
+            OimoVec3 local_end = oimo_transform_inv_point(tf, end);
+            if (oimo_static_mesh_ray_cast(
+                (const OimoStaticMeshGeometry*)geom, &local_begin, &local_end, hit)) {
+                // Transform hit back to world space
+                hit->position = oimo_transform_point(tf, &hit->position);
+                hit->normal = oimo_transform_vector(tf, &hit->normal);
+                return 1;
+            }
+            return 0;
+        }
+
+        default:
+            return 0;  // No hit for unknown geometry type
+    }
+}
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.h
new file mode 100644
index 0000000000..9d39160bbb
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include "../../common/setting.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/transform.h"
+#include "geometry_type.h"
+#include "aabb.h"
+
+typedef struct OimoRayCastHit {
+    OimoVec3 position;
+    OimoVec3 normal;
+    OimoScalar fraction;
+} OimoRayCastHit;
+
+static inline void oimo_raycast_hit_init(OimoRayCastHit* hit) {
+    hit->position = oimo_vec3_zero();
+    hit->normal = oimo_vec3_zero();
+    hit->fraction = 0;
+}
+
+typedef struct OimoGeometry {
+    OimoGeometryType type;
+    OimoScalar volume;
+    OimoMat3 inertia_coeff;
+} OimoGeometry;
+
+static inline void oimo_geometry_init(OimoGeometry* geom, OimoGeometryType type) {
+    geom->type = type;
+    geom->volume = 0;
+    geom->inertia_coeff = oimo_mat3_zero();
+}
+
+static inline OimoGeometryType oimo_geometry_get_type(const OimoGeometry* geom) {
+    return geom->type;
+}
+
+static inline OimoScalar oimo_geometry_get_volume(const OimoGeometry* geom) {
+    return geom->volume;
+}
+
+static inline OimoMat3 oimo_geometry_get_inertia(const OimoGeometry* geom, OimoScalar mass) {
+    return oimo_mat3_scale(&geom->inertia_coeff, mass);
+}
+
+static inline OimoScalar oimo_geometry_compute_mass(const OimoGeometry* geom, OimoScalar density) {
+    return geom->volume * density;
+}
+
+struct OimoSphereGeometry;
+struct OimoBoxGeometry;
+
+void oimo_geometry_compute_aabb(const OimoGeometry* geom, OimoAabb* aabb, const OimoTransform* tf);
+
+int oimo_geometry_ray_cast(
+    const OimoGeometry* geom,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    const OimoTransform* tf,
+    OimoRayCastHit* hit
+);
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry_type.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry_type.h
new file mode 100644
index 0000000000..9d4d6f17da
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/geometry_type.h
@@ -0,0 +1,33 @@
+#pragma once
+
+typedef enum OimoGeometryType {
+    OIMO_GEOMETRY_SPHERE  = 0,
+    OIMO_GEOMETRY_BOX     = 1,
+    OIMO_GEOMETRY_CAPSULE = 2,
+    OIMO_GEOMETRY_STATIC_MESH = 3,
+
+    // Count of supported types
+    OIMO_GEOMETRY_TYPE_COUNT = 4
+} OimoGeometryType;
+
+// Check if type is a convex geometry
+static inline int oimo_geometry_is_convex(OimoGeometryType type) {
+    return type == OIMO_GEOMETRY_SPHERE || type == OIMO_GEOMETRY_BOX || type == OIMO_GEOMETRY_CAPSULE;
+}
+
+// Check if type is a mesh geometry (concave, static only)
+static inline int oimo_geometry_is_mesh(OimoGeometryType type) {
+    return type == OIMO_GEOMETRY_STATIC_MESH;
+}
+
+// Get geometry type name (for debugging)
+static inline const char* oimo_geometry_type_name(OimoGeometryType type) {
+    switch (type) {
+        case OIMO_GEOMETRY_SPHERE:      return "Sphere";
+        case OIMO_GEOMETRY_BOX:         return "Box";
+        case OIMO_GEOMETRY_CAPSULE:     return "Capsule";
+        case OIMO_GEOMETRY_STATIC_MESH: return "StaticMesh";
+        default:                        return "Unknown";
+    }
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/sphere_geometry.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/sphere_geometry.h
new file mode 100644
index 0000000000..c9f9d15ba1
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/sphere_geometry.h
@@ -0,0 +1,149 @@
+#pragma once
+
+#include "../../common/setting.h"
+#include "../../common/math_util.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/transform.h"
+#include "geometry_type.h"
+#include "aabb.h"
+#include "geometry.h"
+
+typedef struct OimoSphereGeometry {
+    OimoGeometry base;
+    OimoScalar radius;
+} OimoSphereGeometry;
+
+static inline void oimo_sphere_geometry_init(OimoSphereGeometry* sphere, OimoScalar radius) {
+    oimo_geometry_init(&sphere->base, OIMO_GEOMETRY_SPHERE);
+    sphere->radius = radius;
+
+    // Compute volume: V = (4/3) * PI * r^3
+    sphere->base.volume = (4.0f / 3.0f) * OIMO_PI * radius * radius * radius;
+
+    // Compute inertia coefficient: I/m = (2/5) * r^2 for all axes (diagonal matrix)
+    OimoScalar inertia_coeff = (2.0f / 5.0f) * radius * radius;
+    sphere->base.inertia_coeff = oimo_mat3(
+        inertia_coeff, 0, 0,
+        0, inertia_coeff, 0,
+        0, 0, inertia_coeff
+    );
+}
+
+// Create sphere geometry (returns by value)
+static inline OimoSphereGeometry oimo_sphere_geometry(OimoScalar radius) {
+    OimoSphereGeometry sphere;
+    oimo_sphere_geometry_init(&sphere, radius);
+    return sphere;
+}
+
+// Get radius
+static inline OimoScalar oimo_sphere_geometry_get_radius(const OimoSphereGeometry* sphere) {
+    return sphere->radius;
+}
+
+// Set radius and update mass properties
+static inline void oimo_sphere_geometry_set_radius(OimoSphereGeometry* sphere, OimoScalar radius) {
+    sphere->radius = radius;
+
+    // Update volume
+    sphere->base.volume = (4.0f / 3.0f) * OIMO_PI * radius * radius * radius;
+
+    // Update inertia coefficient
+    OimoScalar inertia_coeff = (2.0f / 5.0f) * radius * radius;
+    sphere->base.inertia_coeff = oimo_mat3(
+        inertia_coeff, 0, 0,
+        0, inertia_coeff, 0,
+        0, 0, inertia_coeff
+    );
+}
+
+// Compute AABB for sphere at given transform
+static inline void oimo_sphere_geometry_compute_aabb(
+    const OimoSphereGeometry* sphere,
+    OimoAabb* aabb,
+    const OimoTransform* tf
+) {
+    // Sphere AABB is just position ± radius on all axes
+    OimoScalar r = sphere->radius;
+    aabb->min.x = tf->position.x - r;
+    aabb->min.y = tf->position.y - r;
+    aabb->min.z = tf->position.z - r;
+    aabb->max.x = tf->position.x + r;
+    aabb->max.y = tf->position.y + r;
+    aabb->max.z = tf->position.z + r;
+}
+
+// Ray cast against sphere in local coordinates
+// begin and end are in local space (relative to sphere center)
+static inline int oimo_sphere_geometry_ray_cast_local(
+    const OimoSphereGeometry* sphere,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    OimoRayCastHit* hit
+) {
+    // Ray: P(t) = begin + t * d, where d = end - begin
+    OimoVec3 d = oimo_vec3_sub(*end, *begin);
+
+    // Solve: |begin + t*d|^2 = r^2
+    // => (d·d)*t^2 + 2*(begin·d)*t + (begin·begin - r^2) = 0
+    OimoScalar a = oimo_vec3_dot(d, d);
+    OimoScalar b = oimo_vec3_dot(*begin, d);
+    OimoScalar c = oimo_vec3_dot(*begin, *begin) - sphere->radius * sphere->radius;
+
+    // Discriminant: D = b^2 - a*c
+    OimoScalar discriminant = b * b - a * c;
+    if (discriminant < 0) return 0;  // No intersection
+
+    // t = (-b - sqrt(D)) / a  (take the nearer intersection)
+    OimoScalar t = (-b - oimo_sqrt(discriminant)) / a;
+
+    // Check if intersection is within ray segment
+    if (t < 0 || t > 1) return 0;
+
+    // Compute hit position and normal
+    OimoVec3 hit_pos = oimo_vec3_add_scaled(*begin, d, t);
+    OimoVec3 hit_normal = oimo_vec3_normalize(hit_pos);
+
+    hit->position = hit_pos;
+    hit->normal = hit_normal;
+    hit->fraction = t;
+
+    return 1;
+}
+
+// Ray cast against sphere at given transform (world coordinates)
+static inline int oimo_sphere_geometry_ray_cast(
+    const OimoSphereGeometry* sphere,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    const OimoTransform* tf,
+    OimoRayCastHit* hit
+) {
+    // Transform ray to local space
+    OimoVec3 local_begin = oimo_transform_inv_point(tf, begin);
+    OimoVec3 local_end = oimo_transform_inv_point(tf, end);
+
+    // Perform ray cast in local space
+    if (!oimo_sphere_geometry_ray_cast_local(sphere, &local_begin, &local_end, hit)) {
+        return 0;
+    }
+
+    // Transform result back to world space
+    hit->position = oimo_transform_point(tf, &hit->position);
+    hit->normal = oimo_transform_vector(tf, &hit->normal);
+
+    return 1;
+}
+
+// Compute local supporting vertex in given direction
+// For a sphere, the supporting vertex is always at the center (for core geometry)
+static inline OimoVec3 oimo_sphere_geometry_support_local(
+    const OimoSphereGeometry* sphere,
+    const OimoVec3* dir
+) {
+    (void)sphere;  // Unused
+    (void)dir;     // Unused
+    return oimo_vec3_zero();
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/geometry/static_mesh_geometry.h b/armorcore/Deployment/n64/src/oimo/collision/geometry/static_mesh_geometry.h
new file mode 100644
index 0000000000..68aaafd328
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/geometry/static_mesh_geometry.h
@@ -0,0 +1,290 @@
+#pragma once
+
+// static_mesh_geometry.h - Static triangle mesh collision geometry with BVH
+
+#include "geometry.h"
+#include "../broadphase/bvh.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/transform.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Triangle structure
+typedef struct OimoTriangle {
+    OimoVec3 v0, v1, v2;     // Vertices
+    OimoVec3 normal;         // Face normal
+    OimoVec3 edge1, edge2;   // Precomputed edges for collision
+} OimoTriangle;
+
+// Static mesh geometry
+typedef struct OimoStaticMeshGeometry {
+    OimoGeometry base;
+
+    // Mesh data
+    OimoTriangle* triangles;
+    int16_t triangle_count;
+
+    // BVH for spatial queries
+    OimoBvhTree bvh;
+    OimoBvhTriangle* bvh_triangles;  // BVH triangle data (centroids + AABBs)
+
+    // Overall bounds
+    OimoAabb bounds;
+} OimoStaticMeshGeometry;
+
+// Compute triangle normal from vertices
+static inline OimoVec3 oimo_compute_triangle_normal(const OimoVec3* v0, const OimoVec3* v1, const OimoVec3* v2) {
+    OimoVec3 edge1 = oimo_vec3_sub(*v1, *v0);
+    OimoVec3 edge2 = oimo_vec3_sub(*v2, *v0);
+    OimoVec3 normal = oimo_vec3_cross(edge1, edge2);
+    return oimo_vec3_normalize(normal);
+}
+
+// Compute triangle centroid
+static inline OimoVec3 oimo_compute_triangle_centroid(const OimoVec3* v0, const OimoVec3* v1, const OimoVec3* v2) {
+    return oimo_vec3(
+        (v0->x + v1->x + v2->x) / 3.0f,
+        (v0->y + v1->y + v2->y) / 3.0f,
+        (v0->z + v1->z + v2->z) / 3.0f
+    );
+}
+
+// Compute triangle AABB
+static inline void oimo_compute_triangle_aabb(const OimoVec3* v0, const OimoVec3* v1, const OimoVec3* v2, OimoAabb* aabb) {
+    aabb->min.x = fminf(v0->x, fminf(v1->x, v2->x));
+    aabb->min.y = fminf(v0->y, fminf(v1->y, v2->y));
+    aabb->min.z = fminf(v0->z, fminf(v1->z, v2->z));
+    aabb->max.x = fmaxf(v0->x, fmaxf(v1->x, v2->x));
+    aabb->max.y = fmaxf(v0->y, fmaxf(v1->y, v2->y));
+    aabb->max.z = fmaxf(v0->z, fmaxf(v1->z, v2->z));
+}
+
+// Initialize static mesh geometry from vertex and index arrays
+// vertices: array of Vec3 positions
+// indices: array of triangle indices (3 per triangle)
+// vertex_count: number of vertices
+// index_count: number of indices (must be multiple of 3)
+static inline bool oimo_static_mesh_geometry_init(
+    OimoStaticMeshGeometry* geom,
+    const OimoVec3* vertices,
+    const int16_t* indices,
+    int vertex_count,
+    int index_count
+) {
+    oimo_geometry_init(&geom->base, OIMO_GEOMETRY_STATIC_MESH);
+
+    geom->triangle_count = (int16_t)(index_count / 3);
+    if (geom->triangle_count == 0 || geom->triangle_count > OIMO_BVH_MAX_TRIANGLES) {
+        return false;
+    }
+
+    // Allocate triangles
+    geom->triangles = (OimoTriangle*)malloc(sizeof(OimoTriangle) * geom->triangle_count);
+    if (!geom->triangles) return false;
+
+    // Allocate BVH triangle data
+    geom->bvh_triangles = (OimoBvhTriangle*)malloc(sizeof(OimoBvhTriangle) * geom->triangle_count);
+    if (!geom->bvh_triangles) {
+        free(geom->triangles);
+        return false;
+    }
+
+    // Initialize BVH
+    if (!oimo_bvh_tree_init(&geom->bvh, geom->triangle_count)) {
+        free(geom->triangles);
+        free(geom->bvh_triangles);
+        return false;
+    }
+
+    // Build triangles and compute bounds
+    oimo_aabb_init(&geom->bounds);
+
+    for (int i = 0; i < geom->triangle_count; i++) {
+        int idx = i * 3;
+        const OimoVec3* v0 = &vertices[indices[idx]];
+        const OimoVec3* v1 = &vertices[indices[idx + 1]];
+        const OimoVec3* v2 = &vertices[indices[idx + 2]];
+
+        // Store triangle data
+        geom->triangles[i].v0 = *v0;
+        geom->triangles[i].v1 = *v1;
+        geom->triangles[i].v2 = *v2;
+        geom->triangles[i].normal = oimo_compute_triangle_normal(v0, v1, v2);
+        geom->triangles[i].edge1 = oimo_vec3_sub(*v1, *v0);
+        geom->triangles[i].edge2 = oimo_vec3_sub(*v2, *v0);
+
+        // Build BVH data
+        geom->bvh_triangles[i].centroid = oimo_compute_triangle_centroid(v0, v1, v2);
+        oimo_compute_triangle_aabb(v0, v1, v2, &geom->bvh_triangles[i].aabb);
+        geom->bvh_triangles[i].original_index = (int16_t)i;
+
+        // Expand overall bounds
+        oimo_aabb_merge(&geom->bounds, &geom->bounds, &geom->bvh_triangles[i].aabb);
+    }
+
+    // Build BVH
+    if (!oimo_bvh_tree_build(&geom->bvh, geom->bvh_triangles, geom->triangle_count)) {
+        oimo_bvh_tree_free(&geom->bvh);
+        free(geom->triangles);
+        free(geom->bvh_triangles);
+        return false;
+    }
+
+    // Compute approximate volume (bounding box volume)
+    OimoVec3 size = oimo_vec3_sub(geom->bounds.max, geom->bounds.min);
+    geom->base.volume = size.x * size.y * size.z;
+
+    // Compute approximate inertia (as if it were a box)
+    float mass = 1.0f;  // Normalized
+    geom->base.inertia_coeff = oimo_mat3_diagonal(
+        mass / 12.0f * (size.y * size.y + size.z * size.z),
+        mass / 12.0f * (size.z * size.z + size.x * size.x),
+        mass / 12.0f * (size.x * size.x + size.y * size.y)
+    );
+
+    return true;
+}
+
+// Free static mesh geometry
+static inline void oimo_static_mesh_geometry_free(OimoStaticMeshGeometry* geom) {
+    oimo_bvh_tree_free(&geom->bvh);
+    if (geom->triangles) {
+        free(geom->triangles);
+        geom->triangles = NULL;
+    }
+    if (geom->bvh_triangles) {
+        free(geom->bvh_triangles);
+        geom->bvh_triangles = NULL;
+    }
+    geom->triangle_count = 0;
+}
+
+// Query triangles overlapping an AABB (in local space)
+static inline void oimo_static_mesh_query_triangles(
+    const OimoStaticMeshGeometry* geom,
+    const OimoAabb* aabb,
+    OimoBvhQueryResult* result
+) {
+    oimo_bvh_query(&geom->bvh, aabb, result);
+}
+
+// Get triangle by index
+static inline const OimoTriangle* oimo_static_mesh_get_triangle(
+    const OimoStaticMeshGeometry* geom,
+    int index
+) {
+    if (index < 0 || index >= geom->triangle_count) return NULL;
+    return &geom->triangles[index];
+}
+
+// Compute AABB in world space
+static inline void oimo_static_mesh_compute_aabb(
+    const OimoStaticMeshGeometry* geom,
+    OimoAabb* aabb,
+    const OimoTransform* tf
+) {
+    // Transform all 8 corners of local bounds and find enclosing AABB
+    OimoVec3 corners[8];
+    corners[0] = oimo_vec3(geom->bounds.min.x, geom->bounds.min.y, geom->bounds.min.z);
+    corners[1] = oimo_vec3(geom->bounds.max.x, geom->bounds.min.y, geom->bounds.min.z);
+    corners[2] = oimo_vec3(geom->bounds.min.x, geom->bounds.max.y, geom->bounds.min.z);
+    corners[3] = oimo_vec3(geom->bounds.max.x, geom->bounds.max.y, geom->bounds.min.z);
+    corners[4] = oimo_vec3(geom->bounds.min.x, geom->bounds.min.y, geom->bounds.max.z);
+    corners[5] = oimo_vec3(geom->bounds.max.x, geom->bounds.min.y, geom->bounds.max.z);
+    corners[6] = oimo_vec3(geom->bounds.min.x, geom->bounds.max.y, geom->bounds.max.z);
+    corners[7] = oimo_vec3(geom->bounds.max.x, geom->bounds.max.y, geom->bounds.max.z);
+
+    aabb->min = oimo_vec3(1e30f, 1e30f, 1e30f);
+    aabb->max = oimo_vec3(-1e30f, -1e30f, -1e30f);
+
+    for (int i = 0; i < 8; i++) {
+        OimoVec3 world = oimo_mat3_mul_vec3(&tf->rotation, corners[i]);
+        world = oimo_vec3_add(world, tf->position);
+
+        if (world.x < aabb->min.x) aabb->min.x = world.x;
+        if (world.y < aabb->min.y) aabb->min.y = world.y;
+        if (world.z < aabb->min.z) aabb->min.z = world.z;
+        if (world.x > aabb->max.x) aabb->max.x = world.x;
+        if (world.y > aabb->max.y) aabb->max.y = world.y;
+        if (world.z > aabb->max.z) aabb->max.z = world.z;
+    }
+}
+
+// Ray cast against static mesh (uses BVH for acceleration)
+static inline bool oimo_static_mesh_ray_cast(
+    const OimoStaticMeshGeometry* geom,
+    const OimoVec3* begin,
+    const OimoVec3* end,
+    OimoRayCastHit* hit
+) {
+    OimoVec3 ray_dir = oimo_vec3_sub(*end, *begin);
+    float ray_length_sq = oimo_vec3_dot(ray_dir, ray_dir);
+    if (ray_length_sq < 1e-12f) return false;
+
+    float ray_length = sqrtf(ray_length_sq);
+    ray_dir = oimo_vec3_scale(ray_dir, 1.0f / ray_length);
+
+    // Build ray AABB
+    OimoAabb ray_aabb;
+    ray_aabb.min.x = fminf(begin->x, end->x);
+    ray_aabb.min.y = fminf(begin->y, end->y);
+    ray_aabb.min.z = fminf(begin->z, end->z);
+    ray_aabb.max.x = fmaxf(begin->x, end->x);
+    ray_aabb.max.y = fmaxf(begin->y, end->y);
+    ray_aabb.max.z = fmaxf(begin->z, end->z);
+
+    // Query overlapping triangles
+    OimoBvhQueryResult query;
+    oimo_static_mesh_query_triangles(geom, &ray_aabb, &query);
+
+    float closest_t = 1e30f;
+    int closest_tri = -1;
+
+    // Möller–Trumbore ray-triangle intersection
+    for (int i = 0; i < query.count; i++) {
+        const OimoTriangle* tri = &geom->triangles[query.triangles[i]];
+
+        OimoVec3 h = oimo_vec3_cross(ray_dir, tri->edge2);
+        float a = oimo_vec3_dot(tri->edge1, h);
+
+        if (a > -1e-6f && a < 1e-6f) continue;  // Parallel
+
+        float f = 1.0f / a;
+        OimoVec3 s = oimo_vec3_sub(*begin, tri->v0);
+        float u = f * oimo_vec3_dot(s, h);
+
+        if (u < 0.0f || u > 1.0f) continue;
+
+        OimoVec3 q = oimo_vec3_cross(s, tri->edge1);
+        float v = f * oimo_vec3_dot(ray_dir, q);
+
+        if (v < 0.0f || u + v > 1.0f) continue;
+
+        float t = f * oimo_vec3_dot(tri->edge2, q);
+
+        if (t > 1e-6f && t <= ray_length && t < closest_t) {
+            closest_t = t;
+            closest_tri = query.triangles[i];
+        }
+    }
+
+    if (closest_tri >= 0) {
+        OimoVec3 scaled_dir = oimo_vec3_scale(ray_dir, closest_t);
+        hit->position = oimo_vec3_add(*begin, scaled_dir);
+        hit->normal = geom->triangles[closest_tri].normal;
+        hit->fraction = closest_t / ray_length;
+        return true;
+    }
+
+    return false;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_box_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_box_detector.h
new file mode 100644
index 0000000000..9fb260e404
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_box_detector.h
@@ -0,0 +1,804 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/box_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+#include "../../common/mat3.h"
+#include "../../common/setting.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OIMO_BOX_BOX_EDGE_BIAS_MULT 1.0f
+
+typedef struct OimoIncidentVertex {
+    OimoScalar x, y;
+    OimoScalar wx, wy, wz;
+} OimoIncidentVertex;
+
+typedef struct OimoFaceClipper {
+    OimoScalar w, h;
+    int num_vertices;
+    OimoIncidentVertex vertices[8];
+    int num_tmp_vertices;
+    OimoIncidentVertex tmp_vertices[8];
+} OimoFaceClipper;
+
+typedef struct OimoBoxBoxDetector {
+    OimoDetector base;
+    OimoFaceClipper clipper;
+} OimoBoxBoxDetector;
+
+static inline void oimo_incident_vertex_init(OimoIncidentVertex* v,
+    OimoScalar x, OimoScalar y, OimoScalar wx, OimoScalar wy, OimoScalar wz)
+{
+    v->x = x;
+    v->y = y;
+    v->wx = wx;
+    v->wy = wy;
+    v->wz = wz;
+}
+
+static inline void oimo_incident_vertex_copy(OimoIncidentVertex* dst, const OimoIncidentVertex* src) {
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->wx = src->wx;
+    dst->wy = src->wy;
+    dst->wz = src->wz;
+}
+
+static inline void oimo_incident_vertex_interp(OimoIncidentVertex* out,
+    const OimoIncidentVertex* v1, const OimoIncidentVertex* v2, OimoScalar t)
+{
+    out->x = v1->x + (v2->x - v1->x) * t;
+    out->y = v1->y + (v2->y - v1->y) * t;
+    out->wx = v1->wx + (v2->wx - v1->wx) * t;
+    out->wy = v1->wy + (v2->wy - v1->wy) * t;
+    out->wz = v1->wz + (v2->wz - v1->wz) * t;
+}
+
+static inline void oimo_face_clipper_init(OimoFaceClipper* clipper, OimoScalar w, OimoScalar h) {
+    clipper->w = w;
+    clipper->h = h;
+    clipper->num_vertices = 0;
+    clipper->num_tmp_vertices = 0;
+}
+
+static inline void oimo_face_clipper_add_vertex(OimoFaceClipper* clipper,
+    OimoScalar x, OimoScalar y, OimoScalar wx, OimoScalar wy, OimoScalar wz)
+{
+    oimo_incident_vertex_init(&clipper->vertices[clipper->num_vertices++], x, y, wx, wy, wz);
+}
+
+static inline void oimo_face_clipper_flip(OimoFaceClipper* clipper) {
+    // Swap vertices and tmp_vertices
+    OimoIncidentVertex temp[8];
+    for (int i = 0; i < 8; i++) {
+        oimo_incident_vertex_copy(&temp[i], &clipper->vertices[i]);
+        oimo_incident_vertex_copy(&clipper->vertices[i], &clipper->tmp_vertices[i]);
+        oimo_incident_vertex_copy(&clipper->tmp_vertices[i], &temp[i]);
+    }
+    clipper->num_vertices = clipper->num_tmp_vertices;
+    clipper->num_tmp_vertices = 0;
+}
+
+static inline void oimo_face_clipper_add_tmp(OimoFaceClipper* clipper, const OimoIncidentVertex* v) {
+    oimo_incident_vertex_copy(&clipper->tmp_vertices[clipper->num_tmp_vertices++], v);
+}
+
+static inline void oimo_face_clipper_interp_tmp(OimoFaceClipper* clipper,
+    const OimoIncidentVertex* v1, const OimoIncidentVertex* v2, OimoScalar t)
+{
+    oimo_incident_vertex_interp(&clipper->tmp_vertices[clipper->num_tmp_vertices++], v1, v2, t);
+}
+
+static inline void oimo_face_clipper_clip_with_param(OimoFaceClipper* clipper,
+    const OimoIncidentVertex* v1, const OimoIncidentVertex* v2,
+    OimoScalar s1, OimoScalar s2)
+{
+    if (s1 > 0 && s2 > 0) {
+        oimo_face_clipper_add_tmp(clipper, v1);
+    } else if (s1 > 0 && s2 <= 0) {
+        // v2 is clipped
+        oimo_face_clipper_add_tmp(clipper, v1);
+        oimo_face_clipper_interp_tmp(clipper, v1, v2, s1 / (s1 - s2));
+    } else if (s1 <= 0 && s2 > 0) {
+        // v1 is clipped
+        oimo_face_clipper_interp_tmp(clipper, v1, v2, s1 / (s1 - s2));
+    }
+    // else: both outside, skip
+}
+
+static inline void oimo_face_clipper_clip_l(OimoFaceClipper* clipper) {
+    for (int i = 0; i < clipper->num_vertices; i++) {
+        OimoIncidentVertex* v1 = &clipper->vertices[i];
+        OimoIncidentVertex* v2 = &clipper->vertices[(i + 1) % clipper->num_vertices];
+        OimoScalar s1 = clipper->w + v1->x;
+        OimoScalar s2 = clipper->w + v2->x;
+        oimo_face_clipper_clip_with_param(clipper, v1, v2, s1, s2);
+    }
+}
+
+static inline void oimo_face_clipper_clip_r(OimoFaceClipper* clipper) {
+    for (int i = 0; i < clipper->num_vertices; i++) {
+        OimoIncidentVertex* v1 = &clipper->vertices[i];
+        OimoIncidentVertex* v2 = &clipper->vertices[(i + 1) % clipper->num_vertices];
+        OimoScalar s1 = clipper->w - v1->x;
+        OimoScalar s2 = clipper->w - v2->x;
+        oimo_face_clipper_clip_with_param(clipper, v1, v2, s1, s2);
+    }
+}
+
+static inline void oimo_face_clipper_clip_t(OimoFaceClipper* clipper) {
+    for (int i = 0; i < clipper->num_vertices; i++) {
+        OimoIncidentVertex* v1 = &clipper->vertices[i];
+        OimoIncidentVertex* v2 = &clipper->vertices[(i + 1) % clipper->num_vertices];
+        OimoScalar s1 = clipper->h + v1->y;
+        OimoScalar s2 = clipper->h + v2->y;
+        oimo_face_clipper_clip_with_param(clipper, v1, v2, s1, s2);
+    }
+}
+
+static inline void oimo_face_clipper_clip_b(OimoFaceClipper* clipper) {
+    for (int i = 0; i < clipper->num_vertices; i++) {
+        OimoIncidentVertex* v1 = &clipper->vertices[i];
+        OimoIncidentVertex* v2 = &clipper->vertices[(i + 1) % clipper->num_vertices];
+        OimoScalar s1 = clipper->h - v1->y;
+        OimoScalar s2 = clipper->h - v2->y;
+        oimo_face_clipper_clip_with_param(clipper, v1, v2, s1, s2);
+    }
+}
+
+static inline void oimo_face_clipper_clip(OimoFaceClipper* clipper) {
+    oimo_face_clipper_clip_l(clipper);
+    oimo_face_clipper_flip(clipper);
+    oimo_face_clipper_clip_r(clipper);
+    oimo_face_clipper_flip(clipper);
+    oimo_face_clipper_clip_t(clipper);
+    oimo_face_clipper_flip(clipper);
+    oimo_face_clipper_clip_b(clipper);
+    oimo_face_clipper_flip(clipper);
+}
+
+/**
+ * Reduce vertices to 4 or fewer for manifold.
+ */
+static inline void oimo_face_clipper_reduce(OimoFaceClipper* clipper) {
+    if (clipper->num_vertices <= 4) {
+        return;
+    }
+
+    // Find 4 extreme points along diagonal directions
+    OimoScalar e1x = 1.0f;
+    OimoScalar e1y = 1.0f;
+    OimoScalar e2x = -1.0f;
+    OimoScalar e2y = 1.0f;
+
+    OimoScalar max1 = -1e30f;
+    OimoScalar min1 = 1e30f;
+    OimoScalar max2 = -1e30f;
+    OimoScalar min2 = 1e30f;
+
+    int max1_idx = 0, min1_idx = 0, max2_idx = 0, min2_idx = 0;
+
+    for (int i = 0; i < clipper->num_vertices; i++) {
+        OimoIncidentVertex* v = &clipper->vertices[i];
+        OimoScalar dot1 = v->x * e1x + v->y * e1y;
+        OimoScalar dot2 = v->x * e2x + v->y * e2y;
+
+        if (i == 0) {
+            max1 = dot1; max1_idx = i;
+            min1 = dot1; min1_idx = i;
+            max2 = dot2; max2_idx = i;
+            min2 = dot2; min2_idx = i;
+        } else {
+            if (dot1 > max1) { max1 = dot1; max1_idx = i; }
+            if (dot1 < min1) { min1 = dot1; min1_idx = i; }
+            if (dot2 > max2) { max2 = dot2; max2_idx = i; }
+            if (dot2 < min2) { min2 = dot2; min2_idx = i; }
+        }
+    }
+
+    // Copy selected vertices
+    oimo_incident_vertex_copy(&clipper->tmp_vertices[0], &clipper->vertices[max1_idx]);
+    oimo_incident_vertex_copy(&clipper->tmp_vertices[1], &clipper->vertices[max2_idx]);
+    oimo_incident_vertex_copy(&clipper->tmp_vertices[2], &clipper->vertices[min1_idx]);
+    oimo_incident_vertex_copy(&clipper->tmp_vertices[3], &clipper->vertices[min2_idx]);
+    clipper->num_tmp_vertices = 4;
+
+    oimo_face_clipper_flip(clipper);
+}
+
+static inline OimoScalar oimo_box_box_project(const OimoVec3* axis,
+    const OimoVec3* sx, const OimoVec3* sy, const OimoVec3* sz)
+{
+    OimoScalar dx = oimo_abs(oimo_vec3_dot(*axis, *sx));
+    OimoScalar dy = oimo_abs(oimo_vec3_dot(*axis, *sy));
+    OimoScalar dz = oimo_abs(oimo_vec3_dot(*axis, *sz));
+    return dx + dy + dz;
+}
+
+/**
+ * 2D version of project (for edge axes).
+ */
+static inline OimoScalar oimo_box_box_project2(const OimoVec3* axis,
+    const OimoVec3* sx, const OimoVec3* sy)
+{
+    OimoScalar dx = oimo_abs(oimo_vec3_dot(*axis, *sx));
+    OimoScalar dy = oimo_abs(oimo_vec3_dot(*axis, *sy));
+    return dx + dy;
+}
+
+/**
+ * SAT check - checks if axis is separating and updates minimum.
+ * Returns true if separated (should early exit).
+ */
+static inline bool oimo_sat_check(
+    OimoScalar* min_depth, int* min_id, int* min_sign, OimoVec3* min_axis,
+    OimoScalar proj1, OimoScalar proj2, OimoScalar proj_c12,
+    const OimoVec3* axis, int id, OimoScalar bias_mult)
+{
+    OimoScalar sum = proj1 + proj2;
+    bool neg = proj_c12 < 0.0f;
+    OimoScalar abs_proj = neg ? -proj_c12 : proj_c12;
+
+    if (abs_proj >= sum) {
+        return true;  // Separated
+    }
+
+    OimoScalar depth = sum - abs_proj;
+    if (depth * bias_mult < *min_depth) {
+        *min_depth = depth * bias_mult;
+        *min_id = id;
+        *min_axis = *axis;
+        *min_sign = neg ? -1 : 1;
+    }
+
+    return false;
+}
+
+/**
+ * Supporting vertex for rectangle (2D supporting point).
+ */
+static inline void oimo_supporting_vertex_rect(OimoVec3* out,
+    const OimoVec3* half_ext_x, const OimoVec3* half_ext_y, const OimoVec3* axis)
+{
+    bool sign_x = oimo_vec3_dot(*half_ext_x, *axis) > 0.0f;
+    bool sign_y = oimo_vec3_dot(*half_ext_y, *axis) > 0.0f;
+
+    if (sign_x) {
+        if (sign_y) {
+            oimo_vec3_add_to(out, half_ext_x, half_ext_y);
+        } else {
+            oimo_vec3_sub_to(out, half_ext_x, half_ext_y);
+        }
+    } else {
+        if (sign_y) {
+            oimo_vec3_sub_to(out, half_ext_y, half_ext_x);
+        } else {
+            oimo_vec3_add_to(out, half_ext_x, half_ext_y);
+            oimo_vec3_negate_to(out, out);
+        }
+    }
+}
+
+/**
+ * Get box face vertices given the face ID.
+ * Vertices are ordered CCW when viewed from outside.
+ *
+ * OimoPhysics getBoxFace macro signs:
+ * x+: (1,1,1), (1,-1,1), (1,-1,-1), (1,1,-1)
+ * x-: (-1,1,1), (-1,1,-1), (-1,-1,-1), (-1,-1,1)
+ * y+: (1,1,1), (1,1,-1), (-1,1,-1), (-1,1,1)
+ * y-: (1,-1,1), (-1,-1,1), (-1,-1,-1), (1,-1,-1)
+ * z+: (1,1,1), (-1,1,1), (-1,-1,1), (1,-1,1)
+ * z-: (1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)
+ */
+static inline void oimo_get_box_face(
+    OimoVec3* v1, OimoVec3* v2, OimoVec3* v3, OimoVec3* v4,
+    const OimoVec3* sx, const OimoVec3* sy, const OimoVec3* sz, int face_id)
+{
+    OimoVec3 tmp;
+    switch (face_id) {
+        case 0: // x+: (1,1,1), (1,-1,1), (1,-1,-1), (1,1,-1)
+            // v1 = sx + sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_add_to(v1, &tmp, sz);
+            // v2 = sx - sy + sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_add_to(v2, &tmp, sz);
+            // v3 = sx - sy - sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_sub_to(v3, &tmp, sz);
+            // v4 = sx + sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_sub_to(v4, &tmp, sz);
+            break;
+        case 1: // x-: (-1,1,1), (-1,1,-1), (-1,-1,-1), (-1,-1,1)
+            // v1 = -sx + sy + sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_add_to(v1, &tmp, sz);
+            // v2 = -sx + sy - sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_sub_to(v2, &tmp, sz);
+            // v3 = -sx - sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_sub_to(v3, &tmp, sz);
+            // v4 = -sx - sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_add_to(v4, &tmp, sz);
+            break;
+        case 2: // y+: (1,1,1), (1,1,-1), (-1,1,-1), (-1,1,1)
+            // v1 = sx + sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_add_to(v1, &tmp, sz);
+            // v2 = sx + sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_sub_to(v2, &tmp, sz);
+            // v3 = -sx + sy - sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_sub_to(v3, &tmp, sz);
+            // v4 = -sx + sy + sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_add_to(v4, &tmp, sz);
+            break;
+        case 3: // y-: (1,-1,1), (-1,-1,1), (-1,-1,-1), (1,-1,-1)
+            // v1 = sx - sy + sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_add_to(v1, &tmp, sz);
+            // v2 = -sx - sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_add_to(v2, &tmp, sz);
+            // v3 = -sx - sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_sub_to(v3, &tmp, sz);
+            // v4 = sx - sy - sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_sub_to(v4, &tmp, sz);
+            break;
+        case 4: // z+: (1,1,1), (-1,1,1), (-1,-1,1), (1,-1,1)
+            // v1 = sx + sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_add_to(v1, &tmp, sz);
+            // v2 = -sx + sy + sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_add_to(v2, &tmp, sz);
+            // v3 = -sx - sy + sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_add_to(v3, &tmp, sz);
+            // v4 = sx - sy + sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_add_to(v4, &tmp, sz);
+            break;
+        default: // z- (case 5): (1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)
+            // v1 = sx + sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_sub_to(v1, &tmp, sz);
+            // v2 = sx - sy - sz
+            oimo_vec3_sub_to(&tmp, sx, sy); oimo_vec3_sub_to(v2, &tmp, sz);
+            // v3 = -sx - sy - sz
+            oimo_vec3_add_to(&tmp, sx, sy); oimo_vec3_negate_to(&tmp, &tmp); oimo_vec3_sub_to(v3, &tmp, sz);
+            // v4 = -sx + sy - sz
+            oimo_vec3_sub_to(&tmp, sy, sx); oimo_vec3_sub_to(v4, &tmp, sz);
+            break;
+    }
+}
+
+static inline void oimo_box_box_detector_init(OimoBoxBoxDetector* detector) {
+    oimo_detector_init(&detector->base, OIMO_DETECTOR_BOX_BOX, false);
+}
+
+static inline void oimo_box_box_detector_detect(
+    OimoBoxBoxDetector* detector,
+    OimoDetectorResult* result,
+    const OimoBoxGeometry* box1,
+    const OimoBoxGeometry* box2,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2)
+{
+    result->incremental = false;
+
+    // Centers
+    OimoVec3 c1 = tf1->position;
+    OimoVec3 c2 = tf2->position;
+    OimoVec3 c12;
+    oimo_vec3_sub_to(&c12, &c2, &c1);
+
+    // Basis vectors from rotation matrices
+    OimoVec3 x1 = oimo_mat3_get_col(&tf1->rotation, 0);
+    OimoVec3 y1 = oimo_mat3_get_col(&tf1->rotation, 1);
+    OimoVec3 z1 = oimo_mat3_get_col(&tf1->rotation, 2);
+    OimoVec3 x2 = oimo_mat3_get_col(&tf2->rotation, 0);
+    OimoVec3 y2 = oimo_mat3_get_col(&tf2->rotation, 1);
+    OimoVec3 z2 = oimo_mat3_get_col(&tf2->rotation, 2);
+
+    // Half extents
+    OimoScalar w1 = box1->half_extents.x;
+    OimoScalar h1 = box1->half_extents.y;
+    OimoScalar d1 = box1->half_extents.z;
+    OimoScalar w2 = box2->half_extents.x;
+    OimoScalar h2 = box2->half_extents.y;
+    OimoScalar d2 = box2->half_extents.z;
+
+    // Scaled basis vectors
+    OimoVec3 sx1, sy1, sz1, sx2, sy2, sz2;
+    oimo_vec3_scale_to(&sx1, &x1, w1);
+    oimo_vec3_scale_to(&sy1, &y1, h1);
+    oimo_vec3_scale_to(&sz1, &z1, d1);
+    oimo_vec3_scale_to(&sx2, &x2, w2);
+    oimo_vec3_scale_to(&sy2, &y2, h2);
+    oimo_vec3_scale_to(&sz2, &z2, d2);
+
+    // SAT variables
+    OimoScalar proj1, proj2, proj_c12;
+    OimoScalar min_depth = 1e30f;
+    int min_id = -1;
+    int min_sign = 0;
+    OimoVec3 min_axis;
+    oimo_vec3_set(&min_axis, 0.0f, 0.0f, 0.0f);
+
+    // ===================== 6 Face Axes =====================
+
+    // Axis = x1
+    proj1 = w1;
+    proj2 = oimo_box_box_project(&x1, &sx2, &sy2, &sz2);
+    proj_c12 = oimo_vec3_dot(x1, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &x1, 0, 1.0f)) return;
+
+    // Axis = y1
+    proj1 = h1;
+    proj2 = oimo_box_box_project(&y1, &sx2, &sy2, &sz2);
+    proj_c12 = oimo_vec3_dot(y1, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &y1, 1, 1.0f)) return;
+
+    // Axis = z1
+    proj1 = d1;
+    proj2 = oimo_box_box_project(&z1, &sx2, &sy2, &sz2);
+    proj_c12 = oimo_vec3_dot(z1, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &z1, 2, 1.0f)) return;
+
+    // Apply bias to prefer face contacts over edge contacts
+    if (min_depth > OIMO_LINEAR_SLOP) {
+        min_depth -= OIMO_LINEAR_SLOP;
+    } else {
+        min_depth = 0.0f;
+    }
+
+    // Axis = x2
+    proj1 = oimo_box_box_project(&x2, &sx1, &sy1, &sz1);
+    proj2 = w2;
+    proj_c12 = oimo_vec3_dot(x2, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &x2, 3, 1.0f)) return;
+
+    // Axis = y2
+    proj1 = oimo_box_box_project(&y2, &sx1, &sy1, &sz1);
+    proj2 = h2;
+    proj_c12 = oimo_vec3_dot(y2, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &y2, 4, 1.0f)) return;
+
+    // Axis = z2
+    proj1 = oimo_box_box_project(&z2, &sx1, &sy1, &sz1);
+    proj2 = d2;
+    proj_c12 = oimo_vec3_dot(z2, c12);
+    if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &z2, 5, 1.0f)) return;
+
+    // Apply bias again before edge checks
+    if (min_depth > OIMO_LINEAR_SLOP) {
+        min_depth -= OIMO_LINEAR_SLOP;
+    } else {
+        min_depth = 0.0f;
+    }
+
+    // ===================== 9 Edge Axes =====================
+
+    OimoVec3 edge_axis;
+
+    // cross(x1, x2)
+    oimo_vec3_cross_to(&edge_axis, &x1, &x2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sy1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sy2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 6, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(x1, y2)
+    oimo_vec3_cross_to(&edge_axis, &x1, &y2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sy1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 7, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(x1, z2)
+    oimo_vec3_cross_to(&edge_axis, &x1, &z2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sy1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sy2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 8, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(y1, x2)
+    oimo_vec3_cross_to(&edge_axis, &y1, &x2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sy2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 9, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(y1, y2)
+    oimo_vec3_cross_to(&edge_axis, &y1, &y2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 10, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(y1, z2)
+    oimo_vec3_cross_to(&edge_axis, &y1, &z2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sz1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sy2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 11, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(z1, x2)
+    oimo_vec3_cross_to(&edge_axis, &z1, &x2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sy1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sy2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 12, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(z1, y2)
+    oimo_vec3_cross_to(&edge_axis, &z1, &y2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sy1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sz2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 13, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // cross(z1, z2)
+    oimo_vec3_cross_to(&edge_axis, &z1, &z2);
+    if (!oimo_vec3_is_zero(&edge_axis, OIMO_EPSILON)) {
+        oimo_vec3_normalize_to(&edge_axis, &edge_axis);
+        proj1 = oimo_box_box_project2(&edge_axis, &sx1, &sy1);
+        proj2 = oimo_box_box_project2(&edge_axis, &sx2, &sy2);
+        proj_c12 = oimo_vec3_dot(edge_axis, c12);
+        if (oimo_sat_check(&min_depth, &min_id, &min_sign, &min_axis, proj1, proj2, proj_c12, &edge_axis, 14, OIMO_BOX_BOX_EDGE_BIAS_MULT)) return;
+    }
+
+    // ===================== Edge-Edge Contact =====================
+
+    if (min_id >= 6) {
+        // Flip axis to point from box1 to box2
+        oimo_vec3_scale_to(&min_axis, &min_axis, (OimoScalar)min_sign);
+
+        // Direction indices
+        int id1 = (min_id - 6) / 3;  // 0=x, 1=y, 2=z
+        int id2 = (min_id - 6) % 3;
+
+        OimoVec3 p1, p2;  // Points on edges
+        OimoVec3 d1_dir, d2_dir;  // Edge directions
+
+        // Select edge on box1
+        switch (id1) {
+            case 0:
+                d1_dir = x1;
+                oimo_supporting_vertex_rect(&p1, &sy1, &sz1, &min_axis);
+                break;
+            case 1:
+                d1_dir = y1;
+                oimo_supporting_vertex_rect(&p1, &sx1, &sz1, &min_axis);
+                break;
+            default:
+                d1_dir = z1;
+                oimo_supporting_vertex_rect(&p1, &sx1, &sy1, &min_axis);
+                break;
+        }
+        oimo_vec3_add_to(&p1, &c1, &p1);
+
+        // Select edge on box2
+        switch (id2) {
+            case 0:
+                d2_dir = x2;
+                oimo_supporting_vertex_rect(&p2, &sy2, &sz2, &min_axis);
+                break;
+            case 1:
+                d2_dir = y2;
+                oimo_supporting_vertex_rect(&p2, &sx2, &sz2, &min_axis);
+                break;
+            default:
+                d2_dir = z2;
+                oimo_supporting_vertex_rect(&p2, &sx2, &sy2, &min_axis);
+                break;
+        }
+        oimo_vec3_sub_to(&p2, &c2, &p2);
+
+        // Compute closest points on the two edges
+        OimoVec3 r;
+        oimo_vec3_sub_to(&r, &p1, &p2);
+
+        OimoScalar dot12 = oimo_vec3_dot(d1_dir, d2_dir);
+        OimoScalar dot1r = oimo_vec3_dot(d1_dir, r);
+        OimoScalar dot2r = oimo_vec3_dot(d2_dir, r);
+
+        OimoScalar inv_det = 1.0f / (1.0f - dot12 * dot12);
+        OimoScalar t1 = (dot12 * dot2r - dot1r) * inv_det;
+        OimoScalar t2 = (dot2r - dot12 * dot1r) * inv_det;
+
+        OimoVec3 cp1, cp2;
+        OimoVec3 scaled;
+        oimo_vec3_scale_to(&scaled, &d1_dir, t1);
+        oimo_vec3_add_to(&cp1, &p1, &scaled);
+        oimo_vec3_scale_to(&scaled, &d2_dir, t2);
+        oimo_vec3_add_to(&cp2, &p2, &scaled);
+
+        // Normal points from box2 to box1
+        OimoVec3 normal;
+        oimo_vec3_negate_to(&normal, &min_axis);
+
+        oimo_detector_set_normal(&detector->base, result, &normal);
+        oimo_detector_add_point(&detector->base, result, &cp1, &cp2, min_depth, 4);
+        return;
+    }
+
+    // ===================== Face-Face Contact =====================
+
+    bool swapped = false;
+
+    // If collision is with box2's face, swap boxes
+    if (min_id >= 3) {
+        min_sign = -min_sign;
+        oimo_vec3_negate_to(&c12, &c12);
+
+        // Swap all box1 and box2 data
+        OimoVec3 tmp_v;
+        OimoScalar tmp_s;
+
+        #define SWAP_VEC(a, b) tmp_v = a; a = b; b = tmp_v
+        #define SWAP_SCALAR(a, b) tmp_s = a; a = b; b = tmp_s
+
+        SWAP_VEC(c1, c2);
+        SWAP_VEC(x1, x2);
+        SWAP_VEC(y1, y2);
+        SWAP_VEC(z1, z2);
+        SWAP_VEC(sx1, sx2);
+        SWAP_VEC(sy1, sy2);
+        SWAP_VEC(sz1, sz2);
+        SWAP_SCALAR(w1, w2);
+        SWAP_SCALAR(h1, h2);
+        SWAP_SCALAR(d1, d2);
+
+        #undef SWAP_VEC
+        #undef SWAP_SCALAR
+
+        min_id -= 3;
+        swapped = true;
+    }
+
+    // Find reference face on box1
+    OimoVec3 ref_center, ref_normal, ref_x, ref_y;
+    OimoScalar ref_w, ref_h;
+
+    switch (min_id) {
+        case 0: // X face
+            ref_center = sx1;
+            ref_normal = x1;
+            ref_x = y1;
+            ref_y = z1;
+            ref_w = h1;
+            ref_h = d1;
+            break;
+        case 1: // Y face
+            ref_center = sy1;
+            ref_normal = y1;
+            ref_x = z1;
+            ref_y = x1;
+            ref_w = d1;
+            ref_h = w1;
+            break;
+        default: // Z face
+            ref_center = sz1;
+            ref_normal = z1;
+            ref_x = x1;
+            ref_y = y1;
+            ref_w = w1;
+            ref_h = h1;
+            break;
+    }
+
+    if (min_sign < 0) {
+        oimo_vec3_negate_to(&ref_center, &ref_center);
+        oimo_vec3_negate_to(&ref_normal, &ref_normal);
+        // Swap ref_x and ref_y, and their dimensions
+        OimoVec3 tmp_v = ref_x;
+        ref_x = ref_y;
+        ref_y = tmp_v;
+        OimoScalar tmp_s = ref_w;
+        ref_w = ref_h;
+        ref_h = tmp_s;
+    }
+
+    oimo_vec3_add_to(&ref_center, &ref_center, &c1);
+
+    // Find incident face on box2
+    OimoScalar min_inc_dot = 1.0f;
+    int inc_id = 0;
+
+    OimoScalar inc_dot;
+    inc_dot = oimo_vec3_dot(ref_normal, x2);
+    if (inc_dot < min_inc_dot) { min_inc_dot = inc_dot; inc_id = 0; }
+    if (-inc_dot < min_inc_dot) { min_inc_dot = -inc_dot; inc_id = 1; }
+
+    inc_dot = oimo_vec3_dot(ref_normal, y2);
+    if (inc_dot < min_inc_dot) { min_inc_dot = inc_dot; inc_id = 2; }
+    if (-inc_dot < min_inc_dot) { min_inc_dot = -inc_dot; inc_id = 3; }
+
+    inc_dot = oimo_vec3_dot(ref_normal, z2);
+    if (inc_dot < min_inc_dot) { min_inc_dot = inc_dot; inc_id = 4; }
+    if (-inc_dot < min_inc_dot) { min_inc_dot = -inc_dot; inc_id = 5; }
+
+    // Get incident face vertices
+    OimoVec3 inc_v1, inc_v2, inc_v3, inc_v4;
+    oimo_get_box_face(&inc_v1, &inc_v2, &inc_v3, &inc_v4, &sx2, &sy2, &sz2, inc_id);
+
+    // Translate to reference frame (relative to c1)
+    oimo_vec3_add_to(&inc_v1, &inc_v1, &c12);
+    oimo_vec3_add_to(&inc_v2, &inc_v2, &c12);
+    oimo_vec3_add_to(&inc_v3, &inc_v3, &c12);
+    oimo_vec3_add_to(&inc_v4, &inc_v4, &c12);
+
+    // Clip incident face against reference face
+    oimo_face_clipper_init(&detector->clipper, ref_w, ref_h);
+    oimo_face_clipper_add_vertex(&detector->clipper,
+        oimo_vec3_dot(inc_v1, ref_x), oimo_vec3_dot(inc_v1, ref_y),
+        inc_v1.x, inc_v1.y, inc_v1.z);
+    oimo_face_clipper_add_vertex(&detector->clipper,
+        oimo_vec3_dot(inc_v2, ref_x), oimo_vec3_dot(inc_v2, ref_y),
+        inc_v2.x, inc_v2.y, inc_v2.z);
+    oimo_face_clipper_add_vertex(&detector->clipper,
+        oimo_vec3_dot(inc_v3, ref_x), oimo_vec3_dot(inc_v3, ref_y),
+        inc_v3.x, inc_v3.y, inc_v3.z);
+    oimo_face_clipper_add_vertex(&detector->clipper,
+        oimo_vec3_dot(inc_v4, ref_x), oimo_vec3_dot(inc_v4, ref_y),
+        inc_v4.x, inc_v4.y, inc_v4.z);
+
+    oimo_face_clipper_clip(&detector->clipper);
+    oimo_face_clipper_reduce(&detector->clipper);
+
+    // Generate contact points
+    OimoVec3 normal;
+    if (swapped) {
+        normal = ref_normal;
+    } else {
+        oimo_vec3_negate_to(&normal, &ref_normal);
+    }
+    oimo_detector_set_normal(&detector->base, result, &normal);
+
+    for (int i = 0; i < detector->clipper.num_vertices; i++) {
+        OimoIncidentVertex* v = &detector->clipper.vertices[i];
+
+        OimoVec3 clipped_vertex;
+        oimo_vec3_set(&clipped_vertex, v->wx, v->wy, v->wz);
+        oimo_vec3_add_to(&clipped_vertex, &clipped_vertex, &c1);
+
+        OimoVec3 clipped_to_ref;
+        oimo_vec3_sub_to(&clipped_to_ref, &ref_center, &clipped_vertex);
+        OimoScalar depth = oimo_vec3_dot(clipped_to_ref, ref_normal);
+
+        OimoVec3 clipped_on_ref;
+        OimoVec3 scaled;
+        oimo_vec3_scale_to(&scaled, &ref_normal, depth);
+        oimo_vec3_add_to(&clipped_on_ref, &clipped_vertex, &scaled);
+
+        if (depth > -OIMO_CONTACT_PERSISTENCE_THRESHOLD) {
+            if (swapped) {
+                oimo_detector_add_point(&detector->base, result, &clipped_vertex, &clipped_on_ref, depth, i);
+            } else {
+                oimo_detector_add_point(&detector->base, result, &clipped_on_ref, &clipped_vertex, depth, i);
+            }
+        }
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_capsule_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_capsule_detector.h
new file mode 100644
index 0000000000..484d50a5ac
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_capsule_detector.h
@@ -0,0 +1,241 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/box_geometry.h"
+#include "../geometry/capsule_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Box vs Capsule detector
+// Analytical approach: find closest point on capsule segment to box
+typedef struct OimoBoxCapsuleDetector {
+    OimoDetector base;
+    bool swapped;  // true if capsule is geom1, box is geom2
+} OimoBoxCapsuleDetector;
+
+static inline void oimo_box_capsule_detector_init(OimoBoxCapsuleDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base, swapped ? OIMO_DETECTOR_CAPSULE_BOX : OIMO_DETECTOR_BOX_CAPSULE, swapped);
+    detector->swapped = swapped;
+}
+
+// Clamp a point to box bounds
+static inline OimoVec3 oimo_clamp_to_box(const OimoVec3* p, const OimoVec3* halfExt) {
+    OimoVec3 result;
+    result.x = oimo_clamp(p->x, -halfExt->x, halfExt->x);
+    result.y = oimo_clamp(p->y, -halfExt->y, halfExt->y);
+    result.z = oimo_clamp(p->z, -halfExt->z, halfExt->z);
+    return result;
+}
+
+// Compute squared distance from point to clamped point on box
+static inline OimoScalar oimo_point_to_box_dist2(const OimoVec3* p, const OimoVec3* halfExt) {
+    OimoVec3 clamped = oimo_clamp_to_box(p, halfExt);
+    OimoScalar dx = p->x - clamped.x;
+    OimoScalar dy = p->y - clamped.y;
+    OimoScalar dz = p->z - clamped.z;
+    return dx*dx + dy*dy + dz*dz;
+}
+
+// Find closest point on segment [p, q] to box
+// Returns the closest point on segment and the closest point on box
+static inline void oimo_closest_segment_box(
+    const OimoVec3* p, const OimoVec3* q,
+    const OimoVec3* halfExt,
+    OimoVec3* closestOnSeg,
+    OimoVec3* closestOnBox)
+{
+    OimoVec3 d;
+    d.x = q->x - p->x;
+    d.y = q->y - p->y;
+    d.z = q->z - p->z;
+
+    OimoScalar segLen2 = d.x*d.x + d.y*d.y + d.z*d.z;
+
+    if (segLen2 < OIMO_EPSILON) {
+        // Degenerate segment (point)
+        *closestOnSeg = *p;
+        *closestOnBox = oimo_clamp_to_box(p, halfExt);
+        return;
+    }
+
+    // We'll find the t that minimizes distance from segment point to box
+    // The distance function is piecewise and convex, so we can use a simple approach:
+    // 1. Test endpoints
+    // 2. For each box face/edge/corner region, solve for the closest t analytically
+
+    // For simplicity and robustness, use ternary search on the convex distance function
+    OimoScalar lo = 0.0f;
+    OimoScalar hi = 1.0f;
+
+    for (int iter = 0; iter < 16; iter++) {
+        OimoScalar m1 = lo + (hi - lo) / 3.0f;
+        OimoScalar m2 = hi - (hi - lo) / 3.0f;
+
+        OimoVec3 pt1, pt2;
+        pt1.x = p->x + d.x * m1;
+        pt1.y = p->y + d.y * m1;
+        pt1.z = p->z + d.z * m1;
+        pt2.x = p->x + d.x * m2;
+        pt2.y = p->y + d.y * m2;
+        pt2.z = p->z + d.z * m2;
+
+        OimoScalar dist1 = oimo_point_to_box_dist2(&pt1, halfExt);
+        OimoScalar dist2 = oimo_point_to_box_dist2(&pt2, halfExt);
+
+        if (dist1 < dist2) {
+            hi = m2;
+        } else {
+            lo = m1;
+        }
+    }
+
+    OimoScalar t = (lo + hi) * 0.5f;
+    closestOnSeg->x = p->x + d.x * t;
+    closestOnSeg->y = p->y + d.y * t;
+    closestOnSeg->z = p->z + d.z * t;
+    *closestOnBox = oimo_clamp_to_box(closestOnSeg, halfExt);
+}
+
+static inline void oimo_box_capsule_detector_detect(
+    OimoBoxCapsuleDetector* detector,
+    OimoDetectorResult* result,
+    const OimoBoxGeometry* box,
+    const OimoCapsuleGeometry* capsule,
+    const OimoTransform* tfBox,
+    const OimoTransform* tfCapsule)
+{
+    OimoScalar hh = capsule->halfHeight;
+    OimoScalar capsuleRadius = capsule->radius;
+    OimoVec3 boxHalfExtents = box->half_extents;
+
+    // Get capsule axis in world space (Y axis = column 1)
+    OimoVec3 capsuleAxis;
+    capsuleAxis.x = tfCapsule->rotation.e01;
+    capsuleAxis.y = tfCapsule->rotation.e11;
+    capsuleAxis.z = tfCapsule->rotation.e21;
+
+    // Capsule endpoints in world space
+    OimoVec3 capP, capQ;
+    capP.x = tfCapsule->position.x - capsuleAxis.x * hh;
+    capP.y = tfCapsule->position.y - capsuleAxis.y * hh;
+    capP.z = tfCapsule->position.z - capsuleAxis.z * hh;
+    capQ.x = tfCapsule->position.x + capsuleAxis.x * hh;
+    capQ.y = tfCapsule->position.y + capsuleAxis.y * hh;
+    capQ.z = tfCapsule->position.z + capsuleAxis.z * hh;
+
+    // Transform capsule endpoints to box local space
+    OimoVec3 relP, relQ;
+    relP.x = capP.x - tfBox->position.x;
+    relP.y = capP.y - tfBox->position.y;
+    relP.z = capP.z - tfBox->position.z;
+    relQ.x = capQ.x - tfBox->position.x;
+    relQ.y = capQ.y - tfBox->position.y;
+    relQ.z = capQ.z - tfBox->position.z;
+
+    // Multiply by transpose of rotation (inverse for orthonormal matrix)
+    OimoVec3 localP, localQ;
+    localP.x = tfBox->rotation.e00 * relP.x + tfBox->rotation.e10 * relP.y + tfBox->rotation.e20 * relP.z;
+    localP.y = tfBox->rotation.e01 * relP.x + tfBox->rotation.e11 * relP.y + tfBox->rotation.e21 * relP.z;
+    localP.z = tfBox->rotation.e02 * relP.x + tfBox->rotation.e12 * relP.y + tfBox->rotation.e22 * relP.z;
+
+    localQ.x = tfBox->rotation.e00 * relQ.x + tfBox->rotation.e10 * relQ.y + tfBox->rotation.e20 * relQ.z;
+    localQ.y = tfBox->rotation.e01 * relQ.x + tfBox->rotation.e11 * relQ.y + tfBox->rotation.e21 * relQ.z;
+    localQ.z = tfBox->rotation.e02 * relQ.x + tfBox->rotation.e12 * relQ.y + tfBox->rotation.e22 * relQ.z;
+
+    // Find closest points between segment and box in local space
+    OimoVec3 closestOnSeg, closestOnBox;
+    oimo_closest_segment_box(&localP, &localQ, &boxHalfExtents, &closestOnSeg, &closestOnBox);
+
+    // Compute separation vector in local space
+    OimoVec3 diff;
+    diff.x = closestOnSeg.x - closestOnBox.x;
+    diff.y = closestOnSeg.y - closestOnBox.y;
+    diff.z = closestOnSeg.z - closestOnBox.z;
+
+    OimoScalar dist2 = diff.x * diff.x + diff.y * diff.y + diff.z * diff.z;
+
+    // Check if the sphere around the closest segment point penetrates the box
+    if (dist2 >= capsuleRadius * capsuleRadius) {
+        return;  // No collision
+    }
+
+    OimoScalar dist = oimo_sqrt(dist2);
+    OimoVec3 localNormal;
+
+    if (dist > OIMO_EPSILON) {
+        // Normal points from box to capsule segment
+        OimoScalar invDist = 1.0f / dist;
+        localNormal.x = diff.x * invDist;
+        localNormal.y = diff.y * invDist;
+        localNormal.z = diff.z * invDist;
+    } else {
+        // Segment point is inside box - find closest face normal
+        OimoScalar dx = boxHalfExtents.x - oimo_abs(closestOnSeg.x);
+        OimoScalar dy = boxHalfExtents.y - oimo_abs(closestOnSeg.y);
+        OimoScalar dz = boxHalfExtents.z - oimo_abs(closestOnSeg.z);
+
+        if (dx <= dy && dx <= dz) {
+            localNormal.x = closestOnSeg.x >= 0 ? 1.0f : -1.0f;
+            localNormal.y = 0;
+            localNormal.z = 0;
+        } else if (dy <= dz) {
+            localNormal.x = 0;
+            localNormal.y = closestOnSeg.y >= 0 ? 1.0f : -1.0f;
+            localNormal.z = 0;
+        } else {
+            localNormal.x = 0;
+            localNormal.y = 0;
+            localNormal.z = closestOnSeg.z >= 0 ? 1.0f : -1.0f;
+        }
+    }
+
+    // Transform normal back to world space
+    OimoVec3 worldNormal;
+    worldNormal.x = tfBox->rotation.e00 * localNormal.x + tfBox->rotation.e01 * localNormal.y + tfBox->rotation.e02 * localNormal.z;
+    worldNormal.y = tfBox->rotation.e10 * localNormal.x + tfBox->rotation.e11 * localNormal.y + tfBox->rotation.e12 * localNormal.z;
+    worldNormal.z = tfBox->rotation.e20 * localNormal.x + tfBox->rotation.e21 * localNormal.y + tfBox->rotation.e22 * localNormal.z;
+
+    // Transform contact points to world space
+    OimoVec3 pos1;  // Contact on box surface
+    pos1.x = tfBox->rotation.e00 * closestOnBox.x + tfBox->rotation.e01 * closestOnBox.y + tfBox->rotation.e02 * closestOnBox.z + tfBox->position.x;
+    pos1.y = tfBox->rotation.e10 * closestOnBox.x + tfBox->rotation.e11 * closestOnBox.y + tfBox->rotation.e12 * closestOnBox.z + tfBox->position.y;
+    pos1.z = tfBox->rotation.e20 * closestOnBox.x + tfBox->rotation.e21 * closestOnBox.y + tfBox->rotation.e22 * closestOnBox.z + tfBox->position.z;
+
+    // pos2 is on the capsule surface
+    OimoVec3 worldClosestOnSeg;
+    worldClosestOnSeg.x = tfBox->rotation.e00 * closestOnSeg.x + tfBox->rotation.e01 * closestOnSeg.y + tfBox->rotation.e02 * closestOnSeg.z + tfBox->position.x;
+    worldClosestOnSeg.y = tfBox->rotation.e10 * closestOnSeg.x + tfBox->rotation.e11 * closestOnSeg.y + tfBox->rotation.e12 * closestOnSeg.z + tfBox->position.y;
+    worldClosestOnSeg.z = tfBox->rotation.e20 * closestOnSeg.x + tfBox->rotation.e21 * closestOnSeg.y + tfBox->rotation.e22 * closestOnSeg.z + tfBox->position.z;
+
+    OimoVec3 pos2;  // Contact on capsule surface
+    pos2.x = worldClosestOnSeg.x - worldNormal.x * capsuleRadius;
+    pos2.y = worldClosestOnSeg.y - worldNormal.y * capsuleRadius;
+    pos2.z = worldClosestOnSeg.z - worldNormal.z * capsuleRadius;
+
+    OimoScalar depth = capsuleRadius - dist;
+
+    // If swapped, flip normal (normal points from geom1 to geom2)
+    if (detector->swapped) {
+        worldNormal.x = -worldNormal.x;
+        worldNormal.y = -worldNormal.y;
+        worldNormal.z = -worldNormal.z;
+        // Also swap pos1 and pos2
+        oimo_detector_add_point(&detector->base, result, &pos2, &pos1, depth, 0);
+    } else {
+        oimo_detector_add_point(&detector->base, result, &pos1, &pos2, depth, 0);
+    }
+
+    oimo_detector_set_normal(&detector->base, result, &worldNormal);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_mesh_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_mesh_detector.h
new file mode 100644
index 0000000000..1086910259
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/box_mesh_detector.h
@@ -0,0 +1,182 @@
+#pragma once
+
+// box_mesh_detector.h - Box vs Static Mesh collision detection (Optimized for N64)
+
+#include "detector.h"
+#include "detector_result.h"
+#include "triangle_util.h"
+#include "mesh_contact.h"
+#include "../geometry/box_geometry.h"
+#include "../geometry/static_mesh_geometry.h"
+#include "../broadphase/bvh.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoBoxMeshDetector {
+    OimoDetector base;
+} OimoBoxMeshDetector;
+
+static inline void oimo_box_mesh_detector_init(OimoBoxMeshDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base,
+        swapped ? OIMO_DETECTOR_MESH_BOX : OIMO_DETECTOR_BOX_MESH,
+        swapped);
+}
+
+// Cached box axes structure to avoid recomputing per-triangle
+typedef struct OimoBoxAxes {
+    OimoVec3 x, y, z;      // Box axes in mesh local space
+    OimoVec3 half_ext;     // Half extents
+    float max_extent;       // Maximum extent for quick rejection
+} OimoBoxAxes;
+
+// Compute box's effective radius along a direction using cached axes
+static inline float oimo_box_support_distance_cached(const OimoBoxAxes* axes, const OimoVec3* dir) {
+    return axes->half_ext.x * fabsf(oimo_vec3_dot(axes->x, *dir)) +
+           axes->half_ext.y * fabsf(oimo_vec3_dot(axes->y, *dir)) +
+           axes->half_ext.z * fabsf(oimo_vec3_dot(axes->z, *dir));
+}
+
+// Get support point using cached axes
+static inline OimoVec3 oimo_box_support_point_cached(
+    const OimoBoxAxes* axes,
+    const OimoVec3* box_center,
+    const OimoVec3* dir
+) {
+    OimoVec3 result = *box_center;
+    result = oimo_vec3_add(result, oimo_vec3_scale(axes->x, oimo_vec3_dot(axes->x, *dir) > 0 ? axes->half_ext.x : -axes->half_ext.x));
+    result = oimo_vec3_add(result, oimo_vec3_scale(axes->y, oimo_vec3_dot(axes->y, *dir) > 0 ? axes->half_ext.y : -axes->half_ext.y));
+    result = oimo_vec3_add(result, oimo_vec3_scale(axes->z, oimo_vec3_dot(axes->z, *dir) > 0 ? axes->half_ext.z : -axes->half_ext.z));
+    return result;
+}
+
+// Detect box vs mesh collision (optimized single-pass version)
+static inline void oimo_box_mesh_detector_detect(
+    OimoBoxMeshDetector* detector,
+    OimoDetectorResult* result,
+    const OimoBoxGeometry* box,
+    const OimoStaticMeshGeometry* mesh,
+    const OimoTransform* tf_box,
+    const OimoTransform* tf_mesh
+) {
+    result->incremental = false;
+
+    // Transform box center to mesh local space
+    OimoVec3 box_to_mesh = oimo_vec3_sub(tf_box->position, tf_mesh->position);
+    OimoMat3 mesh_rot_inv = oimo_mat3_transpose(&tf_mesh->rotation);
+    OimoVec3 box_center_local = oimo_mat3_mul_vec3(&mesh_rot_inv, box_to_mesh);
+
+    // Box rotation in mesh local space
+    OimoMat3 box_rot_local = oimo_mat3_mul(&mesh_rot_inv, &tf_box->rotation);
+
+    // Cache box axes (computed once, used for all triangles)
+    OimoBoxAxes axes;
+    axes.x = oimo_vec3(box_rot_local.e00, box_rot_local.e10, box_rot_local.e20);
+    axes.y = oimo_vec3(box_rot_local.e01, box_rot_local.e11, box_rot_local.e21);
+    axes.z = oimo_vec3(box_rot_local.e02, box_rot_local.e12, box_rot_local.e22);
+    axes.half_ext = box->half_extents;
+    // Max extent for quick plane distance rejection
+    axes.max_extent = axes.half_ext.x + axes.half_ext.y + axes.half_ext.z;
+
+    // Build query AABB using cached axes
+    float extent_x = axes.half_ext.x * fabsf(axes.x.x) + axes.half_ext.y * fabsf(axes.y.x) + axes.half_ext.z * fabsf(axes.z.x);
+    float extent_y = axes.half_ext.x * fabsf(axes.x.y) + axes.half_ext.y * fabsf(axes.y.y) + axes.half_ext.z * fabsf(axes.z.y);
+    float extent_z = axes.half_ext.x * fabsf(axes.x.z) + axes.half_ext.y * fabsf(axes.y.z) + axes.half_ext.z * fabsf(axes.z.z);
+
+    OimoAabb query_aabb;
+    query_aabb.min.x = box_center_local.x - extent_x;
+    query_aabb.min.y = box_center_local.y - extent_y;
+    query_aabb.min.z = box_center_local.z - extent_z;
+    query_aabb.max.x = box_center_local.x + extent_x;
+    query_aabb.max.y = box_center_local.y + extent_y;
+    query_aabb.max.z = box_center_local.z + extent_z;
+
+    // Query BVH for overlapping triangles
+    OimoBvhQueryResult bvh_result;
+    oimo_static_mesh_query_triangles(mesh, &query_aabb, &bvh_result);
+
+    if (bvh_result.count == 0) return;
+
+    // Initialize contact storage
+    OimoMeshContactStorage storage;
+    oimo_mesh_contact_storage_init(&storage);
+
+    for (int t = 0; t < bvh_result.count; t++) {
+        int tri_idx = bvh_result.triangles[t];
+        const OimoTriangle* tri = oimo_static_mesh_get_triangle(mesh, tri_idx);
+        if (!tri) continue;
+
+        // EARLY OUT: Quick plane distance check
+        // If box center is too far from triangle plane, skip expensive closest point
+        float plane_dist = oimo_point_plane_distance(&box_center_local, &tri->v0, &tri->normal);
+        if (plane_dist > axes.max_extent || plane_dist < -axes.max_extent) {
+            continue;  // Box can't possibly touch this triangle
+        }
+
+        // Find closest point on triangle to box center
+        OimoVec3 closest = oimo_closest_point_on_triangle(
+            &box_center_local, &tri->v0, &tri->v1, &tri->v2
+        );
+
+        // Vector from closest point to box center
+        OimoVec3 diff = oimo_vec3_sub(box_center_local, closest);
+        float dist_sq = oimo_vec3_dot(diff, diff);
+
+        // EARLY OUT: If distance squared > max_extent squared, no collision possible
+        if (dist_sq > axes.max_extent * axes.max_extent) {
+            continue;
+        }
+
+        // Use fast inverse sqrt for normalization
+        OimoVec3 normal_dir;
+        float dist;
+        if (dist_sq > 1e-6f) {
+            float inv_dist = oimo_fast_inv_sqrt(dist_sq);
+            dist = dist_sq * inv_dist;  // dist = dist_sq / sqrt(dist_sq) = sqrt(dist_sq)
+            normal_dir = oimo_vec3_scale(diff, inv_dist);
+        } else {
+            normal_dir = tri->normal;
+            dist = 0.0f;
+        }
+
+        // Compute box's effective radius along this direction
+        float effective_radius = oimo_box_support_distance_cached(&axes, &normal_dir);
+
+        // Check if penetrating
+        if (dist < effective_radius) {
+            float depth = effective_radius - dist;
+            oimo_mesh_contact_storage_add(&storage, &closest, &normal_dir, depth, tri_idx);
+        }
+    }
+
+    if (!storage.has_contact) return;
+
+    // Transform primary normal to world space
+    OimoVec3 normal_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, storage.primary_normal);
+    oimo_detector_set_normal(&detector->base, result, &normal_world);
+
+    // Add all stored contacts
+    for (int i = 0; i < storage.count; i++) {
+        OimoMeshContact* c = &storage.contacts[i];
+
+        // Mesh contact point (in world space)
+        OimoVec3 closest_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, c->closest);
+        closest_world = oimo_vec3_add(closest_world, tf_mesh->position);
+
+        // Box contact point: support point in -normal direction
+        OimoVec3 neg_normal_local = oimo_vec3_scale(c->normal_dir, -1.0f);
+        OimoVec3 box_contact = oimo_box_support_point_cached(&axes, &box_center_local, &neg_normal_local);
+        box_contact = oimo_mat3_mul_vec3(&tf_mesh->rotation, box_contact);
+        box_contact = oimo_vec3_add(box_contact, tf_mesh->position);
+
+        oimo_detector_add_point(&detector->base, result,
+            &box_contact, &closest_world, c->depth, c->tri_idx);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_capsule_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_capsule_detector.h
new file mode 100644
index 0000000000..f1340abf36
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_capsule_detector.h
@@ -0,0 +1,191 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/capsule_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/vec3.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Capsule vs Capsule detector (matches OimoPhysics)
+typedef struct OimoCapsuleCapsuleDetector {
+    OimoDetector base;
+} OimoCapsuleCapsuleDetector;
+
+static inline void oimo_capsule_capsule_detector_init(OimoCapsuleCapsuleDetector* detector) {
+    oimo_detector_init(&detector->base, OIMO_DETECTOR_CAPSULE_CAPSULE, false);
+}
+
+static inline void oimo_capsule_capsule_detector_detect(
+    OimoCapsuleCapsuleDetector* detector,
+    OimoDetectorResult* result,
+    const OimoCapsuleGeometry* c1,
+    const OimoCapsuleGeometry* c2,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2)
+{
+    (void)detector;
+
+    // Y axes (column 1 of rotation matrix)
+    OimoVec3 axis1, axis2;
+    axis1.x = tf1->rotation.e01;
+    axis1.y = tf1->rotation.e11;
+    axis1.z = tf1->rotation.e21;
+
+    axis2.x = tf2->rotation.e01;
+    axis2.y = tf2->rotation.e11;
+    axis2.z = tf2->rotation.e21;
+
+    OimoScalar hh1 = c1->halfHeight;
+    OimoScalar hh2 = c2->halfHeight;
+    OimoScalar r1 = c1->radius;
+    OimoScalar r2 = c2->radius;
+
+    // line segments (p1, q1), (p2, q2)
+    OimoVec3 p1, q1, p2, q2;
+    p1.x = tf1->position.x - axis1.x * hh1;
+    p1.y = tf1->position.y - axis1.y * hh1;
+    p1.z = tf1->position.z - axis1.z * hh1;
+    q1.x = tf1->position.x + axis1.x * hh1;
+    q1.y = tf1->position.y + axis1.y * hh1;
+    q1.z = tf1->position.z + axis1.z * hh1;
+
+    p2.x = tf2->position.x - axis2.x * hh2;
+    p2.y = tf2->position.y - axis2.y * hh2;
+    p2.z = tf2->position.z - axis2.z * hh2;
+    q2.x = tf2->position.x + axis2.x * hh2;
+    q2.y = tf2->position.y + axis2.y * hh2;
+    q2.z = tf2->position.z + axis2.z * hh2;
+
+    // p1 - p2
+    OimoVec3 p12;
+    p12.x = p1.x - p2.x;
+    p12.y = p1.y - p2.y;
+    p12.z = p1.z - p2.z;
+
+    // d1 = q1 - p1, d2 = q2 - p2
+    OimoVec3 d1, d2;
+    d1.x = q1.x - p1.x;
+    d1.y = q1.y - p1.y;
+    d1.z = q1.z - p1.z;
+    d2.x = q2.x - p2.x;
+    d2.y = q2.y - p2.y;
+    d2.z = q2.z - p2.z;
+
+    OimoScalar p21d1 = -(p12.x * d1.x + p12.y * d1.y + p12.z * d1.z);
+    OimoScalar p12d2 = p12.x * d2.x + p12.y * d2.y + p12.z * d2.z;
+
+    OimoScalar d11 = hh1 * hh1 * 4;
+    OimoScalar d12 = d1.x * d2.x + d1.y * d2.y + d1.z * d2.z;
+    OimoScalar d22 = hh2 * hh2 * 4;
+
+    // closest points: p1 + t1 * d1, p2 + t2 * d2
+    OimoScalar t1, t2;
+
+    if (oimo_abs(d11) <= OIMO_EPSILON && oimo_abs(d22) <= OIMO_EPSILON) {
+        // point vs point
+        t1 = 0;
+        t2 = 0;
+    } else if (oimo_abs(d11) <= OIMO_EPSILON) {
+        // point vs segment
+        t1 = 0;
+        // t2 = t1 * d12 + p12d2; <- t1 = 0
+        t2 = p12d2;
+        if (t2 < 0) t2 = 0;
+        else if (t2 > d22) t2 = 1;
+        else t2 /= d22;
+    } else if (oimo_abs(d22) <= OIMO_EPSILON) {
+        // segment vs point
+        t2 = 0;
+        // t1 = t2 * d12 + p21d1; <- t2 = 0
+        t1 = p21d1;
+        if (t1 < 0) t1 = 0;
+        else if (t1 > d11) t1 = 1;
+        else t1 /= d11;
+    } else {
+        OimoScalar det = d11 * d22 - d12 * d12;
+
+        if (oimo_abs(det) <= OIMO_EPSILON) {
+            // d1 is parallel to d2. use 0 for t1
+            t1 = 0;
+        } else {
+            t1 = d12 * p12d2 + d22 * p21d1;
+            if (t1 < 0) t1 = 0;
+            else if (t1 > det) t1 = 1;
+            else t1 /= det;
+        }
+
+        t2 = t1 * d12 + p12d2;
+        if (t2 < 0) {
+            // clamp t2 and recompute t1
+            t2 = 0;
+            // t1 = t2 * d12 + p21d1; <- t2 = 0
+            t1 = p21d1;
+            if (t1 < 0) t1 = 0;
+            else if (t1 > d11) t1 = 1;
+            else t1 /= d11;
+        } else if (t2 > d22) {
+            // clamp t2 and recompute t1
+            t2 = 1;
+            // t1 = t2 * d12 + p21d1; <- t2 = 1
+            t1 = d12 + p21d1;
+            if (t1 < 0) t1 = 0;
+            else if (t1 > d11) t1 = 1;
+            else t1 /= d11;
+        } else {
+            t2 /= d22;
+        }
+    }
+
+    // closest points on each segment
+    OimoVec3 cp1, cp2;
+    cp1.x = p1.x + d1.x * t1;
+    cp1.y = p1.y + d1.y * t1;
+    cp1.z = p1.z + d1.z * t1;
+    cp2.x = p2.x + d2.x * t2;
+    cp2.y = p2.y + d2.y * t2;
+    cp2.z = p2.z + d2.z * t2;
+
+    // perform sphere vs sphere collision
+    OimoVec3 d;
+    d.x = cp1.x - cp2.x;
+    d.y = cp1.y - cp2.y;
+    d.z = cp1.z - cp2.z;
+
+    OimoScalar len2 = d.x * d.x + d.y * d.y + d.z * d.z;
+    if (len2 >= (r1 + r2) * (r1 + r2)) return;
+
+    OimoScalar len = oimo_sqrt(len2);
+    OimoVec3 n;
+    if (len > 0) {
+        OimoScalar invLen = 1.0f / len;
+        n.x = d.x * invLen;
+        n.y = d.y * invLen;
+        n.z = d.z * invLen;
+    } else {
+        n.x = 1;
+        n.y = 0;
+        n.z = 0;
+    }
+
+    result->normal = n;
+
+    OimoVec3 pos1, pos2;
+    pos1.x = cp1.x - n.x * r1;
+    pos1.y = cp1.y - n.y * r1;
+    pos1.z = cp1.z - n.z * r1;
+    pos2.x = cp2.x + n.x * r2;
+    pos2.y = cp2.y + n.y * r2;
+    pos2.z = cp2.z + n.z * r2;
+
+    oimo_detector_result_add_point(result, &pos1, &pos2, r1 + r2 - len, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_mesh_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_mesh_detector.h
new file mode 100644
index 0000000000..111aaca049
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/capsule_mesh_detector.h
@@ -0,0 +1,223 @@
+#pragma once
+
+// capsule_mesh_detector.h - Capsule vs Static Mesh collision detection (Optimized for N64)
+
+#include "detector.h"
+#include "detector_result.h"
+#include "triangle_util.h"
+#include "mesh_contact.h"
+#include "../geometry/capsule_geometry.h"
+#include "../geometry/static_mesh_geometry.h"
+#include "../broadphase/bvh.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoCapsuleMeshDetector {
+    OimoDetector base;
+} OimoCapsuleMeshDetector;
+
+static inline void oimo_capsule_mesh_detector_init(OimoCapsuleMeshDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base,
+        swapped ? OIMO_DETECTOR_MESH_CAPSULE : OIMO_DETECTOR_CAPSULE_MESH,
+        swapped);
+}
+
+// Helper: Test capsule segment against a triangle edge, update contact if closer
+static inline void oimo_test_capsule_vs_edge(
+    const OimoVec3* cap_p1, const OimoVec3* cap_p2,
+    const OimoVec3* edge_a, const OimoVec3* edge_b,
+    const OimoVec3* tri_normal,
+    float radius, float radius_sq, int tri_idx,
+    OimoMeshContactStorage* storage
+) {
+    OimoVec3 closest_cap, closest_edge;
+    oimo_closest_points_segments(*cap_p1, *cap_p2, *edge_a, *edge_b, &closest_cap, &closest_edge);
+
+    OimoVec3 diff = oimo_vec3_sub(closest_cap, closest_edge);
+    float dist_sq = oimo_vec3_dot(diff, diff);
+
+    if (dist_sq < radius_sq && dist_sq > 1e-8f) {
+        float inv_dist = oimo_fast_inv_sqrt(dist_sq);
+        float dist = dist_sq * inv_dist;
+        float depth = radius - dist;
+
+        if (depth > 0.0f) {
+            OimoVec3 normal_dir = oimo_vec3_scale(diff, inv_dist);
+            oimo_mesh_contact_storage_add(storage, &closest_edge, &normal_dir, depth, tri_idx);
+        }
+    }
+}
+
+// Helper: Test a point against a triangle face
+static inline void oimo_test_point_vs_triangle(
+    const OimoVec3* point,
+    const OimoVec3* v0, const OimoVec3* v1, const OimoVec3* v2,
+    const OimoVec3* tri_normal,
+    float radius, float radius_sq, int tri_idx,
+    OimoMeshContactStorage* storage
+) {
+    OimoVec3 closest = oimo_closest_point_on_triangle(point, v0, v1, v2);
+    OimoVec3 diff = oimo_vec3_sub(*point, closest);
+    float dist_sq = oimo_vec3_dot(diff, diff);
+
+    if (dist_sq < radius_sq && dist_sq > 1e-8f) {
+        float inv_dist = oimo_fast_inv_sqrt(dist_sq);
+        float dist = dist_sq * inv_dist;
+        float depth = radius - dist;
+
+        if (depth > 0.0f) {
+            OimoVec3 normal_dir = oimo_vec3_scale(diff, inv_dist);
+            oimo_mesh_contact_storage_add(storage, &closest, &normal_dir, depth, tri_idx);
+        }
+    }
+}
+
+// Helper: Test triangle vertex against capsule axis
+static inline void oimo_test_vertex_vs_capsule(
+    const OimoVec3* vertex,
+    const OimoVec3* cap_p1, const OimoVec3* cap_p2,
+    const OimoVec3* tri_normal,
+    float radius, float radius_sq, int tri_idx,
+    OimoMeshContactStorage* storage
+) {
+    OimoVec3 closest_cap = oimo_closest_point_on_segment(*vertex, *cap_p1, *cap_p2);
+    OimoVec3 diff = oimo_vec3_sub(closest_cap, *vertex);
+    float dist_sq = oimo_vec3_dot(diff, diff);
+
+    if (dist_sq < radius_sq && dist_sq > 1e-8f) {
+        float inv_dist = oimo_fast_inv_sqrt(dist_sq);
+        float dist = dist_sq * inv_dist;
+        float depth = radius - dist;
+
+        if (depth > 0.0f) {
+            OimoVec3 normal_dir = oimo_vec3_scale(diff, inv_dist);
+            oimo_mesh_contact_storage_add(storage, vertex, &normal_dir, depth, tri_idx);
+        }
+    }
+}
+
+// Detect capsule vs mesh collision (optimized single-pass with 4 contacts)
+static inline void oimo_capsule_mesh_detector_detect(
+    OimoCapsuleMeshDetector* detector,
+    OimoDetectorResult* result,
+    const OimoCapsuleGeometry* capsule,
+    const OimoStaticMeshGeometry* mesh,
+    const OimoTransform* tf_capsule,
+    const OimoTransform* tf_mesh
+) {
+    result->incremental = false;
+
+    OimoScalar radius = capsule->radius;
+    OimoScalar half_height = capsule->halfHeight;
+    float radius_sq = radius * radius;
+    float max_extent = radius + half_height;
+
+    // Get capsule axis in world space (local Y axis)
+    OimoVec3 axis_world = oimo_vec3(
+        tf_capsule->rotation.e01,
+        tf_capsule->rotation.e11,
+        tf_capsule->rotation.e21
+    );
+
+    // Capsule endpoints in world space
+    OimoVec3 axis_offset = oimo_vec3_scale(axis_world, half_height);
+    OimoVec3 cap_p1_world = oimo_vec3_add(tf_capsule->position, axis_offset);
+    OimoVec3 cap_p2_world = oimo_vec3_sub(tf_capsule->position, axis_offset);
+
+    // Transform capsule to mesh local space
+    OimoVec3 capsule_to_mesh = oimo_vec3_sub(tf_capsule->position, tf_mesh->position);
+    OimoMat3 mesh_rot_inv = oimo_mat3_transpose(&tf_mesh->rotation);
+    OimoVec3 capsule_local = oimo_mat3_mul_vec3(&mesh_rot_inv, capsule_to_mesh);
+
+    // Also transform endpoints to mesh local space
+    OimoVec3 p1_to_mesh = oimo_vec3_sub(cap_p1_world, tf_mesh->position);
+    OimoVec3 p2_to_mesh = oimo_vec3_sub(cap_p2_world, tf_mesh->position);
+    OimoVec3 cap_p1_local = oimo_mat3_mul_vec3(&mesh_rot_inv, p1_to_mesh);
+    OimoVec3 cap_p2_local = oimo_mat3_mul_vec3(&mesh_rot_inv, p2_to_mesh);
+
+    // Build query AABB in mesh local space
+    float query_extent = max_extent + 0.01f;
+    OimoAabb query_aabb;
+    query_aabb.min.x = capsule_local.x - query_extent;
+    query_aabb.min.y = capsule_local.y - query_extent;
+    query_aabb.min.z = capsule_local.z - query_extent;
+    query_aabb.max.x = capsule_local.x + query_extent;
+    query_aabb.max.y = capsule_local.y + query_extent;
+    query_aabb.max.z = capsule_local.z + query_extent;
+
+    // Query BVH for overlapping triangles
+    OimoBvhQueryResult bvh_result;
+    oimo_static_mesh_query_triangles(mesh, &query_aabb, &bvh_result);
+
+    if (bvh_result.count == 0) return;
+
+    // Initialize contact storage
+    OimoMeshContactStorage storage;
+    oimo_mesh_contact_storage_init(&storage);
+
+    for (int i = 0; i < bvh_result.count; i++) {
+        int tri_idx = bvh_result.triangles[i];
+        const OimoTriangle* tri = oimo_static_mesh_get_triangle(mesh, tri_idx);
+        if (!tri) continue;
+
+        // EARLY OUT: Quick plane distance check using capsule center
+        float plane_dist = oimo_point_plane_distance(&capsule_local, &tri->v0, &tri->normal);
+        if (plane_dist > max_extent || plane_dist < -max_extent) {
+            continue;
+        }
+
+        // Test capsule axis against all triangle edges
+        oimo_test_capsule_vs_edge(&cap_p1_local, &cap_p2_local, &tri->v0, &tri->v1,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+        oimo_test_capsule_vs_edge(&cap_p1_local, &cap_p2_local, &tri->v1, &tri->v2,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+        oimo_test_capsule_vs_edge(&cap_p1_local, &cap_p2_local, &tri->v2, &tri->v0,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+
+        // Test capsule endpoints against triangle face
+        oimo_test_point_vs_triangle(&cap_p1_local, &tri->v0, &tri->v1, &tri->v2,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+        oimo_test_point_vs_triangle(&cap_p2_local, &tri->v0, &tri->v1, &tri->v2,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+
+        // Test triangle vertices against capsule axis
+        oimo_test_vertex_vs_capsule(&tri->v0, &cap_p1_local, &cap_p2_local,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+        oimo_test_vertex_vs_capsule(&tri->v1, &cap_p1_local, &cap_p2_local,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+        oimo_test_vertex_vs_capsule(&tri->v2, &cap_p1_local, &cap_p2_local,
+            &tri->normal, radius, radius_sq, tri_idx, &storage);
+    }
+
+    // No collision
+    if (!storage.has_contact) return;
+
+    // Transform primary normal to world space
+    OimoVec3 normal_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, storage.primary_normal);
+    oimo_detector_set_normal(&detector->base, result, &normal_world);
+
+    // Add all stored contacts
+    for (int i = 0; i < storage.count; i++) {
+        OimoMeshContact* c = &storage.contacts[i];
+
+        // Mesh contact point (in world space)
+        OimoVec3 closest_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, c->closest);
+        OimoVec3 mesh_contact = oimo_vec3_add(closest_world, tf_mesh->position);
+
+        // Capsule contact point: mesh contact offset by (depth - radius) along normal
+        // This places the contact on the capsule surface
+        OimoVec3 cap_contact = oimo_vec3_add(mesh_contact,
+            oimo_vec3_scale(normal_world, c->depth));
+
+        oimo_detector_add_point(&detector->base, result, &cap_contact, &mesh_contact,
+            c->depth, c->tri_idx);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/collision_matrix.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/collision_matrix.h
new file mode 100644
index 0000000000..0c8a18378d
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/collision_matrix.h
@@ -0,0 +1,337 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "sphere_sphere_detector.h"
+#include "sphere_box_detector.h"
+#include "box_box_detector.h"
+#include "capsule_capsule_detector.h"
+#include "sphere_capsule_detector.h"
+#include "box_capsule_detector.h"
+#include "sphere_mesh_detector.h"
+#include "box_mesh_detector.h"
+#include "capsule_mesh_detector.h"
+#include "../geometry/geometry_type.h"
+#include "../geometry/sphere_geometry.h"
+#include "../geometry/box_geometry.h"
+#include "../geometry/capsule_geometry.h"
+#include "../geometry/static_mesh_geometry.h"
+#include "../../common/transform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoCollisionMatrix {
+    OimoSphereSphereDetector sphere_sphere;
+    OimoSphereBoxDetector sphere_box;      // sphere is geom1
+    OimoSphereBoxDetector box_sphere;      // box is geom1 (swapped)
+    OimoBoxBoxDetector box_box;
+    OimoCapsuleCapsuleDetector capsule_capsule;
+    OimoSphereCapsuleDetector sphere_capsule;  // sphere is geom1
+    OimoSphereCapsuleDetector capsule_sphere;  // capsule is geom1 (swapped)
+    OimoBoxCapsuleDetector box_capsule;        // box is geom1
+    OimoBoxCapsuleDetector capsule_box;        // capsule is geom1 (swapped)
+    // Mesh detectors
+    OimoSphereMeshDetector sphere_mesh;
+    OimoSphereMeshDetector mesh_sphere;
+    OimoBoxMeshDetector box_mesh;
+    OimoBoxMeshDetector mesh_box;
+    OimoCapsuleMeshDetector capsule_mesh;
+    OimoCapsuleMeshDetector mesh_capsule;
+} OimoCollisionMatrix;
+
+static inline void oimo_collision_matrix_init(OimoCollisionMatrix* matrix) {
+    oimo_sphere_sphere_detector_init(&matrix->sphere_sphere);
+    oimo_sphere_box_detector_init(&matrix->sphere_box, false);  // sphere-box order
+    oimo_sphere_box_detector_init(&matrix->box_sphere, true);   // box-sphere order (swapped)
+    oimo_box_box_detector_init(&matrix->box_box);
+    oimo_capsule_capsule_detector_init(&matrix->capsule_capsule);
+    oimo_sphere_capsule_detector_init(&matrix->sphere_capsule, false);  // sphere-capsule order
+    oimo_sphere_capsule_detector_init(&matrix->capsule_sphere, true);   // capsule-sphere order (swapped)
+    oimo_box_capsule_detector_init(&matrix->box_capsule, false);        // box-capsule order
+    oimo_box_capsule_detector_init(&matrix->capsule_box, true);         // capsule-box order (swapped)
+    // Mesh detectors
+    oimo_sphere_mesh_detector_init(&matrix->sphere_mesh, false);
+    oimo_sphere_mesh_detector_init(&matrix->mesh_sphere, true);
+    oimo_box_mesh_detector_init(&matrix->box_mesh, false);
+    oimo_box_mesh_detector_init(&matrix->mesh_box, true);
+    oimo_capsule_mesh_detector_init(&matrix->capsule_mesh, false);
+    oimo_capsule_mesh_detector_init(&matrix->mesh_capsule, true);
+}
+
+static inline OimoCollisionMatrix oimo_collision_matrix_create(void) {
+    OimoCollisionMatrix matrix;
+    oimo_collision_matrix_init(&matrix);
+    return matrix;
+}
+
+// Get a detector pointer for the given geometry types (for storing in contacts)
+static inline OimoDetector* oimo_collision_matrix_get_detector(
+    OimoCollisionMatrix* matrix,
+    OimoGeometryType type1,
+    OimoGeometryType type2)
+{
+    if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_SPHERE) {
+        return &matrix->sphere_sphere.base;
+    }
+    if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_BOX) {
+        return &matrix->sphere_box.base;
+    }
+    if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_SPHERE) {
+        return &matrix->box_sphere.base;
+    }
+    if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_BOX) {
+        return &matrix->box_box.base;
+    }
+    if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_CAPSULE) {
+        return &matrix->capsule_capsule.base;
+    }
+    if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_CAPSULE) {
+        return &matrix->sphere_capsule.base;
+    }
+    if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_SPHERE) {
+        return &matrix->capsule_sphere.base;
+    }
+    if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_CAPSULE) {
+        return &matrix->box_capsule.base;
+    }
+    if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_BOX) {
+        return &matrix->capsule_box.base;
+    }
+    // Mesh collisions
+    if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return &matrix->sphere_mesh.base;
+    }
+    if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_SPHERE) {
+        return &matrix->mesh_sphere.base;
+    }
+    if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return &matrix->box_mesh.base;
+    }
+    if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_BOX) {
+        return &matrix->mesh_box.base;
+    }
+    if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return &matrix->capsule_mesh.base;
+    }
+    if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_CAPSULE) {
+        return &matrix->mesh_capsule.base;
+    }
+    return NULL;
+}
+
+static inline bool oimo_collision_matrix_detect(
+    OimoCollisionMatrix* matrix,
+    OimoDetectorResult* result,
+    const OimoGeometry* geom1,
+    const OimoGeometry* geom2,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2)
+{
+    oimo_detector_result_clear(result);
+
+    int type1 = geom1->type;
+    int type2 = geom2->type;
+
+    // Dispatch based on geometry types
+    if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_SPHERE) {
+        oimo_sphere_sphere_detector_detect(
+            &matrix->sphere_sphere,
+            result,
+            (const OimoSphereGeometry*)geom1,
+            (const OimoSphereGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_BOX) {
+        oimo_sphere_box_detector_detect(
+            &matrix->sphere_box,
+            result,
+            (const OimoSphereGeometry*)geom1,
+            (const OimoBoxGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_SPHERE) {
+        // Box-sphere: pass box as "sphere" position, sphere as "box" position
+        // The detector internally handles the swap
+        oimo_sphere_box_detector_detect(
+            &matrix->box_sphere,
+            result,
+            (const OimoSphereGeometry*)geom2,  // sphere
+            (const OimoBoxGeometry*)geom1,     // box
+            tf2, tf1);  // transforms also swapped
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_BOX) {
+        oimo_box_box_detector_detect(
+            &matrix->box_box,
+            result,
+            (const OimoBoxGeometry*)geom1,
+            (const OimoBoxGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    // Capsule collisions
+    else if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_CAPSULE) {
+        oimo_capsule_capsule_detector_detect(
+            &matrix->capsule_capsule,
+            result,
+            (const OimoCapsuleGeometry*)geom1,
+            (const OimoCapsuleGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_CAPSULE) {
+        oimo_sphere_capsule_detector_detect(
+            &matrix->sphere_capsule,
+            result,
+            (const OimoSphereGeometry*)geom1,
+            (const OimoCapsuleGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_SPHERE) {
+        // Capsule-sphere: pass sphere first, capsule second (swapped detector handles normal flip)
+        oimo_sphere_capsule_detector_detect(
+            &matrix->capsule_sphere,
+            result,
+            (const OimoSphereGeometry*)geom2,  // sphere
+            (const OimoCapsuleGeometry*)geom1, // capsule
+            tf2, tf1);  // transforms also swapped
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_CAPSULE) {
+        oimo_box_capsule_detector_detect(
+            &matrix->box_capsule,
+            result,
+            (const OimoBoxGeometry*)geom1,
+            (const OimoCapsuleGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_BOX) {
+        // Capsule-box: pass box first, capsule second (swapped detector handles normal flip)
+        oimo_box_capsule_detector_detect(
+            &matrix->capsule_box,
+            result,
+            (const OimoBoxGeometry*)geom2,     // box
+            (const OimoCapsuleGeometry*)geom1, // capsule
+            tf2, tf1);  // transforms also swapped
+        return true;
+    }
+    // Mesh collisions
+    else if (type1 == OIMO_GEOMETRY_SPHERE && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        oimo_sphere_mesh_detector_detect(
+            &matrix->sphere_mesh,
+            result,
+            (const OimoSphereGeometry*)geom1,
+            (const OimoStaticMeshGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_SPHERE) {
+        oimo_sphere_mesh_detector_detect(
+            &matrix->mesh_sphere,
+            result,
+            (const OimoSphereGeometry*)geom2,
+            (const OimoStaticMeshGeometry*)geom1,
+            tf2, tf1);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_BOX && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        oimo_box_mesh_detector_detect(
+            &matrix->box_mesh,
+            result,
+            (const OimoBoxGeometry*)geom1,
+            (const OimoStaticMeshGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_BOX) {
+        oimo_box_mesh_detector_detect(
+            &matrix->mesh_box,
+            result,
+            (const OimoBoxGeometry*)geom2,
+            (const OimoStaticMeshGeometry*)geom1,
+            tf2, tf1);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_CAPSULE && type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        oimo_capsule_mesh_detector_detect(
+            &matrix->capsule_mesh,
+            result,
+            (const OimoCapsuleGeometry*)geom1,
+            (const OimoStaticMeshGeometry*)geom2,
+            tf1, tf2);
+        return true;
+    }
+    else if (type1 == OIMO_GEOMETRY_STATIC_MESH && type2 == OIMO_GEOMETRY_CAPSULE) {
+        oimo_capsule_mesh_detector_detect(
+            &matrix->mesh_capsule,
+            result,
+            (const OimoCapsuleGeometry*)geom2,
+            (const OimoStaticMeshGeometry*)geom1,
+            tf2, tf1);
+        return true;
+    }
+
+    // Unsupported geometry combination
+    return false;
+}
+
+static inline OimoDetectorType oimo_collision_matrix_get_detector_type(int geom_type1, int geom_type2) {
+    if (geom_type1 == OIMO_GEOMETRY_SPHERE && geom_type2 == OIMO_GEOMETRY_SPHERE) {
+        return OIMO_DETECTOR_SPHERE_SPHERE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_SPHERE && geom_type2 == OIMO_GEOMETRY_BOX) {
+        return OIMO_DETECTOR_SPHERE_BOX;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_BOX && geom_type2 == OIMO_GEOMETRY_SPHERE) {
+        return OIMO_DETECTOR_BOX_SPHERE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_BOX && geom_type2 == OIMO_GEOMETRY_BOX) {
+        return OIMO_DETECTOR_BOX_BOX;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_CAPSULE && geom_type2 == OIMO_GEOMETRY_CAPSULE) {
+        return OIMO_DETECTOR_CAPSULE_CAPSULE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_SPHERE && geom_type2 == OIMO_GEOMETRY_CAPSULE) {
+        return OIMO_DETECTOR_SPHERE_CAPSULE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_CAPSULE && geom_type2 == OIMO_GEOMETRY_SPHERE) {
+        return OIMO_DETECTOR_CAPSULE_SPHERE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_BOX && geom_type2 == OIMO_GEOMETRY_CAPSULE) {
+        return OIMO_DETECTOR_BOX_CAPSULE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_CAPSULE && geom_type2 == OIMO_GEOMETRY_BOX) {
+        return OIMO_DETECTOR_CAPSULE_BOX;
+    }
+    // Mesh collisions
+    if (geom_type1 == OIMO_GEOMETRY_SPHERE && geom_type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return OIMO_DETECTOR_SPHERE_MESH;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_STATIC_MESH && geom_type2 == OIMO_GEOMETRY_SPHERE) {
+        return OIMO_DETECTOR_MESH_SPHERE;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_BOX && geom_type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return OIMO_DETECTOR_BOX_MESH;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_STATIC_MESH && geom_type2 == OIMO_GEOMETRY_BOX) {
+        return OIMO_DETECTOR_MESH_BOX;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_CAPSULE && geom_type2 == OIMO_GEOMETRY_STATIC_MESH) {
+        return OIMO_DETECTOR_CAPSULE_MESH;
+    }
+    if (geom_type1 == OIMO_GEOMETRY_STATIC_MESH && geom_type2 == OIMO_GEOMETRY_CAPSULE) {
+        return OIMO_DETECTOR_MESH_CAPSULE;
+    }
+    return (OimoDetectorType)-1;  // Unsupported
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector.h
new file mode 100644
index 0000000000..f9ae986f3b
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "detector_result.h"
+#include "../geometry/geometry.h"
+#include "../../common/transform.h"
+#include "../../common/vec3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum OimoDetectorType {
+    OIMO_DETECTOR_SPHERE_SPHERE = 0,
+    OIMO_DETECTOR_SPHERE_BOX = 1,
+    OIMO_DETECTOR_BOX_SPHERE = 2,
+    OIMO_DETECTOR_BOX_BOX = 3,
+    OIMO_DETECTOR_SPHERE_CAPSULE = 4,
+    OIMO_DETECTOR_CAPSULE_SPHERE = 5,
+    OIMO_DETECTOR_CAPSULE_CAPSULE = 6,
+    OIMO_DETECTOR_BOX_CAPSULE = 7,
+    OIMO_DETECTOR_CAPSULE_BOX = 8,
+    OIMO_DETECTOR_SPHERE_MESH = 9,
+    OIMO_DETECTOR_MESH_SPHERE = 10,
+    OIMO_DETECTOR_BOX_MESH = 11,
+    OIMO_DETECTOR_MESH_BOX = 12,
+    OIMO_DETECTOR_CAPSULE_MESH = 13,
+    OIMO_DETECTOR_MESH_CAPSULE = 14,
+    OIMO_DETECTOR_COUNT
+} OimoDetectorType;
+
+typedef struct OimoDetector {
+    OimoDetectorType type;
+    bool swapped;
+} OimoDetector;
+
+static inline void oimo_detector_init(OimoDetector* detector, OimoDetectorType type, bool swapped) {
+    detector->type = type;
+    detector->swapped = swapped;
+}
+
+static inline void oimo_detector_set_normal(
+    OimoDetector* detector,
+    OimoDetectorResult* result,
+    const OimoVec3* normal
+) {
+    if (detector->swapped) {
+        oimo_vec3_negate_to(&result->normal, normal);
+    } else {
+        result->normal = *normal;
+    }
+}
+
+static inline void oimo_detector_add_point(
+    OimoDetector* detector,
+    OimoDetectorResult* result,
+    const OimoVec3* pos1,
+    const OimoVec3* pos2,
+    OimoScalar depth,
+    int id
+) {
+    if (detector->swapped) {
+        oimo_detector_result_add_point(result, pos2, pos1, depth, id);
+    } else {
+        oimo_detector_result_add_point(result, pos1, pos2, depth, id);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector_result.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector_result.h
new file mode 100644
index 0000000000..3fd14f5ea9
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/detector_result.h
@@ -0,0 +1,92 @@
+#pragma once
+
+#include "../../common/vec3.h"
+#include "../../common/setting.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoDetectorResultPoint {
+    OimoVec3 position1;  // Closest point on first geometry (world space)
+    OimoVec3 position2;  // Closest point on second geometry (world space)
+    OimoScalar depth;    // Penetration depth (positive = overlapping)
+    int id;              // Point ID for contact persistence
+} OimoDetectorResultPoint;
+
+static inline void oimo_detector_result_point_init(OimoDetectorResultPoint* point) {
+    oimo_vec3_set(&point->position1, 0.0f, 0.0f, 0.0f);
+    oimo_vec3_set(&point->position2, 0.0f, 0.0f, 0.0f);
+    point->depth = 0.0f;
+    point->id = 0;
+}
+
+typedef struct OimoDetectorResult {
+    int num_points;                                    // Number of valid contact points
+    OimoDetectorResultPoint points[OIMO_MAX_MANIFOLD_POINTS]; // Contact points array
+    OimoVec3 normal;                                   // Contact normal (from geom1 to geom2)
+    bool incremental;                                  // For GJK/EPA incremental results
+} OimoDetectorResult;
+
+static inline void oimo_detector_result_init(OimoDetectorResult* result) {
+    result->num_points = 0;
+    oimo_vec3_set(&result->normal, 0.0f, 0.0f, 0.0f);
+    result->incremental = false;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        oimo_detector_result_point_init(&result->points[i]);
+    }
+}
+
+static inline void oimo_detector_result_clear(OimoDetectorResult* result) {
+    result->num_points = 0;
+    oimo_vec3_set(&result->normal, 0.0f, 0.0f, 0.0f);
+    result->incremental = false;
+}
+
+// Create and return a zero-initialized detector result
+static inline OimoDetectorResult oimo_detector_result_create(void) {
+    OimoDetectorResult result;
+    result.num_points = 0;
+    oimo_vec3_set(&result.normal, 0.0f, 0.0f, 0.0f);
+    result.incremental = false;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        oimo_detector_result_point_init(&result.points[i]);
+    }
+    return result;
+}
+
+static inline OimoScalar oimo_detector_result_get_max_depth(const OimoDetectorResult* result) {
+    OimoScalar max_depth = 0.0f;
+    for (int i = 0; i < result->num_points; i++) {
+        if (result->points[i].depth > max_depth) {
+            max_depth = result->points[i].depth;
+        }
+    }
+    return max_depth;
+}
+
+static inline bool oimo_detector_result_add_point(
+    OimoDetectorResult* result,
+    const OimoVec3* pos1,
+    const OimoVec3* pos2,
+    OimoScalar depth,
+    int id
+) {
+    if (result->num_points >= OIMO_MAX_MANIFOLD_POINTS) {
+        return false;
+    }
+
+    OimoDetectorResultPoint* point = &result->points[result->num_points];
+    point->position1 = *pos1;
+    point->position2 = *pos2;
+    point->depth = depth;
+    point->id = id;
+    result->num_points++;
+
+    return true;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/mesh_contact.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/mesh_contact.h
new file mode 100644
index 0000000000..be10289f35
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/mesh_contact.h
@@ -0,0 +1,81 @@
+#pragma once
+
+// mesh_contact.h - Shared contact storage for mesh collision detectors
+
+#include "../../common/vec3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Maximum contacts for mesh collision (balance stability vs performance)
+#define OIMO_MESH_MAX_CONTACTS 4
+
+// Temporary contact storage for single-pass mesh collision
+typedef struct OimoMeshContact {
+    OimoVec3 closest;       // Closest point on triangle (mesh local space)
+    OimoVec3 normal_dir;    // Contact normal direction
+    float depth;            // Penetration depth
+    int tri_idx;            // Triangle index
+} OimoMeshContact;
+
+// Storage for multiple contacts during detection
+typedef struct OimoMeshContactStorage {
+    OimoMeshContact contacts[OIMO_MESH_MAX_CONTACTS];
+    int count;
+    float max_depth;
+    OimoVec3 primary_normal;
+    bool has_contact;
+} OimoMeshContactStorage;
+
+// Initialize contact storage
+static inline void oimo_mesh_contact_storage_init(OimoMeshContactStorage* storage) {
+    storage->count = 0;
+    storage->max_depth = 0.0f;
+    storage->primary_normal = oimo_vec3(0, 1, 0);
+    storage->has_contact = false;
+}
+
+// Add a contact, replacing shallowest if full
+static inline void oimo_mesh_contact_storage_add(
+    OimoMeshContactStorage* storage,
+    const OimoVec3* closest,
+    const OimoVec3* normal_dir,
+    float depth,
+    int tri_idx
+) {
+    // Track primary normal (deepest penetration)
+    if (depth > storage->max_depth) {
+        storage->max_depth = depth;
+        storage->primary_normal = *normal_dir;
+        storage->has_contact = true;
+    }
+
+    // Add contact
+    if (storage->count < OIMO_MESH_MAX_CONTACTS) {
+        OimoMeshContact* c = &storage->contacts[storage->count++];
+        c->closest = *closest;
+        c->normal_dir = *normal_dir;
+        c->depth = depth;
+        c->tri_idx = tri_idx;
+    } else {
+        // Replace shallowest contact if this one is deeper
+        int shallowest = 0;
+        for (int i = 1; i < OIMO_MESH_MAX_CONTACTS; i++) {
+            if (storage->contacts[i].depth < storage->contacts[shallowest].depth) {
+                shallowest = i;
+            }
+        }
+        if (depth > storage->contacts[shallowest].depth) {
+            OimoMeshContact* c = &storage->contacts[shallowest];
+            c->closest = *closest;
+            c->normal_dir = *normal_dir;
+            c->depth = depth;
+            c->tri_idx = tri_idx;
+        }
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_box_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_box_detector.h
new file mode 100644
index 0000000000..77d0af6131
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_box_detector.h
@@ -0,0 +1,175 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/sphere_geometry.h"
+#include "../geometry/box_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+#include "../../common/mat3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoSphereBoxDetector {
+    OimoDetector base;
+} OimoSphereBoxDetector;
+
+static inline void oimo_sphere_box_detector_init(OimoSphereBoxDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base,
+        swapped ? OIMO_DETECTOR_BOX_SPHERE : OIMO_DETECTOR_SPHERE_BOX,
+        swapped);
+}
+
+static inline void oimo_sphere_box_detector_detect(
+    OimoSphereBoxDetector* detector,
+    OimoDetectorResult* result,
+    const OimoSphereGeometry* sphere,
+    const OimoBoxGeometry* box,
+    const OimoTransform* tf_sphere,
+    const OimoTransform* tf_box
+) {
+    result->incremental = false;
+
+    OimoVec3 half_ext = box->half_extents;
+    OimoVec3 neg_half_ext;
+    oimo_vec3_negate_to(&neg_half_ext, &half_ext);
+
+    OimoScalar r = sphere->radius;
+
+    // Vector from box center to sphere center
+    OimoVec3 box_to_sphere;
+    oimo_vec3_sub_to(&box_to_sphere, &tf_sphere->position, &tf_box->position);
+
+    // Transform to box's local space (multiply by transposed rotation)
+    OimoMat3 rot_transposed = oimo_mat3_transpose(&tf_box->rotation);
+    OimoVec3 box_to_sphere_in_box = oimo_mat3_mul_vec3(&rot_transposed, box_to_sphere);
+
+    // Check if sphere center is inside the box
+    bool inside_box =
+        box_to_sphere_in_box.x >= neg_half_ext.x && box_to_sphere_in_box.x <= half_ext.x &&
+        box_to_sphere_in_box.y >= neg_half_ext.y && box_to_sphere_in_box.y <= half_ext.y &&
+        box_to_sphere_in_box.z >= neg_half_ext.z && box_to_sphere_in_box.z <= half_ext.z;
+
+    if (inside_box) {
+        // Compute distance to each face
+        OimoVec3 sphere_to_box_surface;
+        sphere_to_box_surface.x = half_ext.x - oimo_abs(box_to_sphere_in_box.x);
+        sphere_to_box_surface.y = half_ext.y - oimo_abs(box_to_sphere_in_box.y);
+        sphere_to_box_surface.z = half_ext.z - oimo_abs(box_to_sphere_in_box.z);
+
+        OimoVec3 normal_in_box;
+        OimoVec3 projection_mask;
+        OimoScalar depth;
+
+        // Find minimum distance axis
+        OimoScalar dist_x = sphere_to_box_surface.x;
+        OimoScalar dist_y = sphere_to_box_surface.y;
+        OimoScalar dist_z = sphere_to_box_surface.z;
+
+        if (dist_x <= dist_y && dist_x <= dist_z) {
+            // X axis is closest
+            if (box_to_sphere_in_box.x > 0.0f) {
+                oimo_vec3_set(&normal_in_box, 1.0f, 0.0f, 0.0f);
+            } else {
+                oimo_vec3_set(&normal_in_box, -1.0f, 0.0f, 0.0f);
+            }
+            oimo_vec3_set(&projection_mask, 0.0f, 1.0f, 1.0f);
+            depth = dist_x;
+        } else if (dist_y <= dist_x && dist_y <= dist_z) {
+            // Y axis is closest
+            if (box_to_sphere_in_box.y > 0.0f) {
+                oimo_vec3_set(&normal_in_box, 0.0f, 1.0f, 0.0f);
+            } else {
+                oimo_vec3_set(&normal_in_box, 0.0f, -1.0f, 0.0f);
+            }
+            oimo_vec3_set(&projection_mask, 1.0f, 0.0f, 1.0f);
+            depth = dist_y;
+        } else {
+            // Z axis is closest
+            if (box_to_sphere_in_box.z > 0.0f) {
+                oimo_vec3_set(&normal_in_box, 0.0f, 0.0f, 1.0f);
+            } else {
+                oimo_vec3_set(&normal_in_box, 0.0f, 0.0f, -1.0f);
+            }
+            oimo_vec3_set(&projection_mask, 1.0f, 1.0f, 0.0f);
+            depth = dist_z;
+        }
+
+        // Compute closest point on box
+        OimoVec3 base;
+        base.x = projection_mask.x * box_to_sphere_in_box.x;
+        base.y = projection_mask.y * box_to_sphere_in_box.y;
+        base.z = projection_mask.z * box_to_sphere_in_box.z;
+
+        OimoVec3 box_to_closest_in_box;
+        box_to_closest_in_box.x = normal_in_box.x * half_ext.x + base.x;
+        box_to_closest_in_box.y = normal_in_box.y * half_ext.y + base.y;
+        box_to_closest_in_box.z = normal_in_box.z * half_ext.z + base.z;
+
+        // Transform back to world space
+        OimoVec3 box_to_closest = oimo_mat3_mul_vec3(&tf_box->rotation, box_to_closest_in_box);
+        OimoVec3 normal = oimo_mat3_mul_vec3(&tf_box->rotation, normal_in_box);
+
+        oimo_detector_set_normal(&detector->base, result, &normal);
+
+        // Contact positions
+        OimoVec3 pos1, pos2;
+        OimoVec3 scaled_n;
+        oimo_vec3_scale_to(&scaled_n, &normal, -r);
+        oimo_vec3_add_to(&pos1, &tf_sphere->position, &scaled_n);
+        oimo_vec3_add_to(&pos2, &tf_box->position, &box_to_closest);
+
+        oimo_detector_add_point(&detector->base, result, &pos1, &pos2, depth, 0);
+        return;
+    }
+
+    // Sphere center is outside the box
+    // Clamp sphere center to box bounds to find closest point
+
+    // Avoid division by zero with epsilon adjustment
+    OimoScalar eps = 1e-9f;
+    OimoVec3 adjusted_half_ext, adjusted_neg_half_ext;
+    oimo_vec3_set(&adjusted_half_ext, half_ext.x - eps, half_ext.y - eps, half_ext.z - eps);
+    oimo_vec3_set(&adjusted_neg_half_ext, neg_half_ext.x + eps, neg_half_ext.y + eps, neg_half_ext.z + eps);
+
+    OimoVec3 box_to_closest_in_box;
+    box_to_closest_in_box.x = oimo_clamp(box_to_sphere_in_box.x, adjusted_neg_half_ext.x, adjusted_half_ext.x);
+    box_to_closest_in_box.y = oimo_clamp(box_to_sphere_in_box.y, adjusted_neg_half_ext.y, adjusted_half_ext.y);
+    box_to_closest_in_box.z = oimo_clamp(box_to_sphere_in_box.z, adjusted_neg_half_ext.z, adjusted_half_ext.z);
+
+    // Vector from closest point to sphere center
+    OimoVec3 closest_to_sphere_in_box;
+    oimo_vec3_sub_to(&closest_to_sphere_in_box, &box_to_sphere_in_box, &box_to_closest_in_box);
+
+    OimoScalar dist2 = oimo_vec3_dot(closest_to_sphere_in_box, closest_to_sphere_in_box);
+    if (dist2 >= r * r) {
+        return;  // No collision
+    }
+
+    OimoScalar dist = oimo_sqrt(dist2);
+
+    // Transform back to world space
+    OimoVec3 box_to_closest = oimo_mat3_mul_vec3(&tf_box->rotation, box_to_closest_in_box);
+    OimoVec3 closest_to_sphere = oimo_mat3_mul_vec3(&tf_box->rotation, closest_to_sphere_in_box);
+
+    // Normal from box to sphere
+    OimoVec3 normal;
+    oimo_vec3_normalize_to(&normal, &closest_to_sphere);
+    oimo_detector_set_normal(&detector->base, result, &normal);
+
+    // Contact positions
+    OimoVec3 pos1, pos2;
+    OimoVec3 scaled_n;
+    oimo_vec3_scale_to(&scaled_n, &normal, -r);
+    oimo_vec3_add_to(&pos1, &tf_sphere->position, &scaled_n);
+    oimo_vec3_add_to(&pos2, &tf_box->position, &box_to_closest);
+
+    OimoScalar depth = r - dist;
+    oimo_detector_add_point(&detector->base, result, &pos1, &pos2, depth, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_capsule_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_capsule_detector.h
new file mode 100644
index 0000000000..a579494f47
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_capsule_detector.h
@@ -0,0 +1,143 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/capsule_geometry.h"
+#include "../geometry/sphere_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/vec3.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Sphere vs Capsule detector (matches OimoPhysics)
+// If swapped is true, expects CapsuleGeometry and SphereGeometry
+// If swapped is false, expects SphereGeometry and CapsuleGeometry
+typedef struct OimoSphereCapsuleDetector {
+    OimoDetector base;
+    bool swapped;
+} OimoSphereCapsuleDetector;
+
+static inline void oimo_sphere_capsule_detector_init(OimoSphereCapsuleDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base, swapped ? OIMO_DETECTOR_CAPSULE_SPHERE : OIMO_DETECTOR_SPHERE_CAPSULE, swapped);
+    detector->swapped = swapped;
+}
+
+// Always called with sphere as s1, capsule as c2 (handles swapped internally via result normal)
+static inline void oimo_sphere_capsule_detector_detect(
+    OimoSphereCapsuleDetector* detector,
+    OimoDetectorResult* result,
+    const OimoSphereGeometry* s1,
+    const OimoCapsuleGeometry* c2,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2)
+{
+    OimoScalar hh2 = c2->halfHeight;
+    OimoScalar r1 = s1->radius;
+    OimoScalar r2 = c2->radius;
+
+    // capsule axis (Y axis = column 1)
+    OimoVec3 axis2;
+    axis2.x = tf2->rotation.e01;
+    axis2.y = tf2->rotation.e11;
+    axis2.z = tf2->rotation.e21;
+
+    // closest point 1 is just sphere center
+    OimoVec3 cp1;
+    cp1.x = tf1->position.x;
+    cp1.y = tf1->position.y;
+    cp1.z = tf1->position.z;
+
+    // find closest point on segment 2
+    // line segment (p2, q2)
+    OimoVec3 p2, q2;
+    p2.x = tf2->position.x - axis2.x * hh2;
+    p2.y = tf2->position.y - axis2.y * hh2;
+    p2.z = tf2->position.z - axis2.z * hh2;
+    q2.x = tf2->position.x + axis2.x * hh2;
+    q2.y = tf2->position.y + axis2.y * hh2;
+    q2.z = tf2->position.z + axis2.z * hh2;
+
+    // p12 = cp1 - p2
+    OimoVec3 p12;
+    p12.x = cp1.x - p2.x;
+    p12.y = cp1.y - p2.y;
+    p12.z = cp1.z - p2.z;
+
+    // d2 = q2 - p2
+    OimoVec3 d2;
+    d2.x = q2.x - p2.x;
+    d2.y = q2.y - p2.y;
+    d2.z = q2.z - p2.z;
+
+    OimoScalar d22 = hh2 * hh2 * 4;
+
+    OimoScalar t = p12.x * d2.x + p12.y * d2.y + p12.z * d2.z;
+    if (t < 0) t = 0;
+    else if (t > d22) t = 1;
+    else t /= d22;
+
+    OimoVec3 cp2;
+    cp2.x = p2.x + d2.x * t;
+    cp2.y = p2.y + d2.y * t;
+    cp2.z = p2.z + d2.z * t;
+
+    // perform sphere vs sphere collision
+    OimoVec3 d;
+    d.x = cp1.x - cp2.x;
+    d.y = cp1.y - cp2.y;
+    d.z = cp1.z - cp2.z;
+
+    OimoScalar len2 = d.x * d.x + d.y * d.y + d.z * d.z;
+    if (len2 >= (r1 + r2) * (r1 + r2)) return;
+
+    OimoScalar len = oimo_sqrt(len2);
+    OimoVec3 n;
+    if (len > 0) {
+        OimoScalar invLen = 1.0f / len;
+        n.x = d.x * invLen;
+        n.y = d.y * invLen;
+        n.z = d.z * invLen;
+    } else {
+        n.x = 1;
+        n.y = 0;
+        n.z = 0;
+    }
+
+    // If swapped, flip normal
+    if (detector->swapped) {
+        n.x = -n.x;
+        n.y = -n.y;
+        n.z = -n.z;
+    }
+
+    result->normal = n;
+
+    OimoVec3 pos1, pos2;
+    if (detector->swapped) {
+        // Normal points from capsule to sphere
+        pos1.x = cp2.x - n.x * r2;
+        pos1.y = cp2.y - n.y * r2;
+        pos1.z = cp2.z - n.z * r2;
+        pos2.x = cp1.x + n.x * r1;
+        pos2.y = cp1.y + n.y * r1;
+        pos2.z = cp1.z + n.z * r1;
+    } else {
+        // Normal points from sphere to capsule
+        pos1.x = cp1.x - n.x * r1;
+        pos1.y = cp1.y - n.y * r1;
+        pos1.z = cp1.z - n.z * r1;
+        pos2.x = cp2.x + n.x * r2;
+        pos2.y = cp2.y + n.y * r2;
+        pos2.z = cp2.z + n.z * r2;
+    }
+
+    oimo_detector_result_add_point(result, &pos1, &pos2, r1 + r2 - len, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_mesh_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_mesh_detector.h
new file mode 100644
index 0000000000..b35e4ab879
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_mesh_detector.h
@@ -0,0 +1,128 @@
+#pragma once
+
+// sphere_mesh_detector.h - Sphere vs Static Mesh collision detection (Optimized for N64)
+
+#include "detector.h"
+#include "detector_result.h"
+#include "triangle_util.h"
+#include "mesh_contact.h"
+#include "../geometry/sphere_geometry.h"
+#include "../geometry/static_mesh_geometry.h"
+#include "../broadphase/bvh.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoSphereMeshDetector {
+    OimoDetector base;
+} OimoSphereMeshDetector;
+
+static inline void oimo_sphere_mesh_detector_init(OimoSphereMeshDetector* detector, bool swapped) {
+    oimo_detector_init(&detector->base,
+        swapped ? OIMO_DETECTOR_MESH_SPHERE : OIMO_DETECTOR_SPHERE_MESH,
+        swapped);
+}
+
+// Detect sphere vs mesh collision (optimized single-pass)
+static inline void oimo_sphere_mesh_detector_detect(
+    OimoSphereMeshDetector* detector,
+    OimoDetectorResult* result,
+    const OimoSphereGeometry* sphere,
+    const OimoStaticMeshGeometry* mesh,
+    const OimoTransform* tf_sphere,
+    const OimoTransform* tf_mesh
+) {
+    result->incremental = false;
+
+    OimoScalar radius = sphere->radius;
+    float radius_sq = radius * radius;
+
+    // Transform sphere center to mesh local space
+    OimoVec3 sphere_world = tf_sphere->position;
+    OimoVec3 sphere_to_mesh = oimo_vec3_sub(sphere_world, tf_mesh->position);
+    OimoMat3 mesh_rot_inv = oimo_mat3_transpose(&tf_mesh->rotation);
+    OimoVec3 sphere_local = oimo_mat3_mul_vec3(&mesh_rot_inv, sphere_to_mesh);
+
+    // Build query AABB around sphere in mesh local space
+    OimoAabb query_aabb;
+    query_aabb.min.x = sphere_local.x - radius;
+    query_aabb.min.y = sphere_local.y - radius;
+    query_aabb.min.z = sphere_local.z - radius;
+    query_aabb.max.x = sphere_local.x + radius;
+    query_aabb.max.y = sphere_local.y + radius;
+    query_aabb.max.z = sphere_local.z + radius;
+
+    // Query BVH for overlapping triangles
+    OimoBvhQueryResult bvh_result;
+    oimo_static_mesh_query_triangles(mesh, &query_aabb, &bvh_result);
+
+    if (bvh_result.count == 0) return;
+
+    // Initialize contact storage
+    OimoMeshContactStorage storage;
+    oimo_mesh_contact_storage_init(&storage);
+
+    for (int i = 0; i < bvh_result.count; i++) {
+        int tri_idx = bvh_result.triangles[i];
+        const OimoTriangle* tri = oimo_static_mesh_get_triangle(mesh, tri_idx);
+        if (!tri) continue;
+
+        // EARLY OUT: Quick plane distance check
+        float plane_dist = oimo_point_plane_distance(&sphere_local, &tri->v0, &tri->normal);
+        if (plane_dist > radius || plane_dist < -radius) {
+            continue;  // Sphere too far from triangle plane
+        }
+
+        OimoVec3 closest = oimo_closest_point_on_triangle(
+            &sphere_local, &tri->v0, &tri->v1, &tri->v2
+        );
+
+        OimoVec3 diff = oimo_vec3_sub(sphere_local, closest);
+        float dist_sq = oimo_vec3_dot(diff, diff);
+
+        if (dist_sq < radius_sq) {
+            // Use fast inverse sqrt
+            float inv_dist = oimo_fast_inv_sqrt(dist_sq);
+            float dist = dist_sq * inv_dist;
+            float depth = radius - dist;
+
+            OimoVec3 normal_dir;
+            if (dist_sq > 1e-6f) {
+                normal_dir = oimo_vec3_scale(diff, inv_dist);
+            } else {
+                normal_dir = tri->normal;
+            }
+
+            oimo_mesh_contact_storage_add(&storage, &closest, &normal_dir, depth, tri_idx);
+        }
+    }
+
+    if (!storage.has_contact) return;
+
+    // Transform primary normal to world space and set it
+    OimoVec3 normal_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, storage.primary_normal);
+    oimo_detector_set_normal(&detector->base, result, &normal_world);
+
+    // Add all stored contacts
+    for (int i = 0; i < storage.count; i++) {
+        OimoMeshContact* c = &storage.contacts[i];
+
+        // Contact point on mesh (in world space)
+        OimoVec3 closest_world = oimo_mat3_mul_vec3(&tf_mesh->rotation, c->closest);
+        OimoVec3 mesh_contact = oimo_vec3_add(closest_world, tf_mesh->position);
+
+        // Contact point on sphere (in world space)
+        OimoVec3 sphere_contact_offset = oimo_vec3_scale(normal_world, -radius);
+        OimoVec3 sphere_contact = oimo_vec3_add(sphere_world, sphere_contact_offset);
+
+        oimo_detector_add_point(&detector->base, result, &sphere_contact, &mesh_contact,
+            c->depth, c->tri_idx);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_sphere_detector.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_sphere_detector.h
new file mode 100644
index 0000000000..63de85cdb0
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/sphere_sphere_detector.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "detector.h"
+#include "detector_result.h"
+#include "../geometry/sphere_geometry.h"
+#include "../../common/transform.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OimoSphereSphereDetector {
+    OimoDetector base;
+} OimoSphereSphereDetector;
+
+static inline void oimo_sphere_sphere_detector_init(OimoSphereSphereDetector* detector) {
+    oimo_detector_init(&detector->base, OIMO_DETECTOR_SPHERE_SPHERE, false);
+}
+
+static inline void oimo_sphere_sphere_detector_detect(
+    OimoSphereSphereDetector* detector,
+    OimoDetectorResult* result,
+    const OimoSphereGeometry* sphere1,
+    const OimoSphereGeometry* sphere2,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    result->incremental = false;
+
+    // Vector from sphere2 center to sphere1 center
+    OimoVec3 d;
+    oimo_vec3_sub_to(&d, &tf1->position, &tf2->position);
+
+    OimoScalar r1 = sphere1->radius;
+    OimoScalar r2 = sphere2->radius;
+    OimoScalar sum_radii = r1 + r2;
+
+    // Check if spheres are separated
+    OimoScalar len2 = oimo_vec3_dot(d, d);
+    if (len2 >= sum_radii * sum_radii) {
+        return;  // No collision
+    }
+
+    OimoScalar len = oimo_sqrt(len2);
+
+    // Compute contact normal
+    OimoVec3 n;
+    if (len > 0.0f) {
+        oimo_vec3_scale_to(&n, &d, 1.0f / len);
+    } else {
+        // Spheres are coincident, use arbitrary normal
+        oimo_vec3_set(&n, 1.0f, 0.0f, 0.0f);
+    }
+
+    // Set normal (from sphere2 to sphere1, but we want geom1 to geom2)
+    // OimoPhysics: normal points from geom1's contact point to geom2's
+    oimo_detector_set_normal(&detector->base, result, &n);
+
+    // Compute contact positions
+    // pos1 = center1 - normal * r1 (point on sphere1 surface)
+    // pos2 = center2 + normal * r2 (point on sphere2 surface)
+    OimoVec3 pos1, pos2;
+    OimoVec3 scaled_n;
+
+    oimo_vec3_scale_to(&scaled_n, &n, -r1);
+    oimo_vec3_add_to(&pos1, &tf1->position, &scaled_n);
+
+    oimo_vec3_scale_to(&scaled_n, &n, r2);
+    oimo_vec3_add_to(&pos2, &tf2->position, &scaled_n);
+
+    // Penetration depth
+    OimoScalar depth = sum_radii - len;
+
+    oimo_detector_add_point(&detector->base, result, &pos1, &pos2, depth, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/collision/narrowphase/triangle_util.h b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/triangle_util.h
new file mode 100644
index 0000000000..614e1df200
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/collision/narrowphase/triangle_util.h
@@ -0,0 +1,169 @@
+#pragma once
+
+// triangle_util.h - Shared triangle utility functions for mesh collision
+
+#include "../../common/vec3.h"
+#include "../../common/math_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Quick signed distance from point to triangle plane
+// Returns positive if on normal side, negative if behind
+static inline float oimo_point_plane_distance(
+    const OimoVec3* p,
+    const OimoVec3* tri_v0,
+    const OimoVec3* tri_normal
+) {
+    OimoVec3 to_point = oimo_vec3_sub(*p, *tri_v0);
+    return oimo_vec3_dot(to_point, *tri_normal);
+}
+
+// Closest point on line segment
+static inline OimoVec3 oimo_closest_point_on_segment(OimoVec3 p, OimoVec3 a, OimoVec3 b) {
+    OimoVec3 ab = oimo_vec3_sub(b, a);
+    OimoVec3 ap = oimo_vec3_sub(p, a);
+
+    float ab_len_sq = oimo_vec3_dot(ab, ab);
+    if (ab_len_sq < 1e-10f) return a;
+
+    float t = oimo_vec3_dot(ap, ab) / ab_len_sq;
+    if (t < 0.0f) t = 0.0f;
+    if (t > 1.0f) t = 1.0f;
+
+    return oimo_vec3_add(a, oimo_vec3_scale(ab, t));
+}
+
+// Closest points between two line segments
+static inline void oimo_closest_points_segments(
+    OimoVec3 p1, OimoVec3 p2, OimoVec3 p3, OimoVec3 p4,
+    OimoVec3* closest1, OimoVec3* closest2
+) {
+    OimoVec3 d1 = oimo_vec3_sub(p2, p1);
+    OimoVec3 d2 = oimo_vec3_sub(p4, p3);
+    OimoVec3 r = oimo_vec3_sub(p1, p3);
+
+    float a = oimo_vec3_dot(d1, d1);
+    float e = oimo_vec3_dot(d2, d2);
+    float f = oimo_vec3_dot(d2, r);
+
+    float s, t;
+
+    if (a <= 1e-6f && e <= 1e-6f) {
+        *closest1 = p1;
+        *closest2 = p3;
+        return;
+    }
+
+    if (a <= 1e-6f) {
+        s = 0.0f;
+        t = f / e;
+        if (t < 0.0f) t = 0.0f;
+        if (t > 1.0f) t = 1.0f;
+    } else {
+        float c = oimo_vec3_dot(d1, r);
+        if (e <= 1e-6f) {
+            t = 0.0f;
+            s = -c / a;
+            if (s < 0.0f) s = 0.0f;
+            if (s > 1.0f) s = 1.0f;
+        } else {
+            float b = oimo_vec3_dot(d1, d2);
+            float denom = a * e - b * b;
+
+            if (denom != 0.0f) {
+                s = (b * f - c * e) / denom;
+                if (s < 0.0f) s = 0.0f;
+                if (s > 1.0f) s = 1.0f;
+            } else {
+                s = 0.0f;
+            }
+
+            t = (b * s + f) / e;
+
+            if (t < 0.0f) {
+                t = 0.0f;
+                s = -c / a;
+                if (s < 0.0f) s = 0.0f;
+                if (s > 1.0f) s = 1.0f;
+            } else if (t > 1.0f) {
+                t = 1.0f;
+                s = (b - c) / a;
+                if (s < 0.0f) s = 0.0f;
+                if (s > 1.0f) s = 1.0f;
+            }
+        }
+    }
+
+    *closest1 = oimo_vec3_add(p1, oimo_vec3_scale(d1, s));
+    *closest2 = oimo_vec3_add(p3, oimo_vec3_scale(d2, t));
+}
+
+// Find closest point on triangle to a point (Barycentric method)
+static inline OimoVec3 oimo_closest_point_on_triangle(
+    const OimoVec3* p,
+    const OimoVec3* a,
+    const OimoVec3* b,
+    const OimoVec3* c
+) {
+    // Check if P in vertex region outside A
+    OimoVec3 ab = oimo_vec3_sub(*b, *a);
+    OimoVec3 ac = oimo_vec3_sub(*c, *a);
+    OimoVec3 ap = oimo_vec3_sub(*p, *a);
+
+    float d1 = oimo_vec3_dot(ab, ap);
+    float d2 = oimo_vec3_dot(ac, ap);
+    if (d1 <= 0.0f && d2 <= 0.0f) return *a;  // barycentric coordinates (1,0,0)
+
+    // Check if P in vertex region outside B
+    OimoVec3 bp = oimo_vec3_sub(*p, *b);
+    float d3 = oimo_vec3_dot(ab, bp);
+    float d4 = oimo_vec3_dot(ac, bp);
+    if (d3 >= 0.0f && d4 <= d3) return *b;  // barycentric coordinates (0,1,0)
+
+    // Check if P in edge region of AB
+    float vc = d1 * d4 - d3 * d2;
+    if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f) {
+        float v = d1 / (d1 - d3);
+        OimoVec3 scaled = oimo_vec3_scale(ab, v);
+        return oimo_vec3_add(*a, scaled);
+    }
+
+    // Check if P in vertex region outside C
+    OimoVec3 cp = oimo_vec3_sub(*p, *c);
+    float d5 = oimo_vec3_dot(ab, cp);
+    float d6 = oimo_vec3_dot(ac, cp);
+    if (d6 >= 0.0f && d5 <= d6) return *c;  // barycentric coordinates (0,0,1)
+
+    // Check if P in edge region of AC
+    float vb = d5 * d2 - d1 * d6;
+    if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f) {
+        float w = d2 / (d2 - d6);
+        OimoVec3 scaled = oimo_vec3_scale(ac, w);
+        return oimo_vec3_add(*a, scaled);
+    }
+
+    // Check if P in edge region of BC
+    float va = d3 * d6 - d5 * d4;
+    if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f) {
+        float w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+        OimoVec3 bc = oimo_vec3_sub(*c, *b);
+        OimoVec3 scaled = oimo_vec3_scale(bc, w);
+        return oimo_vec3_add(*b, scaled);
+    }
+
+    // P inside face region
+    float denom = 1.0f / (va + vb + vc);
+    float v = vb * denom;
+    float w = vc * denom;
+
+    OimoVec3 ab_scaled = oimo_vec3_scale(ab, v);
+    OimoVec3 ac_scaled = oimo_vec3_scale(ac, w);
+    OimoVec3 result = oimo_vec3_add(*a, ab_scaled);
+    return oimo_vec3_add(result, ac_scaled);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armorcore/Deployment/n64/src/oimo/common/mat3.h b/armorcore/Deployment/n64/src/oimo/common/mat3.h
new file mode 100644
index 0000000000..37142a9825
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/mat3.h
@@ -0,0 +1,296 @@
+#pragma once
+
+#include "setting.h"
+#include "math_util.h"
+#include "vec3.h"
+
+struct OimoQuat;
+
+typedef struct OimoMat3 {
+    OimoScalar e00, e01, e02;
+    OimoScalar e10, e11, e12;
+    OimoScalar e20, e21, e22;
+} OimoMat3;
+
+static inline OimoMat3 oimo_mat3_identity(void) {
+    return (OimoMat3){
+        1, 0, 0,
+        0, 1, 0,
+        0, 0, 1
+    };
+}
+
+// Create zero matrix
+static inline OimoMat3 oimo_mat3_zero(void) {
+    return (OimoMat3){
+        0, 0, 0,
+        0, 0, 0,
+        0, 0, 0
+    };
+}
+
+// Create matrix with explicit elements
+static inline OimoMat3 oimo_mat3(
+    OimoScalar e00, OimoScalar e01, OimoScalar e02,
+    OimoScalar e10, OimoScalar e11, OimoScalar e12,
+    OimoScalar e20, OimoScalar e21, OimoScalar e22
+) {
+    return (OimoMat3){
+        e00, e01, e02,
+        e10, e11, e12,
+        e20, e21, e22
+    };
+}
+
+// Copy matrix
+static inline OimoMat3 oimo_mat3_copy(const OimoMat3* m) {
+    return (OimoMat3){
+        m->e00, m->e01, m->e02,
+        m->e10, m->e11, m->e12,
+        m->e20, m->e21, m->e22
+    };
+}
+
+static inline OimoMat3 oimo_mat3_add(const OimoMat3* m1, const OimoMat3* m2) {
+    return (OimoMat3){
+        m1->e00 + m2->e00, m1->e01 + m2->e01, m1->e02 + m2->e02,
+        m1->e10 + m2->e10, m1->e11 + m2->e11, m1->e12 + m2->e12,
+        m1->e20 + m2->e20, m1->e21 + m2->e21, m1->e22 + m2->e22
+    };
+}
+
+// m1 - m2
+static inline OimoMat3 oimo_mat3_sub(const OimoMat3* m1, const OimoMat3* m2) {
+    return (OimoMat3){
+        m1->e00 - m2->e00, m1->e01 - m2->e01, m1->e02 - m2->e02,
+        m1->e10 - m2->e10, m1->e11 - m2->e11, m1->e12 - m2->e12,
+        m1->e20 - m2->e20, m1->e21 - m2->e21, m1->e22 - m2->e22
+    };
+}
+
+// m * s (scalar multiplication)
+static inline OimoMat3 oimo_mat3_scale(const OimoMat3* m, OimoScalar s) {
+    return (OimoMat3){
+        m->e00 * s, m->e01 * s, m->e02 * s,
+        m->e10 * s, m->e11 * s, m->e12 * s,
+        m->e20 * s, m->e21 * s, m->e22 * s
+    };
+}
+
+// m1 * m2 (matrix multiplication)
+static inline OimoMat3 oimo_mat3_mul(const OimoMat3* m1, const OimoMat3* m2) {
+    return (OimoMat3){
+        m1->e00 * m2->e00 + m1->e01 * m2->e10 + m1->e02 * m2->e20,
+        m1->e00 * m2->e01 + m1->e01 * m2->e11 + m1->e02 * m2->e21,
+        m1->e00 * m2->e02 + m1->e01 * m2->e12 + m1->e02 * m2->e22,
+
+        m1->e10 * m2->e00 + m1->e11 * m2->e10 + m1->e12 * m2->e20,
+        m1->e10 * m2->e01 + m1->e11 * m2->e11 + m1->e12 * m2->e21,
+        m1->e10 * m2->e02 + m1->e11 * m2->e12 + m1->e12 * m2->e22,
+
+        m1->e20 * m2->e00 + m1->e21 * m2->e10 + m1->e22 * m2->e20,
+        m1->e20 * m2->e01 + m1->e21 * m2->e11 + m1->e22 * m2->e21,
+        m1->e20 * m2->e02 + m1->e21 * m2->e12 + m1->e22 * m2->e22
+    };
+}
+
+static inline OimoVec3 oimo_mat3_mul_vec3(const OimoMat3* m, OimoVec3 v) {
+    return (OimoVec3){
+        m->e00 * v.x + m->e01 * v.y + m->e02 * v.z,
+        m->e10 * v.x + m->e11 * v.y + m->e12 * v.z,
+        m->e20 * v.x + m->e21 * v.y + m->e22 * v.z
+    };
+}
+
+// m^T * v (transform vector by transposed matrix)
+static inline OimoVec3 oimo_mat3_tmul_vec3(const OimoMat3* m, OimoVec3 v) {
+    return (OimoVec3){
+        m->e00 * v.x + m->e10 * v.y + m->e20 * v.z,
+        m->e01 * v.x + m->e11 * v.y + m->e21 * v.z,
+        m->e02 * v.x + m->e12 * v.y + m->e22 * v.z
+    };
+}
+
+static inline OimoVec3 oimo_mat3_get_row(const OimoMat3* m, int i) {
+    switch (i) {
+        case 0: return (OimoVec3){ m->e00, m->e01, m->e02 };
+        case 1: return (OimoVec3){ m->e10, m->e11, m->e12 };
+        case 2: return (OimoVec3){ m->e20, m->e21, m->e22 };
+        default: return (OimoVec3){ 0, 0, 0 };
+    }
+}
+
+// Get column i as vector
+static inline OimoVec3 oimo_mat3_get_col(const OimoMat3* m, int i) {
+    switch (i) {
+        case 0: return (OimoVec3){ m->e00, m->e10, m->e20 };
+        case 1: return (OimoVec3){ m->e01, m->e11, m->e21 };
+        case 2: return (OimoVec3){ m->e02, m->e12, m->e22 };
+        default: return (OimoVec3){ 0, 0, 0 };
+    }
+}
+
+// Set row i from vector
+static inline void oimo_mat3_set_row(OimoMat3* m, int i, const OimoVec3* v) {
+    switch (i) {
+        case 0: m->e00 = v->x; m->e01 = v->y; m->e02 = v->z; break;
+        case 1: m->e10 = v->x; m->e11 = v->y; m->e12 = v->z; break;
+        case 2: m->e20 = v->x; m->e21 = v->y; m->e22 = v->z; break;
+    }
+}
+
+// Set column i from vector
+static inline void oimo_mat3_set_col(OimoMat3* m, int i, const OimoVec3* v) {
+    switch (i) {
+        case 0: m->e00 = v->x; m->e10 = v->y; m->e20 = v->z; break;
+        case 1: m->e01 = v->x; m->e11 = v->y; m->e21 = v->z; break;
+        case 2: m->e02 = v->x; m->e12 = v->y; m->e22 = v->z; break;
+    }
+}
+
+// Create matrix from column vectors
+static inline OimoMat3 oimo_mat3_from_cols(const OimoVec3* c0, const OimoVec3* c1, const OimoVec3* c2) {
+    return (OimoMat3){
+        c0->x, c1->x, c2->x,
+        c0->y, c1->y, c2->y,
+        c0->z, c1->z, c2->z
+    };
+}
+
+// Create matrix from row vectors
+static inline OimoMat3 oimo_mat3_from_rows(const OimoVec3* r0, const OimoVec3* r1, const OimoVec3* r2) {
+    return (OimoMat3){
+        r0->x, r0->y, r0->z,
+        r1->x, r1->y, r1->z,
+        r2->x, r2->y, r2->z
+    };
+}
+
+static inline OimoMat3 oimo_mat3_transpose(const OimoMat3* m) {
+    return (OimoMat3){
+        m->e00, m->e10, m->e20,
+        m->e01, m->e11, m->e21,
+        m->e02, m->e12, m->e22
+    };
+}
+
+// Determinant
+static inline OimoScalar oimo_mat3_determinant(const OimoMat3* m) {
+    return m->e00 * (m->e11 * m->e22 - m->e12 * m->e21)
+         - m->e01 * (m->e10 * m->e22 - m->e12 * m->e20)
+         + m->e02 * (m->e10 * m->e21 - m->e11 * m->e20);
+}
+
+// Trace
+static inline OimoScalar oimo_mat3_trace(const OimoMat3* m) {
+    return m->e00 + m->e11 + m->e22;
+}
+
+// Inverse (returns zero matrix if determinant is zero)
+static inline OimoMat3 oimo_mat3_inverse(const OimoMat3* m) {
+    OimoScalar d00 = m->e11 * m->e22 - m->e12 * m->e21;
+    OimoScalar d01 = m->e10 * m->e22 - m->e12 * m->e20;
+    OimoScalar d02 = m->e10 * m->e21 - m->e11 * m->e20;
+    OimoScalar d10 = m->e01 * m->e22 - m->e02 * m->e21;
+    OimoScalar d11 = m->e00 * m->e22 - m->e02 * m->e20;
+    OimoScalar d12 = m->e00 * m->e21 - m->e01 * m->e20;
+    OimoScalar d20 = m->e01 * m->e12 - m->e02 * m->e11;
+    OimoScalar d21 = m->e00 * m->e12 - m->e02 * m->e10;
+    OimoScalar d22 = m->e00 * m->e11 - m->e01 * m->e10;
+
+    OimoScalar det = m->e00 * d00 - m->e01 * d01 + m->e02 * d02;
+    OimoScalar inv_det = (oimo_abs(det) > OIMO_EPSILON) ? (1.0f / det) : 0;
+
+    return (OimoMat3){
+         d00 * inv_det, -d10 * inv_det,  d20 * inv_det,
+        -d01 * inv_det,  d11 * inv_det, -d21 * inv_det,
+         d02 * inv_det, -d12 * inv_det,  d22 * inv_det
+    };
+}
+
+static inline OimoMat3 oimo_mat3_prepend_scale(const OimoMat3* m, OimoScalar sx, OimoScalar sy, OimoScalar sz) {
+    return (OimoMat3){
+        m->e00 * sx, m->e01 * sx, m->e02 * sx,
+        m->e10 * sy, m->e11 * sy, m->e12 * sy,
+        m->e20 * sz, m->e21 * sz, m->e22 * sz
+    };
+}
+
+// append scale: m * scaling_matrix
+static inline OimoMat3 oimo_mat3_append_scale(const OimoMat3* m, OimoScalar sx, OimoScalar sy, OimoScalar sz) {
+    return (OimoMat3){
+        m->e00 * sx, m->e01 * sy, m->e02 * sz,
+        m->e10 * sx, m->e11 * sy, m->e12 * sz,
+        m->e20 * sx, m->e21 * sy, m->e22 * sz
+    };
+}
+
+static inline OimoMat3 oimo_mat3_from_axis_angle(OimoScalar rad, OimoScalar ax, OimoScalar ay, OimoScalar az) {
+    OimoScalar s = oimo_sin(rad);
+    OimoScalar c = oimo_cos(rad);
+    OimoScalar c1 = 1.0f - c;
+
+    return (OimoMat3){
+        ax * ax * c1 + c,      ax * ay * c1 - az * s, ax * az * c1 + ay * s,
+        ay * ax * c1 + az * s, ay * ay * c1 + c,      ay * az * c1 - ax * s,
+        az * ax * c1 - ay * s, az * ay * c1 + ax * s, az * az * c1 + c
+    };
+}
+
+// Create rotation matrix from Euler angles (XYZ order)
+static inline OimoMat3 oimo_mat3_from_euler_xyz(OimoScalar rx, OimoScalar ry, OimoScalar rz) {
+    OimoScalar sx = oimo_sin(rx), cx = oimo_cos(rx);
+    OimoScalar sy = oimo_sin(ry), cy = oimo_cos(ry);
+    OimoScalar sz = oimo_sin(rz), cz = oimo_cos(rz);
+
+    return (OimoMat3){
+        cy * cz,                -cy * sz,                 sy,
+        cx * sz + cz * sx * sy,  cx * cz - sx * sy * sz, -cy * sx,
+        sx * sz - cx * cz * sy,  cz * sx + cx * sy * sz,  cx * cy
+    };
+}
+
+static inline void oimo_mat3_set_identity(OimoMat3* m) {
+    m->e00 = 1; m->e01 = 0; m->e02 = 0;
+    m->e10 = 0; m->e11 = 1; m->e12 = 0;
+    m->e20 = 0; m->e21 = 0; m->e22 = 1;
+}
+
+// Copy from another matrix
+static inline void oimo_mat3_copy_to(OimoMat3* dst, const OimoMat3* src) {
+    dst->e00 = src->e00; dst->e01 = src->e01; dst->e02 = src->e02;
+    dst->e10 = src->e10; dst->e11 = src->e11; dst->e12 = src->e12;
+    dst->e20 = src->e20; dst->e21 = src->e21; dst->e22 = src->e22;
+}
+
+// m1 = m1 + m2
+static inline void oimo_mat3_add_eq(OimoMat3* m1, const OimoMat3* m2) {
+    m1->e00 += m2->e00; m1->e01 += m2->e01; m1->e02 += m2->e02;
+    m1->e10 += m2->e10; m1->e11 += m2->e11; m1->e12 += m2->e12;
+    m1->e20 += m2->e20; m1->e21 += m2->e21; m1->e22 += m2->e22;
+}
+
+// m = m * s
+static inline void oimo_mat3_scale_eq(OimoMat3* m, OimoScalar s) {
+    m->e00 *= s; m->e01 *= s; m->e02 *= s;
+    m->e10 *= s; m->e11 *= s; m->e12 *= s;
+    m->e20 *= s; m->e21 *= s; m->e22 *= s;
+}
+
+// Transpose in-place
+static inline void oimo_mat3_transpose_eq(OimoMat3* m) {
+    OimoScalar t;
+    t = m->e01; m->e01 = m->e10; m->e10 = t;
+    t = m->e02; m->e02 = m->e20; m->e20 = t;
+    t = m->e12; m->e12 = m->e21; m->e21 = t;
+}
+
+// Create diagonal matrix
+static inline OimoMat3 oimo_mat3_diagonal(OimoScalar d00, OimoScalar d11, OimoScalar d22) {
+    return (OimoMat3){
+        d00, 0, 0,
+        0, d11, 0,
+        0, 0, d22
+    };
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/common/math_util.h b/armorcore/Deployment/n64/src/oimo/common/math_util.h
new file mode 100644
index 0000000000..5fa32eb69f
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/math_util.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "setting.h"
+#include <libdragon.h>
+#include <math.h>
+
+#define OIMO_PI         3.14159265358979f
+#define OIMO_TWO_PI     6.28318530717958f
+#define OIMO_HALF_PI    1.57079632679490f
+#define OIMO_TO_RADIANS 0.01745329251994f   // PI / 180
+#define OIMO_TO_DEGREES 57.2957795130823f   // 180 / PI
+
+static inline OimoScalar oimo_abs(OimoScalar x) {
+    return x > 0 ? x : -x;
+}
+
+static inline OimoScalar oimo_min(OimoScalar a, OimoScalar b) {
+    return a < b ? a : b;
+}
+
+static inline OimoScalar oimo_max(OimoScalar a, OimoScalar b) {
+    return a > b ? a : b;
+}
+
+static inline OimoScalar oimo_clamp(OimoScalar x, OimoScalar min_val, OimoScalar max_val) {
+    return x < min_val ? min_val : (x > max_val ? max_val : x);
+}
+
+static inline OimoScalar oimo_sqrt(OimoScalar x) {
+    return sqrtf(x);
+}
+
+static inline OimoScalar oimo_sin(OimoScalar x) {
+    return fm_sinf(x);
+}
+
+static inline OimoScalar oimo_cos(OimoScalar x) {
+    return fm_cosf(x);
+}
+
+static inline OimoScalar oimo_tan(OimoScalar x) {
+    return tanf(x);
+}
+
+static inline OimoScalar oimo_asin(OimoScalar x) {
+    return asinf(x);  // No fastmath version available
+}
+
+static inline OimoScalar oimo_acos(OimoScalar x) {
+    return acosf(x);  // No fastmath version available
+}
+
+static inline OimoScalar oimo_atan(OimoScalar x) {
+    return atanf(x);  // No fastmath version available
+}
+
+static inline OimoScalar oimo_atan2(OimoScalar y, OimoScalar x) {
+    return fm_atan2f(y, x);
+}
+
+// Returns asin(clamp(x, -1, 1)) - never returns NaN
+static inline OimoScalar oimo_safe_asin(OimoScalar x) {
+    if (x <= -1.0f) return -OIMO_HALF_PI;
+    if (x >= 1.0f) return OIMO_HALF_PI;
+    return asinf(x);
+}
+
+// Returns acos(clamp(x, -1, 1)) - never returns NaN
+static inline OimoScalar oimo_safe_acos(OimoScalar x) {
+    if (x <= -1.0f) return OIMO_PI;
+    if (x >= 1.0f) return 0.0f;
+    return acosf(x);
+}
+
+// Inverse square root (1 / sqrt(x))
+static inline OimoScalar oimo_inv_sqrt(OimoScalar x) {
+    if (x <= 0) return 0;
+    return 1.0f / oimo_sqrt(x);
+}
+
+// Sign function: returns -1, 0, or 1
+static inline int oimo_sign(OimoScalar x) {
+    if (x > 0) return 1;
+    if (x < 0) return -1;
+    return 0;
+}
+
+// Linear interpolation
+static inline OimoScalar oimo_lerp(OimoScalar a, OimoScalar b, OimoScalar t) {
+    return a + (b - a) * t;
+}
+
+// Fast inverse square root (Quake III style) - useful for normalizing vectors
+// Avoids expensive division and sqrt on N64
+// Uses union to avoid strict-aliasing violations
+static inline float oimo_fast_inv_sqrt(float x) {
+    union { float f; int i; } conv;
+    float xhalf = 0.5f * x;
+    conv.f = x;
+    conv.i = 0x5f375a86 - (conv.i >> 1);  // Magic number for float
+    conv.f = conv.f * (1.5f - xhalf * conv.f * conv.f);  // One Newton-Raphson iteration
+    return conv.f;
+}
+
+// Fast approximate sqrt using fast_inv_sqrt
+static inline float oimo_fast_sqrt(float x) {
+    if (x <= 0.0f) return 0.0f;
+    return x * oimo_fast_inv_sqrt(x);
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/common/quat.h b/armorcore/Deployment/n64/src/oimo/common/quat.h
new file mode 100644
index 0000000000..29dba87971
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/quat.h
@@ -0,0 +1,316 @@
+#pragma once
+
+#include "setting.h"
+#include "math_util.h"
+#include "vec3.h"
+#include "mat3.h"
+
+typedef struct OimoQuat {
+    OimoScalar x, y, z, w;
+} OimoQuat;
+
+static inline OimoQuat oimo_quat_identity(void) {
+    return (OimoQuat){ 0, 0, 0, 1 };
+}
+
+static inline OimoQuat oimo_quat(OimoScalar x, OimoScalar y, OimoScalar z, OimoScalar w) {
+    return (OimoQuat){ x, y, z, w };
+}
+
+static inline OimoQuat oimo_quat_copy(const OimoQuat* q) {
+    return (OimoQuat){ q->x, q->y, q->z, q->w };
+}
+
+static inline OimoQuat oimo_quat_add(const OimoQuat* q1, const OimoQuat* q2) {
+    return (OimoQuat){ q1->x + q2->x, q1->y + q2->y, q1->z + q2->z, q1->w + q2->w };
+}
+
+static inline OimoQuat oimo_quat_sub(const OimoQuat* q1, const OimoQuat* q2) {
+    return (OimoQuat){ q1->x - q2->x, q1->y - q2->y, q1->z - q2->z, q1->w - q2->w };
+}
+
+static inline OimoQuat oimo_quat_scale(const OimoQuat* q, OimoScalar s) {
+    return (OimoQuat){ q->x * s, q->y * s, q->z * s, q->w * s };
+}
+
+static inline OimoQuat oimo_quat_neg(const OimoQuat* q) {
+    return (OimoQuat){ -q->x, -q->y, -q->z, -q->w };
+}
+
+static inline OimoQuat oimo_quat_conjugate(const OimoQuat* q) {
+    return (OimoQuat){ -q->x, -q->y, -q->z, q->w };
+}
+
+static inline OimoScalar oimo_quat_dot(const OimoQuat* q1, const OimoQuat* q2) {
+    return q1->x * q2->x + q1->y * q2->y + q1->z * q2->z + q1->w * q2->w;
+}
+
+static inline OimoQuat oimo_quat_mul(const OimoQuat* q1, const OimoQuat* q2) {
+    return (OimoQuat){
+        q1->w * q2->x + q1->x * q2->w + q1->y * q2->z - q1->z * q2->y,
+        q1->w * q2->y - q1->x * q2->z + q1->y * q2->w + q1->z * q2->x,
+        q1->w * q2->z + q1->x * q2->y - q1->y * q2->x + q1->z * q2->w,
+        q1->w * q2->w - q1->x * q2->x - q1->y * q2->y - q1->z * q2->z
+    };
+}
+
+// Squared length: |q|²
+static inline OimoScalar oimo_quat_len_sq(const OimoQuat* q) {
+    return q->x * q->x + q->y * q->y + q->z * q->z + q->w * q->w;
+}
+
+// Length: |q|
+static inline OimoScalar oimo_quat_len(const OimoQuat* q) {
+    return oimo_sqrt(q->x * q->x + q->y * q->y + q->z * q->z + q->w * q->w);
+}
+
+// Normalize: q / |q| (returns identity if length is zero)
+static inline OimoQuat oimo_quat_normalize(const OimoQuat* q) {
+    OimoScalar len = oimo_quat_len(q);
+    if (len > 0) {
+        OimoScalar inv_len = 1.0f / len;
+        return (OimoQuat){ q->x * inv_len, q->y * inv_len, q->z * inv_len, q->w * inv_len };
+    }
+    return (OimoQuat){ 0, 0, 0, 1 };
+}
+
+static inline OimoMat3 oimo_quat_to_mat3(const OimoQuat* q) {
+    OimoScalar x = q->x, y = q->y, z = q->z, w = q->w;
+    OimoScalar x2 = 2 * x, y2 = 2 * y, z2 = 2 * z;
+    OimoScalar xx = x * x2, yy = y * y2, zz = z * z2;
+    OimoScalar xy = x * y2, yz = y * z2, xz = x * z2;
+    OimoScalar wx = w * x2, wy = w * y2, wz = w * z2;
+
+    return (OimoMat3){
+        1 - yy - zz, xy - wz,     xz + wy,
+        xy + wz,     1 - xx - zz, yz - wx,
+        xz - wy,     yz + wx,     1 - xx - yy
+    };
+}
+
+// Convert rotation matrix to quaternion
+// Matrix must be a rotation matrix (orthogonal with determinant 1)
+static inline OimoQuat oimo_mat3_to_quat(const OimoMat3* m) {
+    OimoScalar e00 = m->e00, e11 = m->e11, e22 = m->e22;
+    OimoScalar t = e00 + e11 + e22;
+    OimoScalar s;
+    OimoQuat q;
+
+    if (t > 0) {
+        s = oimo_sqrt(t + 1);
+        q.w = 0.5f * s;
+        s = 0.5f / s;
+        q.x = (m->e21 - m->e12) * s;
+        q.y = (m->e02 - m->e20) * s;
+        q.z = (m->e10 - m->e01) * s;
+    } else if (e00 >= e11 && e00 >= e22) {
+        // e00 is the largest diagonal element
+        s = oimo_sqrt(e00 - e11 - e22 + 1);
+        q.x = 0.5f * s;
+        s = 0.5f / s;
+        q.y = (m->e01 + m->e10) * s;
+        q.z = (m->e02 + m->e20) * s;
+        q.w = (m->e21 - m->e12) * s;
+    } else if (e11 >= e22) {
+        // e11 is the largest diagonal element
+        s = oimo_sqrt(e11 - e22 - e00 + 1);
+        q.y = 0.5f * s;
+        s = 0.5f / s;
+        q.x = (m->e01 + m->e10) * s;
+        q.z = (m->e12 + m->e21) * s;
+        q.w = (m->e02 - m->e20) * s;
+    } else {
+        // e22 is the largest diagonal element
+        s = oimo_sqrt(e22 - e00 - e11 + 1);
+        q.z = 0.5f * s;
+        s = 0.5f / s;
+        q.x = (m->e02 + m->e20) * s;
+        q.y = (m->e12 + m->e21) * s;
+        q.w = (m->e10 - m->e01) * s;
+    }
+
+    return q;
+}
+
+// Set Mat3 from quaternion (in-place)
+static inline void oimo_mat3_from_quat(OimoMat3* m, const OimoQuat* q) {
+    OimoScalar x = q->x, y = q->y, z = q->z, w = q->w;
+    OimoScalar x2 = 2 * x, y2 = 2 * y, z2 = 2 * z;
+    OimoScalar xx = x * x2, yy = y * y2, zz = z * z2;
+    OimoScalar xy = x * y2, yz = y * z2, xz = x * z2;
+    OimoScalar wx = w * x2, wy = w * y2, wz = w * z2;
+
+    m->e00 = 1 - yy - zz; m->e01 = xy - wz;     m->e02 = xz + wy;
+    m->e10 = xy + wz;     m->e11 = 1 - xx - zz; m->e12 = yz - wx;
+    m->e20 = xz - wy;     m->e21 = yz + wx;     m->e22 = 1 - xx - yy;
+}
+
+static inline OimoQuat oimo_quat_from_axis_angle(const OimoVec3* axis, OimoScalar angle) {
+    OimoScalar half_angle = angle * 0.5f;
+    OimoScalar s = oimo_sin(half_angle);
+    return (OimoQuat){
+        axis->x * s,
+        axis->y * s,
+        axis->z * s,
+        oimo_cos(half_angle)
+    };
+}
+
+// Extract axis-angle from quaternion
+// angle is returned, axis is written to out_axis
+static inline OimoScalar oimo_quat_to_axis_angle(const OimoQuat* q, OimoVec3* out_axis) {
+    OimoScalar sin_half_sq = q->x * q->x + q->y * q->y + q->z * q->z;
+
+    if (sin_half_sq <= OIMO_EPSILON * OIMO_EPSILON) {
+        // Near identity, return arbitrary axis
+        out_axis->x = 1;
+        out_axis->y = 0;
+        out_axis->z = 0;
+        return 0;
+    }
+
+    OimoScalar sin_half = oimo_sqrt(sin_half_sq);
+    OimoScalar inv_sin = 1.0f / sin_half;
+    out_axis->x = q->x * inv_sin;
+    out_axis->y = q->y * inv_sin;
+    out_axis->z = q->z * inv_sin;
+
+    return 2.0f * oimo_atan2(sin_half, q->w);
+}
+
+static inline OimoQuat oimo_quat_set_arc(const OimoVec3* v1, const OimoVec3* v2) {
+    OimoScalar d = oimo_vec3_dot(*v1, *v2);
+    OimoQuat q;
+
+    q.w = oimo_sqrt((1.0f + d) * 0.5f);
+
+    if (q.w < OIMO_EPSILON) {
+        // Vectors are opposite, need perpendicular axis
+        OimoScalar x2 = v1->x * v1->x;
+        OimoScalar y2 = v1->y * v1->y;
+        OimoScalar z2 = v1->z * v1->z;
+        OimoScalar inv_len;
+
+        if (x2 <= y2 && x2 <= z2) {
+            // x is smallest, use x-axis
+            inv_len = 1.0f / oimo_sqrt(y2 + z2);
+            q.x = 0;
+            q.y = v1->z * inv_len;
+            q.z = -v1->y * inv_len;
+        } else if (y2 <= z2) {
+            // y is smallest, use y-axis
+            inv_len = 1.0f / oimo_sqrt(z2 + x2);
+            q.y = 0;
+            q.z = v1->x * inv_len;
+            q.x = -v1->z * inv_len;
+        } else {
+            // z is smallest, use z-axis
+            inv_len = 1.0f / oimo_sqrt(x2 + y2);
+            q.z = 0;
+            q.x = v1->y * inv_len;
+            q.y = -v1->x * inv_len;
+        }
+        q.w = 0;
+        return q;
+    }
+
+    // Normal case: sin(theta/2) / sin(theta) = 1 / (2 * cos(theta/2))
+    OimoScalar s = 0.5f / q.w;
+    OimoVec3 cross = oimo_vec3_cross(*v1, *v2);
+    q.x = cross.x * s;
+    q.y = cross.y * s;
+    q.z = cross.z * s;
+
+    return q;
+}
+
+static inline OimoQuat oimo_quat_slerp(const OimoQuat* q1, const OimoQuat* q2, OimoScalar t) {
+    OimoScalar qx = q2->x, qy = q2->y, qz = q2->z, qw = q2->w;
+    OimoScalar d = oimo_quat_dot(q1, q2);
+
+    // If dot is negative, negate one quaternion to take shorter path
+    if (d < 0) {
+        d = -d;
+        qx = -qx;
+        qy = -qy;
+        qz = -qz;
+        qw = -qw;
+    }
+
+    // If quaternions are very close, use linear interpolation
+    if (d > 1.0f - OIMO_EPSILON) {
+        OimoQuat result = {
+            q1->x + (qx - q1->x) * t,
+            q1->y + (qy - q1->y) * t,
+            q1->z + (qz - q1->z) * t,
+            q1->w + (qw - q1->w) * t
+        };
+        return oimo_quat_normalize(&result);
+    }
+
+    // Target angle
+    OimoScalar theta = t * oimo_acos(d);
+
+    // Make q orthogonal to q1
+    qx -= q1->x * d;
+    qy -= q1->y * d;
+    qz -= q1->z * d;
+    qw -= q1->w * d;
+    OimoScalar inv_len = 1.0f / oimo_sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
+    qx *= inv_len;
+    qy *= inv_len;
+    qz *= inv_len;
+    qw *= inv_len;
+
+    // Mix them
+    OimoScalar sin_theta = oimo_sin(theta);
+    OimoScalar cos_theta = oimo_cos(theta);
+
+    return (OimoQuat){
+        q1->x * cos_theta + qx * sin_theta,
+        q1->y * cos_theta + qy * sin_theta,
+        q1->z * cos_theta + qz * sin_theta,
+        q1->w * cos_theta + qw * sin_theta
+    };
+}
+
+static inline void oimo_quat_set_identity(OimoQuat* q) {
+    q->x = 0; q->y = 0; q->z = 0; q->w = 1;
+}
+
+// Copy from another quaternion
+static inline void oimo_quat_copy_to(OimoQuat* dst, const OimoQuat* src) {
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->z = src->z;
+    dst->w = src->w;
+}
+
+// Normalize in-place
+static inline void oimo_quat_normalize_eq(OimoQuat* q) {
+    OimoScalar len = oimo_quat_len(q);
+    if (len > 0) {
+        OimoScalar inv_len = 1.0f / len;
+        q->x *= inv_len;
+        q->y *= inv_len;
+        q->z *= inv_len;
+        q->w *= inv_len;
+    } else {
+        q->x = 0; q->y = 0; q->z = 0; q->w = 1;
+    }
+}
+
+static inline OimoVec3 oimo_quat_rotate_vec3(const OimoQuat* q, const OimoVec3* v) {
+    // Using the formula: v' = v + 2*w*(qv × v) + 2*(qv × (qv × v))
+    // where qv = (x, y, z) is the vector part of quaternion
+    OimoVec3 qv = { q->x, q->y, q->z };
+    OimoVec3 uv = oimo_vec3_cross(qv, *v);
+    OimoVec3 uuv = oimo_vec3_cross(qv, uv);
+
+    return (OimoVec3){
+        v->x + 2.0f * (q->w * uv.x + uuv.x),
+        v->y + 2.0f * (q->w * uv.y + uuv.y),
+        v->z + 2.0f * (q->w * uv.z + uuv.z)
+    };
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/common/setting.h b/armorcore/Deployment/n64/src/oimo/common/setting.h
new file mode 100644
index 0000000000..1bd8c60658
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/setting.h
@@ -0,0 +1,42 @@
+#pragma once
+
+// Using float with libdragon fastmath. Can be changed to fixed-point later.
+typedef float OimoScalar;
+
+#define OIMO_DEFAULT_FRICTION       0.2f
+#define OIMO_DEFAULT_RESTITUTION    0.2f
+#define OIMO_DEFAULT_DENSITY        1.0f
+#define OIMO_DEFAULT_COLLISION_GROUP 1
+#define OIMO_DEFAULT_COLLISION_MASK  1
+
+#define OIMO_MAX_TRANSLATION_PER_STEP  20.0f
+#define OIMO_MAX_ROTATION_PER_STEP     3.14159265358979f  // PI
+
+#define OIMO_BVH_PROXY_PADDING                     0.1f
+#define OIMO_BVH_INCREMENTAL_COLLISION_THRESHOLD   0.45f
+
+#define OIMO_CONTACT_ENABLE_BOUNCE_THRESHOLD       0.5f
+#define OIMO_VELOCITY_BAUMGARTE                    0.2f
+#define OIMO_POSITION_SPLIT_IMPULSE_BAUMGARTE      0.4f
+#define OIMO_POSITION_NGS_BAUMGARTE                1.0f
+
+#define OIMO_CONTACT_USE_ALT_POS_CORRECTION_DEPTH_THRESHOLD  0.05f
+#define OIMO_CONTACT_PERSISTENCE_THRESHOLD         0.05f
+#define OIMO_MAX_MANIFOLD_POINTS                   4
+
+#define OIMO_SLEEPING_VELOCITY_THRESHOLD           0.2f
+#define OIMO_SLEEPING_ANGULAR_VELOCITY_THRESHOLD   0.5f
+#define OIMO_SLEEPING_TIME_THRESHOLD               1.0f
+#define OIMO_DISABLE_SLEEPING                      0  // 0 = false, 1 = true
+
+#define OIMO_LINEAR_SLOP           0.005f
+#define OIMO_ANGULAR_SLOP          0.01745329251f  // 1 degree in radians
+
+#define OIMO_EPSILON               1e-6f
+#define OIMO_POSITIVE_INFINITY     1e30f
+#define OIMO_NEGATIVE_INFINITY     (-1e30f)
+
+#define OIMO_DEFAULT_GRAVITY_X     0.0f
+#define OIMO_DEFAULT_GRAVITY_Y     -9.80665f
+#define OIMO_DEFAULT_GRAVITY_Z     0.0f
+
diff --git a/armorcore/Deployment/n64/src/oimo/common/transform.h b/armorcore/Deployment/n64/src/oimo/common/transform.h
new file mode 100644
index 0000000000..9909cc88b8
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/transform.h
@@ -0,0 +1,183 @@
+#pragma once
+
+#include "setting.h"
+#include "vec3.h"
+#include "mat3.h"
+#include "quat.h"
+
+typedef struct OimoTransform {
+    OimoVec3 position;   // Translation
+    OimoMat3 rotation;   // Rotation matrix (3x3 orthogonal)
+} OimoTransform;
+
+// Create identity transform (no translation, no rotation)
+static inline OimoTransform oimo_transform_identity(void) {
+    OimoTransform tf;
+    tf.position = oimo_vec3_zero();
+    tf.rotation = oimo_mat3_identity();
+    return tf;
+}
+
+// Create transform with position and identity rotation
+static inline OimoTransform oimo_transform_from_position(const OimoVec3* pos) {
+    OimoTransform tf;
+    tf.position = oimo_vec3_copy(pos);
+    tf.rotation = oimo_mat3_identity();
+    return tf;
+}
+
+// Create transform with position and rotation matrix
+static inline OimoTransform oimo_transform(const OimoVec3* pos, const OimoMat3* rot) {
+    OimoTransform tf;
+    tf.position = oimo_vec3_copy(pos);
+    tf.rotation = oimo_mat3_copy(rot);
+    return tf;
+}
+
+// Create transform from position and quaternion
+static inline OimoTransform oimo_transform_from_quat(const OimoVec3* pos, const OimoQuat* q) {
+    OimoTransform tf;
+    tf.position = oimo_vec3_copy(pos);
+    tf.rotation = oimo_quat_to_mat3(q);
+    return tf;
+}
+
+// Copy transform
+static inline OimoTransform oimo_transform_copy(const OimoTransform* tf) {
+    OimoTransform result;
+    result.position = oimo_vec3_copy(&tf->position);
+    result.rotation = oimo_mat3_copy(&tf->rotation);
+    return result;
+}
+
+// Get position
+static inline OimoVec3 oimo_transform_get_position(const OimoTransform* tf) {
+    return oimo_vec3_copy(&tf->position);
+}
+
+// Get rotation matrix
+static inline OimoMat3 oimo_transform_get_rotation(const OimoTransform* tf) {
+    return oimo_mat3_copy(&tf->rotation);
+}
+
+// Get rotation as quaternion
+static inline OimoQuat oimo_transform_get_orientation(const OimoTransform* tf) {
+    return oimo_mat3_to_quat(&tf->rotation);
+}
+
+// Set to identity
+static inline void oimo_transform_set_identity(OimoTransform* tf) {
+    tf->position = oimo_vec3_zero();
+    tf->rotation = oimo_mat3_identity();
+}
+
+// Set position
+static inline void oimo_transform_set_position(OimoTransform* tf, const OimoVec3* pos) {
+    oimo_vec3_copy_to(&tf->position, pos);
+}
+
+// Set position from components
+static inline void oimo_transform_set_position3(OimoTransform* tf, OimoScalar x, OimoScalar y, OimoScalar z) {
+    oimo_vec3_set(&tf->position, x, y, z);
+}
+
+// Set rotation matrix
+static inline void oimo_transform_set_rotation(OimoTransform* tf, const OimoMat3* rot) {
+    oimo_mat3_copy_to(&tf->rotation, rot);
+}
+
+// Set rotation from quaternion
+static inline void oimo_transform_set_orientation(OimoTransform* tf, const OimoQuat* q) {
+    oimo_mat3_from_quat(&tf->rotation, q);
+}
+
+// Set rotation from Euler angles (XYZ order)
+static inline void oimo_transform_set_rotation_xyz(OimoTransform* tf, OimoScalar rx, OimoScalar ry, OimoScalar rz) {
+    tf->rotation = oimo_mat3_from_euler_xyz(rx, ry, rz);
+}
+
+// Translate by offset
+static inline void oimo_transform_translate(OimoTransform* tf, const OimoVec3* offset) {
+    oimo_vec3_add_eq(&tf->position, offset);
+}
+
+// Rotate by rotation matrix (prepend: new_rotation * old_rotation)
+static inline void oimo_transform_rotate(OimoTransform* tf, const OimoMat3* rot) {
+    tf->rotation = oimo_mat3_mul(rot, &tf->rotation);
+}
+
+// Rotate by quaternion
+static inline void oimo_transform_rotate_quat(OimoTransform* tf, const OimoQuat* q) {
+    OimoMat3 rot = oimo_quat_to_mat3(q);
+    tf->rotation = oimo_mat3_mul(&rot, &tf->rotation);
+}
+
+// Rotate by Euler angles (XYZ order)
+static inline void oimo_transform_rotate_xyz(OimoTransform* tf, OimoScalar rx, OimoScalar ry, OimoScalar rz) {
+    OimoMat3 rot = oimo_mat3_from_euler_xyz(rx, ry, rz);
+    tf->rotation = oimo_mat3_mul(&rot, &tf->rotation);
+}
+
+// Transform a point: rotation * point + position
+static inline OimoVec3 oimo_transform_point(const OimoTransform* tf, const OimoVec3* p) {
+    OimoVec3 rotated = oimo_mat3_mul_vec3(&tf->rotation, *p);
+    return oimo_vec3_add(rotated, tf->position);
+}
+
+// Transform a vector (direction): rotation * vector (no translation)
+static inline OimoVec3 oimo_transform_vector(const OimoTransform* tf, const OimoVec3* v) {
+    return oimo_mat3_mul_vec3(&tf->rotation, *v);
+}
+
+// Inverse transform a point: rotation^T * (point - position)
+static inline OimoVec3 oimo_transform_inv_point(const OimoTransform* tf, const OimoVec3* p) {
+    OimoVec3 local = oimo_vec3_sub(*p, tf->position);
+    return oimo_mat3_tmul_vec3(&tf->rotation, local);
+}
+
+// Inverse transform a vector: rotation^T * vector
+static inline OimoVec3 oimo_transform_inv_vector(const OimoTransform* tf, const OimoVec3* v) {
+    return oimo_mat3_tmul_vec3(&tf->rotation, *v);
+}
+
+// Multiply transforms: tf1 * tf2
+// Result position = tf1.rotation * tf2.position + tf1.position
+// Result rotation = tf1.rotation * tf2.rotation
+static inline OimoTransform oimo_transform_mul(const OimoTransform* tf1, const OimoTransform* tf2) {
+    OimoTransform result;
+    OimoVec3 rotated_pos = oimo_mat3_mul_vec3(&tf1->rotation, tf2->position);
+    result.position = oimo_vec3_add(rotated_pos, tf1->position);
+    result.rotation = oimo_mat3_mul(&tf1->rotation, &tf2->rotation);
+    return result;
+}
+
+// Inverse transform: rotation^T, -rotation^T * position
+static inline OimoTransform oimo_transform_inverse(const OimoTransform* tf) {
+    OimoTransform result;
+    result.rotation = oimo_mat3_transpose(&tf->rotation);
+    OimoVec3 neg_pos = oimo_vec3_neg(tf->position);
+    result.position = oimo_mat3_mul_vec3(&result.rotation, neg_pos);
+    return result;
+}
+
+// Copy from another transform
+static inline void oimo_transform_copy_to(OimoTransform* dst, const OimoTransform* src) {
+    oimo_vec3_copy_to(&dst->position, &src->position);
+    oimo_mat3_copy_to(&dst->rotation, &src->rotation);
+}
+
+// Get the X axis of the rotation (first column)
+static inline OimoVec3 oimo_transform_get_x_axis(const OimoTransform* tf) {
+    return oimo_mat3_get_col(&tf->rotation, 0);
+}
+
+// Get the Y axis of the rotation (second column)
+static inline OimoVec3 oimo_transform_get_y_axis(const OimoTransform* tf) {
+    return oimo_mat3_get_col(&tf->rotation, 1);
+}
+
+// Get the Z axis of the rotation (third column)
+static inline OimoVec3 oimo_transform_get_z_axis(const OimoTransform* tf) {
+    return oimo_mat3_get_col(&tf->rotation, 2);
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/common/vec3.h b/armorcore/Deployment/n64/src/oimo/common/vec3.h
new file mode 100644
index 0000000000..d2b2e8a7ac
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/common/vec3.h
@@ -0,0 +1,243 @@
+#pragma once
+
+#include "setting.h"
+#include "math_util.h"
+
+typedef struct OimoVec3 {
+    OimoScalar x;
+    OimoScalar y;
+    OimoScalar z;
+} OimoVec3;
+
+static inline OimoVec3 oimo_vec3_zero(void) {
+    return (OimoVec3){ 0, 0, 0 };
+}
+
+static inline OimoVec3 oimo_vec3(OimoScalar x, OimoScalar y, OimoScalar z) {
+    return (OimoVec3){ x, y, z };
+}
+
+static inline OimoVec3 oimo_vec3_copy(const OimoVec3* v) {
+    return (OimoVec3){ v->x, v->y, v->z };
+}
+
+// Core operations - by value for ease of chaining
+static inline OimoVec3 oimo_vec3_add(OimoVec3 v1, OimoVec3 v2) {
+    return (OimoVec3){ v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
+}
+
+static inline OimoVec3 oimo_vec3_add3(OimoVec3 v, OimoScalar x, OimoScalar y, OimoScalar z) {
+    return (OimoVec3){ v.x + x, v.y + y, v.z + z };
+}
+
+static inline OimoVec3 oimo_vec3_add_scaled(OimoVec3 v1, OimoVec3 v2, OimoScalar s) {
+    return (OimoVec3){ v1.x + v2.x * s, v1.y + v2.y * s, v1.z + v2.z * s };
+}
+
+static inline OimoVec3 oimo_vec3_sub(OimoVec3 v1, OimoVec3 v2) {
+    return (OimoVec3){ v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
+}
+
+static inline OimoVec3 oimo_vec3_sub3(OimoVec3 v, OimoScalar x, OimoScalar y, OimoScalar z) {
+    return (OimoVec3){ v.x - x, v.y - y, v.z - z };
+}
+
+static inline OimoVec3 oimo_vec3_scale(OimoVec3 v, OimoScalar s) {
+    return (OimoVec3){ v.x * s, v.y * s, v.z * s };
+}
+
+static inline OimoVec3 oimo_vec3_scale3(OimoVec3 v, OimoScalar sx, OimoScalar sy, OimoScalar sz) {
+    return (OimoVec3){ v.x * sx, v.y * sy, v.z * sz };
+}
+
+static inline OimoVec3 oimo_vec3_neg(OimoVec3 v) {
+    return (OimoVec3){ -v.x, -v.y, -v.z };
+}
+
+static inline OimoScalar oimo_vec3_dot(OimoVec3 v1, OimoVec3 v2) {
+    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+}
+
+static inline OimoVec3 oimo_vec3_cross(OimoVec3 v1, OimoVec3 v2) {
+    return (OimoVec3){
+        v1.y * v2.z - v1.z * v2.y,
+        v1.z * v2.x - v1.x * v2.z,
+        v1.x * v2.y - v1.y * v2.x
+    };
+}
+
+// Squared length: |v|²
+static inline OimoScalar oimo_vec3_len_sq(OimoVec3 v) {
+    return v.x * v.x + v.y * v.y + v.z * v.z;
+}
+
+// Length: |v|
+static inline OimoScalar oimo_vec3_len(OimoVec3 v) {
+    return oimo_sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+
+// Normalize: v / |v| (returns zero vector if length is zero)
+static inline OimoVec3 oimo_vec3_normalize(OimoVec3 v) {
+    OimoScalar len = oimo_vec3_len(v);
+    if (len > 0) {
+        OimoScalar inv_len = 1.0f / len;
+        return (OimoVec3){ v.x * inv_len, v.y * inv_len, v.z * inv_len };
+    }
+    return (OimoVec3){ 0, 0, 0 };
+}
+
+// Normalize with explicit epsilon check
+static inline OimoVec3 oimo_vec3_normalize_eps(OimoVec3 v, OimoScalar epsilon) {
+    OimoScalar len_sq = oimo_vec3_len_sq(v);
+    if (len_sq > epsilon * epsilon) {
+        OimoScalar inv_len = 1.0f / oimo_sqrt(len_sq);
+        return (OimoVec3){ v.x * inv_len, v.y * inv_len, v.z * inv_len };
+    }
+    return (OimoVec3){ 0, 0, 0 };
+}
+
+// out = v1 + v2
+static inline void oimo_vec3_add_to(OimoVec3* out, const OimoVec3* v1, const OimoVec3* v2) {
+    out->x = v1->x + v2->x;
+    out->y = v1->y + v2->y;
+    out->z = v1->z + v2->z;
+}
+
+// out = v1 - v2
+static inline void oimo_vec3_sub_to(OimoVec3* out, const OimoVec3* v1, const OimoVec3* v2) {
+    out->x = v1->x - v2->x;
+    out->y = v1->y - v2->y;
+    out->z = v1->z - v2->z;
+}
+
+// out = v * s
+static inline void oimo_vec3_scale_to(OimoVec3* out, const OimoVec3* v, OimoScalar s) {
+    out->x = v->x * s;
+    out->y = v->y * s;
+    out->z = v->z * s;
+}
+
+// out = -v
+static inline void oimo_vec3_negate_to(OimoVec3* out, const OimoVec3* v) {
+    out->x = -v->x;
+    out->y = -v->y;
+    out->z = -v->z;
+}
+
+// out = normalize(v)
+static inline void oimo_vec3_normalize_to(OimoVec3* out, const OimoVec3* v) {
+    OimoScalar len_sq = v->x * v->x + v->y * v->y + v->z * v->z;
+    if (len_sq > 0) {
+        OimoScalar inv_len = 1.0f / oimo_sqrt(len_sq);
+        out->x = v->x * inv_len;
+        out->y = v->y * inv_len;
+        out->z = v->z * inv_len;
+    } else {
+        out->x = out->y = out->z = 0;
+    }
+}
+
+// out = cross(v1, v2)
+static inline void oimo_vec3_cross_to(OimoVec3* out, const OimoVec3* v1, const OimoVec3* v2) {
+    // Use temp in case out aliases v1 or v2
+    OimoScalar x = v1->y * v2->z - v1->z * v2->y;
+    OimoScalar y = v1->z * v2->x - v1->x * v2->z;
+    OimoScalar z = v1->x * v2->y - v1->y * v2->x;
+    out->x = x;
+    out->y = y;
+    out->z = z;
+}
+
+// v1 = v1 + v2
+static inline void oimo_vec3_add_eq(OimoVec3* v1, const OimoVec3* v2) {
+    v1->x += v2->x;
+    v1->y += v2->y;
+    v1->z += v2->z;
+}
+
+// v1 = v1 + v2 * s
+static inline void oimo_vec3_add_scaled_eq(OimoVec3* v1, const OimoVec3* v2, OimoScalar s) {
+    v1->x += v2->x * s;
+    v1->y += v2->y * s;
+    v1->z += v2->z * s;
+}
+
+// v1 = v1 - v2
+static inline void oimo_vec3_sub_eq(OimoVec3* v1, const OimoVec3* v2) {
+    v1->x -= v2->x;
+    v1->y -= v2->y;
+    v1->z -= v2->z;
+}
+
+// v = v * s
+static inline void oimo_vec3_scale_eq(OimoVec3* v, OimoScalar s) {
+    v->x *= s;
+    v->y *= s;
+    v->z *= s;
+}
+
+// v = -v
+static inline void oimo_vec3_neg_eq(OimoVec3* v) {
+    v->x = -v->x;
+    v->y = -v->y;
+    v->z = -v->z;
+}
+
+// Normalize in-place
+static inline void oimo_vec3_normalize_eq(OimoVec3* v) {
+    OimoScalar len = oimo_vec3_len(*v);
+    if (len > 0) {
+        OimoScalar inv_len = 1.0f / len;
+        v->x *= inv_len;
+        v->y *= inv_len;
+        v->z *= inv_len;
+    } else {
+        v->x = v->y = v->z = 0;
+    }
+}
+
+static inline void oimo_vec3_copy_to(OimoVec3* dst, const OimoVec3* src) {
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->z = src->z;
+}
+
+// Set components: v = (x, y, z)
+static inline void oimo_vec3_set(OimoVec3* v, OimoScalar x, OimoScalar y, OimoScalar z) {
+    v->x = x;
+    v->y = y;
+    v->z = z;
+}
+
+// Set to zero: v = (0, 0, 0)
+static inline void oimo_vec3_set_zero(OimoVec3* v) {
+    v->x = v->y = v->z = 0;
+}
+
+// Linear interpolation: lerp(v1, v2, t) = v1 + (v2 - v1) * t
+static inline OimoVec3 oimo_vec3_lerp(OimoVec3 v1, OimoVec3 v2, OimoScalar t) {
+    return (OimoVec3){
+        v1.x + (v2.x - v1.x) * t,
+        v1.y + (v2.y - v1.y) * t,
+        v1.z + (v2.z - v1.z) * t
+    };
+}
+
+// Check if approximately zero
+static inline int oimo_vec3_is_zero(const OimoVec3* v, OimoScalar epsilon) {
+    OimoScalar len_sq = v->x * v->x + v->y * v->y + v->z * v->z;
+    return len_sq < epsilon * epsilon;
+}
+
+// Distance between two points
+static inline OimoScalar oimo_vec3_distance(OimoVec3 v1, OimoVec3 v2) {
+    OimoVec3 diff = oimo_vec3_sub(v1, v2);
+    return oimo_vec3_len(diff);
+}
+
+// Squared distance between two points
+static inline OimoScalar oimo_vec3_distance_sq(OimoVec3 v1, OimoVec3 v2) {
+    OimoVec3 diff = oimo_vec3_sub(v1, v2);
+    return oimo_vec3_len_sq(diff);
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/debug/physics_debug.c b/armorcore/Deployment/n64/src/oimo/debug/physics_debug.c
new file mode 100644
index 0000000000..fd16bee6a4
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/debug/physics_debug.c
@@ -0,0 +1,954 @@
+/**
+ * Physics Debug Drawing for N64
+ * Hardware rendering version - uses RDP triangles for line drawing
+ *
+ * Uses rdpq_triangle() with degenerate triangles for line rendering.
+ * This provides hardware acceleration while staying within the RDP pipeline.
+ */
+
+#include "physics_debug.h"
+#include <libdragon.h>
+#include <rdpq.h>
+#include <rdpq_mode.h>
+#include <rdpq_tri.h>
+#include <t3d/t3d.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+// Geometry headers
+#include "../collision/geometry/box_geometry.h"
+#include "../collision/geometry/sphere_geometry.h"
+#include "../collision/geometry/capsule_geometry.h"
+#include "../collision/geometry/static_mesh_geometry.h"
+
+// =============================================================================
+// Configuration Constants
+// =============================================================================
+
+#define CIRCLE_SEGMENTS 8
+#define RGBA5551(r, g, b) (((r) << 11) | ((g) << 6) | ((b) << 1) | 1)
+
+// Safety limits to prevent crashes and RDP command buffer overflow
+#define MAX_BODIES_PER_FRAME      256
+#define MAX_SHAPES_PER_BODY       16
+#define MAX_CONTACTS_PER_FRAME    128
+#define MAX_CONTACT_POINTS        4
+#define MAX_LINES_PER_FRAME       2000
+#define MAX_MESH_TRIANGLES        400
+#define MAX_NORMAL_TRIANGLES      100
+
+// Screen bounds for clipping (with margin for off-screen rejection)
+#define SCREEN_MARGIN             100
+#define MAX_SCREEN_WIDTH          640
+#define MAX_SCREEN_HEIGHT         480
+
+// Precomputed step for capsule vertical lines (avoids division in loop)
+#define CAPSULE_VERT_STEP         (CIRCLE_SEGMENTS / 4)
+
+// =============================================================================
+// Global State
+// =============================================================================
+
+static PhysicsDebugDraw g_debug = {0};
+
+// Pre-computed circle LUT for sphere/capsule rendering
+static float g_circle_sin[CIRCLE_SEGMENTS + 1];
+static float g_circle_cos[CIRCLE_SEGMENTS + 1];
+static bool g_circle_lut_ready = false;
+
+// Per-frame state
+static uint32_t g_screen_w = 0;
+static uint32_t g_screen_h = 0;
+static T3DViewport *g_viewport = NULL;
+
+// Cached frustum pointer for per-shape culling
+static const T3DFrustum *g_frustum = NULL;
+
+// =============================================================================
+// Color Conversion (must be before line batching)
+// =============================================================================
+
+/**
+ * Convert RGBA5551 to color_t for RDP
+ */
+static inline color_t rgba5551_to_color(uint16_t c)
+{
+    uint8_t r = ((c >> 11) & 0x1F) << 3;
+    uint8_t g = ((c >> 6) & 0x1F) << 3;
+    uint8_t b = ((c >> 1) & 0x1F) << 3;
+    return RGBA32(r, g, b, 255);
+}
+
+// =============================================================================
+// Line Bucket System - O(1) color batching using separate buffers per color
+// =============================================================================
+
+// Number of distinct colors we support
+#define NUM_COLOR_BUCKETS 10
+
+// Color bucket indices
+#define BUCKET_WIREFRAME_ACTIVE   0
+#define BUCKET_WIREFRAME_SLEEPING 1
+#define BUCKET_WIREFRAME_STATIC   2
+#define BUCKET_AABB               3
+#define BUCKET_CONTACT_POINT      4
+#define BUCKET_CONTACT_NORMAL     5
+#define BUCKET_FACE_NORMAL        6
+#define BUCKET_AXIS_X             7
+#define BUCKET_AXIS_Y             8
+#define BUCKET_AXIS_Z             9
+
+// Lines per bucket (distribute MAX_LINES across buckets)
+#define LINES_PER_BUCKET (MAX_LINES_PER_FRAME / NUM_COLOR_BUCKETS)
+
+// Batched line structure (screen space, ready to draw)
+typedef struct {
+    int16_t x0, y0, x1, y1;
+} BatchedLine;
+
+// Line buckets - one array per color
+static BatchedLine g_buckets[NUM_COLOR_BUCKETS][LINES_PER_BUCKET];
+static int g_bucket_counts[NUM_COLOR_BUCKETS] = {0};
+
+// Color lookup for each bucket (set during init)
+static uint16_t g_bucket_colors[NUM_COLOR_BUCKETS];
+
+/**
+ * Add a 2D line directly to a specific bucket (O(1) - no color lookup)
+ */
+static inline void batch_line_to_bucket(int bucket, int x0, int y0, int x1, int y1)
+{
+    // Early reject lines completely off screen
+    int w = (int)g_screen_w;
+    int h = (int)g_screen_h;
+
+    if ((x0 > w + SCREEN_MARGIN && x1 > w + SCREEN_MARGIN) ||
+        (y0 > h + SCREEN_MARGIN && y1 > h + SCREEN_MARGIN) ||
+        (x0 < -SCREEN_MARGIN && x1 < -SCREEN_MARGIN) ||
+        (y0 < -SCREEN_MARGIN && y1 < -SCREEN_MARGIN)) {
+        return;
+    }
+
+    if (g_bucket_counts[bucket] >= LINES_PER_BUCKET) return;
+
+    BatchedLine *line = &g_buckets[bucket][g_bucket_counts[bucket]++];
+    line->x0 = (int16_t)x0;
+    line->y0 = (int16_t)y0;
+    line->x1 = (int16_t)x1;
+    line->y1 = (int16_t)y1;
+}
+
+/**
+ * Fast inverse square root (Quake III style)
+ * Avoids expensive sqrtf() per line
+ * Uses union for type-punning to avoid strict-aliasing violations
+ */
+static inline float fast_inv_sqrt(float x)
+{
+    union { float f; int32_t i; } conv;
+    float xhalf = 0.5f * x;
+    conv.f = x;
+    conv.i = 0x5f3759df - (conv.i >> 1);
+    conv.f = conv.f * (1.5f - xhalf * conv.f * conv.f);  // One Newton-Raphson iteration
+    return conv.f;
+}
+
+/**
+ * Flush all color buckets to RDP
+ * One rdpq_set_prim_color() per bucket instead of per line
+ */
+static void flush_line_buckets(void)
+{
+    for (int bucket = 0; bucket < NUM_COLOR_BUCKETS; bucket++) {
+        int count = g_bucket_counts[bucket];
+        if (count == 0) continue;
+
+        // Set color once for entire bucket
+        rdpq_set_prim_color(rgba5551_to_color(g_bucket_colors[bucket]));
+
+        BatchedLine *lines = g_buckets[bucket];
+        for (int i = 0; i < count; i++) {
+            BatchedLine *line = &lines[i];
+
+            float dx = (float)(line->x1 - line->x0);
+            float dy = (float)(line->y1 - line->y0);
+            float len_sq = dx * dx + dy * dy;
+            if (len_sq < 0.001f) continue;
+
+            // Use fast inverse sqrt instead of sqrtf + division
+            float inv_len = fast_inv_sqrt(len_sq);
+            float px = -dy * inv_len * 0.5f;
+            float py = dx * inv_len * 0.5f;
+
+            // Two triangles forming a thin quad (line)
+            float v0[] = { (float)line->x0 - px, (float)line->y0 - py };
+            float v1[] = { (float)line->x0 + px, (float)line->y0 + py };
+            float v2[] = { (float)line->x1 + px, (float)line->y1 + py };
+            float v3[] = { (float)line->x1 - px, (float)line->y1 - py };
+
+            rdpq_triangle(&TRIFMT_FILL, v0, v1, v2);
+            rdpq_triangle(&TRIFMT_FILL, v0, v2, v3);
+        }
+
+        g_bucket_counts[bucket] = 0;
+    }
+}
+
+// =============================================================================
+// Initialization
+// =============================================================================
+
+/**
+ * Initialize circle lookup tables for sphere/capsule rendering
+ */
+static void init_circle_lut(void)
+{
+    if (g_circle_lut_ready) return;
+
+    const float PI2 = 6.28318530718f;
+    for (int i = 0; i <= CIRCLE_SEGMENTS; i++) {
+        float angle = (float)i / CIRCLE_SEGMENTS * PI2;
+        g_circle_sin[i] = sinf(angle);
+        g_circle_cos[i] = cosf(angle);
+    }
+    g_circle_lut_ready = true;
+}
+
+// =============================================================================
+// Low-level Drawing Utilities
+// =============================================================================
+
+/**
+ * Check if float is valid (not NaN, not Inf, within reasonable range)
+ * Uses isfinite() which is the proper C99 way to check for valid floats.
+ */
+static inline bool is_valid_float(float f)
+{
+    // isfinite() returns true if f is not NaN and not Inf
+    if (!isfinite(f)) return false;
+
+    // Reject extreme values that could cause projection issues
+    if (f > 1e6f || f < -1e6f) return false;
+
+    return true;
+}
+
+/**
+ * Draw 3D line projected to screen space via T3D viewport
+ * Takes bucket index directly for O(1) batching
+ */
+static void draw_line_3d(int bucket, float x0, float y0, float z0,
+                         float x1, float y1, float z1)
+{
+    // Validate input coordinates
+    if (!is_valid_float(x0) || !is_valid_float(y0) || !is_valid_float(z0) ||
+        !is_valid_float(x1) || !is_valid_float(y1) || !is_valid_float(z1)) {
+        return;
+    }
+
+    if (!g_viewport) return;
+
+    T3DVec3 p0 = {{x0, y0, z0}};
+    T3DVec3 p1 = {{x1, y1, z1}};
+    T3DVec3 s0, s1;
+
+    t3d_viewport_calc_viewspace_pos(g_viewport, &s0, &p0);
+    t3d_viewport_calc_viewspace_pos(g_viewport, &s1, &p1);
+
+    // Validate projected coordinates
+    if (!is_valid_float(s0.v[0]) || !is_valid_float(s0.v[1]) || !is_valid_float(s0.v[2]) ||
+        !is_valid_float(s1.v[0]) || !is_valid_float(s1.v[1]) || !is_valid_float(s1.v[2])) {
+        return;
+    }
+
+    // Near-plane clipping: reject lines that cross or are behind the near plane.
+    // z values close to 0 or negative indicate the point is at or behind camera.
+    // Using 0.01f as minimum depth to avoid division issues in projection.
+    const float MIN_DEPTH = 0.01f;
+    if (s0.v[2] < MIN_DEPTH || s1.v[2] < MIN_DEPTH) {
+        return;
+    }
+
+    // Only draw if both points in front of camera (z < 1.0 means in view frustum)
+    if (s0.v[2] < 1.0f && s1.v[2] < 1.0f) {
+        batch_line_to_bucket(bucket, (int)s0.v[0], (int)s0.v[1], (int)s1.v[0], (int)s1.v[1]);
+    }
+}
+
+// =============================================================================
+// Shape Drawing Functions
+// =============================================================================
+
+// Box edge indices (const - never changes)
+static const int box_edges[12][2] = {
+    {0,1}, {1,2}, {2,3}, {3,0},  // Bottom face
+    {4,5}, {5,6}, {6,7}, {7,4},  // Top face
+    {0,4}, {1,5}, {2,6}, {3,7}   // Vertical edges
+};
+
+/**
+ * Draw box wireframe (12 edges)
+ * Uses static arrays to avoid N64 stack overflow
+ */
+static void draw_box(int bucket, const OimoVec3 *center,
+                     const OimoMat3 *rot, float hx, float hy, float hz)
+{
+    if (!center || !rot) return;
+
+    // Static to avoid stack allocation
+    static float world[8][3];
+
+    // 8 corners - compute directly into world space
+    const float signs[8][3] = {
+        {-1, -1, -1}, {+1, -1, -1}, {+1, +1, -1}, {-1, +1, -1},
+        {-1, -1, +1}, {+1, -1, +1}, {+1, +1, +1}, {-1, +1, +1}
+    };
+
+    for (int i = 0; i < 8; i++) {
+        float lx = signs[i][0] * hx;
+        float ly = signs[i][1] * hy;
+        float lz = signs[i][2] * hz;
+        world[i][0] = center->x + rot->e00*lx + rot->e01*ly + rot->e02*lz;
+        world[i][1] = center->y + rot->e10*lx + rot->e11*ly + rot->e12*lz;
+        world[i][2] = center->z + rot->e20*lx + rot->e21*ly + rot->e22*lz;
+    }
+
+    for (int i = 0; i < 12; i++) {
+        int a = box_edges[i][0], b = box_edges[i][1];
+        draw_line_3d(bucket, world[a][0], world[a][1], world[a][2],
+                     world[b][0], world[b][1], world[b][2]);
+    }
+}
+
+/**
+ * Draw sphere wireframe (3 orthogonal circles)
+ * Precomputes scaled axes to reduce FPU operations in loops
+ */
+static void draw_sphere(int bucket, const OimoVec3 *center,
+                        const OimoMat3 *rot, float radius)
+{
+    if (!center || !rot || radius <= 0.0f) return;
+
+    // Precompute scaled axes (axis * radius) - reduces multiplications in loop
+    const float axXx = rot->e00 * radius, axXy = rot->e10 * radius, axXz = rot->e20 * radius;
+    const float axYx = rot->e01 * radius, axYy = rot->e11 * radius, axYz = rot->e21 * radius;
+    const float axZx = rot->e02 * radius, axZy = rot->e12 * radius, axZz = rot->e22 * radius;
+    const float cx = center->x, cy = center->y, cz = center->z;
+
+    // XY circle
+    for (int i = 0; i < CIRCLE_SEGMENTS; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+        draw_line_3d(bucket, cx + c0*axXx + s0*axYx, cy + c0*axXy + s0*axYy, cz + c0*axXz + s0*axYz,
+                     cx + c1*axXx + s1*axYx, cy + c1*axXy + s1*axYy, cz + c1*axXz + s1*axYz);
+    }
+
+    // XZ circle
+    for (int i = 0; i < CIRCLE_SEGMENTS; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+        draw_line_3d(bucket, cx + c0*axXx + s0*axZx, cy + c0*axXy + s0*axZy, cz + c0*axXz + s0*axZz,
+                     cx + c1*axXx + s1*axZx, cy + c1*axXy + s1*axZy, cz + c1*axXz + s1*axZz);
+    }
+
+    // YZ circle
+    for (int i = 0; i < CIRCLE_SEGMENTS; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+        draw_line_3d(bucket, cx + c0*axYx + s0*axZx, cy + c0*axYy + s0*axZy, cz + c0*axYz + s0*axZz,
+                     cx + c1*axYx + s1*axZx, cy + c1*axYy + s1*axZy, cz + c1*axYz + s1*axZz);
+    }
+}
+
+/**
+ * Draw capsule wireframe with hemisphere caps
+ * Precomputes scaled axes to reduce FPU operations
+ */
+static void draw_capsule(int bucket, const OimoVec3 *center,
+                         const OimoMat3 *rot, float radius, float halfHeight)
+{
+    if (!center || !rot || radius <= 0.0f) return;
+
+    // Precompute scaled axes (axis * radius)
+    const float rx = rot->e00 * radius, ry = rot->e10 * radius, rz = rot->e20 * radius;
+    const float ux = rot->e01 * radius, uy = rot->e11 * radius, uz = rot->e21 * radius;
+    const float fx = rot->e02 * radius, fy = rot->e12 * radius, fz = rot->e22 * radius;
+
+    // Precompute top and bottom centers
+    const float upx = rot->e01 * halfHeight, upy = rot->e11 * halfHeight, upz = rot->e21 * halfHeight;
+    const float tx = center->x + upx, ty = center->y + upy, tz = center->z + upz;
+    const float bx = center->x - upx, by = center->y - upy, bz = center->z - upz;
+
+    // Top and bottom circles (at cylinder ends)
+    for (int i = 0; i < CIRCLE_SEGMENTS; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+
+        // Top circle
+        draw_line_3d(bucket, tx + rx*c0 + fx*s0, ty + ry*c0 + fy*s0, tz + rz*c0 + fz*s0,
+                     tx + rx*c1 + fx*s1, ty + ry*c1 + fy*s1, tz + rz*c1 + fz*s1);
+        // Bottom circle
+        draw_line_3d(bucket, bx + rx*c0 + fx*s0, by + ry*c0 + fy*s0, bz + rz*c0 + fz*s0,
+                     bx + rx*c1 + fx*s1, by + ry*c1 + fy*s1, bz + rz*c1 + fz*s1);
+    }
+
+    // 4 vertical lines connecting top and bottom circles
+    // Using precomputed step constant instead of division
+    int idx = 0;
+    for (int i = 0; i < 4; i++) {
+        float c = g_circle_cos[idx], s = g_circle_sin[idx];
+        float px = rx*c + fx*s, py = ry*c + fy*s, pz = rz*c + fz*s;
+        draw_line_3d(bucket, tx + px, ty + py, tz + pz, bx + px, by + py, bz + pz);
+        idx += CAPSULE_VERT_STEP;
+    }
+
+    // Top hemisphere cap arcs (upper half of circle)
+    const int halfSeg = CIRCLE_SEGMENTS / 2;
+    for (int i = 0; i < halfSeg; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+        // Right-up arc
+        draw_line_3d(bucket, tx + rx*c0 + ux*s0, ty + ry*c0 + uy*s0, tz + rz*c0 + uz*s0,
+                     tx + rx*c1 + ux*s1, ty + ry*c1 + uy*s1, tz + rz*c1 + uz*s1);
+        // Forward-up arc
+        draw_line_3d(bucket, tx + fx*c0 + ux*s0, ty + fy*c0 + uy*s0, tz + fz*c0 + uz*s0,
+                     tx + fx*c1 + ux*s1, ty + fy*c1 + uy*s1, tz + fz*c1 + uz*s1);
+    }
+
+    // Bottom hemisphere cap arcs (lower half of circle)
+    for (int i = halfSeg; i < CIRCLE_SEGMENTS; i++) {
+        float c0 = g_circle_cos[i], s0 = g_circle_sin[i];
+        float c1 = g_circle_cos[i+1], s1 = g_circle_sin[i+1];
+        // Right-up arc
+        draw_line_3d(bucket, bx + rx*c0 + ux*s0, by + ry*c0 + uy*s0, bz + rz*c0 + uz*s0,
+                     bx + rx*c1 + ux*s1, by + ry*c1 + uy*s1, bz + rz*c1 + uz*s1);
+        // Forward-up arc
+        draw_line_3d(bucket, bx + fx*c0 + ux*s0, by + fy*c0 + uy*s0, bz + fz*c0 + uz*s0,
+                     bx + fx*c1 + ux*s1, by + fy*c1 + uy*s1, bz + fz*c1 + uz*s1);
+    }
+}
+
+/**
+ * Draw AABB wireframe (12 edges)
+ */
+static void draw_aabb(const OimoAabb *aabb)
+{
+    if (!aabb) return;
+
+    float minX = aabb->min.x, minY = aabb->min.y, minZ = aabb->min.z;
+    float maxX = aabb->max.x, maxY = aabb->max.y, maxZ = aabb->max.z;
+
+    // Validate AABB bounds
+    if (!is_valid_float(minX) || !is_valid_float(minY) || !is_valid_float(minZ) ||
+        !is_valid_float(maxX) || !is_valid_float(maxY) || !is_valid_float(maxZ)) {
+        return;
+    }
+
+    // Bottom face
+    draw_line_3d(BUCKET_AABB, minX, minY, minZ, maxX, minY, minZ);
+    draw_line_3d(BUCKET_AABB, maxX, minY, minZ, maxX, minY, maxZ);
+    draw_line_3d(BUCKET_AABB, maxX, minY, maxZ, minX, minY, maxZ);
+    draw_line_3d(BUCKET_AABB, minX, minY, maxZ, minX, minY, minZ);
+
+    // Top face
+    draw_line_3d(BUCKET_AABB, minX, maxY, minZ, maxX, maxY, minZ);
+    draw_line_3d(BUCKET_AABB, maxX, maxY, minZ, maxX, maxY, maxZ);
+    draw_line_3d(BUCKET_AABB, maxX, maxY, maxZ, minX, maxY, maxZ);
+    draw_line_3d(BUCKET_AABB, minX, maxY, maxZ, minX, maxY, minZ);
+
+    // Vertical edges
+    draw_line_3d(BUCKET_AABB, minX, minY, minZ, minX, maxY, minZ);
+    draw_line_3d(BUCKET_AABB, maxX, minY, minZ, maxX, maxY, minZ);
+    draw_line_3d(BUCKET_AABB, maxX, minY, maxZ, maxX, maxY, maxZ);
+    draw_line_3d(BUCKET_AABB, minX, minY, maxZ, minX, maxY, maxZ);
+}
+
+/**
+ * Draw body coordinate axes gizmo (XYZ colored arrows)
+ */
+static void draw_axes(const OimoVec3 *center,
+                      const OimoMat3 *rot, float length)
+{
+    if (!center || !rot || length <= 0.0f) return;
+    // X axis (red)
+    draw_line_3d(BUCKET_AXIS_X, center->x, center->y, center->z,
+                 center->x + rot->e00 * length,
+                 center->y + rot->e10 * length,
+                 center->z + rot->e20 * length);
+    // Y axis (green)
+    draw_line_3d(BUCKET_AXIS_Y, center->x, center->y, center->z,
+                 center->x + rot->e01 * length,
+                 center->y + rot->e11 * length,
+                 center->z + rot->e21 * length);
+    // Z axis (blue)
+    draw_line_3d(BUCKET_AXIS_Z, center->x, center->y, center->z,
+                 center->x + rot->e02 * length,
+                 center->y + rot->e12 * length,
+                 center->z + rot->e22 * length);
+}
+
+/**
+ * Draw static mesh wireframe (triangle edges)
+ * Limited to prevent frame time overflow
+ */
+static void draw_static_mesh(int bucket, const OimoVec3 *pos, const OimoMat3 *rot,
+                             OimoStaticMeshGeometry *mesh)
+{
+    if (!pos || !rot || !mesh || !mesh->triangles || mesh->triangle_count <= 0) return;
+
+    // Limit triangles to prevent slowdown (each triangle = 3 lines)
+    int max_tris = mesh->triangle_count;
+    if (max_tris > MAX_MESH_TRIANGLES) max_tris = MAX_MESH_TRIANGLES;
+
+    for (int i = 0; i < max_tris; i++) {
+        OimoTriangle *tri = &mesh->triangles[i];
+
+        // Transform vertices to world space
+        float wx0 = pos->x + rot->e00*tri->v0.x + rot->e01*tri->v0.y + rot->e02*tri->v0.z;
+        float wy0 = pos->y + rot->e10*tri->v0.x + rot->e11*tri->v0.y + rot->e12*tri->v0.z;
+        float wz0 = pos->z + rot->e20*tri->v0.x + rot->e21*tri->v0.y + rot->e22*tri->v0.z;
+
+        float wx1 = pos->x + rot->e00*tri->v1.x + rot->e01*tri->v1.y + rot->e02*tri->v1.z;
+        float wy1 = pos->y + rot->e10*tri->v1.x + rot->e11*tri->v1.y + rot->e12*tri->v1.z;
+        float wz1 = pos->z + rot->e20*tri->v1.x + rot->e21*tri->v1.y + rot->e22*tri->v1.z;
+
+        float wx2 = pos->x + rot->e00*tri->v2.x + rot->e01*tri->v2.y + rot->e02*tri->v2.z;
+        float wy2 = pos->y + rot->e10*tri->v2.x + rot->e11*tri->v2.y + rot->e12*tri->v2.z;
+        float wz2 = pos->z + rot->e20*tri->v2.x + rot->e21*tri->v2.y + rot->e22*tri->v2.z;
+
+        // Draw the 3 edges of the triangle
+        draw_line_3d(bucket, wx0, wy0, wz0, wx1, wy1, wz1);
+        draw_line_3d(bucket, wx1, wy1, wz1, wx2, wy2, wz2);
+        draw_line_3d(bucket, wx2, wy2, wz2, wx0, wy0, wz0);
+    }
+}
+
+/**
+ * Draw face normals for static mesh geometry
+ */
+static void draw_mesh_normals(const OimoVec3 *pos, const OimoMat3 *rot,
+                              OimoStaticMeshGeometry *mesh)
+{
+    if (!pos || !rot || !mesh || !mesh->triangles || mesh->triangle_count <= 0) return;
+
+    // Limit triangles to prevent slowdown
+    int max_tris = mesh->triangle_count;
+    if (max_tris > MAX_NORMAL_TRIANGLES) max_tris = MAX_NORMAL_TRIANGLES;
+
+    for (int i = 0; i < max_tris; i++) {
+        OimoTriangle *tri = &mesh->triangles[i];
+
+        // Compute triangle center (multiply by 1/3 instead of division)
+        const float ONE_THIRD = 0.333333333f;
+        float cx = (tri->v0.x + tri->v1.x + tri->v2.x) * ONE_THIRD;
+        float cy = (tri->v0.y + tri->v1.y + tri->v2.y) * ONE_THIRD;
+        float cz = (tri->v0.z + tri->v1.z + tri->v2.z) * ONE_THIRD;
+
+        // Transform center to world space
+        float wcx = pos->x + rot->e00*cx + rot->e01*cy + rot->e02*cz;
+        float wcy = pos->y + rot->e10*cx + rot->e11*cy + rot->e12*cz;
+        float wcz = pos->z + rot->e20*cx + rot->e21*cy + rot->e22*cz;
+
+        // Transform normal to world space (rotation only)
+        float wnx = rot->e00*tri->normal.x + rot->e01*tri->normal.y + rot->e02*tri->normal.z;
+        float wny = rot->e10*tri->normal.x + rot->e11*tri->normal.y + rot->e12*tri->normal.z;
+        float wnz = rot->e20*tri->normal.x + rot->e21*tri->normal.y + rot->e22*tri->normal.z;
+
+        // Draw normal line (0.3 units long)
+        float len = 0.3f;
+        draw_line_3d(BUCKET_FACE_NORMAL, wcx, wcy, wcz,
+                     wcx + wnx * len, wcy + wny * len, wcz + wnz * len);
+    }
+}
+
+// =============================================================================
+// Body Drawing
+// =============================================================================
+
+/**
+ * Quick frustum cull check using shape's AABB center and approximate radius.
+ * Returns true if shape is potentially visible, false if definitely outside frustum.
+ */
+static inline bool shape_in_frustum(const OimoShape *shape)
+{
+    if (!g_frustum) return true;  // No frustum = draw everything
+
+    // Use AABB center as sphere center
+    const OimoAabb *aabb = &shape->_aabb;
+    T3DVec3 center = {{
+        (aabb->min.x + aabb->max.x) * 0.5f,
+        (aabb->min.y + aabb->max.y) * 0.5f,
+        (aabb->min.z + aabb->max.z) * 0.5f
+    }};
+
+    // Compute bounding sphere radius from AABB half-extents
+    float hx = (aabb->max.x - aabb->min.x) * 0.5f;
+    float hy = (aabb->max.y - aabb->min.y) * 0.5f;
+    float hz = (aabb->max.z - aabb->min.z) * 0.5f;
+    // Approximate: use max half-extent * sqrt(3) ≈ 1.73, but 2.0 is safer
+    float maxH = hx;
+    if (hy > maxH) maxH = hy;
+    if (hz > maxH) maxH = hz;
+    float radius = maxH * 1.8f;
+
+    return t3d_frustum_vs_sphere(g_frustum, &center, radius);
+}
+
+/**
+ * Draw one physics body with all shapes
+ */
+static void draw_body(OimoRigidBody *body)
+{
+    if (!body) return;
+
+    // Determine wireframe bucket based on body state
+    int wireframe_bucket;
+    if (body->_type == OIMO_RIGID_BODY_STATIC) {
+        wireframe_bucket = BUCKET_WIREFRAME_STATIC;
+    } else if (body->_sleeping) {
+        wireframe_bucket = BUCKET_WIREFRAME_SLEEPING;
+    } else {
+        wireframe_bucket = BUCKET_WIREFRAME_ACTIVE;
+    }
+
+    // Iterate shapes with strict safety limit
+    OimoShape *shape = body->_shapeList;
+    int shape_count = 0;
+    while (shape && shape_count < MAX_SHAPES_PER_BODY) {
+        if (!shape->_geom) {
+            shape = shape->_next;
+            shape_count++;
+            continue;
+        }
+
+        // Frustum cull: skip shapes outside view frustum
+        if (!shape_in_frustum(shape)) {
+            shape = shape->_next;
+            shape_count++;
+            continue;
+        }
+
+        OimoVec3 pos = shape->_transform.position;
+        OimoMat3 rot = shape->_transform.rotation;
+
+        // Draw AABB if enabled
+        if (g_debug.mode & PHYSICS_DEBUG_AABB) {
+            draw_aabb(&shape->_aabb);
+        }
+
+        // Draw wireframe if enabled
+        if (g_debug.mode & PHYSICS_DEBUG_WIREFRAME) {
+            switch (shape->_geom->type) {
+                case OIMO_GEOMETRY_BOX: {
+                    OimoBoxGeometry *box = (OimoBoxGeometry*)shape->_geom;
+                    draw_box(wireframe_bucket, &pos, &rot,
+                             box->half_extents.x, box->half_extents.y, box->half_extents.z);
+                    break;
+                }
+                case OIMO_GEOMETRY_SPHERE: {
+                    OimoSphereGeometry *sphere = (OimoSphereGeometry*)shape->_geom;
+                    draw_sphere(wireframe_bucket, &pos, &rot, sphere->radius);
+                    break;
+                }
+                case OIMO_GEOMETRY_CAPSULE: {
+                    OimoCapsuleGeometry *capsule = (OimoCapsuleGeometry*)shape->_geom;
+                    draw_capsule(wireframe_bucket, &pos, &rot, capsule->radius, capsule->halfHeight);
+                    break;
+                }
+                case OIMO_GEOMETRY_STATIC_MESH: {
+                    OimoStaticMeshGeometry *mesh = (OimoStaticMeshGeometry*)shape->_geom;
+                    draw_static_mesh(wireframe_bucket, &pos, &rot, mesh);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+
+        // Draw face normals if enabled
+        if (g_debug.mode & PHYSICS_DEBUG_NORMALS) {
+            switch (shape->_geom->type) {
+                case OIMO_GEOMETRY_BOX: {
+                    // Draw 6 face normals for box
+                    OimoBoxGeometry *box = (OimoBoxGeometry*)shape->_geom;
+                    float len = 0.3f;
+                    // +X face
+                    float fx = pos.x + rot.e00 * box->half_extents.x;
+                    float fy = pos.y + rot.e10 * box->half_extents.x;
+                    float fz = pos.z + rot.e20 * box->half_extents.x;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx + rot.e00 * len, fy + rot.e10 * len, fz + rot.e20 * len);
+                    // -X face
+                    fx = pos.x - rot.e00 * box->half_extents.x;
+                    fy = pos.y - rot.e10 * box->half_extents.x;
+                    fz = pos.z - rot.e20 * box->half_extents.x;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx - rot.e00 * len, fy - rot.e10 * len, fz - rot.e20 * len);
+                    // +Y face
+                    fx = pos.x + rot.e01 * box->half_extents.y;
+                    fy = pos.y + rot.e11 * box->half_extents.y;
+                    fz = pos.z + rot.e21 * box->half_extents.y;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx + rot.e01 * len, fy + rot.e11 * len, fz + rot.e21 * len);
+                    // -Y face
+                    fx = pos.x - rot.e01 * box->half_extents.y;
+                    fy = pos.y - rot.e11 * box->half_extents.y;
+                    fz = pos.z - rot.e21 * box->half_extents.y;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx - rot.e01 * len, fy - rot.e11 * len, fz - rot.e21 * len);
+                    // +Z face
+                    fx = pos.x + rot.e02 * box->half_extents.z;
+                    fy = pos.y + rot.e12 * box->half_extents.z;
+                    fz = pos.z + rot.e22 * box->half_extents.z;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx + rot.e02 * len, fy + rot.e12 * len, fz + rot.e22 * len);
+                    // -Z face
+                    fx = pos.x - rot.e02 * box->half_extents.z;
+                    fy = pos.y - rot.e12 * box->half_extents.z;
+                    fz = pos.z - rot.e22 * box->half_extents.z;
+                    draw_line_3d(BUCKET_FACE_NORMAL, fx, fy, fz, fx - rot.e02 * len, fy - rot.e12 * len, fz - rot.e22 * len);
+                    break;
+                }
+                case OIMO_GEOMETRY_SPHERE: {
+                    // Draw 6 surface normals for sphere (along rotated local axes)
+                    OimoSphereGeometry *sphere = (OimoSphereGeometry*)shape->_geom;
+                    float r = sphere->radius;
+                    float len = 0.3f;
+                    // +X axis (rotated)
+                    float sx = pos.x + rot.e00 * r;
+                    float sy = pos.y + rot.e10 * r;
+                    float sz = pos.z + rot.e20 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx + rot.e00 * len, sy + rot.e10 * len, sz + rot.e20 * len);
+                    // -X axis (rotated)
+                    sx = pos.x - rot.e00 * r;
+                    sy = pos.y - rot.e10 * r;
+                    sz = pos.z - rot.e20 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx - rot.e00 * len, sy - rot.e10 * len, sz - rot.e20 * len);
+                    // +Y axis (rotated)
+                    sx = pos.x + rot.e01 * r;
+                    sy = pos.y + rot.e11 * r;
+                    sz = pos.z + rot.e21 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx + rot.e01 * len, sy + rot.e11 * len, sz + rot.e21 * len);
+                    // -Y axis (rotated)
+                    sx = pos.x - rot.e01 * r;
+                    sy = pos.y - rot.e11 * r;
+                    sz = pos.z - rot.e21 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx - rot.e01 * len, sy - rot.e11 * len, sz - rot.e21 * len);
+                    // +Z axis (rotated)
+                    sx = pos.x + rot.e02 * r;
+                    sy = pos.y + rot.e12 * r;
+                    sz = pos.z + rot.e22 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx + rot.e02 * len, sy + rot.e12 * len, sz + rot.e22 * len);
+                    // -Z axis (rotated)
+                    sx = pos.x - rot.e02 * r;
+                    sy = pos.y - rot.e12 * r;
+                    sz = pos.z - rot.e22 * r;
+                    draw_line_3d(BUCKET_FACE_NORMAL, sx, sy, sz, sx - rot.e02 * len, sy - rot.e12 * len, sz - rot.e22 * len);
+                    break;
+                }
+                case OIMO_GEOMETRY_CAPSULE: {
+                    // Draw normals at top/bottom caps and around cylinder
+                    OimoCapsuleGeometry *capsule = (OimoCapsuleGeometry*)shape->_geom;
+                    float r = capsule->radius;
+                    float hh = capsule->halfHeight;
+                    float len = 0.3f;
+                    // Top cap normal (up direction)
+                    float tx = pos.x + rot.e01 * (hh + r);
+                    float ty = pos.y + rot.e11 * (hh + r);
+                    float tz = pos.z + rot.e21 * (hh + r);
+                    draw_line_3d(BUCKET_FACE_NORMAL, tx, ty, tz, tx + rot.e01 * len, ty + rot.e11 * len, tz + rot.e21 * len);
+                    // Bottom cap normal (-up direction)
+                    float bx = pos.x - rot.e01 * (hh + r);
+                    float by = pos.y - rot.e11 * (hh + r);
+                    float bz = pos.z - rot.e21 * (hh + r);
+                    draw_line_3d(BUCKET_FACE_NORMAL, bx, by, bz, bx - rot.e01 * len, by - rot.e11 * len, bz - rot.e21 * len);
+                    // Side normals (+X, -X, +Z, -Z in local space)
+                    draw_line_3d(BUCKET_FACE_NORMAL, pos.x + rot.e00 * r, pos.y + rot.e10 * r, pos.z + rot.e20 * r,
+                                 pos.x + rot.e00 * (r + len), pos.y + rot.e10 * (r + len), pos.z + rot.e20 * (r + len));
+                    draw_line_3d(BUCKET_FACE_NORMAL, pos.x - rot.e00 * r, pos.y - rot.e10 * r, pos.z - rot.e20 * r,
+                                 pos.x - rot.e00 * (r + len), pos.y - rot.e10 * (r + len), pos.z - rot.e20 * (r + len));
+                    draw_line_3d(BUCKET_FACE_NORMAL, pos.x + rot.e02 * r, pos.y + rot.e12 * r, pos.z + rot.e22 * r,
+                                 pos.x + rot.e02 * (r + len), pos.y + rot.e12 * (r + len), pos.z + rot.e22 * (r + len));
+                    draw_line_3d(BUCKET_FACE_NORMAL, pos.x - rot.e02 * r, pos.y - rot.e12 * r, pos.z - rot.e22 * r,
+                                 pos.x - rot.e02 * (r + len), pos.y - rot.e12 * (r + len), pos.z - rot.e22 * (r + len));
+                    break;
+                }
+                case OIMO_GEOMETRY_STATIC_MESH: {
+                    OimoStaticMeshGeometry *mesh = (OimoStaticMeshGeometry*)shape->_geom;
+                    draw_mesh_normals(&pos, &rot, mesh);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+
+        // Draw axes gizmo if enabled (per-shape)
+        if (g_debug.mode & PHYSICS_DEBUG_AXES) {
+            draw_axes(&pos, &rot, 0.5f);
+        }
+
+        shape = shape->_next;
+        shape_count++;
+    }
+}
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+void physics_debug_init(void)
+{
+    // Clear all state
+    g_debug.mode = PHYSICS_DEBUG_NONE;
+    g_debug.enabled = false;
+    g_screen_w = 0;
+    g_screen_h = 0;
+    g_viewport = NULL;
+    g_frustum = NULL;
+
+    // Clear bucket counts
+    for (int i = 0; i < NUM_COLOR_BUCKETS; i++) {
+        g_bucket_counts[i] = 0;
+    }
+
+    // Default colors (bright, easily visible)
+    g_debug.colors.wireframe_active   = RGBA5551(0, 31, 0);   // Green
+    g_debug.colors.wireframe_sleeping = RGBA5551(16, 16, 16); // Gray
+    g_debug.colors.wireframe_static   = RGBA5551(31, 31, 0);  // Yellow
+    g_debug.colors.aabb               = RGBA5551(31, 16, 0);  // Orange
+    g_debug.colors.contact_point      = RGBA5551(31, 0, 0);   // Red
+    g_debug.colors.contact_normal     = RGBA5551(31, 0, 31);  // Magenta
+    g_debug.colors.face_normal        = RGBA5551(0, 31, 31);  // Cyan
+    g_debug.colors.axis_x             = RGBA5551(31, 0, 0);   // Red
+    g_debug.colors.axis_y             = RGBA5551(0, 31, 0);   // Green
+    g_debug.colors.axis_z             = RGBA5551(0, 0, 31);   // Blue
+
+    // Set up bucket color lookup table
+    g_bucket_colors[BUCKET_WIREFRAME_ACTIVE]   = g_debug.colors.wireframe_active;
+    g_bucket_colors[BUCKET_WIREFRAME_SLEEPING] = g_debug.colors.wireframe_sleeping;
+    g_bucket_colors[BUCKET_WIREFRAME_STATIC]   = g_debug.colors.wireframe_static;
+    g_bucket_colors[BUCKET_AABB]               = g_debug.colors.aabb;
+    g_bucket_colors[BUCKET_CONTACT_POINT]      = g_debug.colors.contact_point;
+    g_bucket_colors[BUCKET_CONTACT_NORMAL]     = g_debug.colors.contact_normal;
+    g_bucket_colors[BUCKET_FACE_NORMAL]        = g_debug.colors.face_normal;
+    g_bucket_colors[BUCKET_AXIS_X]             = g_debug.colors.axis_x;
+    g_bucket_colors[BUCKET_AXIS_Y]             = g_debug.colors.axis_y;
+    g_bucket_colors[BUCKET_AXIS_Z]             = g_debug.colors.axis_z;
+
+    // Pre-compute circle LUT
+    init_circle_lut();
+}
+
+void physics_debug_set_mode(PhysicsDebugMode mode)
+{
+    g_debug.mode = mode;
+}
+
+void physics_debug_enable(bool enabled)
+{
+    g_debug.enabled = enabled;
+}
+
+bool physics_debug_is_enabled(void)
+{
+    return g_debug.enabled;
+}
+
+PhysicsDebugMode physics_debug_get_mode(void)
+{
+    return g_debug.mode;
+}
+
+void physics_debug_draw(T3DViewport *viewport, OimoWorld *world)
+{
+    // Early out checks
+    if (!g_debug.enabled || g_debug.mode == PHYSICS_DEBUG_NONE) return;
+    if (!viewport || !world) return;
+
+    // Reset per-frame state
+    for (int i = 0; i < NUM_COLOR_BUCKETS; i++) {
+        g_bucket_counts[i] = 0;
+    }
+    g_viewport = viewport;
+    g_frustum = &viewport->viewFrustum;  // Cache frustum for shape culling
+    g_screen_w = display_get_width();
+    g_screen_h = display_get_height();
+
+    // Validate screen dimensions (sanity check)
+    if (g_screen_w == 0 || g_screen_h == 0 ||
+        g_screen_w > MAX_SCREEN_WIDTH || g_screen_h > MAX_SCREEN_HEIGHT) {
+        g_viewport = NULL;
+        g_frustum = NULL;
+        return;
+    }
+
+    // Set up RDP mode for flat-colored triangle drawing
+    rdpq_sync_pipe();
+    rdpq_set_mode_standard();
+    rdpq_mode_combiner(RDPQ_COMBINER_FLAT);
+    rdpq_mode_blender(0);  // Disable blending for solid lines
+
+    // Draw bodies with strict limit
+    OimoRigidBody *body = world->_rigidBodyList;
+    int body_count = 0;
+    while (body && body_count < MAX_BODIES_PER_FRAME) {
+        draw_body(body);
+        body = body->_next;
+        body_count++;
+    }
+
+    // Draw contact points if enabled
+    if (g_debug.mode & PHYSICS_DEBUG_CONTACTS) {
+        OimoContact *contact = world->_contactManager._contactList;
+        int contact_count = 0;
+
+        while (contact && contact_count < MAX_CONTACTS_PER_FRAME) {
+            if (contact->_touching) {
+                OimoManifold *manifold = &contact->_manifold;
+                if (manifold) {
+                    int numPoints = manifold->_numPoints;
+                    if (numPoints < 0) numPoints = 0;
+                    if (numPoints > MAX_CONTACT_POINTS) numPoints = MAX_CONTACT_POINTS;
+
+                    for (int i = 0; i < numPoints; i++) {
+                        OimoManifoldPoint *mp = &manifold->_points[i];
+                        if (!mp) continue;
+
+                        // Average contact position
+                        float px = (mp->_pos1.x + mp->_pos2.x) * 0.5f;
+                        float py = (mp->_pos1.y + mp->_pos2.y) * 0.5f;
+                        float pz = (mp->_pos1.z + mp->_pos2.z) * 0.5f;
+
+                        // Skip invalid positions
+                        if (!is_valid_float(px) || !is_valid_float(py) || !is_valid_float(pz)) {
+                            continue;
+                        }
+
+                        // Draw contact normal
+                        float nx = manifold->_normal.x;
+                        float ny = manifold->_normal.y;
+                        float nz = manifold->_normal.z;
+                        float len = 0.3f;
+                        draw_line_3d(BUCKET_CONTACT_NORMAL, px, py, pz,
+                                     px + nx * len, py + ny * len, pz + nz * len);
+
+                        // Draw small cross at contact point
+                        float cross = 0.05f;
+                        draw_line_3d(BUCKET_CONTACT_POINT, px - cross, py, pz, px + cross, py, pz);
+                        draw_line_3d(BUCKET_CONTACT_POINT, px, py - cross, pz, px, py + cross, pz);
+                        draw_line_3d(BUCKET_CONTACT_POINT, px, py, pz - cross, px, py, pz + cross);
+                    }
+                }
+            }
+            contact = contact->_next;
+            contact_count++;
+        }
+    }
+
+    // Flush all color buckets to RDP (one color change per bucket)
+    flush_line_buckets();
+
+    // Sync before finishing debug drawing
+    rdpq_sync_pipe();
+
+    // Clear per-frame pointers
+    g_viewport = NULL;
+    g_frustum = NULL;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/debug/physics_debug.h b/armorcore/Deployment/n64/src/oimo/debug/physics_debug.h
new file mode 100644
index 0000000000..9d8726e513
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/debug/physics_debug.h
@@ -0,0 +1,104 @@
+/**
+ * Physics Debug Drawing for N64
+ * Hardware-accelerated debug visualization for OimoPhysics
+ * Uses RDP triangles for line rendering via T3D viewport projection
+ *
+ * Features:
+ * - Collider wireframes (box, sphere, capsule)
+ * - AABBs (axis-aligned bounding boxes)
+ * - Contact points and normals
+ * - Body axes/gizmos
+ */
+
+#pragma once
+
+#include <libdragon.h>
+#include <stdint.h>
+#include <t3d/t3d.h>
+#include "../oimo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Debug draw mode flags (can be combined with |)
+// Values match Blender's arm_physics_dbg_draw_* settings exactly
+typedef enum PhysicsDebugMode {
+    PHYSICS_DEBUG_NONE              = 0,
+    PHYSICS_DEBUG_WIREFRAME         = (1 << 0),   // Collider wireframes
+    PHYSICS_DEBUG_AABB              = (1 << 1),   // Axis-aligned bounding boxes
+    PHYSICS_DEBUG_CONTACTS          = (1 << 3),   // Contact points (Blender uses bit 3)
+    PHYSICS_DEBUG_CONSTRAINTS       = (1 << 11),  // Constraints (not implemented on N64)
+    PHYSICS_DEBUG_CONSTRAINT_LIMITS = (1 << 12),  // Constraint limits (not implemented)
+    PHYSICS_DEBUG_NORMALS           = (1 << 14),  // Face normals
+    PHYSICS_DEBUG_AXES              = (1 << 15),  // Body coordinate axes/gizmos
+    PHYSICS_DEBUG_RAYCASTS          = (1 << 16),  // Raycasts (not implemented)
+    PHYSICS_DEBUG_ALL               = 0x1C80B     // All implemented modes
+} PhysicsDebugMode;
+
+// Debug draw colors (RGBA5551 format, converted to color_t for RDP)
+typedef struct PhysicsDebugColors {
+    uint16_t wireframe_active;   // Active dynamic bodies (green)
+    uint16_t wireframe_sleeping; // Sleeping bodies (gray)
+    uint16_t wireframe_static;   // Static bodies (yellow)
+    uint16_t aabb;               // AABB outlines (orange)
+    uint16_t contact_point;      // Contact point markers (red)
+    uint16_t contact_normal;     // Contact normal lines (magenta)
+    uint16_t face_normal;        // Face normals (cyan)
+    uint16_t axis_x;             // X axis (red)
+    uint16_t axis_y;             // Y axis (green)
+    uint16_t axis_z;             // Z axis (blue)
+} PhysicsDebugColors;
+
+// Debug draw state
+typedef struct PhysicsDebugDraw {
+    PhysicsDebugMode mode;
+    PhysicsDebugColors colors;
+    bool enabled;
+} PhysicsDebugDraw;
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+/**
+ * Initialize debug draw system with default colors
+ */
+void physics_debug_init(void);
+
+/**
+ * Set which debug visualizations are active
+ * @param mode Combination of PhysicsDebugMode flags
+ */
+void physics_debug_set_mode(PhysicsDebugMode mode);
+
+/**
+ * Enable or disable debug drawing entirely
+ */
+void physics_debug_enable(bool enabled);
+
+/**
+ * Check if debug drawing is enabled
+ */
+bool physics_debug_is_enabled(void);
+
+/**
+ * Get current debug mode
+ */
+PhysicsDebugMode physics_debug_get_mode(void);
+
+/**
+ * Main debug draw function - draws all enabled debug visualization
+ *
+ * Call this while RDP is attached (before rdpq_detach_show).
+ * Uses RDP hardware triangles for line rendering.
+ *
+ * @param viewport  T3D viewport (for 3D->2D projection)
+ * @param world     Physics world to visualize
+ */
+void physics_debug_draw(T3DViewport* viewport, OimoWorld* world);
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_constraint.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_constraint.h
new file mode 100644
index 0000000000..30f3f2c02d
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_constraint.h
@@ -0,0 +1,220 @@
+#pragma once
+
+// contact_constraint.h
+// 1:1 port from OimoPhysics ContactConstraint.hx
+
+#include "../../../common/vec3.h"
+#include "../../../common/mat3.h"
+#include "../../../common/transform.h"
+#include "../../../common/setting.h"
+#include "../../../common/math_util.h"
+#include "../../rigidbody/shape.h"
+#include "../../rigidbody/rigid_body.h"
+#include "../../time_step.h"
+#include "../position_correction_algorithm.h"
+#include "../info/jacobian_row.h"
+#include "../info/contact/contact_solver_info.h"
+#include "manifold.h"
+
+typedef struct OimoContactConstraint {
+    int _positionCorrectionAlgorithm;
+    OimoManifold* _manifold;
+
+    OimoShape* _s1;
+    OimoShape* _s2;
+    OimoTransform* _tf1;
+    OimoTransform* _tf2;
+    OimoScalar _invM1;
+    OimoScalar _invM2;
+    OimoScalar _friction;
+    OimoScalar _restitution;
+
+    OimoMat3 _invI1;
+    OimoMat3 _invI2;
+
+    OimoRigidBody* _b1;
+    OimoRigidBody* _b2;
+} OimoContactConstraint;
+
+static inline void oimo_contact_constraint_init(OimoContactConstraint* cc, OimoManifold* manifold) {
+    cc->_positionCorrectionAlgorithm = OIMO_POSITION_CORRECTION_BAUMGARTE;
+    cc->_manifold = manifold;
+    cc->_s1 = NULL;
+    cc->_s2 = NULL;
+    cc->_tf1 = NULL;
+    cc->_tf2 = NULL;
+    cc->_invM1 = 0.0f;
+    cc->_invM2 = 0.0f;
+    cc->_friction = 0.0f;
+    cc->_restitution = 0.0f;
+    cc->_invI1 = oimo_mat3_identity();
+    cc->_invI2 = oimo_mat3_identity();
+    cc->_b1 = NULL;
+    cc->_b2 = NULL;
+}
+
+static inline void oimo_contact_constraint_attach(OimoContactConstraint* cc, OimoShape* s1, OimoShape* s2) {
+    cc->_s1 = s1;
+    cc->_s2 = s2;
+    cc->_b1 = s1->_rigidBody;
+    cc->_b2 = s2->_rigidBody;
+    cc->_tf1 = &cc->_b1->_transform;
+    cc->_tf2 = &cc->_b2->_transform;
+}
+
+static inline void oimo_contact_constraint_detach(OimoContactConstraint* cc) {
+    cc->_s1 = NULL;
+    cc->_s2 = NULL;
+    cc->_b1 = NULL;
+    cc->_b2 = NULL;
+    cc->_tf1 = NULL;
+    cc->_tf2 = NULL;
+}
+
+static inline void oimo_contact_constraint_sync_manifold(OimoContactConstraint* cc) {
+    oimo_manifold_update_depths_and_positions(cc->_manifold, cc->_tf1, cc->_tf2);
+}
+
+// Get velocity solver info - 1:1 from ContactConstraint._getVelocitySolverInfo
+static inline void oimo_contact_constraint_get_velocity_solver_info(
+    OimoContactConstraint* cc,
+    OimoTimeStep* timeStep,
+    OimoContactSolverInfo* info
+) {
+    info->b1 = cc->_b1;
+    info->b2 = cc->_b2;
+
+    OimoVec3 normal = cc->_manifold->_normal;
+    OimoVec3 tangent = cc->_manifold->_tangent;
+    OimoVec3 binormal = cc->_manifold->_binormal;
+
+    // Combined friction and restitution
+    OimoScalar friction = oimo_sqrt(cc->_s1->_friction * cc->_s2->_friction);
+    OimoScalar restitution = oimo_sqrt(cc->_s1->_restitution * cc->_s2->_restitution);
+
+    int num = cc->_manifold->_numPoints;
+    info->numRows = 0;
+
+    for (int i = 0; i < num; i++) {
+        OimoManifoldPoint* p = &cc->_manifold->_points[i];
+
+        if (p->_depth < 0.0f) {
+            p->_disabled = true;
+            oimo_contact_impulse_clear(&p->_impulse);
+            continue;  // Skip separated points
+        } else {
+            p->_disabled = false;
+        }
+
+        OimoContactSolverInfoRow* row = &info->rows[info->numRows++];
+
+        row->friction = friction;
+        row->cfm = 0.0f;
+
+        // Set Jacobian for normal
+        OimoJacobianRow* j = &row->jacobianN;
+        j->lin1 = normal;
+        j->lin2 = normal;
+        j->ang1 = oimo_vec3_cross(p->_relPos1, normal);
+        j->ang2 = oimo_vec3_cross(p->_relPos2, normal);
+
+        // Set Jacobian for tangent
+        j = &row->jacobianT;
+        j->lin1 = tangent;
+        j->lin2 = tangent;
+        j->ang1 = oimo_vec3_cross(p->_relPos1, tangent);
+        j->ang2 = oimo_vec3_cross(p->_relPos2, tangent);
+
+        // Set Jacobian for binormal
+        j = &row->jacobianB;
+        j->lin1 = binormal;
+        j->lin2 = binormal;
+        j->ang1 = oimo_vec3_cross(p->_relPos1, binormal);
+        j->ang2 = oimo_vec3_cross(p->_relPos2, binormal);
+
+        // Compute relative velocity along normal
+        j = &row->jacobianN;
+        OimoScalar rvn =
+            (oimo_vec3_dot(j->lin1, cc->_b1->_vel) + oimo_vec3_dot(j->ang1, cc->_b1->_angVel)) -
+            (oimo_vec3_dot(j->lin2, cc->_b2->_vel) + oimo_vec3_dot(j->ang2, cc->_b2->_angVel));
+
+        // Disable bounce for warm-started contacts
+        if (rvn < -OIMO_CONTACT_ENABLE_BOUNCE_THRESHOLD && !p->_warmStarted) {
+            row->rhs = -rvn * restitution;
+        } else {
+            row->rhs = 0.0f;
+        }
+
+        // Set minimum RHS for Baumgarte position correction
+        if (cc->_positionCorrectionAlgorithm == OIMO_POSITION_CORRECTION_BAUMGARTE) {
+            if (p->_depth > OIMO_LINEAR_SLOP) {
+                OimoScalar minRhs = (p->_depth - OIMO_LINEAR_SLOP) * OIMO_VELOCITY_BAUMGARTE * timeStep->invDt;
+                if (row->rhs < minRhs) row->rhs = minRhs;
+            }
+        }
+
+        // Reset impulses if warm starting is disabled
+        if (!p->_warmStarted) {
+            oimo_contact_impulse_clear(&p->_impulse);
+        }
+
+        row->impulse = &p->_impulse;
+    }
+}
+
+// Get position solver info - 1:1 from ContactConstraint._getPositionSolverInfo
+static inline void oimo_contact_constraint_get_position_solver_info(
+    OimoContactConstraint* cc,
+    OimoContactSolverInfo* info
+) {
+    info->b1 = cc->_b1;
+    info->b2 = cc->_b2;
+
+    OimoVec3 normal = cc->_manifold->_normal;
+
+    int num = cc->_manifold->_numPoints;
+    info->numRows = 0;
+
+    for (int i = 0; i < num; i++) {
+        OimoManifoldPoint* p = &cc->_manifold->_points[i];
+
+        if (p->_disabled) {
+            continue;  // Skip disabled points
+        }
+
+        OimoContactSolverInfoRow* row = &info->rows[info->numRows++];
+
+        // Set normal Jacobian
+        OimoJacobianRow* j = &row->jacobianN;
+        j->lin1 = normal;
+        j->lin2 = normal;
+        j->ang1 = oimo_vec3_cross(p->_relPos1, normal);
+        j->ang2 = oimo_vec3_cross(p->_relPos2, normal);
+
+        row->rhs = p->_depth - OIMO_LINEAR_SLOP;
+        if (row->rhs < 0.0f) {
+            row->rhs = 0.0f;
+        }
+
+        row->impulse = &p->_impulse;
+    }
+}
+
+static inline bool oimo_contact_constraint_is_touching(const OimoContactConstraint* cc) {
+    for (int i = 0; i < cc->_manifold->_numPoints; i++) {
+        if (cc->_manifold->_points[i]._depth >= 0.0f) return true;
+    }
+    return false;
+}
+
+static inline OimoShape* oimo_contact_constraint_get_shape1(const OimoContactConstraint* cc) {
+    return cc->_s1;
+}
+
+static inline OimoShape* oimo_contact_constraint_get_shape2(const OimoContactConstraint* cc) {
+    return cc->_s2;
+}
+
+static inline OimoManifold* oimo_contact_constraint_get_manifold(const OimoContactConstraint* cc) {
+    return cc->_manifold;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_impulse.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_impulse.h
new file mode 100644
index 0000000000..b90e593415
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/contact_impulse.h
@@ -0,0 +1,39 @@
+#pragma once
+
+// contact_impulse.h
+// 1:1 port from OimoPhysics ContactImpulse.hx
+
+#include "../../../common/vec3.h"
+
+typedef struct OimoContactImpulse {
+    OimoScalar impulseN;  // Normal impulse
+    OimoScalar impulseT;  // Tangent impulse
+    OimoScalar impulseB;  // Binormal impulse
+    OimoScalar impulseP;  // Position impulse
+    OimoVec3 impulseL;    // Lateral impulse
+} OimoContactImpulse;
+
+static inline OimoContactImpulse oimo_contact_impulse_create(void) {
+    OimoContactImpulse imp;
+    imp.impulseN = 0.0f;
+    imp.impulseT = 0.0f;
+    imp.impulseB = 0.0f;
+    imp.impulseP = 0.0f;
+    imp.impulseL = oimo_vec3_zero();
+    return imp;
+}
+
+static inline void oimo_contact_impulse_clear(OimoContactImpulse* imp) {
+    imp->impulseN = 0.0f;
+    imp->impulseT = 0.0f;
+    imp->impulseB = 0.0f;
+    imp->impulseP = 0.0f;
+    imp->impulseL = oimo_vec3_zero();
+}
+
+static inline void oimo_contact_impulse_copy_from(OimoContactImpulse* dst, const OimoContactImpulse* src) {
+    dst->impulseN = src->impulseN;
+    dst->impulseT = src->impulseT;
+    dst->impulseB = src->impulseB;
+    dst->impulseL = src->impulseL;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold.h
new file mode 100644
index 0000000000..0dc2adc4a6
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold.h
@@ -0,0 +1,131 @@
+#pragma once
+
+// manifold.h
+// 1:1 port from OimoPhysics Manifold.hx
+
+#include "../../../common/vec3.h"
+#include "../../../common/mat3.h"
+#include "../../../common/transform.h"
+#include "../../../common/setting.h"
+#include "../../../common/math_util.h"
+#include "manifold_point.h"
+
+typedef struct OimoManifold {
+    OimoVec3 _normal;
+    OimoVec3 _tangent;
+    OimoVec3 _binormal;
+    int _numPoints;
+    OimoManifoldPoint _points[OIMO_MAX_MANIFOLD_POINTS];
+} OimoManifold;
+
+static inline OimoManifold oimo_manifold_create(void) {
+    OimoManifold m;
+    m._normal = oimo_vec3_zero();
+    m._tangent = oimo_vec3_zero();
+    m._binormal = oimo_vec3_zero();
+    m._numPoints = 0;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        m._points[i] = oimo_manifold_point_create();
+    }
+    return m;
+}
+
+static inline void oimo_manifold_clear(OimoManifold* m) {
+    for (int i = 0; i < m->_numPoints; i++) {
+        oimo_manifold_point_clear(&m->_points[i]);
+    }
+    m->_numPoints = 0;
+}
+
+// Build orthonormal basis from normal - 1:1 from Manifold._buildBasis
+static inline void oimo_manifold_build_basis(OimoManifold* m, OimoVec3 normal) {
+    m->_normal = normal;
+
+    OimoScalar nx = normal.x;
+    OimoScalar ny = normal.y;
+    OimoScalar nz = normal.z;
+    OimoScalar nx2 = nx * nx;
+    OimoScalar ny2 = ny * ny;
+    OimoScalar nz2 = nz * nz;
+
+    OimoScalar tx, ty, tz;
+    OimoScalar bx, by, bz;
+
+    // compare3min: find smallest component squared
+    if (nx2 <= ny2 && nx2 <= nz2) {
+        // nx2 is smallest
+        OimoScalar invL = 1.0f / oimo_sqrt(ny2 + nz2);
+        tx = 0.0f;
+        ty = -nz * invL;
+        tz = ny * invL;
+        bx = ny * tz - nz * ty;
+        by = -nx * tz;
+        bz = nx * ty;
+    } else if (ny2 <= nx2 && ny2 <= nz2) {
+        // ny2 is smallest
+        OimoScalar invL = 1.0f / oimo_sqrt(nx2 + nz2);
+        tx = nz * invL;
+        ty = 0.0f;
+        tz = -nx * invL;
+        bx = ny * tz;
+        by = nz * tx - nx * tz;
+        bz = -ny * tx;
+    } else {
+        // nz2 is smallest
+        OimoScalar invL = 1.0f / oimo_sqrt(nx2 + ny2);
+        tx = -ny * invL;
+        ty = nx * invL;
+        tz = 0.0f;
+        bx = -nz * ty;
+        by = nz * tx;
+        bz = nx * ty - ny * tx;
+    }
+
+    m->_tangent = oimo_vec3(tx, ty, tz);
+    m->_binormal = oimo_vec3(bx, by, bz);
+}
+
+// Update depths and positions - 1:1 from Manifold._updateDepthsAndPositions
+static inline void oimo_manifold_update_depths_and_positions(
+    OimoManifold* m,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    for (int i = 0; i < m->_numPoints; i++) {
+        OimoManifoldPoint* p = &m->_points[i];
+
+        // relPos = R * localPos
+        p->_relPos1 = oimo_mat3_mul_vec3(&tf1->rotation, p->_localPos1);
+        p->_relPos2 = oimo_mat3_mul_vec3(&tf2->rotation, p->_localPos2);
+
+        // pos = relPos + tf.position
+        p->_pos1 = oimo_vec3_add(p->_relPos1, tf1->position);
+        p->_pos2 = oimo_vec3_add(p->_relPos2, tf2->position);
+
+        // Compute depth from difference along normal
+        OimoVec3 diff = oimo_vec3_sub(p->_pos1, p->_pos2);
+        OimoScalar dotN = oimo_vec3_dot(diff, m->_normal);
+        p->_depth = -dotN;
+    }
+}
+
+// Public getters
+static inline OimoVec3 oimo_manifold_get_normal(const OimoManifold* m) {
+    return m->_normal;
+}
+
+static inline OimoVec3 oimo_manifold_get_tangent(const OimoManifold* m) {
+    return m->_tangent;
+}
+
+static inline OimoVec3 oimo_manifold_get_binormal(const OimoManifold* m) {
+    return m->_binormal;
+}
+
+static inline int oimo_manifold_get_num_points(const OimoManifold* m) {
+    return m->_numPoints;
+}
+
+static inline OimoManifoldPoint* oimo_manifold_get_points(OimoManifold* m) {
+    return m->_points;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_point.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_point.h
new file mode 100644
index 0000000000..19882a5fda
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_point.h
@@ -0,0 +1,148 @@
+#pragma once
+
+// manifold_point.h
+// 1:1 port from OimoPhysics ManifoldPoint.hx
+
+#include "../../../common/vec3.h"
+#include "../../../common/mat3.h"
+#include "../../../common/transform.h"
+#include "../../../collision/narrowphase/detector_result.h"
+#include "contact_impulse.h"
+
+typedef struct OimoManifoldPoint {
+    // Local position relative to rigid bodies (NOT shapes)
+    OimoVec3 _localPos1;
+    OimoVec3 _localPos2;
+
+    // Local position with rotation applied
+    OimoVec3 _relPos1;
+    OimoVec3 _relPos2;
+
+    // World position
+    OimoVec3 _pos1;
+    OimoVec3 _pos2;
+
+    OimoScalar _depth;
+    OimoContactImpulse _impulse;
+
+    bool _warmStarted;
+    bool _disabled;
+    int _id;
+} OimoManifoldPoint;
+
+static inline OimoManifoldPoint oimo_manifold_point_create(void) {
+    OimoManifoldPoint mp;
+    mp._localPos1 = oimo_vec3_zero();
+    mp._localPos2 = oimo_vec3_zero();
+    mp._relPos1 = oimo_vec3_zero();
+    mp._relPos2 = oimo_vec3_zero();
+    mp._pos1 = oimo_vec3_zero();
+    mp._pos2 = oimo_vec3_zero();
+    mp._depth = 0.0f;
+    mp._impulse = oimo_contact_impulse_create();
+    mp._warmStarted = false;
+    mp._disabled = false;
+    mp._id = -1;
+    return mp;
+}
+
+static inline void oimo_manifold_point_clear(OimoManifoldPoint* mp) {
+    mp->_localPos1 = oimo_vec3_zero();
+    mp->_localPos2 = oimo_vec3_zero();
+    mp->_relPos1 = oimo_vec3_zero();
+    mp->_relPos2 = oimo_vec3_zero();
+    mp->_pos1 = oimo_vec3_zero();
+    mp->_pos2 = oimo_vec3_zero();
+    mp->_depth = 0.0f;
+    oimo_contact_impulse_clear(&mp->_impulse);
+    mp->_warmStarted = false;
+    mp->_disabled = false;
+    mp->_id = -1;
+}
+
+static inline void oimo_manifold_point_initialize(
+    OimoManifoldPoint* mp,
+    const OimoDetectorResultPoint* result,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    // World position
+    mp->_pos1 = result->position1;
+    mp->_pos2 = result->position2;
+
+    // Local position with rotation (relPos = pos - tf.position)
+    mp->_relPos1 = oimo_vec3_sub(mp->_pos1, tf1->position);
+    mp->_relPos2 = oimo_vec3_sub(mp->_pos2, tf2->position);
+
+    // Local position (localPos = R^T * relPos)
+    mp->_localPos1 = oimo_mat3_tmul_vec3(&tf1->rotation, mp->_relPos1);
+    mp->_localPos2 = oimo_mat3_tmul_vec3(&tf2->rotation, mp->_relPos2);
+
+    mp->_depth = result->depth;
+    oimo_contact_impulse_clear(&mp->_impulse);
+    mp->_id = result->id;
+    mp->_warmStarted = false;
+    mp->_disabled = false;
+}
+
+static inline void oimo_manifold_point_update_depth_and_positions(
+    OimoManifoldPoint* mp,
+    const OimoDetectorResultPoint* result,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    mp->_pos1 = result->position1;
+    mp->_pos2 = result->position2;
+    mp->_relPos1 = oimo_vec3_sub(mp->_pos1, tf1->position);
+    mp->_relPos2 = oimo_vec3_sub(mp->_pos2, tf2->position);
+    mp->_localPos1 = oimo_mat3_tmul_vec3(&tf1->rotation, mp->_relPos1);
+    mp->_localPos2 = oimo_mat3_tmul_vec3(&tf2->rotation, mp->_relPos2);
+    mp->_depth = result->depth;
+}
+
+static inline void oimo_manifold_point_copy_from(OimoManifoldPoint* dst, const OimoManifoldPoint* src) {
+    dst->_localPos1 = src->_localPos1;
+    dst->_localPos2 = src->_localPos2;
+    dst->_relPos1 = src->_relPos1;
+    dst->_relPos2 = src->_relPos2;
+    dst->_pos1 = src->_pos1;
+    dst->_pos2 = src->_pos2;
+    dst->_depth = src->_depth;
+    oimo_contact_impulse_copy_from(&dst->_impulse, &src->_impulse);
+    dst->_id = src->_id;
+    dst->_warmStarted = src->_warmStarted;
+    dst->_disabled = false;
+}
+
+// Public getters
+static inline OimoVec3 oimo_manifold_point_get_position1(const OimoManifoldPoint* mp) {
+    return mp->_pos1;
+}
+
+static inline OimoVec3 oimo_manifold_point_get_position2(const OimoManifoldPoint* mp) {
+    return mp->_pos2;
+}
+
+static inline OimoScalar oimo_manifold_point_get_depth(const OimoManifoldPoint* mp) {
+    return mp->_depth;
+}
+
+static inline bool oimo_manifold_point_is_warm_started(const OimoManifoldPoint* mp) {
+    return mp->_warmStarted;
+}
+
+static inline OimoScalar oimo_manifold_point_get_normal_impulse(const OimoManifoldPoint* mp) {
+    return mp->_impulse.impulseN;
+}
+
+static inline OimoScalar oimo_manifold_point_get_tangent_impulse(const OimoManifoldPoint* mp) {
+    return mp->_impulse.impulseT;
+}
+
+static inline OimoScalar oimo_manifold_point_get_binormal_impulse(const OimoManifoldPoint* mp) {
+    return mp->_impulse.impulseB;
+}
+
+static inline bool oimo_manifold_point_is_enabled(const OimoManifoldPoint* mp) {
+    return !mp->_disabled;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_updater.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_updater.h
new file mode 100644
index 0000000000..2f4dfcf8f2
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/contact/manifold_updater.h
@@ -0,0 +1,269 @@
+#pragma once
+
+// manifold_updater.h
+// 1:1 port from OimoPhysics ManifoldUpdater.hx
+
+#include "../../../common/vec3.h"
+#include "../../../common/mat3.h"
+#include "../../../common/transform.h"
+#include "../../../common/setting.h"
+#include "../../../collision/narrowphase/detector_result.h"
+#include "manifold.h"
+
+typedef struct OimoManifoldUpdater {
+    OimoManifold* _manifold;
+    int numOldPoints;
+    OimoManifoldPoint oldPoints[OIMO_MAX_MANIFOLD_POINTS];
+} OimoManifoldUpdater;
+
+static inline OimoManifoldUpdater oimo_manifold_updater_create(OimoManifold* manifold) {
+    OimoManifoldUpdater updater;
+    updater._manifold = manifold;
+    updater.numOldPoints = 0;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        updater.oldPoints[i] = oimo_manifold_point_create();
+    }
+    return updater;
+}
+
+static inline void oimo_manifold_updater_init(OimoManifoldUpdater* updater, OimoManifold* manifold) {
+    updater->_manifold = manifold;
+    updater->numOldPoints = 0;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        updater->oldPoints[i] = oimo_manifold_point_create();
+    }
+}
+
+// Remove a manifold point at given index
+static inline void oimo_manifold_updater_remove_point(OimoManifoldUpdater* updater, int index) {
+    OimoManifold* m = updater->_manifold;
+    int lastIndex = --m->_numPoints;
+    if (index != lastIndex) {
+        OimoManifoldPoint tmp = m->_points[index];
+        m->_points[index] = m->_points[lastIndex];
+        m->_points[lastIndex] = tmp;
+    }
+    oimo_manifold_point_clear(&m->_points[lastIndex]);
+}
+
+// Remove outdated points - 1:1 from ManifoldUpdater.removeOutdatedPoints
+static inline void oimo_manifold_updater_remove_outdated_points(OimoManifoldUpdater* updater) {
+    OimoManifold* m = updater->_manifold;
+    int index = m->_numPoints;
+
+    while (--index >= 0) {
+        OimoManifoldPoint* p = &m->_points[index];
+
+        OimoVec3 diff = oimo_vec3_sub(p->_pos1, p->_pos2);
+        OimoScalar dotN = oimo_vec3_dot(m->_normal, diff);
+
+        if (dotN > OIMO_CONTACT_PERSISTENCE_THRESHOLD) {
+            oimo_manifold_updater_remove_point(updater, index);
+            continue;
+        }
+
+        // Compute projection of diff (remove normal component)
+        OimoVec3 scaled = oimo_vec3_scale(m->_normal, dotN);
+        diff = oimo_vec3_sub(diff, scaled);
+        if (oimo_vec3_dot(diff, diff) > OIMO_CONTACT_PERSISTENCE_THRESHOLD * OIMO_CONTACT_PERSISTENCE_THRESHOLD) {
+            oimo_manifold_updater_remove_point(updater, index);
+            continue;
+        }
+    }
+}
+
+// Compute area of quadrilateral for point selection - 1:1 from ManifoldUpdater.quadAreaFast
+static inline OimoScalar oimo_manifold_updater_quad_area_fast(
+    OimoVec3 p1, OimoVec3 p2, OimoVec3 p3, OimoVec3 p4
+) {
+    // Possible diagonals
+    OimoVec3 v12 = oimo_vec3_sub(p2, p1);
+    OimoVec3 v34 = oimo_vec3_sub(p4, p3);
+    OimoVec3 v13 = oimo_vec3_sub(p3, p1);
+    OimoVec3 v24 = oimo_vec3_sub(p4, p2);
+    OimoVec3 v14 = oimo_vec3_sub(p4, p1);
+    OimoVec3 v23 = oimo_vec3_sub(p3, p2);
+
+    OimoVec3 cross1 = oimo_vec3_cross(v12, v34);
+    OimoVec3 cross2 = oimo_vec3_cross(v13, v24);
+    OimoVec3 cross3 = oimo_vec3_cross(v14, v23);
+
+    OimoScalar a1 = oimo_vec3_dot(cross1, cross1);
+    OimoScalar a2 = oimo_vec3_dot(cross2, cross2);
+    OimoScalar a3 = oimo_vec3_dot(cross3, cross3);
+
+    if (a1 > a2) {
+        return (a1 > a3) ? a1 : a3;
+    } else {
+        return (a2 > a3) ? a2 : a3;
+    }
+}
+
+// Compute target index for point replacement - 1:1 from ManifoldUpdater.computeTargetIndex
+static inline int oimo_manifold_updater_compute_target_index(
+    OimoManifoldUpdater* updater,
+    const OimoDetectorResultPoint* newPoint,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    OimoManifold* m = updater->_manifold;
+    OimoManifoldPoint* p1 = &m->_points[0];
+    OimoManifoldPoint* p2 = &m->_points[1];
+    OimoManifoldPoint* p3 = &m->_points[2];
+    OimoManifoldPoint* p4 = &m->_points[3];
+
+    OimoScalar maxDepth = p1->_depth;
+    int maxDepthIndex = 0;
+    if (p2->_depth > maxDepth) { maxDepth = p2->_depth; maxDepthIndex = 1; }
+    if (p3->_depth > maxDepth) { maxDepth = p3->_depth; maxDepthIndex = 2; }
+    if (p4->_depth > maxDepth) { maxDepth = p4->_depth; maxDepthIndex = 3; }
+
+    OimoVec3 rp1 = oimo_vec3_sub(newPoint->position1, tf1->position);
+
+    OimoScalar a1 = oimo_manifold_updater_quad_area_fast(p2->_relPos1, p3->_relPos1, p4->_relPos1, rp1);
+    OimoScalar a2 = oimo_manifold_updater_quad_area_fast(p1->_relPos1, p3->_relPos1, p4->_relPos1, rp1);
+    OimoScalar a3 = oimo_manifold_updater_quad_area_fast(p1->_relPos1, p2->_relPos1, p4->_relPos1, rp1);
+    OimoScalar a4 = oimo_manifold_updater_quad_area_fast(p1->_relPos1, p2->_relPos1, p3->_relPos1, rp1);
+
+    OimoScalar max = a1;
+    int target = 0;
+    if ((a2 > max && maxDepthIndex != 1) || maxDepthIndex == 0) { max = a2; target = 1; }
+    if (a3 > max && maxDepthIndex != 2) { max = a3; target = 2; }
+    if (a4 > max && maxDepthIndex != 3) { max = a4; target = 3; }
+
+    return target;
+}
+
+// Add manifold point - 1:1 from ManifoldUpdater.addManifoldPoint
+static inline void oimo_manifold_updater_add_point(
+    OimoManifoldUpdater* updater,
+    const OimoDetectorResultPoint* point,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    OimoManifold* m = updater->_manifold;
+    int num = m->_numPoints;
+
+    if (num == OIMO_MAX_MANIFOLD_POINTS) {
+        int targetIndex = oimo_manifold_updater_compute_target_index(updater, point, tf1, tf2);
+        oimo_manifold_point_initialize(&m->_points[targetIndex], point, tf1, tf2);
+        return;
+    }
+
+    oimo_manifold_point_initialize(&m->_points[num], point, tf1, tf2);
+    m->_numPoints++;
+}
+
+// Distance squared between manifold point and result point
+static inline OimoScalar oimo_manifold_updater_dist_sq(
+    const OimoManifoldPoint* mp,
+    const OimoDetectorResultPoint* result,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    OimoVec3 rp1 = oimo_vec3_sub(result->position1, tf1->position);
+    OimoVec3 rp2 = oimo_vec3_sub(result->position2, tf2->position);
+
+    OimoVec3 diff1 = oimo_vec3_sub(mp->_relPos1, rp1);
+    OimoVec3 diff2 = oimo_vec3_sub(mp->_relPos2, rp2);
+
+    OimoScalar sq1 = oimo_vec3_dot(diff1, diff1);
+    OimoScalar sq2 = oimo_vec3_dot(diff2, diff2);
+
+    return (sq1 < sq2) ? sq1 : sq2;
+}
+
+// Find nearest contact point - 1:1 from ManifoldUpdater.findNearestContactPointIndex
+static inline int oimo_manifold_updater_find_nearest_index(
+    OimoManifoldUpdater* updater,
+    const OimoDetectorResultPoint* target,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    OimoManifold* m = updater->_manifold;
+    OimoScalar nearestSq = OIMO_CONTACT_PERSISTENCE_THRESHOLD * OIMO_CONTACT_PERSISTENCE_THRESHOLD;
+    int idx = -1;
+
+    for (int i = 0; i < m->_numPoints; i++) {
+        OimoScalar d = oimo_manifold_updater_dist_sq(&m->_points[i], target, tf1, tf2);
+        if (d < nearestSq) {
+            nearestSq = d;
+            idx = i;
+        }
+    }
+    return idx;
+}
+
+// Save old data for warm starting
+static inline void oimo_manifold_updater_save_old_data(OimoManifoldUpdater* updater) {
+    OimoManifold* m = updater->_manifold;
+    updater->numOldPoints = m->_numPoints;
+    for (int i = 0; i < updater->numOldPoints; i++) {
+        oimo_manifold_point_copy_from(&updater->oldPoints[i], &m->_points[i]);
+    }
+}
+
+// Update contact point by ID for warm starting
+static inline void oimo_manifold_updater_update_by_id(OimoManifoldUpdater* updater, OimoManifoldPoint* cp) {
+    for (int i = 0; i < updater->numOldPoints; i++) {
+        OimoManifoldPoint* ocp = &updater->oldPoints[i];
+        if (cp->_id == ocp->_id) {
+            oimo_contact_impulse_copy_from(&cp->_impulse, &ocp->_impulse);
+            cp->_warmStarted = true;
+            break;
+        }
+    }
+}
+
+// Total update - replace all points - 1:1 from ManifoldUpdater.totalUpdate
+static inline void oimo_manifold_updater_total_update(
+    OimoManifoldUpdater* updater,
+    const OimoDetectorResult* result,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    oimo_manifold_updater_save_old_data(updater);
+
+    OimoManifold* m = updater->_manifold;
+    int num = result->num_points;
+    m->_numPoints = num;
+
+    for (int i = 0; i < num; i++) {
+        OimoManifoldPoint* p = &m->_points[i];
+        oimo_manifold_point_initialize(p, &result->points[i], tf1, tf2);
+        oimo_manifold_updater_update_by_id(updater, p);
+    }
+}
+
+// Incremental update - 1:1 from ManifoldUpdater.incrementalUpdate
+static inline void oimo_manifold_updater_incremental_update(
+    OimoManifoldUpdater* updater,
+    const OimoDetectorResult* result,
+    const OimoTransform* tf1,
+    const OimoTransform* tf2
+) {
+    OimoManifold* m = updater->_manifold;
+
+    // Update old data
+    oimo_manifold_update_depths_and_positions(m, tf1, tf2);
+
+    // Set warm started flag
+    for (int i = 0; i < m->_numPoints; i++) {
+        m->_points[i]._warmStarted = true;
+    }
+
+    // Remove outdated points
+    oimo_manifold_updater_remove_outdated_points(updater);
+
+    // Add new points
+    for (int i = 0; i < result->num_points; i++) {
+        const OimoDetectorResultPoint* newPoint = &result->points[i];
+        int idx = oimo_manifold_updater_find_nearest_index(updater, newPoint, tf1, tf2);
+
+        if (idx == -1) {
+            oimo_manifold_updater_add_point(updater, newPoint, tf1, tf2);
+        } else {
+            oimo_manifold_point_update_depth_and_positions(&m->_points[idx], newPoint, tf1, tf2);
+        }
+    }
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info.h
new file mode 100644
index 0000000000..91a6a3b5f1
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info.h
@@ -0,0 +1,28 @@
+#pragma once
+
+// contact_solver_info.h
+// 1:1 port from OimoPhysics ContactSolverInfo.hx
+
+#include "../../../../common/setting.h"
+#include "contact_solver_info_row.h"
+
+// Forward declare
+struct OimoRigidBody;
+
+typedef struct OimoContactSolverInfo {
+    struct OimoRigidBody* b1;
+    struct OimoRigidBody* b2;
+    int numRows;
+    OimoContactSolverInfoRow rows[OIMO_MAX_MANIFOLD_POINTS];
+} OimoContactSolverInfo;
+
+static inline OimoContactSolverInfo oimo_contact_solver_info_create(void) {
+    OimoContactSolverInfo info;
+    info.b1 = NULL;
+    info.b2 = NULL;
+    info.numRows = 0;
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        info.rows[i] = oimo_contact_solver_info_row_create();
+    }
+    return info;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info_row.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info_row.h
new file mode 100644
index 0000000000..b7ed25430d
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/contact/contact_solver_info_row.h
@@ -0,0 +1,39 @@
+#pragma once
+
+// contact_solver_info_row.h
+// 1:1 port from OimoPhysics ContactSolverInfoRow.hx
+
+#include "../jacobian_row.h"
+#include "../../contact/contact_impulse.h"
+
+typedef struct OimoContactSolverInfoRow {
+    OimoJacobianRow jacobianN;  // Normal jacobian (velocity + position solver)
+    OimoJacobianRow jacobianT;  // Tangent jacobian (velocity solver)
+    OimoJacobianRow jacobianB;  // Binormal jacobian (velocity solver)
+    OimoScalar rhs;             // Right-hand side (velocity + position solver)
+    OimoScalar cfm;             // Constraint force mixing (velocity solver)
+    OimoScalar friction;        // Friction coefficient (velocity solver)
+    OimoContactImpulse* impulse; // Impulse pointer (velocity + position solver)
+} OimoContactSolverInfoRow;
+
+static inline OimoContactSolverInfoRow oimo_contact_solver_info_row_create(void) {
+    OimoContactSolverInfoRow row;
+    row.jacobianN = oimo_jacobian_row_create();
+    row.jacobianT = oimo_jacobian_row_create();
+    row.jacobianB = oimo_jacobian_row_create();
+    row.rhs = 0.0f;
+    row.cfm = 0.0f;
+    row.friction = 0.0f;
+    row.impulse = NULL;
+    return row;
+}
+
+static inline void oimo_contact_solver_info_row_clear(OimoContactSolverInfoRow* row) {
+    oimo_jacobian_row_clear(&row->jacobianN);
+    oimo_jacobian_row_clear(&row->jacobianT);
+    oimo_jacobian_row_clear(&row->jacobianB);
+    row->rhs = 0.0f;
+    row->cfm = 0.0f;
+    row->friction = 0.0f;
+    row->impulse = NULL;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/jacobian_row.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/jacobian_row.h
new file mode 100644
index 0000000000..c9355442a0
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/info/jacobian_row.h
@@ -0,0 +1,29 @@
+#pragma once
+
+// jacobian_row.h
+// 1:1 port from OimoPhysics JacobianRow.hx
+
+#include "../../../common/vec3.h"
+
+typedef struct OimoJacobianRow {
+    OimoVec3 lin1;
+    OimoVec3 lin2;
+    OimoVec3 ang1;
+    OimoVec3 ang2;
+} OimoJacobianRow;
+
+static inline OimoJacobianRow oimo_jacobian_row_create(void) {
+    OimoJacobianRow row;
+    row.lin1 = oimo_vec3_zero();
+    row.lin2 = oimo_vec3_zero();
+    row.ang1 = oimo_vec3_zero();
+    row.ang2 = oimo_vec3_zero();
+    return row;
+}
+
+static inline void oimo_jacobian_row_clear(OimoJacobianRow* row) {
+    row->lin1 = oimo_vec3_zero();
+    row->lin2 = oimo_vec3_zero();
+    row->ang1 = oimo_vec3_zero();
+    row->ang2 = oimo_vec3_zero();
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/position_correction_algorithm.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/position_correction_algorithm.h
new file mode 100644
index 0000000000..74952ae7c5
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/position_correction_algorithm.h
@@ -0,0 +1,13 @@
+#pragma once
+
+// position_correction_algorithm.h
+// 1:1 port from OimoPhysics PositionCorrectionAlgorithm.hx
+
+// Baumgarte stabilization - fastest but introduces extra energy
+#define OIMO_POSITION_CORRECTION_BAUMGARTE 0
+
+// Split impulse - fast, doesn't introduce extra energy, but somewhat unstable for joints
+#define OIMO_POSITION_CORRECTION_SPLIT_IMPULSE 1
+
+// Nonlinear Gauss-Seidel - slow but stable
+#define OIMO_POSITION_CORRECTION_NGS 2
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/contact_solver_mass_data_row.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/contact_solver_mass_data_row.h
new file mode 100644
index 0000000000..3b3d7f7f79
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/contact_solver_mass_data_row.h
@@ -0,0 +1,57 @@
+#pragma once
+
+// contact_solver_mass_data_row.h
+// 1:1 port from OimoPhysics ContactSolverMassDataRow.hx
+
+#include "../../../common/vec3.h"
+
+typedef struct OimoContactSolverMassDataRow {
+    // Normal impulse -> linear/angular velocity change
+    OimoVec3 invMLinN1;
+    OimoVec3 invMLinN2;
+    OimoVec3 invMAngN1;
+    OimoVec3 invMAngN2;
+
+    // Tangent impulse -> linear/angular velocity change
+    OimoVec3 invMLinT1;
+    OimoVec3 invMLinT2;
+    OimoVec3 invMAngT1;
+    OimoVec3 invMAngT2;
+
+    // Binormal impulse -> linear/angular velocity change
+    OimoVec3 invMLinB1;
+    OimoVec3 invMLinB2;
+    OimoVec3 invMAngB1;
+    OimoVec3 invMAngB2;
+
+    // Normal mass
+    OimoScalar massN;
+
+    // Tangent/binormal mass matrix for cone friction
+    OimoScalar massTB00;
+    OimoScalar massTB01;
+    OimoScalar massTB10;
+    OimoScalar massTB11;
+} OimoContactSolverMassDataRow;
+
+static inline OimoContactSolverMassDataRow oimo_contact_solver_mass_data_row_create(void) {
+    OimoContactSolverMassDataRow row;
+    row.invMLinN1 = oimo_vec3_zero();
+    row.invMLinN2 = oimo_vec3_zero();
+    row.invMAngN1 = oimo_vec3_zero();
+    row.invMAngN2 = oimo_vec3_zero();
+    row.invMLinT1 = oimo_vec3_zero();
+    row.invMLinT2 = oimo_vec3_zero();
+    row.invMAngT1 = oimo_vec3_zero();
+    row.invMAngT2 = oimo_vec3_zero();
+    row.invMLinB1 = oimo_vec3_zero();
+    row.invMLinB2 = oimo_vec3_zero();
+    row.invMAngB1 = oimo_vec3_zero();
+    row.invMAngB2 = oimo_vec3_zero();
+    row.massN = 0.0f;
+    row.massTB00 = 0.0f;
+    row.massTB01 = 0.0f;
+    row.massTB10 = 0.0f;
+    row.massTB11 = 0.0f;
+    return row;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/pgs/pgs_contact_constraint_solver.h b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/pgs/pgs_contact_constraint_solver.h
new file mode 100644
index 0000000000..ba0c212c7e
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/constraint/solver/pgs/pgs_contact_constraint_solver.h
@@ -0,0 +1,418 @@
+#pragma once
+
+// pgs_contact_constraint_solver.h
+// 1:1 port from OimoPhysics PgsContactConstraintSolver.hx
+// Projected Gauss-Seidel (Sequential Impulse) solver
+
+#include "../../../../common/vec3.h"
+#include "../../../../common/mat3.h"
+#include "../../../../common/setting.h"
+#include "../../../../common/math_util.h"
+#include "../../../time_step.h"
+#include "../../info/jacobian_row.h"
+#include "../../info/contact/contact_solver_info.h"
+#include "../contact_solver_mass_data_row.h"
+#include "../../contact/contact_constraint.h"
+#include "../../../rigidbody/rigid_body.h"
+
+typedef struct OimoPgsContactConstraintSolver {
+    OimoContactConstraint* constraint;
+    OimoContactSolverInfo info;
+    OimoContactSolverMassDataRow massData[OIMO_MAX_MANIFOLD_POINTS];
+    OimoRigidBody* _b1;
+    OimoRigidBody* _b2;
+    bool _addedToIsland;
+} OimoPgsContactConstraintSolver;
+
+static inline void oimo_pgs_contact_solver_init(OimoPgsContactConstraintSolver* solver, OimoContactConstraint* constraint) {
+    solver->constraint = constraint;
+    solver->info = oimo_contact_solver_info_create();
+    for (int i = 0; i < OIMO_MAX_MANIFOLD_POINTS; i++) {
+        solver->massData[i] = oimo_contact_solver_mass_data_row_create();
+    }
+    solver->_b1 = NULL;
+    solver->_b2 = NULL;
+    solver->_addedToIsland = false;
+}
+
+// Pre-solve velocity - compute mass data - 1:1 from PgsContactConstraintSolver.preSolveVelocity
+static inline void oimo_pgs_contact_solver_pre_solve_velocity(
+    OimoPgsContactConstraintSolver* solver,
+    OimoTimeStep* timeStep
+) {
+    oimo_contact_constraint_get_velocity_solver_info(solver->constraint, timeStep, &solver->info);
+
+    solver->_b1 = solver->info.b1;
+    solver->_b2 = solver->info.b2;
+
+    OimoScalar invM1 = solver->_b1->_invMass;
+    OimoScalar invM2 = solver->_b2->_invMass;
+
+    OimoMat3 invI1 = solver->_b1->_invInertia;
+    OimoMat3 invI2 = solver->_b2->_invInertia;
+
+    // Compute mass data for each row
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoJacobianRow* j;
+
+        // Normal mass
+        j = &row->jacobianN;
+        md->invMLinN1 = oimo_vec3_scale(j->lin1, invM1);
+        md->invMLinN2 = oimo_vec3_scale(j->lin2, invM2);
+        md->invMAngN1 = oimo_mat3_mul_vec3(&invI1, j->ang1);
+        md->invMAngN2 = oimo_mat3_mul_vec3(&invI2, j->ang2);
+
+        md->massN = invM1 + invM2 + oimo_vec3_dot(md->invMAngN1, j->ang1) + oimo_vec3_dot(md->invMAngN2, j->ang2);
+        if (oimo_abs(md->massN) > OIMO_EPSILON) md->massN = 1.0f / md->massN;
+
+        // Tangent/binormal mass
+        OimoJacobianRow* jt = &row->jacobianT;
+        OimoJacobianRow* jb = &row->jacobianB;
+        md->invMLinT1 = oimo_vec3_scale(jt->lin1, invM1);
+        md->invMLinT2 = oimo_vec3_scale(jt->lin2, invM2);
+        md->invMLinB1 = oimo_vec3_scale(jb->lin1, invM1);
+        md->invMLinB2 = oimo_vec3_scale(jb->lin2, invM2);
+        md->invMAngT1 = oimo_mat3_mul_vec3(&invI1, jt->ang1);
+        md->invMAngT2 = oimo_mat3_mul_vec3(&invI2, jt->ang2);
+        md->invMAngB1 = oimo_mat3_mul_vec3(&invI1, jb->ang1);
+        md->invMAngB2 = oimo_mat3_mul_vec3(&invI2, jb->ang2);
+
+        // Compute effective mass matrix for friction
+        OimoScalar invMassTB00 = invM1 + invM2 + oimo_vec3_dot(md->invMAngT1, jt->ang1) + oimo_vec3_dot(md->invMAngT2, jt->ang2);
+        OimoScalar invMassTB01 = oimo_vec3_dot(md->invMAngT1, jb->ang1) + oimo_vec3_dot(md->invMAngT2, jb->ang2);
+        OimoScalar invMassTB10 = invMassTB01;
+        OimoScalar invMassTB11 = invM1 + invM2 + oimo_vec3_dot(md->invMAngB1, jb->ang1) + oimo_vec3_dot(md->invMAngB2, jb->ang2);
+
+        OimoScalar invDet = invMassTB00 * invMassTB11 - invMassTB01 * invMassTB10;
+        if (oimo_abs(invDet) > OIMO_EPSILON) invDet = 1.0f / invDet;
+
+        md->massTB00 = invMassTB11 * invDet;
+        md->massTB01 = -invMassTB01 * invDet;
+        md->massTB10 = -invMassTB10 * invDet;
+        md->massTB11 = invMassTB00 * invDet;
+    }
+}
+
+// Warm start - apply accumulated impulses - 1:1 from PgsContactConstraintSolver.warmStart
+static inline void oimo_pgs_contact_solver_warm_start(
+    OimoPgsContactConstraintSolver* solver,
+    OimoTimeStep* timeStep
+) {
+    OimoVec3 lv1 = solver->_b1->_vel;
+    OimoVec3 lv2 = solver->_b2->_vel;
+    OimoVec3 av1 = solver->_b1->_angVel;
+    OimoVec3 av2 = solver->_b2->_angVel;
+
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoJacobianRow* jt = &row->jacobianT;
+        OimoJacobianRow* jb = &row->jacobianB;
+
+        OimoScalar impulseN = imp->impulseN;
+        OimoScalar impulseT = oimo_vec3_dot(imp->impulseL, jt->lin1);
+        OimoScalar impulseB = oimo_vec3_dot(imp->impulseL, jb->lin1);
+        imp->impulseT = impulseT;
+        imp->impulseB = impulseB;
+
+        // Adjust impulse for variable time step
+        imp->impulseN *= timeStep->dtRatio;
+        imp->impulseT *= timeStep->dtRatio;
+        imp->impulseB *= timeStep->dtRatio;
+
+        // Apply impulses
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinN1, impulseN));
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinT1, impulseT));
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinB1, impulseB));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinN2, impulseN));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinT2, impulseT));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinB2, impulseB));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngN1, impulseN));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngT1, impulseT));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngB1, impulseB));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngN2, impulseN));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngT2, impulseT));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngB2, impulseB));
+    }
+
+    solver->_b1->_vel = lv1;
+    solver->_b2->_vel = lv2;
+    solver->_b1->_angVel = av1;
+    solver->_b2->_angVel = av2;
+}
+
+// Solve velocity constraints - 1:1 from PgsContactConstraintSolver.solveVelocity
+static inline void oimo_pgs_contact_solver_solve_velocity(OimoPgsContactConstraintSolver* solver) {
+    OimoVec3 lv1 = solver->_b1->_vel;
+    OimoVec3 lv2 = solver->_b2->_vel;
+    OimoVec3 av1 = solver->_b1->_angVel;
+    OimoVec3 av2 = solver->_b2->_angVel;
+
+    // Solve friction first
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoJacobianRow* j;
+
+        // Measure relative velocity along tangent
+        OimoScalar rvt = 0.0f;
+        j = &row->jacobianT;
+        rvt += oimo_vec3_dot(lv1, j->lin1);
+        rvt -= oimo_vec3_dot(lv2, j->lin2);
+        rvt += oimo_vec3_dot(av1, j->ang1);
+        rvt -= oimo_vec3_dot(av2, j->ang2);
+
+        // Measure relative velocity along binormal
+        OimoScalar rvb = 0.0f;
+        j = &row->jacobianB;
+        rvb += oimo_vec3_dot(lv1, j->lin1);
+        rvb -= oimo_vec3_dot(lv2, j->lin2);
+        rvb += oimo_vec3_dot(av1, j->ang1);
+        rvb -= oimo_vec3_dot(av2, j->ang2);
+
+        OimoScalar impulseT = -(rvt * md->massTB00 + rvb * md->massTB01);
+        OimoScalar impulseB = -(rvt * md->massTB10 + rvb * md->massTB11);
+
+        OimoScalar oldImpulseT = imp->impulseT;
+        OimoScalar oldImpulseB = imp->impulseB;
+        imp->impulseT += impulseT;
+        imp->impulseB += impulseB;
+
+        // Cone friction
+        OimoScalar maxImpulse = row->friction * imp->impulseN;
+        if (oimo_abs(maxImpulse) <= OIMO_EPSILON) {
+            imp->impulseT = 0.0f;
+            imp->impulseB = 0.0f;
+        } else {
+            OimoScalar impulseLengthSq = imp->impulseT * imp->impulseT + imp->impulseB * imp->impulseB;
+            if (impulseLengthSq > maxImpulse * maxImpulse) {
+                OimoScalar invL = maxImpulse / oimo_sqrt(impulseLengthSq);
+                imp->impulseT *= invL;
+                imp->impulseB *= invL;
+            }
+        }
+
+        impulseT = imp->impulseT - oldImpulseT;
+        impulseB = imp->impulseB - oldImpulseB;
+
+        // Apply delta impulse
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinT1, impulseT));
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinB1, impulseB));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinT2, impulseT));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinB2, impulseB));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngT1, impulseT));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngB1, impulseB));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngT2, impulseT));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngB2, impulseB));
+    }
+
+    // Solve normal
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoJacobianRow* j;
+
+        // Measure relative velocity along normal
+        OimoScalar rvn = 0.0f;
+        j = &row->jacobianN;
+        rvn += oimo_vec3_dot(lv1, j->lin1);
+        rvn -= oimo_vec3_dot(lv2, j->lin2);
+        rvn += oimo_vec3_dot(av1, j->ang1);
+        rvn -= oimo_vec3_dot(av2, j->ang2);
+
+        OimoScalar impulseN = (row->rhs - rvn) * md->massN;
+
+        // Clamp impulse (only pushing, no pulling)
+        OimoScalar oldImpulseN = imp->impulseN;
+        imp->impulseN += impulseN;
+        if (imp->impulseN < 0.0f) imp->impulseN = 0.0f;
+        impulseN = imp->impulseN - oldImpulseN;
+
+        // Apply delta impulse
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinN1, impulseN));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinN2, impulseN));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngN1, impulseN));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngN2, impulseN));
+    }
+
+    solver->_b1->_vel = lv1;
+    solver->_b2->_vel = lv2;
+    solver->_b1->_angVel = av1;
+    solver->_b2->_angVel = av2;
+}
+
+// Update position data for position solver
+static inline void oimo_pgs_contact_solver_update_position_data(OimoPgsContactConstraintSolver* solver) {
+    oimo_contact_constraint_sync_manifold(solver->constraint);
+    oimo_contact_constraint_get_position_solver_info(solver->constraint, &solver->info);
+
+    OimoScalar invM1 = solver->_b1->_invMass;
+    OimoScalar invM2 = solver->_b2->_invMass;
+
+    OimoMat3 invI1 = solver->_b1->_invInertia;
+    OimoMat3 invI2 = solver->_b2->_invInertia;
+
+    // Compute mass data
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoJacobianRow* j = &row->jacobianN;
+
+        md->invMLinN1 = oimo_vec3_scale(j->lin1, invM1);
+        md->invMLinN2 = oimo_vec3_scale(j->lin2, invM2);
+        md->invMAngN1 = oimo_mat3_mul_vec3(&invI1, j->ang1);
+        md->invMAngN2 = oimo_mat3_mul_vec3(&invI2, j->ang2);
+
+        md->massN = invM1 + invM2 + oimo_vec3_dot(md->invMAngN1, j->ang1) + oimo_vec3_dot(md->invMAngN2, j->ang2);
+        if (oimo_abs(md->massN) > OIMO_EPSILON) md->massN = 1.0f / md->massN;
+    }
+}
+
+// Pre-solve position
+static inline void oimo_pgs_contact_solver_pre_solve_position(
+    OimoPgsContactConstraintSolver* solver,
+    OimoTimeStep* timeStep
+) {
+    oimo_pgs_contact_solver_update_position_data(solver);
+
+    // Clear position impulses
+    for (int i = 0; i < solver->info.numRows; i++) {
+        solver->info.rows[i].impulse->impulseP = 0.0f;
+    }
+}
+
+// Solve position with split impulse - 1:1 from PgsContactConstraintSolver.solvePositionSplitImpulse
+static inline void oimo_pgs_contact_solver_solve_position_split_impulse(OimoPgsContactConstraintSolver* solver) {
+    OimoVec3 lv1 = solver->_b1->_pseudoVel;
+    OimoVec3 lv2 = solver->_b2->_pseudoVel;
+    OimoVec3 av1 = solver->_b1->_angPseudoVel;
+    OimoVec3 av2 = solver->_b2->_angPseudoVel;
+
+    // Solve normal
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoJacobianRow* j = &row->jacobianN;
+
+        // Measure relative velocity
+        OimoScalar rvn = 0.0f;
+        rvn += oimo_vec3_dot(lv1, j->lin1);
+        rvn -= oimo_vec3_dot(lv2, j->lin2);
+        rvn += oimo_vec3_dot(av1, j->ang1);
+        rvn -= oimo_vec3_dot(av2, j->ang2);
+
+        OimoScalar impulseP = (row->rhs - rvn) * md->massN * OIMO_POSITION_SPLIT_IMPULSE_BAUMGARTE;
+
+        // Clamp impulse
+        OimoScalar oldImpulseP = imp->impulseP;
+        imp->impulseP += impulseP;
+        if (imp->impulseP < 0.0f) imp->impulseP = 0.0f;
+        impulseP = imp->impulseP - oldImpulseP;
+
+        // Apply delta impulse
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinN1, impulseP));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinN2, impulseP));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngN1, impulseP));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngN2, impulseP));
+    }
+
+    solver->_b1->_pseudoVel = lv1;
+    solver->_b2->_pseudoVel = lv2;
+    solver->_b1->_angPseudoVel = av1;
+    solver->_b2->_angPseudoVel = av2;
+}
+
+// Solve position with NGS - 1:1 from PgsContactConstraintSolver.solvePositionNgs
+static inline void oimo_pgs_contact_solver_solve_position_ngs(
+    OimoPgsContactConstraintSolver* solver,
+    OimoTimeStep* timeStep
+) {
+    oimo_pgs_contact_solver_update_position_data(solver);
+
+    OimoVec3 lv1 = oimo_vec3_zero();
+    OimoVec3 lv2 = oimo_vec3_zero();
+    OimoVec3 av1 = oimo_vec3_zero();
+    OimoVec3 av2 = oimo_vec3_zero();
+
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactSolverMassDataRow* md = &solver->massData[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoJacobianRow* j = &row->jacobianN;
+
+        // Estimate translation along the normal
+        OimoScalar rvn = 0.0f;
+        rvn += oimo_vec3_dot(lv1, j->lin1);
+        rvn -= oimo_vec3_dot(lv2, j->lin2);
+        rvn += oimo_vec3_dot(av1, j->ang1);
+        rvn -= oimo_vec3_dot(av2, j->ang2);
+
+        OimoScalar impulseP = (row->rhs - rvn) * md->massN * OIMO_POSITION_NGS_BAUMGARTE;
+
+        // Clamp impulse
+        OimoScalar oldImpulseP = imp->impulseP;
+        imp->impulseP += impulseP;
+        if (imp->impulseP < 0.0f) imp->impulseP = 0.0f;
+        impulseP = imp->impulseP - oldImpulseP;
+
+        // Apply delta impulse
+        lv1 = oimo_vec3_add(lv1, oimo_vec3_scale(md->invMLinN1, impulseP));
+        lv2 = oimo_vec3_sub(lv2, oimo_vec3_scale(md->invMLinN2, impulseP));
+        av1 = oimo_vec3_add(av1, oimo_vec3_scale(md->invMAngN1, impulseP));
+        av2 = oimo_vec3_sub(av2, oimo_vec3_scale(md->invMAngN2, impulseP));
+    }
+
+    oimo_rigid_body_apply_translation(solver->_b1, &lv1);
+    oimo_rigid_body_apply_translation(solver->_b2, &lv2);
+    oimo_rigid_body_apply_rotation(solver->_b1, &av1);
+    oimo_rigid_body_apply_rotation(solver->_b2, &av2);
+}
+
+// Post solve - store lateral impulse and accumulate contact impulses
+// 1:1 from PgsContactConstraintSolver.postSolve
+static inline void oimo_pgs_contact_solver_post_solve(OimoPgsContactConstraintSolver* solver) {
+    OimoVec3 lin1 = oimo_vec3_zero();
+    OimoVec3 ang1 = oimo_vec3_zero();
+    OimoVec3 ang2 = oimo_vec3_zero();
+
+    for (int i = 0; i < solver->info.numRows; i++) {
+        OimoContactSolverInfoRow* row = &solver->info.rows[i];
+        OimoContactImpulse* imp = row->impulse;
+        OimoJacobianRow* jn = &row->jacobianN;
+        OimoJacobianRow* jt = &row->jacobianT;
+        OimoJacobianRow* jb = &row->jacobianB;
+        OimoScalar impN = imp->impulseN;
+        OimoScalar impT = imp->impulseT;
+        OimoScalar impB = imp->impulseB;
+
+        // Store lateral impulse
+        OimoVec3 impulseL = oimo_vec3_zero();
+        impulseL = oimo_vec3_add(impulseL, oimo_vec3_scale(jt->lin1, impT));
+        impulseL = oimo_vec3_add(impulseL, oimo_vec3_scale(jb->lin1, impB));
+        imp->impulseL = impulseL;
+
+        // Accumulate contact impulses
+        lin1 = oimo_vec3_add(lin1, oimo_vec3_scale(jn->lin1, impN));
+        ang1 = oimo_vec3_add(ang1, oimo_vec3_scale(jn->ang1, impN));
+        ang2 = oimo_vec3_add(ang2, oimo_vec3_scale(jn->ang2, impN));
+        lin1 = oimo_vec3_add(lin1, oimo_vec3_scale(jt->lin1, impT));
+        ang1 = oimo_vec3_add(ang1, oimo_vec3_scale(jt->ang1, impT));
+        ang2 = oimo_vec3_add(ang2, oimo_vec3_scale(jt->ang2, impT));
+        lin1 = oimo_vec3_add(lin1, oimo_vec3_scale(jb->lin1, impB));
+        ang1 = oimo_vec3_add(ang1, oimo_vec3_scale(jb->ang1, impB));
+        ang2 = oimo_vec3_add(ang2, oimo_vec3_scale(jb->ang2, impB));
+    }
+
+    solver->_b1->_linearContactImpulse = oimo_vec3_add(solver->_b1->_linearContactImpulse, lin1);
+    solver->_b1->_angularContactImpulse = oimo_vec3_add(solver->_b1->_angularContactImpulse, ang1);
+    solver->_b2->_linearContactImpulse = oimo_vec3_sub(solver->_b2->_linearContactImpulse, lin1);
+    solver->_b2->_angularContactImpulse = oimo_vec3_sub(solver->_b2->_angularContactImpulse, ang2);
+
+    oimo_contact_constraint_sync_manifold(solver->constraint);
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/contact.h b/armorcore/Deployment/n64/src/oimo/dynamics/contact.h
new file mode 100644
index 0000000000..d0f4dd62f5
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/contact.h
@@ -0,0 +1,218 @@
+#pragma once
+
+// contact.h
+// 1:1 port from OimoPhysics Contact.hx
+
+#include <stdbool.h>
+#include "../common/vec3.h"
+#include "../collision/narrowphase/detector.h"
+#include "../collision/narrowphase/detector_result.h"
+#include "rigidbody/shape.h"
+#include "rigidbody/rigid_body.h"
+#include "contact_link.h"
+#include "constraint/contact/manifold.h"
+#include "constraint/contact/manifold_updater.h"
+#include "constraint/contact/contact_constraint.h"
+#include "constraint/solver/pgs/pgs_contact_constraint_solver.h"
+
+typedef struct OimoContact {
+    struct OimoContact* _next;
+    struct OimoContact* _prev;
+
+    OimoContactLink _link1;
+    OimoContactLink _link2;
+
+    OimoShape* _s1;
+    OimoShape* _s2;
+    OimoRigidBody* _b1;
+    OimoRigidBody* _b2;
+
+    // Detector data
+    OimoDetector* _detector;
+    OimoDetectorResult _detectorResult;
+
+    // Temp flags
+    bool _latest;
+    bool _shouldBeSkipped;
+
+    // Constraint/manifold data
+    OimoManifold _manifold;
+    OimoManifoldUpdater _updater;
+    OimoContactConstraint _contactConstraint;
+    OimoPgsContactConstraintSolver _solver;
+
+    bool _touching;
+    bool _triggering;  // True if either shape is a trigger
+} OimoContact;
+
+static inline void oimo_contact_init(OimoContact* c) {
+    c->_next = NULL;
+    c->_prev = NULL;
+    c->_link1 = oimo_contact_link_create();
+    c->_link2 = oimo_contact_link_create();
+    c->_s1 = NULL;
+    c->_s2 = NULL;
+    c->_b1 = NULL;
+    c->_b2 = NULL;
+    c->_detector = NULL;
+    c->_detectorResult = oimo_detector_result_create();
+    c->_latest = false;
+    c->_shouldBeSkipped = false;
+    c->_manifold = oimo_manifold_create();
+    oimo_manifold_updater_init(&c->_updater, &c->_manifold);
+    oimo_contact_constraint_init(&c->_contactConstraint, &c->_manifold);
+    oimo_pgs_contact_solver_init(&c->_solver, &c->_contactConstraint);
+    c->_touching = false;
+    c->_triggering = false;
+}
+
+// Attach contact to shapes
+static inline void oimo_contact_attach(OimoContact* c, OimoShape* s1, OimoShape* s2, OimoDetector* detector) {
+    c->_s1 = s1;
+    c->_s2 = s2;
+    c->_b1 = s1->_rigidBody;
+    c->_b2 = s2->_rigidBody;
+    c->_touching = false;
+    c->_triggering = false;
+    c->_detector = detector;
+
+    // Attach links to rigid bodies
+    c->_link1._contact = c;
+    c->_link2._contact = c;
+    c->_link1._other = c->_b2;
+    c->_link2._other = c->_b1;
+
+    // Add to rigid body contact link lists
+    // Link1 to b1
+    c->_link1._next = c->_b1->_contactLinkList;
+    c->_link1._prev = NULL;
+    if (c->_b1->_contactLinkList != NULL) {
+        c->_b1->_contactLinkList->_prev = &c->_link1;
+    }
+    c->_b1->_contactLinkList = &c->_link1;
+    if (c->_b1->_contactLinkListLast == NULL) {
+        c->_b1->_contactLinkListLast = &c->_link1;
+    }
+    c->_b1->_numContactLinks++;
+
+    // Link2 to b2
+    c->_link2._next = c->_b2->_contactLinkList;
+    c->_link2._prev = NULL;
+    if (c->_b2->_contactLinkList != NULL) {
+        c->_b2->_contactLinkList->_prev = &c->_link2;
+    }
+    c->_b2->_contactLinkList = &c->_link2;
+    if (c->_b2->_contactLinkListLast == NULL) {
+        c->_b2->_contactLinkListLast = &c->_link2;
+    }
+    c->_b2->_numContactLinks++;
+
+    oimo_contact_constraint_attach(&c->_contactConstraint, s1, s2);
+}
+
+// Detach contact from shapes
+static inline void oimo_contact_detach(OimoContact* c) {
+    // Remove link1 from b1
+    if (c->_link1._prev != NULL) {
+        c->_link1._prev->_next = c->_link1._next;
+    } else {
+        c->_b1->_contactLinkList = c->_link1._next;
+    }
+    if (c->_link1._next != NULL) {
+        c->_link1._next->_prev = c->_link1._prev;
+    } else {
+        c->_b1->_contactLinkListLast = c->_link1._prev;
+    }
+    c->_b1->_numContactLinks--;
+
+    // Remove link2 from b2
+    if (c->_link2._prev != NULL) {
+        c->_link2._prev->_next = c->_link2._next;
+    } else {
+        c->_b2->_contactLinkList = c->_link2._next;
+    }
+    if (c->_link2._next != NULL) {
+        c->_link2._next->_prev = c->_link2._prev;
+    } else {
+        c->_b2->_contactLinkListLast = c->_link2._prev;
+    }
+    c->_b2->_numContactLinks--;
+
+    c->_link1._other = NULL;
+    c->_link2._other = NULL;
+    c->_link1._contact = NULL;
+    c->_link2._contact = NULL;
+
+    c->_s1 = NULL;
+    c->_s2 = NULL;
+    c->_b1 = NULL;
+    c->_b2 = NULL;
+    c->_touching = false;
+    c->_triggering = false;
+
+    oimo_manifold_clear(&c->_manifold);
+    c->_detector = NULL;
+
+    oimo_contact_constraint_detach(&c->_contactConstraint);
+}
+
+// Update manifold with collision detection result
+// Uses collision_matrix for detection dispatch
+static inline void oimo_contact_update_manifold_with_matrix(
+    OimoContact* c,
+    OimoCollisionMatrix* matrix)
+{
+    if (c->_s1 == NULL || c->_s2 == NULL) return;
+    if (c->_s1->_geom == NULL || c->_s2->_geom == NULL) return;
+
+    OimoTransform* tf1 = &c->_s1->_transform;
+    OimoTransform* tf2 = &c->_s2->_transform;
+
+    // Run narrowphase detection using collision matrix
+    oimo_collision_matrix_detect(matrix, &c->_detectorResult,
+        c->_s1->_geom, c->_s2->_geom, tf1, tf2);
+
+    if (c->_detectorResult.num_points > 0) {
+        // Build basis from normal
+        oimo_manifold_build_basis(&c->_manifold, c->_detectorResult.normal);
+
+        // Incremental update for persistent contacts
+        if (c->_manifold._numPoints > 0) {
+            oimo_manifold_updater_incremental_update(&c->_updater, &c->_detectorResult, tf1, tf2);
+        } else {
+            oimo_manifold_updater_total_update(&c->_updater, &c->_detectorResult, tf1, tf2);
+        }
+
+        c->_touching = true;
+        // 1:1 from OimoPhysics: _triggering = _touching && (_s1._isTrigger || _s2._isTrigger)
+        c->_triggering = (c->_s1->_isTrigger || c->_s2->_isTrigger);
+    } else {
+        oimo_manifold_clear(&c->_manifold);
+        c->_touching = false;
+        c->_triggering = false;
+    }
+}
+
+static inline bool oimo_contact_is_touching(const OimoContact* c) {
+    return c->_touching;
+}
+
+static inline OimoShape* oimo_contact_get_shape1(const OimoContact* c) {
+    return c->_s1;
+}
+
+static inline OimoShape* oimo_contact_get_shape2(const OimoContact* c) {
+    return c->_s2;
+}
+
+static inline OimoManifold* oimo_contact_get_manifold(OimoContact* c) {
+    return &c->_manifold;
+}
+
+static inline OimoContact* oimo_contact_get_next(const OimoContact* c) {
+    return c->_next;
+}
+
+static inline OimoContact* oimo_contact_get_prev(const OimoContact* c) {
+    return c->_prev;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/contact_link.h b/armorcore/Deployment/n64/src/oimo/dynamics/contact_link.h
new file mode 100644
index 0000000000..ef864f6862
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/contact_link.h
@@ -0,0 +1,40 @@
+#pragma once
+
+// contact_link.h
+// 1:1 port from OimoPhysics ContactLink.hx
+
+// Forward declarations
+struct OimoContact;
+struct OimoRigidBody;
+
+typedef struct OimoContactLink {
+    struct OimoContactLink* _prev;
+    struct OimoContactLink* _next;
+    struct OimoContact* _contact;
+    struct OimoRigidBody* _other;
+} OimoContactLink;
+
+static inline OimoContactLink oimo_contact_link_create(void) {
+    OimoContactLink link;
+    link._prev = NULL;
+    link._next = NULL;
+    link._contact = NULL;
+    link._other = NULL;
+    return link;
+}
+
+static inline struct OimoContact* oimo_contact_link_get_contact(const OimoContactLink* link) {
+    return link->_contact;
+}
+
+static inline struct OimoRigidBody* oimo_contact_link_get_other(const OimoContactLink* link) {
+    return link->_other;
+}
+
+static inline OimoContactLink* oimo_contact_link_get_prev(const OimoContactLink* link) {
+    return link->_prev;
+}
+
+static inline OimoContactLink* oimo_contact_link_get_next(const OimoContactLink* link) {
+    return link->_next;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/contact_manager.h b/armorcore/Deployment/n64/src/oimo/dynamics/contact_manager.h
new file mode 100644
index 0000000000..00981b0a3e
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/contact_manager.h
@@ -0,0 +1,258 @@
+#pragma once
+
+// contact_manager.h
+// 1:1 port from OimoPhysics ContactManager.hx
+
+#include <libdragon.h>
+#include "../collision/broadphase/broadphase.h"
+#include "../collision/broadphase/proxy_pair.h"
+#include "../collision/narrowphase/collision_matrix.h"
+#include "rigidbody/shape.h"
+#include "rigidbody/rigid_body.h"
+#include "rigidbody/rigid_body_type.h"
+#include "contact.h"
+
+// Maximum contacts (for N64 memory constraints)
+#define OIMO_MAX_CONTACTS 64
+
+typedef struct OimoContactManager {
+    int _numContacts;
+    OimoContact* _contactList;
+    OimoContact* _contactListLast;
+
+    // Contact pool for reuse
+    OimoContact _contactPool[OIMO_MAX_CONTACTS];
+    int _contactPoolUsed;
+    OimoContact* _freeList;
+    bool _poolOverflowWarned;
+
+    OimoBroadPhase* _broadPhase;
+    OimoCollisionMatrix _collisionMatrix;
+} OimoContactManager;
+
+static inline void oimo_contact_manager_init(OimoContactManager* cm, OimoBroadPhase* broadPhase) {
+    cm->_numContacts = 0;
+    cm->_contactList = NULL;
+    cm->_contactListLast = NULL;
+    cm->_broadPhase = broadPhase;
+    cm->_collisionMatrix = oimo_collision_matrix_create();
+
+    // Initialize contact pool
+    cm->_contactPoolUsed = 0;
+    cm->_freeList = NULL;
+    cm->_poolOverflowWarned = false;
+    for (int i = 0; i < OIMO_MAX_CONTACTS; i++) {
+        oimo_contact_init(&cm->_contactPool[i]);
+    }
+}
+
+// Get a contact from the pool
+static inline OimoContact* oimo_contact_manager_alloc_contact(OimoContactManager* cm) {
+    if (cm->_freeList != NULL) {
+        OimoContact* c = cm->_freeList;
+        cm->_freeList = c->_next;
+        oimo_contact_init(c);
+        return c;
+    }
+    if (cm->_contactPoolUsed < OIMO_MAX_CONTACTS) {
+        OimoContact* c = &cm->_contactPool[cm->_contactPoolUsed++];
+        oimo_contact_init(c);
+        return c;
+    }
+    if (!cm->_poolOverflowWarned) {
+        debugf("Oimo: contact pool exhausted (%d max). Increase OIMO_MAX_CONTACTS.\n", OIMO_MAX_CONTACTS);
+        cm->_poolOverflowWarned = true;
+    }
+    return NULL; // Pool exhausted
+}
+
+// Return a contact to the pool
+static inline void oimo_contact_manager_free_contact(OimoContactManager* cm, OimoContact* c) {
+    c->_next = cm->_freeList;
+    cm->_freeList = c;
+    cm->_poolOverflowWarned = false;
+}
+
+// Check if two shapes should collide - 1:1 from ContactManager.shouldCollide
+static inline bool oimo_contact_manager_should_collide(OimoShape* s1, OimoShape* s2) {
+    OimoRigidBody* r1 = s1->_rigidBody;
+    OimoRigidBody* r2 = s2->_rigidBody;
+
+    if (r1 == r2) {
+        return false;  // Same parent
+    }
+
+    if (r1->_type != OIMO_RIGID_BODY_DYNAMIC && r2->_type != OIMO_RIGID_BODY_DYNAMIC) {
+        return false;  // Neither is dynamic
+    }
+
+    // Collision filtering
+    if ((s1->_collisionGroup & s2->_collisionMask) == 0 ||
+        (s2->_collisionGroup & s1->_collisionMask) == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+// Create contacts from broadphase pairs - 1:1 from ContactManager.createContacts
+static inline void oimo_contact_manager_create_contacts(OimoContactManager* cm) {
+    OimoProxyPair* pp = cm->_broadPhase->_proxyPairList;
+
+    while (pp != NULL) {
+        OimoShape* s1;
+        OimoShape* s2;
+
+        if (pp->_p1->_id < pp->_p2->_id) {
+            s1 = (OimoShape*)pp->_p1->userData;
+            s2 = (OimoShape*)pp->_p2->userData;
+        } else {
+            s1 = (OimoShape*)pp->_p2->userData;
+            s2 = (OimoShape*)pp->_p1->userData;
+        }
+
+        // Collision filtering
+        if (!oimo_contact_manager_should_collide(s1, s2)) {
+            pp = pp->_next;
+            continue;
+        }
+
+        // Search for existing contact
+        OimoRigidBody* b1 = s1->_rigidBody;
+        OimoRigidBody* b2 = s2->_rigidBody;
+        int n1 = b1->_numContactLinks;
+        int n2 = b2->_numContactLinks;
+
+        OimoContactLink* l;
+        if (n1 < n2) {
+            l = b1->_contactLinkList;
+        } else {
+            l = b2->_contactLinkList;
+        }
+
+        int id1 = s1->_id;
+        int id2 = s2->_id;
+        bool found = false;
+
+        while (l != NULL) {
+            OimoContact* c = l->_contact;
+            if (c->_s1->_id == id1 && c->_s2->_id == id2) {
+                c->_latest = true;
+                found = true;
+                break;
+            }
+            l = l->_next;
+        }
+
+        // If not found, create new contact
+        if (!found) {
+            OimoContact* c = oimo_contact_manager_alloc_contact(cm);
+            if (c != NULL) {
+                // Add to contact list
+                c->_prev = cm->_contactListLast;
+                c->_next = NULL;
+                if (cm->_contactListLast != NULL) {
+                    cm->_contactListLast->_next = c;
+                } else {
+                    cm->_contactList = c;
+                }
+                cm->_contactListLast = c;
+
+                c->_latest = true;
+                OimoDetector* detector = oimo_collision_matrix_get_detector(&cm->_collisionMatrix, s1->_geom->type, s2->_geom->type);
+                oimo_contact_attach(c, s1, s2, detector);
+                cm->_numContacts++;
+            }
+        }
+
+        pp = pp->_next;
+    }
+}
+
+// Destroy a contact - 1:1 from ContactManager._destroyContact
+static inline void oimo_contact_manager_destroy_contact(OimoContactManager* cm, OimoContact* contact) {
+    // Remove from list
+    if (contact->_prev != NULL) {
+        contact->_prev->_next = contact->_next;
+    } else {
+        cm->_contactList = contact->_next;
+    }
+    if (contact->_next != NULL) {
+        contact->_next->_prev = contact->_prev;
+    } else {
+        cm->_contactListLast = contact->_prev;
+    }
+
+    oimo_contact_detach(contact);
+    oimo_contact_manager_free_contact(cm, contact);
+    cm->_numContacts--;
+}
+
+// Destroy outdated contacts - 1:1 from ContactManager.destroyOutdatedContacts
+static inline void oimo_contact_manager_destroy_outdated_contacts(OimoContactManager* cm) {
+    bool incremental = cm->_broadPhase->_incremental;
+
+    OimoContact* c = cm->_contactList;
+    while (c != NULL) {
+        OimoContact* next = c->_next;
+
+        if (c->_latest) {
+            c->_latest = false;
+            c->_shouldBeSkipped = false;
+        } else if (!incremental) {
+            oimo_contact_manager_destroy_contact(cm, c);
+        } else {
+            OimoShape* s1 = c->_s1;
+            OimoShape* s2 = c->_s2;
+            OimoRigidBody* r1 = s1->_rigidBody;
+            OimoRigidBody* r2 = s2->_rigidBody;
+
+            bool active1 = !r1->_sleeping && r1->_type != OIMO_RIGID_BODY_STATIC;
+            bool active2 = !r2->_sleeping && r2->_type != OIMO_RIGID_BODY_STATIC;
+
+            if (!active1 && !active2) {
+                c->_shouldBeSkipped = true;
+            } else if (!oimo_broadphase_is_overlapping(s1->_proxy, s2->_proxy) ||
+                       !oimo_contact_manager_should_collide(s1, s2)) {
+                oimo_contact_manager_destroy_contact(cm, c);
+            } else {
+                // Check AABB overlap
+                bool aabbOverlapping = oimo_aabb_overlap(&s1->_aabb, &s2->_aabb);
+                c->_shouldBeSkipped = !aabbOverlapping;
+            }
+        }
+
+        c = next;
+    }
+}
+
+// Update contacts (broadphase) - 1:1 from ContactManager._updateContacts
+static inline void oimo_contact_manager_update_contacts(OimoContactManager* cm) {
+    oimo_broadphase_collect_pairs(cm->_broadPhase);
+    oimo_contact_manager_create_contacts(cm);
+    oimo_contact_manager_destroy_outdated_contacts(cm);
+}
+
+// Update manifolds (narrowphase) - 1:1 from ContactManager._updateManifolds
+static inline void oimo_contact_manager_update_manifolds(OimoContactManager* cm) {
+    OimoContact* c = cm->_contactList;
+    while (c != NULL) {
+        if (!c->_shouldBeSkipped) {
+            oimo_contact_update_manifold_with_matrix(c, &cm->_collisionMatrix);
+        }
+        c = c->_next;
+    }
+}
+
+// Post solve
+static inline void oimo_contact_manager_post_solve(OimoContactManager* cm) {
+    // Currently no callbacks needed for N64
+}
+
+static inline int oimo_contact_manager_get_num_contacts(const OimoContactManager* cm) {
+    return cm->_numContacts;
+}
+
+static inline OimoContact* oimo_contact_manager_get_contact_list(const OimoContactManager* cm) {
+    return cm->_contactList;
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/island.h b/armorcore/Deployment/n64/src/oimo/dynamics/island.h
new file mode 100644
index 0000000000..653f6545d5
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/island.h
@@ -0,0 +1,261 @@
+#pragma once
+
+// island.h
+// 1:1 port from OimoPhysics Island.hx
+
+#include "../common/vec3.h"
+#include "../common/mat3.h"
+#include "../common/setting.h"
+#include "time_step.h"
+#include "rigidbody/rigid_body.h"
+#include "rigidbody/rigid_body_type.h"
+#include "constraint/position_correction_algorithm.h"
+#include "constraint/solver/pgs/pgs_contact_constraint_solver.h"
+
+// Island size limits for N64
+#define OIMO_MAX_ISLAND_BODIES 32
+#define OIMO_MAX_ISLAND_SOLVERS 64
+
+typedef struct OimoIsland {
+    OimoVec3 gravity;
+
+    int numRigidBodies;
+    OimoRigidBody* rigidBodies[OIMO_MAX_ISLAND_BODIES];
+
+    // All constraint solvers
+    int numSolvers;
+    OimoPgsContactConstraintSolver* solvers[OIMO_MAX_ISLAND_SOLVERS];
+
+    // Split impulse solvers
+    int numSolversSi;
+    OimoPgsContactConstraintSolver* solversSi[OIMO_MAX_ISLAND_SOLVERS];
+
+    // NGS solvers
+    int numSolversNgs;
+    OimoPgsContactConstraintSolver* solversNgs[OIMO_MAX_ISLAND_SOLVERS];
+} OimoIsland;
+
+static inline void oimo_island_init(OimoIsland* island) {
+    island->gravity = oimo_vec3(0.0f, -9.80665f, 0.0f);
+    island->numRigidBodies = 0;
+    island->numSolvers = 0;
+    island->numSolversSi = 0;
+    island->numSolversNgs = 0;
+}
+
+// Fast inverse exponential approximation - 1:1 from Island.fastInvExp
+static inline OimoScalar oimo_island_fast_inv_exp(OimoScalar x) {
+    OimoScalar x2 = x * x;
+    return 1.0f / (1.0f + x + x2 * (0.5f + x * (1.0f/6.0f) + x2 * (1.0f/24.0f)));
+}
+
+static inline void oimo_island_clear(OimoIsland* island) {
+    for (int i = 0; i < island->numRigidBodies; i++) {
+        island->rigidBodies[i] = NULL;
+    }
+    for (int i = 0; i < island->numSolvers; i++) {
+        island->solvers[i] = NULL;
+    }
+    for (int i = 0; i < island->numSolversSi; i++) {
+        island->solversSi[i] = NULL;
+    }
+    for (int i = 0; i < island->numSolversNgs; i++) {
+        island->solversNgs[i] = NULL;
+    }
+    island->numRigidBodies = 0;
+    island->numSolvers = 0;
+    island->numSolversSi = 0;
+    island->numSolversNgs = 0;
+}
+
+static inline void oimo_island_set_gravity(OimoIsland* island, OimoVec3 gravity) {
+    island->gravity = gravity;
+}
+
+static inline void oimo_island_add_rigid_body(OimoIsland* island, OimoRigidBody* rb) {
+    if (island->numRigidBodies < OIMO_MAX_ISLAND_BODIES) {
+        rb->_addedToIsland = 1;
+        island->rigidBodies[island->numRigidBodies++] = rb;
+    }
+}
+
+static inline void oimo_island_add_solver(OimoIsland* island, OimoPgsContactConstraintSolver* solver, int positionCorrection) {
+    if (island->numSolvers < OIMO_MAX_ISLAND_SOLVERS) {
+        solver->_addedToIsland = true;
+        island->solvers[island->numSolvers++] = solver;
+
+        if (positionCorrection == OIMO_POSITION_CORRECTION_SPLIT_IMPULSE) {
+            if (island->numSolversSi < OIMO_MAX_ISLAND_SOLVERS) {
+                island->solversSi[island->numSolversSi++] = solver;
+            }
+        }
+        if (positionCorrection == OIMO_POSITION_CORRECTION_NGS) {
+            if (island->numSolversNgs < OIMO_MAX_ISLAND_SOLVERS) {
+                island->solversNgs[island->numSolversNgs++] = solver;
+            }
+        }
+    }
+}
+
+// Step single rigid body - 1:1 from Island._stepSingleRigidBody
+static inline void oimo_island_step_single_rigid_body(OimoIsland* island, OimoTimeStep* timeStep, OimoRigidBody* rb) {
+    OimoScalar dt = timeStep->dt;
+
+    // Store previous transform
+    rb->_ptransform = rb->_transform;
+
+    // Clear contact impulses
+    rb->_linearContactImpulse = oimo_vec3_zero();
+    rb->_angularContactImpulse = oimo_vec3_zero();
+
+    // Update sleep time
+    if (oimo_rigid_body_is_sleepy(rb)) {
+        rb->_sleepTime += dt;
+        if (rb->_sleepTime >= rb->_sleepingTimeThreshold) {
+            oimo_rigid_body_sleep(rb);
+        }
+    } else {
+        rb->_sleepTime = 0.0f;
+    }
+
+    if (!rb->_sleeping) {
+        if (rb->_type == OIMO_RIGID_BODY_DYNAMIC) {
+            // Damping
+            OimoScalar linScale = oimo_island_fast_inv_exp(dt * rb->_linearDamping);
+            OimoScalar angScale = oimo_island_fast_inv_exp(dt * rb->_angularDamping);
+
+            // Compute accelerations
+            OimoVec3 linAcc = oimo_vec3_scale(island->gravity, rb->_gravityScale);
+            OimoVec3 forceAcc = oimo_vec3_scale(rb->_force, rb->_invMass);
+            linAcc = oimo_vec3_add(linAcc, forceAcc);
+            OimoVec3 angAcc = oimo_mat3_mul_vec3(&rb->_invInertia, rb->_torque);
+
+            // Update velocity
+            OimoVec3 linAccDt = oimo_vec3_scale(linAcc, dt);
+            rb->_vel = oimo_vec3_add(rb->_vel, linAccDt);
+            rb->_vel = oimo_vec3_scale(rb->_vel, linScale);
+            OimoVec3 angAccDt = oimo_vec3_scale(angAcc, dt);
+            rb->_angVel = oimo_vec3_add(rb->_angVel, angAccDt);
+            rb->_angVel = oimo_vec3_scale(rb->_angVel, angScale);
+        }
+        oimo_rigid_body_integrate(rb, dt);
+        oimo_rigid_body_sync_shapes(rb);
+    }
+}
+
+// Step island with multiple bodies and constraints - 1:1 from Island._step
+static inline void oimo_island_step(
+    OimoIsland* island,
+    OimoTimeStep* timeStep,
+    int numVelocityIterations,
+    int numPositionIterations
+) {
+    OimoScalar dt = timeStep->dt;
+    bool sleepIsland = true;
+
+    // Sleep check and apply gravity
+    for (int i = 0; i < island->numRigidBodies; i++) {
+        OimoRigidBody* rb = island->rigidBodies[i];
+
+        // Store previous transform
+        rb->_ptransform = rb->_transform;
+
+        // Clear contact impulses
+        rb->_linearContactImpulse = oimo_vec3_zero();
+        rb->_angularContactImpulse = oimo_vec3_zero();
+
+        // Don't let the rigid body sleep yet
+        rb->_sleeping = 0;
+
+        // Update sleep time
+        if (oimo_rigid_body_is_sleepy(rb)) {
+            rb->_sleepTime += dt;
+        } else {
+            rb->_sleepTime = 0.0f;
+        }
+
+        // Check if awake
+        if (rb->_sleepTime < rb->_sleepingTimeThreshold) {
+            sleepIsland = false;
+        }
+
+        // Apply forces
+        if (rb->_type == OIMO_RIGID_BODY_DYNAMIC) {
+            OimoScalar linScale = oimo_island_fast_inv_exp(dt * rb->_linearDamping);
+            OimoScalar angScale = oimo_island_fast_inv_exp(dt * rb->_angularDamping);
+
+            OimoVec3 linAcc = oimo_vec3_scale(island->gravity, rb->_gravityScale);
+            OimoVec3 forceAcc = oimo_vec3_scale(rb->_force, rb->_invMass);
+            linAcc = oimo_vec3_add(linAcc, forceAcc);
+            OimoVec3 angAcc = oimo_mat3_mul_vec3(&rb->_invInertia, rb->_torque);
+
+            OimoVec3 linAccDt = oimo_vec3_scale(linAcc, dt);
+            rb->_vel = oimo_vec3_add(rb->_vel, linAccDt);
+            rb->_vel = oimo_vec3_scale(rb->_vel, linScale);
+            OimoVec3 angAccDt = oimo_vec3_scale(angAcc, dt);
+            rb->_angVel = oimo_vec3_add(rb->_angVel, angAccDt);
+            rb->_angVel = oimo_vec3_scale(rb->_angVel, angScale);
+        }
+    }
+
+    // Sleep the whole island if all bodies are sleepy
+    if (sleepIsland) {
+        for (int i = 0; i < island->numRigidBodies; i++) {
+            oimo_rigid_body_sleep(island->rigidBodies[i]);
+        }
+        return;
+    }
+
+    // Solve velocity constraints
+    for (int i = 0; i < island->numSolvers; i++) {
+        oimo_pgs_contact_solver_pre_solve_velocity(island->solvers[i], timeStep);
+    }
+    for (int i = 0; i < island->numSolvers; i++) {
+        oimo_pgs_contact_solver_warm_start(island->solvers[i], timeStep);
+    }
+    for (int t = 0; t < numVelocityIterations; t++) {
+        for (int i = 0; i < island->numSolvers; i++) {
+            oimo_pgs_contact_solver_solve_velocity(island->solvers[i]);
+        }
+    }
+
+    // Integrate positions
+    for (int i = 0; i < island->numRigidBodies; i++) {
+        oimo_rigid_body_integrate(island->rigidBodies[i], dt);
+    }
+
+    // Solve split impulse position correction
+    for (int i = 0; i < island->numSolversSi; i++) {
+        oimo_pgs_contact_solver_pre_solve_position(island->solversSi[i], timeStep);
+    }
+    for (int t = 0; t < numPositionIterations; t++) {
+        for (int i = 0; i < island->numSolversSi; i++) {
+            oimo_pgs_contact_solver_solve_position_split_impulse(island->solversSi[i]);
+        }
+    }
+
+    // Integrate pseudo velocity
+    for (int i = 0; i < island->numRigidBodies; i++) {
+        oimo_rigid_body_integrate_pseudo_velocity(island->rigidBodies[i]);
+    }
+
+    // Solve NGS position correction
+    for (int i = 0; i < island->numSolversNgs; i++) {
+        oimo_pgs_contact_solver_pre_solve_position(island->solversNgs[i], timeStep);
+    }
+    for (int t = 0; t < numPositionIterations; t++) {
+        for (int i = 0; i < island->numSolversNgs; i++) {
+            oimo_pgs_contact_solver_solve_position_ngs(island->solversNgs[i], timeStep);
+        }
+    }
+
+    // Post solve
+    for (int i = 0; i < island->numSolvers; i++) {
+        oimo_pgs_contact_solver_post_solve(island->solvers[i]);
+    }
+
+    // Synchronize shapes
+    for (int i = 0; i < island->numRigidBodies; i++) {
+        oimo_rigid_body_sync_shapes(island->rigidBodies[i]);
+    }
+}
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/mass_data.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/mass_data.h
new file mode 100644
index 0000000000..f54584b642
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/mass_data.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../../common/mat3.h"
+
+typedef struct OimoMassData {
+    OimoScalar mass;           // Mass (0 for non-dynamic)
+    OimoMat3 localInertia;     // Inertia tensor in local space
+} OimoMassData;
+
+static inline void oimo_mass_data_init(OimoMassData* md) {
+    md->mass = 0;
+    md->localInertia = oimo_mat3_zero();
+}
+
+static inline OimoMassData oimo_mass_data(void) {
+    OimoMassData md;
+    oimo_mass_data_init(&md);
+    return md;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body.h
new file mode 100644
index 0000000000..25f219ee61
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body.h
@@ -0,0 +1,595 @@
+#pragma once
+
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/quat.h"
+#include "../../common/transform.h"
+#include "../../common/setting.h"
+#include "../../common/math_util.h"
+#include "rigid_body_type.h"
+#include "rigid_body_config.h"
+#include "mass_data.h"
+#include "shape.h"
+
+// Forward declarations
+struct OimoWorld;
+struct OimoContactLink;
+struct OimoJointLink;
+
+typedef struct OimoRigidBody {
+    struct OimoRigidBody* _next;
+    struct OimoRigidBody* _prev;
+
+    // Shape linked list
+    OimoShape* _shapeList;
+    OimoShape* _shapeListLast;
+    int _numShapes;
+
+    // Velocities
+    OimoVec3 _vel;
+    OimoVec3 _angVel;
+    OimoVec3 _pseudoVel;
+    OimoVec3 _angPseudoVel;
+
+    // Transforms
+    OimoTransform _ptransform;  // Previous
+    OimoTransform _transform;   // Current
+
+    int _type;
+
+    // Sleeping
+    OimoScalar _sleepTime;
+    int _sleeping;
+    int _autoSleep;
+    OimoScalar _sleepingVelocityThreshold;
+    OimoScalar _sleepingAngularVelocityThreshold;
+    OimoScalar _sleepingTimeThreshold;
+
+    // Mass properties
+    OimoScalar _mass;
+    OimoScalar _invMass;
+    OimoMat3 _localInertia;
+    OimoMat3 _invLocalInertia;
+    OimoMat3 _invLocalInertiaWithoutRotFactor;
+    OimoMat3 _invInertia;
+    OimoVec3 _rotFactor;
+
+    // Damping
+    OimoScalar _linearDamping;
+    OimoScalar _angularDamping;
+
+    // Forces (accumulated per frame)
+    OimoVec3 _force;
+    OimoVec3 _torque;
+
+    // Contact impulses (for querying)
+    OimoVec3 _linearContactImpulse;
+    OimoVec3 _angularContactImpulse;
+
+    // World reference
+    struct OimoWorld* _world;
+
+    // Contact/Joint links
+    struct OimoContactLink* _contactLinkList;
+    struct OimoContactLink* _contactLinkListLast;
+    int _numContactLinks;
+
+    struct OimoJointLink* _jointLinkList;
+    struct OimoJointLink* _jointLinkListLast;
+    int _numJointLinks;
+
+    int _addedToIsland;
+    OimoScalar _gravityScale;
+
+    void* userData;
+} OimoRigidBody;
+
+static inline void oimo_rigid_body_update_inv_inertia(OimoRigidBody* rb) {
+    // _invInertia = R * _invLocalInertia * R^T
+    OimoMat3 tmp = oimo_mat3_mul(&rb->_transform.rotation, &rb->_invLocalInertia);
+    OimoMat3 rt = oimo_mat3_transpose(&rb->_transform.rotation);
+    rb->_invInertia = oimo_mat3_mul(&tmp, &rt);
+}
+
+static inline void oimo_rigid_body_complete_mass_data(OimoRigidBody* rb) {
+    OimoScalar det = oimo_mat3_determinant(&rb->_localInertia);
+
+    if (rb->_mass > 0 && det > 0 && rb->_type == OIMO_RIGID_BODY_DYNAMIC) {
+        rb->_invMass = 1.0f / rb->_mass;
+        rb->_invLocalInertia = oimo_mat3_inverse(&rb->_localInertia);
+        rb->_invLocalInertiaWithoutRotFactor = rb->_invLocalInertia;
+
+        // Apply rotation factor
+        rb->_invLocalInertia.e00 *= rb->_rotFactor.x;
+        rb->_invLocalInertia.e10 *= rb->_rotFactor.x;
+        rb->_invLocalInertia.e20 *= rb->_rotFactor.x;
+        rb->_invLocalInertia.e01 *= rb->_rotFactor.y;
+        rb->_invLocalInertia.e11 *= rb->_rotFactor.y;
+        rb->_invLocalInertia.e21 *= rb->_rotFactor.y;
+        rb->_invLocalInertia.e02 *= rb->_rotFactor.z;
+        rb->_invLocalInertia.e12 *= rb->_rotFactor.z;
+        rb->_invLocalInertia.e22 *= rb->_rotFactor.z;
+    } else {
+        rb->_invMass = 0;
+        rb->_invLocalInertia = oimo_mat3_zero();
+        rb->_invLocalInertiaWithoutRotFactor = oimo_mat3_zero();
+
+        // Minimum mass for dynamic bodies to avoid NaN
+        if (rb->_type == OIMO_RIGID_BODY_DYNAMIC) {
+            rb->_invMass = 1e-9f;
+            rb->_invLocalInertiaWithoutRotFactor = oimo_mat3(
+                1e-9f, 0, 0,
+                0, 1e-9f, 0,
+                0, 0, 1e-9f
+            );
+            rb->_invLocalInertia = rb->_invLocalInertiaWithoutRotFactor;
+        }
+    }
+    oimo_rigid_body_update_inv_inertia(rb);
+}
+
+static inline void oimo_rigid_body_sync_shapes(OimoRigidBody* rb) {
+    OimoShape* s = rb->_shapeList;
+    while (s != NULL) {
+        oimo_shape_sync(s, &rb->_ptransform, &rb->_transform);
+        s = s->_next;
+    }
+}
+
+static inline void oimo_rigid_body_update_mass(OimoRigidBody* rb);
+
+static inline void oimo_rigid_body_shape_modified(OimoRigidBody* rb) {
+    oimo_rigid_body_update_mass(rb);
+    oimo_rigid_body_sync_shapes(rb);
+}
+
+static inline void oimo_rigid_body_wake_up(OimoRigidBody* rb) {
+    rb->_sleeping = 0;
+    rb->_sleepTime = 0;
+}
+
+static inline void oimo_rigid_body_sleep(OimoRigidBody* rb) {
+    rb->_sleeping = 1;
+    rb->_sleepTime = 0;
+}
+
+static inline void oimo_rigid_body_update_transform_ext(OimoRigidBody* rb) {
+    rb->_ptransform = oimo_transform_copy(&rb->_transform);
+    oimo_rigid_body_sync_shapes(rb);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_init(OimoRigidBody* rb, const OimoRigidBodyConfig* config) {
+    rb->_next = NULL;
+    rb->_prev = NULL;
+
+    rb->_shapeList = NULL;
+    rb->_shapeListLast = NULL;
+    rb->_numShapes = 0;
+
+    rb->_contactLinkList = NULL;
+    rb->_contactLinkListLast = NULL;
+    rb->_numContactLinks = 0;
+
+    rb->_jointLinkList = NULL;
+    rb->_jointLinkListLast = NULL;
+    rb->_numJointLinks = 0;
+
+    rb->_vel = config->linearVelocity;
+    rb->_angVel = config->angularVelocity;
+    rb->_pseudoVel = oimo_vec3_zero();
+    rb->_angPseudoVel = oimo_vec3_zero();
+
+    rb->_ptransform = oimo_transform(&config->position, &config->rotation);
+    rb->_transform = oimo_transform_copy(&rb->_ptransform);
+
+    rb->_type = config->type;
+
+    rb->_sleepTime = 0;
+    rb->_sleeping = 0;
+    rb->_autoSleep = config->autoSleep;
+    rb->_sleepingVelocityThreshold = config->sleepingVelocityThreshold;
+    rb->_sleepingAngularVelocityThreshold = config->sleepingAngularVelocityThreshold;
+    rb->_sleepingTimeThreshold = config->sleepingTimeThreshold;
+
+    rb->_mass = 0;
+    rb->_invMass = 0;
+    rb->_localInertia = oimo_mat3_zero();
+    rb->_invLocalInertia = oimo_mat3_zero();
+    rb->_invLocalInertiaWithoutRotFactor = oimo_mat3_zero();
+    rb->_invInertia = oimo_mat3_zero();
+
+    rb->_linearDamping = config->linearDamping;
+    rb->_angularDamping = config->angularDamping;
+
+    rb->_force = oimo_vec3_zero();
+    rb->_torque = oimo_vec3_zero();
+    rb->_linearContactImpulse = oimo_vec3_zero();
+    rb->_angularContactImpulse = oimo_vec3_zero();
+
+    rb->_rotFactor = oimo_vec3(1, 1, 1);
+    rb->_addedToIsland = 0;
+    rb->_gravityScale = 1.0f;
+    rb->_world = NULL;
+    rb->userData = NULL;
+}
+
+static inline void oimo_rigid_body_apply_translation(OimoRigidBody* rb, const OimoVec3* translation) {
+    oimo_vec3_add_eq(&rb->_transform.position, translation);
+}
+
+static inline void oimo_rigid_body_apply_rotation(OimoRigidBody* rb, const OimoVec3* rotation) {
+    OimoScalar theta = oimo_vec3_len(*rotation);
+    OimoScalar halfTheta = theta * 0.5f;
+    OimoScalar rotationToSinAxisFactor;
+    OimoScalar cosHalfTheta;
+
+    if (halfTheta < 0.5f) {
+        // Maclaurin expansion for small angles
+        OimoScalar ht2 = halfTheta * halfTheta;
+        rotationToSinAxisFactor = 0.5f * (1.0f - ht2 * (1.0f / 6.0f) + ht2 * ht2 * (1.0f / 120.0f));
+        cosHalfTheta = 1.0f - ht2 * 0.5f + ht2 * ht2 * (1.0f / 24.0f);
+    } else {
+        rotationToSinAxisFactor = oimo_sin(halfTheta) / theta;
+        cosHalfTheta = oimo_cos(halfTheta);
+    }
+
+    OimoVec3 sinAxis = oimo_vec3_scale(*rotation, rotationToSinAxisFactor);
+    OimoQuat dq = oimo_quat(sinAxis.x, sinAxis.y, sinAxis.z, cosHalfTheta);
+
+    // Get current rotation as quaternion
+    OimoQuat q = oimo_mat3_to_quat(&rb->_transform.rotation);
+
+    // Integrate: q = dq * q
+    q = oimo_quat_mul(&dq, &q);
+    q = oimo_quat_normalize(&q);
+
+    // Update rotation matrix
+    rb->_transform.rotation = oimo_quat_to_mat3(&q);
+
+    oimo_rigid_body_update_inv_inertia(rb);
+}
+
+static inline void oimo_rigid_body_integrate(OimoRigidBody* rb, OimoScalar dt) {
+    if (rb->_type == OIMO_RIGID_BODY_STATIC) {
+        rb->_vel = oimo_vec3_zero();
+        rb->_angVel = oimo_vec3_zero();
+        rb->_pseudoVel = oimo_vec3_zero();
+        rb->_angPseudoVel = oimo_vec3_zero();
+        return;
+    }
+
+    OimoVec3 translation = oimo_vec3_scale(rb->_vel, dt);
+    OimoVec3 rotation = oimo_vec3_scale(rb->_angVel, dt);
+
+    OimoScalar translationLengthSq = oimo_vec3_len_sq(translation);
+    OimoScalar rotationLengthSq = oimo_vec3_len_sq(rotation);
+
+    if (translationLengthSq <= OIMO_EPSILON && rotationLengthSq <= OIMO_EPSILON) {
+        return;
+    }
+
+    // Limit linear velocity - use inv_sqrt to avoid sqrt in common case
+    if (translationLengthSq > OIMO_MAX_TRANSLATION_PER_STEP * OIMO_MAX_TRANSLATION_PER_STEP) {
+        OimoScalar l = OIMO_MAX_TRANSLATION_PER_STEP * oimo_inv_sqrt(translationLengthSq);
+        oimo_vec3_scale_eq(&rb->_vel, l);
+        oimo_vec3_scale_eq(&translation, l);
+    }
+
+    // Limit angular velocity - use inv_sqrt to avoid sqrt in common case
+    if (rotationLengthSq > OIMO_MAX_ROTATION_PER_STEP * OIMO_MAX_ROTATION_PER_STEP) {
+        OimoScalar l = OIMO_MAX_ROTATION_PER_STEP * oimo_inv_sqrt(rotationLengthSq);
+        oimo_vec3_scale_eq(&rb->_angVel, l);
+        oimo_vec3_scale_eq(&rotation, l);
+    }
+
+    oimo_rigid_body_apply_translation(rb, &translation);
+    oimo_rigid_body_apply_rotation(rb, &rotation);
+}
+
+static inline void oimo_rigid_body_integrate_pseudo_velocity(OimoRigidBody* rb) {
+    OimoScalar pseudoVelLengthSq = oimo_vec3_len_sq(rb->_pseudoVel);
+    OimoScalar angPseudoVelLengthSq = oimo_vec3_len_sq(rb->_angPseudoVel);
+
+    if (pseudoVelLengthSq <= OIMO_EPSILON && angPseudoVelLengthSq <= OIMO_EPSILON) {
+        return;
+    }
+
+    if (rb->_type == OIMO_RIGID_BODY_STATIC) {
+        rb->_pseudoVel = oimo_vec3_zero();
+        rb->_angPseudoVel = oimo_vec3_zero();
+        return;
+    }
+
+    OimoVec3 translation = rb->_pseudoVel;
+    OimoVec3 rotation = rb->_angPseudoVel;
+
+    rb->_pseudoVel = oimo_vec3_zero();
+    rb->_angPseudoVel = oimo_vec3_zero();
+
+    oimo_rigid_body_apply_translation(rb, &translation);
+    oimo_rigid_body_apply_rotation(rb, &rotation);
+}
+
+static inline int oimo_rigid_body_is_sleepy(const OimoRigidBody* rb) {
+    return rb->_autoSleep &&
+           oimo_vec3_len_sq(rb->_vel) < rb->_sleepingVelocityThreshold * rb->_sleepingVelocityThreshold &&
+           oimo_vec3_len_sq(rb->_angVel) < rb->_sleepingAngularVelocityThreshold * rb->_sleepingAngularVelocityThreshold;
+}
+
+static inline int oimo_rigid_body_is_alone(const OimoRigidBody* rb) {
+    return rb->_numContactLinks == 0 && rb->_numJointLinks == 0;
+}
+
+static inline void oimo_rigid_body_update_mass(OimoRigidBody* rb) {
+    OimoMat3 totalInertia = oimo_mat3_zero();
+    OimoScalar totalMass = 0;
+
+    OimoShape* s = rb->_shapeList;
+    while (s != NULL) {
+        OimoGeometry* g = s->_geom;
+
+        OimoScalar mass = s->_density * g->volume;
+
+        // I_transformed = R * I_localCoeff * R^T * mass
+        OimoMat3 inertia = oimo_mat3_mul(&s->_localTransform.rotation, &g->inertia_coeff);
+        OimoMat3 rt = oimo_mat3_transpose(&s->_localTransform.rotation);
+        inertia = oimo_mat3_mul(&inertia, &rt);
+        inertia = oimo_mat3_scale(&inertia, mass);
+
+        // Add parallel axis theorem contribution
+        OimoVec3* p = &s->_localTransform.position;
+        OimoScalar xx = p->x * p->x, yy = p->y * p->y, zz = p->z * p->z;
+        OimoScalar xy = p->x * p->y, xz = p->x * p->z, yz = p->y * p->z;
+
+        OimoMat3 cogInertia = oimo_mat3(
+            (yy + zz) * mass, -xy * mass,       -xz * mass,
+            -xy * mass,       (xx + zz) * mass, -yz * mass,
+            -xz * mass,       -yz * mass,       (xx + yy) * mass
+        );
+
+        inertia = oimo_mat3_add(&inertia, &cogInertia);
+
+        totalMass += mass;
+        totalInertia = oimo_mat3_add(&totalInertia, &inertia);
+
+        s = s->_next;
+    }
+
+    rb->_mass = totalMass;
+    rb->_localInertia = totalInertia;
+
+    oimo_rigid_body_complete_mass_data(rb);
+    oimo_rigid_body_wake_up(rb);
+}
+
+// Set mass data directly (like OimoPhysics setMassData)
+// This overrides the auto-calculated mass from density * volume
+static inline void oimo_rigid_body_set_mass_data(OimoRigidBody* rb, const OimoMassData* massData) {
+    rb->_mass = massData->mass;
+    rb->_localInertia = massData->localInertia;
+
+    oimo_rigid_body_complete_mass_data(rb);
+    oimo_rigid_body_wake_up(rb);
+}
+
+// Convenience function to just set mass (keeping computed inertia)
+static inline void oimo_rigid_body_set_mass(OimoRigidBody* rb, OimoScalar mass) {
+    rb->_mass = mass;
+    oimo_rigid_body_complete_mass_data(rb);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline OimoVec3 oimo_rigid_body_get_position(const OimoRigidBody* rb) {
+    return rb->_transform.position;
+}
+
+static inline void oimo_rigid_body_set_position(OimoRigidBody* rb, const OimoVec3* position) {
+    rb->_transform.position = *position;
+    oimo_rigid_body_update_transform_ext(rb);
+}
+
+static inline OimoMat3 oimo_rigid_body_get_rotation(const OimoRigidBody* rb) {
+    return rb->_transform.rotation;
+}
+
+static inline void oimo_rigid_body_set_rotation(OimoRigidBody* rb, const OimoMat3* rotation) {
+    rb->_transform.rotation = *rotation;
+    oimo_rigid_body_update_inv_inertia(rb);
+    oimo_rigid_body_update_transform_ext(rb);
+}
+
+static inline OimoQuat oimo_rigid_body_get_orientation(const OimoRigidBody* rb) {
+    return oimo_mat3_to_quat(&rb->_transform.rotation);
+}
+
+static inline void oimo_rigid_body_set_orientation(OimoRigidBody* rb, const OimoQuat* q) {
+    rb->_transform.rotation = oimo_quat_to_mat3(q);
+    oimo_rigid_body_update_inv_inertia(rb);
+    oimo_rigid_body_update_transform_ext(rb);
+}
+
+static inline OimoTransform oimo_rigid_body_get_transform(const OimoRigidBody* rb) {
+    return oimo_transform_copy(&rb->_transform);
+}
+
+static inline void oimo_rigid_body_set_transform(OimoRigidBody* rb, const OimoTransform* tf) {
+    rb->_transform = oimo_transform_copy(tf);
+    oimo_rigid_body_update_inv_inertia(rb);
+    oimo_rigid_body_update_transform_ext(rb);
+}
+
+static inline OimoScalar oimo_rigid_body_get_mass(const OimoRigidBody* rb) {
+    return rb->_mass;
+}
+
+static inline OimoVec3 oimo_rigid_body_get_linear_velocity(const OimoRigidBody* rb) {
+    return rb->_vel;
+}
+
+static inline void oimo_rigid_body_set_linear_velocity(OimoRigidBody* rb, const OimoVec3* vel) {
+    if (rb->_type == OIMO_RIGID_BODY_STATIC) {
+        rb->_vel = oimo_vec3_zero();
+    } else {
+        rb->_vel = *vel;
+    }
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline OimoVec3 oimo_rigid_body_get_angular_velocity(const OimoRigidBody* rb) {
+    return rb->_angVel;
+}
+
+static inline void oimo_rigid_body_set_angular_velocity(OimoRigidBody* rb, const OimoVec3* vel) {
+    if (rb->_type == OIMO_RIGID_BODY_STATIC) {
+        rb->_angVel = oimo_vec3_zero();
+    } else {
+        rb->_angVel = *vel;
+    }
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_impulse(OimoRigidBody* rb, const OimoVec3* impulse, const OimoVec3* positionInWorld) {
+    // Linear impulse
+    oimo_vec3_add_scaled_eq(&rb->_vel, impulse, rb->_invMass);
+
+    // Angular impulse
+    OimoVec3 r = oimo_vec3_sub(*positionInWorld, rb->_transform.position);
+    OimoVec3 angImp = oimo_vec3_cross(r, *impulse);
+    angImp = oimo_mat3_mul_vec3(&rb->_invInertia, angImp);
+    oimo_vec3_add_eq(&rb->_angVel, &angImp);
+
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_linear_impulse(OimoRigidBody* rb, const OimoVec3* impulse) {
+    oimo_vec3_add_scaled_eq(&rb->_vel, impulse, rb->_invMass);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_angular_impulse(OimoRigidBody* rb, const OimoVec3* impulse) {
+    OimoVec3 angImp = oimo_mat3_mul_vec3(&rb->_invInertia, *impulse);
+    oimo_vec3_add_eq(&rb->_angVel, &angImp);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_force(OimoRigidBody* rb, const OimoVec3* force, const OimoVec3* positionInWorld) {
+    oimo_vec3_add_eq(&rb->_force, force);
+
+    OimoVec3 r = oimo_vec3_sub(*positionInWorld, rb->_transform.position);
+    OimoVec3 torque = oimo_vec3_cross(r, *force);
+    oimo_vec3_add_eq(&rb->_torque, &torque);
+
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_force_to_center(OimoRigidBody* rb, const OimoVec3* force) {
+    oimo_vec3_add_eq(&rb->_force, force);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline void oimo_rigid_body_apply_torque(OimoRigidBody* rb, const OimoVec3* torque) {
+    oimo_vec3_add_eq(&rb->_torque, torque);
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline int oimo_rigid_body_get_type(const OimoRigidBody* rb) {
+    return rb->_type;
+}
+
+static inline void oimo_rigid_body_set_type(OimoRigidBody* rb, int type) {
+    rb->_type = type;
+    oimo_rigid_body_update_mass(rb);
+}
+
+static inline int oimo_rigid_body_is_sleeping(const OimoRigidBody* rb) {
+    return rb->_sleeping;
+}
+
+static inline OimoScalar oimo_rigid_body_get_gravity_scale(const OimoRigidBody* rb) {
+    return rb->_gravityScale;
+}
+
+static inline void oimo_rigid_body_set_gravity_scale(OimoRigidBody* rb, OimoScalar scale) {
+    rb->_gravityScale = scale;
+    oimo_rigid_body_wake_up(rb);
+}
+
+static inline int oimo_rigid_body_get_num_shapes(const OimoRigidBody* rb) {
+    return rb->_numShapes;
+}
+
+static inline OimoShape* oimo_rigid_body_get_shape_list(const OimoRigidBody* rb) {
+    return rb->_shapeList;
+}
+
+static inline OimoRigidBody* oimo_rigid_body_get_prev(const OimoRigidBody* rb) {
+    return rb->_prev;
+}
+
+static inline OimoRigidBody* oimo_rigid_body_get_next(const OimoRigidBody* rb) {
+    return rb->_next;
+}
+
+static inline void oimo_rigid_body_add_shape_internal(OimoRigidBody* rb, OimoShape* shape) {
+    // Add to linked list
+    if (rb->_shapeListLast != NULL) {
+        rb->_shapeListLast->_next = shape;
+        shape->_prev = rb->_shapeListLast;
+        shape->_next = NULL;
+        rb->_shapeListLast = shape;
+    } else {
+        rb->_shapeList = shape;
+        rb->_shapeListLast = shape;
+        shape->_prev = NULL;
+        shape->_next = NULL;
+    }
+    rb->_numShapes++;
+    shape->_rigidBody = rb;
+}
+
+static inline void oimo_rigid_body_remove_shape_internal(OimoRigidBody* rb, OimoShape* shape) {
+    // Remove from linked list
+    if (shape->_prev != NULL) {
+        shape->_prev->_next = shape->_next;
+    } else {
+        rb->_shapeList = shape->_next;
+    }
+    if (shape->_next != NULL) {
+        shape->_next->_prev = shape->_prev;
+    } else {
+        rb->_shapeListLast = shape->_prev;
+    }
+    shape->_prev = NULL;
+    shape->_next = NULL;
+    rb->_numShapes--;
+    shape->_rigidBody = NULL;
+}
+
+// Public shape management functions
+static inline void oimo_rigid_body_add_shape(OimoRigidBody* rb, OimoShape* shape) {
+    oimo_rigid_body_add_shape_internal(rb, shape);
+    // Sync transform
+    oimo_shape_sync(shape, &rb->_ptransform, &rb->_transform);
+}
+
+static inline void oimo_rigid_body_remove_shape(OimoRigidBody* rb, OimoShape* shape) {
+    oimo_rigid_body_remove_shape_internal(rb, shape);
+}
+
+// Public mass getter/setter (for compatibility with body->mass pattern)
+#define mass _mass
+
+// Compatibility aliases (without underscore between rigid and body)
+// Note: oimo_rigidbody_apply_force maps to _to_center variant (2 args, not 3)
+#define oimo_rigidbody_apply_force           oimo_rigid_body_apply_force_to_center
+#define oimo_rigidbody_apply_force_to_center oimo_rigid_body_apply_force_to_center
+#define oimo_rigidbody_apply_torque          oimo_rigid_body_apply_torque
+#define oimo_rigidbody_apply_impulse         oimo_rigid_body_apply_impulse
+#define oimo_rigidbody_apply_linear_impulse  oimo_rigid_body_apply_linear_impulse
+#define oimo_rigidbody_apply_angular_impulse oimo_rigid_body_apply_angular_impulse
+#define oimo_rigidbody_wake_up               oimo_rigid_body_wake_up
+#define oimo_rigidbody_sleep                 oimo_rigid_body_sleep
+#define oimo_rigidbody_get_type              oimo_rigid_body_get_type
+#define oimo_rigidbody_set_type              oimo_rigid_body_set_type
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_config.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_config.h
new file mode 100644
index 0000000000..f67037b531
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_config.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/setting.h"
+#include "rigid_body_type.h"
+
+typedef struct OimoRigidBodyConfig {
+    OimoVec3 position;                        // World position
+    OimoMat3 rotation;                        // Rotation matrix
+    OimoVec3 linearVelocity;                  // Initial linear velocity
+    OimoVec3 angularVelocity;                 // Initial angular velocity
+    int type;                                 // DYNAMIC, STATIC, or KINEMATIC
+    OimoScalar linearDamping;                 // Linear velocity damping
+    OimoScalar angularDamping;                // Angular velocity damping
+    int autoSleep;                            // Auto-sleep when stationary
+    OimoScalar sleepingVelocityThreshold;     // Linear velocity threshold for sleep
+    OimoScalar sleepingAngularVelocityThreshold; // Angular velocity threshold for sleep
+    OimoScalar sleepingTimeThreshold;         // Time threshold for sleep
+} OimoRigidBodyConfig;
+
+static inline void oimo_rigid_body_config_init(OimoRigidBodyConfig* config) {
+    config->position = oimo_vec3_zero();
+    config->rotation = oimo_mat3_identity();
+    config->linearVelocity = oimo_vec3_zero();
+    config->angularVelocity = oimo_vec3_zero();
+    config->type = OIMO_RIGID_BODY_DYNAMIC;
+    config->linearDamping = 0;
+    config->angularDamping = 0;
+    config->autoSleep = !OIMO_DISABLE_SLEEPING;
+    config->sleepingVelocityThreshold = OIMO_SLEEPING_VELOCITY_THRESHOLD;
+    config->sleepingAngularVelocityThreshold = OIMO_SLEEPING_ANGULAR_VELOCITY_THRESHOLD;
+    config->sleepingTimeThreshold = OIMO_SLEEPING_TIME_THRESHOLD;
+}
+
+static inline OimoRigidBodyConfig oimo_rigid_body_config(void) {
+    OimoRigidBodyConfig config;
+    oimo_rigid_body_config_init(&config);
+    return config;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_type.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_type.h
new file mode 100644
index 0000000000..db53e75f4f
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/rigid_body_type.h
@@ -0,0 +1,11 @@
+#pragma once
+
+// Dynamic: finite mass, affected by gravity and constraints
+#define OIMO_RIGID_BODY_DYNAMIC    0
+
+// Static: infinite mass, zero velocity, not affected by forces
+#define OIMO_RIGID_BODY_STATIC     1
+
+// Kinematic: infinite mass, can have velocity, not affected by forces
+#define OIMO_RIGID_BODY_KINEMATIC  2
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape.h
new file mode 100644
index 0000000000..1c6b1d5683
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape.h
@@ -0,0 +1,177 @@
+#pragma once
+
+#include "../../common/transform.h"
+#include "../../collision/geometry/geometry.h"
+#include "../../collision/geometry/aabb.h"
+#include "../../collision/broadphase/proxy.h"
+#include "shape_config.h"
+
+// Forward declarations
+struct OimoRigidBody;
+struct OimoWorld;
+
+typedef struct OimoShape {
+    int _id;
+    struct OimoShape* _prev;
+    struct OimoShape* _next;
+    struct OimoRigidBody* _rigidBody;
+    OimoGeometry* _geom;
+    int _isTrigger;
+
+    OimoTransform _localTransform;  // Relative to rigid body
+    OimoTransform _ptransform;      // Previous world transform
+    OimoTransform _transform;       // Current world transform
+
+    OimoScalar _restitution;
+    OimoScalar _friction;
+    OimoScalar _density;
+
+    OimoAabb _aabb;
+    OimoProxy* _proxy;
+
+    int _collisionGroup;
+    int _collisionMask;
+
+    void* userData;
+} OimoShape;
+
+// Initialize shape from config
+static inline void oimo_shape_init(OimoShape* shape, const OimoShapeConfig* config) {
+    shape->_id = -1;
+    shape->_prev = NULL;
+    shape->_next = NULL;
+    shape->_rigidBody = NULL;
+    shape->_isTrigger = 0;
+
+    shape->_localTransform = oimo_transform(&config->position, &config->rotation);
+    shape->_ptransform = oimo_transform_copy(&shape->_localTransform);
+    shape->_transform = oimo_transform_copy(&shape->_localTransform);
+
+    shape->_restitution = config->restitution;
+    shape->_friction = config->friction;
+    shape->_density = config->density;
+    shape->_geom = config->geometry;
+    shape->_collisionGroup = config->collisionGroup;
+    shape->_collisionMask = config->collisionMask;
+
+    shape->_aabb = oimo_aabb_zero();
+    shape->_proxy = NULL;
+    shape->userData = NULL;
+}
+
+// Forward declaration for geometry types
+#include "../../collision/geometry/capsule_geometry.h"
+#include "../../collision/geometry/static_mesh_geometry.h"
+
+// Sync shape transforms with rigid body (called during simulation)
+// tf1 = previous body transform, tf2 = current body transform
+// 1:1 from OimoPhysics Shape._sync
+static inline void oimo_shape_sync(OimoShape* shape, const OimoTransform* tf1, const OimoTransform* tf2) {
+    // _ptransform = _localTransform * tf1
+    shape->_ptransform = oimo_transform_mul(&shape->_localTransform, tf1);
+    // _transform = _localTransform * tf2
+    shape->_transform = oimo_transform_mul(&shape->_localTransform, tf2);
+
+    // Compute combined AABB from both transforms
+    OimoAabb aabb1, aabb2;
+
+    // Compute AABB at previous transform
+    if (shape->_geom->type == OIMO_GEOMETRY_SPHERE) {
+        OimoSphereGeometry* sphere = (OimoSphereGeometry*)shape->_geom;
+        oimo_sphere_geometry_compute_aabb(sphere, &aabb1, &shape->_ptransform);
+        oimo_sphere_geometry_compute_aabb(sphere, &aabb2, &shape->_transform);
+    } else if (shape->_geom->type == OIMO_GEOMETRY_BOX) {
+        OimoBoxGeometry* box = (OimoBoxGeometry*)shape->_geom;
+        oimo_box_geometry_compute_aabb(box, &aabb1, &shape->_ptransform);
+        oimo_box_geometry_compute_aabb(box, &aabb2, &shape->_transform);
+    } else if (shape->_geom->type == OIMO_GEOMETRY_CAPSULE) {
+        OimoCapsuleGeometry* capsule = (OimoCapsuleGeometry*)shape->_geom;
+        oimo_capsule_geometry_compute_aabb(capsule, &aabb1, &shape->_ptransform);
+        oimo_capsule_geometry_compute_aabb(capsule, &aabb2, &shape->_transform);
+    } else if (shape->_geom->type == OIMO_GEOMETRY_STATIC_MESH) {
+        OimoStaticMeshGeometry* mesh = (OimoStaticMeshGeometry*)shape->_geom;
+        oimo_static_mesh_compute_aabb(mesh, &aabb1, &shape->_ptransform);
+        oimo_static_mesh_compute_aabb(mesh, &aabb2, &shape->_transform);
+    }
+
+    // Combine AABBs (min of mins, max of maxes)
+    shape->_aabb.min.x = oimo_min(aabb1.min.x, aabb2.min.x);
+    shape->_aabb.min.y = oimo_min(aabb1.min.y, aabb2.min.y);
+    shape->_aabb.min.z = oimo_min(aabb1.min.z, aabb2.min.z);
+    shape->_aabb.max.x = oimo_max(aabb1.max.x, aabb2.max.x);
+    shape->_aabb.max.y = oimo_max(aabb1.max.y, aabb2.max.y);
+    shape->_aabb.max.z = oimo_max(aabb1.max.z, aabb2.max.z);
+
+    // CRITICAL: Update proxy AABB for broadphase collision detection
+    // 1:1 from OimoPhysics: _rigidBody._world._broadPhase.moveProxy(_proxy, _aabb, displacement)
+    if (shape->_proxy != NULL) {
+        shape->_proxy->_aabbMin = shape->_aabb.min;
+        shape->_proxy->_aabbMax = shape->_aabb.max;
+    }
+}
+
+// Getters
+static inline OimoScalar oimo_shape_get_friction(const OimoShape* shape) {
+    return shape->_friction;
+}
+
+static inline void oimo_shape_set_friction(OimoShape* shape, OimoScalar friction) {
+    shape->_friction = friction;
+}
+
+static inline OimoScalar oimo_shape_get_restitution(const OimoShape* shape) {
+    return shape->_restitution;
+}
+
+static inline void oimo_shape_set_restitution(OimoShape* shape, OimoScalar restitution) {
+    shape->_restitution = restitution;
+}
+
+static inline OimoScalar oimo_shape_get_density(const OimoShape* shape) {
+    return shape->_density;
+}
+
+static inline OimoTransform oimo_shape_get_local_transform(const OimoShape* shape) {
+    return oimo_transform_copy(&shape->_localTransform);
+}
+
+static inline OimoTransform oimo_shape_get_transform(const OimoShape* shape) {
+    return oimo_transform_copy(&shape->_transform);
+}
+
+static inline OimoAabb oimo_shape_get_aabb(const OimoShape* shape) {
+    return oimo_aabb_copy(&shape->_aabb);
+}
+
+static inline OimoGeometry* oimo_shape_get_geometry(const OimoShape* shape) {
+    return shape->_geom;
+}
+
+static inline int oimo_shape_get_collision_group(const OimoShape* shape) {
+    return shape->_collisionGroup;
+}
+
+static inline void oimo_shape_set_collision_group(OimoShape* shape, int group) {
+    shape->_collisionGroup = group;
+}
+
+static inline int oimo_shape_get_collision_mask(const OimoShape* shape) {
+    return shape->_collisionMask;
+}
+
+static inline void oimo_shape_set_collision_mask(OimoShape* shape, int mask) {
+    shape->_collisionMask = mask;
+}
+
+static inline struct OimoRigidBody* oimo_shape_get_rigid_body(const OimoShape* shape) {
+    return shape->_rigidBody;
+}
+
+static inline OimoShape* oimo_shape_get_prev(const OimoShape* shape) {
+    return shape->_prev;
+}
+
+static inline OimoShape* oimo_shape_get_next(const OimoShape* shape) {
+    return shape->_next;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape_config.h b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape_config.h
new file mode 100644
index 0000000000..97609cac1a
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/rigidbody/shape_config.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "../../common/vec3.h"
+#include "../../common/mat3.h"
+#include "../../common/setting.h"
+#include "../../collision/geometry/geometry.h"
+
+typedef struct OimoShapeConfig {
+    OimoVec3 position;         // Local position relative to rigid body
+    OimoMat3 rotation;         // Local rotation relative to rigid body
+    OimoScalar friction;       // Coefficient of friction
+    OimoScalar restitution;    // Coefficient of restitution
+    OimoScalar density;        // Density in Kg/m^3
+    OimoGeometry* geometry;    // Collision geometry
+    int collisionGroup;        // Collision group bits
+    int collisionMask;         // Collision mask bits
+} OimoShapeConfig;
+
+// Snake_case compatibility aliases for Armory code generator
+#define collision_group collisionGroup
+#define collision_mask collisionMask
+
+static inline void oimo_shape_config_init(OimoShapeConfig* config) {
+    config->position = oimo_vec3_zero();
+    config->rotation = oimo_mat3_identity();
+    config->friction = OIMO_DEFAULT_FRICTION;
+    config->restitution = OIMO_DEFAULT_RESTITUTION;
+    config->density = OIMO_DEFAULT_DENSITY;
+    config->geometry = NULL;
+    config->collisionGroup = OIMO_DEFAULT_COLLISION_GROUP;
+    config->collisionMask = OIMO_DEFAULT_COLLISION_MASK;
+}
+
+static inline OimoShapeConfig oimo_shape_config(void) {
+    OimoShapeConfig config;
+    oimo_shape_config_init(&config);
+    return config;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/time_step.h b/armorcore/Deployment/n64/src/oimo/dynamics/time_step.h
new file mode 100644
index 0000000000..b4ccd8b0bb
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/time_step.h
@@ -0,0 +1,17 @@
+#pragma once
+
+// TimeStep holds simulation timing information
+typedef struct OimoTimeStep {
+    float dt;        // Time step of simulation
+    float invDt;     // Inverse time step (simulation FPS)
+    float dtRatio;   // Ratio: current dt / previous dt
+} OimoTimeStep;
+
+static inline OimoTimeStep oimo_time_step_create(void) {
+    OimoTimeStep ts;
+    ts.dt = 0.0f;
+    ts.invDt = 0.0f;
+    ts.dtRatio = 1.0f;
+    return ts;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/dynamics/world.h b/armorcore/Deployment/n64/src/oimo/dynamics/world.h
new file mode 100644
index 0000000000..4ad6a12375
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/dynamics/world.h
@@ -0,0 +1,331 @@
+#pragma once
+
+#include "../common/vec3.h"
+#include "../common/setting.h"
+#include "../collision/broadphase/broadphase.h"
+#include "../collision/broadphase/bruteforce_broadphase.h"
+#include "time_step.h"
+#include "rigidbody/rigid_body.h"
+#include "rigidbody/rigid_body_type.h"
+#include "rigidbody/shape.h"
+#include "contact.h"
+#include "contact_link.h"
+#include "contact_manager.h"
+#include "island.h"
+
+// World limits for N64
+#define OIMO_MAX_RIGID_BODIES 32
+#define OIMO_MAX_SHAPES 64
+
+typedef struct OimoWorld {
+    OimoRigidBody* _rigidBodyList;
+    OimoRigidBody* _rigidBodyListLast;
+
+    OimoBroadPhase _broadPhaseStorage;
+    OimoBroadPhase* _broadPhase;
+    OimoContactManager _contactManager;
+
+    int _numRigidBodies;
+    int _numShapes;
+    int _numIslands;
+
+    int _numVelocityIterations;
+    int _numPositionIterations;
+
+    OimoVec3 _gravity;
+
+    OimoTimeStep _timeStep;
+    OimoIsland _island;
+
+    // Stack for island building
+    OimoRigidBody* _rigidBodyStack[OIMO_MAX_RIGID_BODIES];
+
+    int _shapeIdCount;
+} OimoWorld;
+
+// Forward declarations for internal functions
+static inline void oimo_world_update_contacts(OimoWorld* world);
+static inline void oimo_world_solve_islands(OimoWorld* world);
+static inline void oimo_world_build_island(OimoWorld* world, OimoRigidBody* base);
+
+// Initialize world - 1:1 from World constructor
+static inline void oimo_world_init(OimoWorld* world, OimoVec3* gravity) {
+    // Initialize broadphase (brute-force O(n²) - reliable for N64's small object counts)
+    oimo_bruteforce_broadphase_init(&world->_broadPhaseStorage);
+    world->_broadPhase = &world->_broadPhaseStorage;
+
+    // Initialize contact manager
+    oimo_contact_manager_init(&world->_contactManager, world->_broadPhase);
+
+    // Set gravity
+    if (gravity != NULL) {
+        world->_gravity = *gravity;
+    } else {
+        world->_gravity = oimo_vec3(0.0f, -9.80665f, 0.0f);
+    }
+
+    world->_rigidBodyList = NULL;
+    world->_rigidBodyListLast = NULL;
+
+    world->_numRigidBodies = 0;
+    world->_numShapes = 0;
+    world->_numIslands = 0;
+
+    world->_numVelocityIterations = 10;
+    world->_numPositionIterations = 5;
+
+    world->_timeStep = oimo_time_step_create();
+    oimo_island_init(&world->_island);
+
+    world->_shapeIdCount = 0;
+}
+
+// Add shape to broadphase
+static inline void oimo_world_add_shape(OimoWorld* world, OimoShape* shape) {
+    shape->_proxy = oimo_broadphase_create_proxy(world->_broadPhase, shape, &shape->_aabb);
+    shape->_id = world->_shapeIdCount++;
+    world->_numShapes++;
+}
+
+// Remove shape from broadphase
+static inline void oimo_world_remove_shape(OimoWorld* world, OimoShape* shape) {
+    oimo_broadphase_destroy_proxy(world->_broadPhase, shape->_proxy);
+    shape->_proxy = NULL;
+    shape->_id = -1;
+
+    // Destroy linked contacts
+    OimoContactLink* cl = shape->_rigidBody->_contactLinkList;
+    while (cl != NULL) {
+        OimoContactLink* next = cl->_next;
+        OimoContact* c = cl->_contact;
+        if (c->_s1 == shape || c->_s2 == shape) {
+            oimo_rigid_body_wake_up(cl->_other);
+            oimo_contact_manager_destroy_contact(&world->_contactManager, c);
+        }
+        cl = next;
+    }
+
+    world->_numShapes--;
+}
+
+// Add rigid body to world - 1:1 from World.addRigidBody
+static inline void oimo_world_add_rigid_body(OimoWorld* world, OimoRigidBody* rigidBody) {
+    if (rigidBody->_world != NULL) {
+        return; // Already in a world
+    }
+
+    // Add to list
+    rigidBody->_prev = world->_rigidBodyListLast;
+    rigidBody->_next = NULL;
+    if (world->_rigidBodyListLast != NULL) {
+        world->_rigidBodyListLast->_next = rigidBody;
+    } else {
+        world->_rigidBodyList = rigidBody;
+    }
+    world->_rigidBodyListLast = rigidBody;
+    rigidBody->_world = world;
+
+    // Add shapes to broadphase
+    OimoShape* s = rigidBody->_shapeList;
+    while (s != NULL) {
+        oimo_world_add_shape(world, s);
+        s = s->_next;
+    }
+
+    world->_numRigidBodies++;
+}
+
+// Remove rigid body from world - 1:1 from World.removeRigidBody
+static inline void oimo_world_remove_rigid_body(OimoWorld* world, OimoRigidBody* rigidBody) {
+    if (rigidBody->_world != world) {
+        return; // Not in this world
+    }
+
+    // Remove from list
+    if (rigidBody->_prev != NULL) {
+        rigidBody->_prev->_next = rigidBody->_next;
+    } else {
+        world->_rigidBodyList = rigidBody->_next;
+    }
+    if (rigidBody->_next != NULL) {
+        rigidBody->_next->_prev = rigidBody->_prev;
+    } else {
+        world->_rigidBodyListLast = rigidBody->_prev;
+    }
+    rigidBody->_world = NULL;
+
+    // Remove shapes from broadphase
+    OimoShape* s = rigidBody->_shapeList;
+    while (s != NULL) {
+        oimo_world_remove_shape(world, s);
+        s = s->_next;
+    }
+
+    world->_numRigidBodies--;
+}
+
+// Update contacts - 1:1 from World._updateContacts
+static inline void oimo_world_update_contacts(OimoWorld* world) {
+    oimo_contact_manager_update_contacts(&world->_contactManager);
+    oimo_contact_manager_update_manifolds(&world->_contactManager);
+}
+
+// Build island using DFS - 1:1 from World.buildIsland
+static inline void oimo_world_build_island(OimoWorld* world, OimoRigidBody* base) {
+    int stackCount = 1;
+    oimo_island_add_rigid_body(&world->_island, base);
+    world->_rigidBodyStack[0] = base;
+
+    while (stackCount > 0) {
+        OimoRigidBody* rb = world->_rigidBodyStack[--stackCount];
+        world->_rigidBodyStack[stackCount] = NULL;
+
+        // Stop searching at static bodies
+        if (rb->_type == OIMO_RIGID_BODY_STATIC) {
+            continue;
+        }
+
+        // Search contacts
+        OimoContactLink* cl = rb->_contactLinkList;
+        while (cl != NULL) {
+            OimoContact* contact = cl->_contact;
+            OimoContactConstraint* cc = &contact->_contactConstraint;
+            OimoPgsContactConstraintSolver* solver = &contact->_solver;
+
+            // 1:1 from OimoPhysics: skip triggers - they detect contact but don't generate collision response
+            bool isTrigger = (contact->_s1->_isTrigger || contact->_s2->_isTrigger);
+            if (!isTrigger && oimo_contact_constraint_is_touching(cc) && !solver->_addedToIsland) {
+                oimo_island_add_solver(&world->_island, solver, cc->_positionCorrectionAlgorithm);
+
+                OimoRigidBody* other = cl->_other;
+                if (!other->_addedToIsland && stackCount < OIMO_MAX_RIGID_BODIES) {
+                    oimo_island_add_rigid_body(&world->_island, other);
+                    world->_rigidBodyStack[stackCount++] = other;
+                }
+            }
+            cl = cl->_next;
+        }
+    }
+}
+
+// Solve islands - 1:1 from World._solveIslands
+static inline void oimo_world_solve_islands(OimoWorld* world) {
+    // Wake up all bodies if sleeping disabled
+    if (OIMO_DISABLE_SLEEPING) {
+        OimoRigidBody* b = world->_rigidBodyList;
+        while (b != NULL) {
+            b->_sleeping = 0;
+            b->_sleepTime = 0.0f;
+            b = b->_next;
+        }
+    }
+
+    // Build and solve islands
+    world->_numIslands = 0;
+    oimo_island_set_gravity(&world->_island, world->_gravity);
+
+    OimoRigidBody* b = world->_rigidBodyList;
+    while (b != NULL) {
+        if (!b->_addedToIsland && !b->_sleeping && b->_type != OIMO_RIGID_BODY_STATIC) {
+            // Check if alone (no contacts)
+            if (b->_numContactLinks == 0) {
+                oimo_island_step_single_rigid_body(&world->_island, &world->_timeStep, b);
+                world->_numIslands++;
+            } else {
+                oimo_world_build_island(world, b);
+                oimo_island_step(&world->_island, &world->_timeStep,
+                                world->_numVelocityIterations, world->_numPositionIterations);
+                oimo_island_clear(&world->_island);
+                world->_numIslands++;
+            }
+        }
+        b = b->_next;
+    }
+
+    oimo_contact_manager_post_solve(&world->_contactManager);
+
+    // Clear island flags
+    b = world->_rigidBodyList;
+    while (b != NULL) {
+        b->_addedToIsland = 0;
+        b = b->_next;
+    }
+
+    // Clear forces and torques
+    b = world->_rigidBodyList;
+    while (b != NULL) {
+        b->_force = oimo_vec3_zero();
+        b->_torque = oimo_vec3_zero();
+        b = b->_next;
+    }
+
+    // Clear solver island flags
+    OimoContact* c = world->_contactManager._contactList;
+    while (c != NULL) {
+        c->_solver._addedToIsland = false;
+        c = c->_next;
+    }
+}
+
+// Step the simulation - 1:1 from World.step
+static inline void oimo_world_step(OimoWorld* world, OimoScalar timeStep) {
+    // Guard against zero or negative timestep
+    if (timeStep <= OIMO_EPSILON) {
+        return;
+    }
+
+    if (world->_timeStep.dt > 0.0f) {
+        world->_timeStep.dtRatio = timeStep / world->_timeStep.dt;
+    }
+    world->_timeStep.dt = timeStep;
+    world->_timeStep.invDt = 1.0f / timeStep;
+
+    oimo_world_update_contacts(world);
+    oimo_world_solve_islands(world);
+}
+
+// Getters
+static inline OimoRigidBody* oimo_world_get_rigid_body_list(const OimoWorld* world) {
+    return world->_rigidBodyList;
+}
+
+static inline OimoBroadPhase* oimo_world_get_broadphase(const OimoWorld* world) {
+    return world->_broadPhase;
+}
+
+static inline OimoContactManager* oimo_world_get_contact_manager(OimoWorld* world) {
+    return &world->_contactManager;
+}
+
+static inline int oimo_world_get_num_rigid_bodies(const OimoWorld* world) {
+    return world->_numRigidBodies;
+}
+
+static inline int oimo_world_get_num_shapes(const OimoWorld* world) {
+    return world->_numShapes;
+}
+
+static inline int oimo_world_get_num_contacts(const OimoWorld* world) {
+    return world->_contactManager._numContacts;
+}
+
+static inline int oimo_world_get_num_islands(const OimoWorld* world) {
+    return world->_numIslands;
+}
+
+static inline void oimo_world_set_gravity(OimoWorld* world, OimoVec3 gravity) {
+    world->_gravity = gravity;
+}
+
+static inline OimoVec3 oimo_world_get_gravity(const OimoWorld* world) {
+    return world->_gravity;
+}
+
+static inline void oimo_world_set_num_velocity_iterations(OimoWorld* world, int iterations) {
+    world->_numVelocityIterations = iterations;
+}
+
+static inline void oimo_world_set_num_position_iterations(OimoWorld* world, int iterations) {
+    world->_numPositionIterations = iterations;
+}
+
diff --git a/armorcore/Deployment/n64/src/oimo/oimo.h b/armorcore/Deployment/n64/src/oimo/oimo.h
new file mode 100644
index 0000000000..ffffe4a70c
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/oimo.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "common/setting.h"
+#include "common/math_util.h"
+#include "common/vec3.h"
+#include "common/mat3.h"
+#include "common/quat.h"
+#include "common/transform.h"
+
+#include "collision/geometry/geometry_type.h"
+#include "collision/geometry/aabb.h"
+#include "collision/geometry/geometry.h"
+#include "collision/geometry/sphere_geometry.h"
+#include "collision/geometry/box_geometry.h"
+#include "collision/geometry/capsule_geometry.h"
+
+#include "collision/narrowphase/detector_result.h"
+#include "collision/narrowphase/detector.h"
+#include "collision/narrowphase/sphere_sphere_detector.h"
+#include "collision/narrowphase/sphere_box_detector.h"
+#include "collision/narrowphase/box_box_detector.h"
+#include "collision/narrowphase/collision_matrix.h"
+
+#include "collision/broadphase/broadphase_type.h"
+#include "collision/broadphase/proxy.h"
+#include "collision/broadphase/proxy_pair.h"
+#include "collision/broadphase/broadphase.h"
+#include "collision/broadphase/bruteforce_broadphase.h"
+
+#include "dynamics/rigidbody/rigid_body_type.h"
+#include "dynamics/rigidbody/mass_data.h"
+#include "dynamics/rigidbody/shape_config.h"
+#include "dynamics/rigidbody/rigid_body_config.h"
+#include "dynamics/rigidbody/shape.h"
+#include "dynamics/rigidbody/rigid_body.h"
+
+#include "dynamics/time_step.h"
+#include "dynamics/contact_link.h"
+#include "dynamics/constraint/position_correction_algorithm.h"
+#include "dynamics/constraint/info/jacobian_row.h"
+#include "dynamics/constraint/contact/contact_impulse.h"
+#include "dynamics/constraint/contact/manifold_point.h"
+#include "dynamics/constraint/contact/manifold.h"
+#include "dynamics/constraint/contact/manifold_updater.h"
+#include "dynamics/constraint/contact/contact_constraint.h"
+#include "dynamics/constraint/info/contact/contact_solver_info_row.h"
+#include "dynamics/constraint/info/contact/contact_solver_info.h"
+#include "dynamics/constraint/solver/contact_solver_mass_data_row.h"
+#include "dynamics/constraint/solver/pgs/pgs_contact_constraint_solver.h"
+
+#include "dynamics/contact.h"
+#include "dynamics/contact_manager.h"
+#include "dynamics/island.h"
+#include "dynamics/world.h"
+
+// Armory3D compatibility layer
+
+// Body type aliases
+#define OIMO_BODY_STATIC    OIMO_RIGID_BODY_STATIC
+#define OIMO_BODY_DYNAMIC   OIMO_RIGID_BODY_DYNAMIC
+#define OIMO_BODY_KINEMATIC OIMO_RIGID_BODY_KINEMATIC
+
+// Config defaults
+static inline OimoRigidBodyConfig oimo_rigidbody_config_default(void) {
+    return oimo_rigid_body_config();
+}
+
+static inline OimoShapeConfig oimo_shape_config_default(void) {
+    return oimo_shape_config();
+}
+
+// Function aliases
+#define oimo_rigidbody_init             oimo_rigid_body_init
+#define oimo_rigidbody_add_shape        oimo_rigid_body_add_shape
+#define oimo_rigidbody_remove_shape     oimo_rigid_body_remove_shape
+#define oimo_rigidbody_update_mass      oimo_rigid_body_update_mass
+
+
+#define oimo_world_add_rigidbody        oimo_world_add_rigid_body
+#define oimo_world_remove_rigidbody     oimo_world_remove_rigid_body
diff --git a/armorcore/Deployment/n64/src/oimo/physics.c.j2 b/armorcore/Deployment/n64/src/oimo/physics.c.j2
new file mode 100644
index 0000000000..42f488df7a
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/physics.c.j2
@@ -0,0 +1,469 @@
+// physics.c - Mini-engine physics implementation
+#include "physics.h"
+#include "../events/physics_events.h"
+#include "../engine.h"
+#include "../iron/object/object.h"
+#if ENGINE_ENABLE_PHYSICS_DEBUG
+#include "debug/physics_debug.h"
+#endif
+#include "../utils.h"
+#include "collision/geometry/static_mesh_geometry.h"
+#include <t3d/t3d.h>
+#include <string.h>
+
+#define MAX_PHYSICS_BODIES {max_physics_bodies}
+
+// Static pools
+static OimoWorld g_world;
+static bool g_paused = false;
+static bool g_initialized = false;
+
+// Contact callback
+static PhysicsContactCallback g_contact_callback = NULL;
+static void* g_contact_user_data = NULL;
+
+static OimoRigidBody g_bodies[MAX_PHYSICS_BODIES];
+static bool g_body_used[MAX_PHYSICS_BODIES];
+static OimoShape g_shapes[MAX_PHYSICS_BODIES];
+
+typedef union {{
+    OimoSphereGeometry sphere;
+    OimoBoxGeometry box;
+    OimoCapsuleGeometry capsule;
+}} GeometryUnion;
+static GeometryUnion g_geometries[MAX_PHYSICS_BODIES];
+
+// Mesh collider storage (separate due to dynamic allocation)
+static OimoStaticMeshGeometry g_mesh_geometries[MAX_MESH_COLLIDERS];
+static OimoRigidBody g_mesh_bodies[MAX_MESH_COLLIDERS];
+static OimoShape g_mesh_shapes[MAX_MESH_COLLIDERS];
+static bool g_mesh_used[MAX_MESH_COLLIDERS];
+
+// Pool helpers
+static OimoRigidBody* alloc_body(void) {{
+    for (int i = 0; i < MAX_PHYSICS_BODIES; i++) {{
+        if (!g_body_used[i]) {{
+            g_body_used[i] = true;
+            return &g_bodies[i];
+        }}
+    }}
+    return NULL;
+}}
+
+static void free_body(OimoRigidBody* rb) {{
+    for (int i = 0; i < MAX_PHYSICS_BODIES; i++) {{
+        if (&g_bodies[i] == rb) {{
+            g_body_used[i] = false;
+            return;
+        }}
+    }}
+}}
+
+static int get_body_index(OimoRigidBody* rb) {{
+    for (int i = 0; i < MAX_PHYSICS_BODIES; i++) {{
+        if (&g_bodies[i] == rb) return i;
+    }}
+    return -1;
+}}
+
+// World management
+void physics_init(void) {{
+    if (g_initialized) return;
+
+    memset(g_bodies, 0, sizeof(g_bodies));
+    memset(g_body_used, 0, sizeof(g_body_used));
+    memset(g_shapes, 0, sizeof(g_shapes));
+    memset(g_geometries, 0, sizeof(g_geometries));
+
+    // Mesh colliders
+    memset(g_mesh_geometries, 0, sizeof(g_mesh_geometries));
+    memset(g_mesh_bodies, 0, sizeof(g_mesh_bodies));
+    memset(g_mesh_shapes, 0, sizeof(g_mesh_shapes));
+    memset(g_mesh_used, 0, sizeof(g_mesh_used));
+
+    // Contact event subscriptions
+    physics_contact_init();
+
+    OimoVec3 gravity = oimo_vec3(0.0f, -9.80665f, 0.0f);
+    oimo_world_init(&g_world, &gravity);
+
+    g_paused = false;
+    g_initialized = true;
+}}
+
+void physics_shutdown(void) {{
+    if (!g_initialized) return;
+    physics_reset();
+    g_initialized = false;
+}}
+
+void physics_reset(void) {{
+    if (!g_initialized) return;
+
+    // Clear contact subscriptions
+    physics_contact_clear();
+
+    // Remove regular bodies
+    for (int i = 0; i < MAX_PHYSICS_BODIES; i++) {{
+        if (g_body_used[i]) {{
+            oimo_world_remove_rigid_body(&g_world, &g_bodies[i]);
+            g_body_used[i] = false;
+        }}
+    }}
+
+    // Remove mesh bodies and free their geometry
+    for (int i = 0; i < MAX_MESH_COLLIDERS; i++) {{
+        if (g_mesh_used[i]) {{
+            oimo_world_remove_rigid_body(&g_world, &g_mesh_bodies[i]);
+            oimo_static_mesh_geometry_free(&g_mesh_geometries[i]);
+            g_mesh_used[i] = false;
+        }}
+    }}
+
+    OimoVec3 gravity = g_world._gravity;
+    oimo_world_init(&g_world, &gravity);
+}}
+
+void physics_step(float dt) {{
+    if (!g_initialized || g_paused) return;
+    oimo_world_step(&g_world, dt);
+
+    // Dispatch per-body contact subscriptions
+    physics_contact_dispatch();
+
+    // Process deferred object removals after contact dispatch is complete
+    object_process_removals();
+
+    // Process global contact callbacks if registered
+    if (g_contact_callback) {{
+        OimoContact* contact = g_world._contactManager._contactList;
+        while (contact != NULL) {{
+            if (contact->_touching && contact->_manifold._numPoints > 0) {{
+                OimoManifoldPoint* pt = &contact->_manifold._points[0];
+                if (pt->_depth > 0) {{
+                    PhysicsContactPair pair;
+                    pair.obj_a = (ArmObject*)contact->_b1->userData;
+                    pair.obj_b = (ArmObject*)contact->_b2->userData;
+                    pair.pos_a = pt->_pos1;
+                    pair.pos_b = pt->_pos2;
+                    pair.normal = contact->_manifold._normal;
+                    pair.impulse = pt->_impulse.impulseN;
+                    g_contact_callback(&pair, g_contact_user_data);
+                }}
+            }}
+            contact = contact->_next;
+        }}
+    }}
+}}
+
+void physics_pause(void) {{ g_paused = true; }}
+void physics_resume(void) {{ g_paused = false; }}
+OimoWorld* physics_get_world(void) {{ return &g_world; }}
+
+// Gravity
+void physics_set_gravity(float x, float y, float z) {{
+    if (!g_initialized) return;
+    oimo_world_set_gravity(&g_world, oimo_vec3(x, y, z));
+}}
+
+OimoVec3 physics_get_gravity(void) {{
+    return g_initialized ? oimo_world_get_gravity(&g_world) : oimo_vec3_zero();
+}}
+
+static int resolve_body_type(int requested_type, const PhysicsBodyParams* params) {{
+    return (params && params->animated) ? OIMO_RIGID_BODY_KINEMATIC : requested_type;
+}}
+
+typedef struct {{
+    OimoRigidBody* rb;
+    int idx;
+    int final_type;
+}} BodySetupResult;
+
+static bool setup_body_common(ArmObject* obj, int type, const PhysicsBodyParams* params,
+                              BodySetupResult* out) {{
+    if (!g_initialized || !obj || !params) return false;
+
+    OimoRigidBody* rb = alloc_body();
+    if (!rb) {{
+        debugf("Physics: body pool exhausted\\n");
+        return false;
+    }}
+
+    out->rb = rb;
+    out->idx = get_body_index(rb);
+    out->final_type = resolve_body_type(type, params);
+
+    OimoRigidBodyConfig config = oimo_rigid_body_config();
+    config.type = out->final_type;
+    config.position = oimo_vec3(obj->transform.loc.x, obj->transform.loc.y, obj->transform.loc.z);
+    OimoQuat q = oimo_quat(obj->transform.rot.x, obj->transform.rot.y,
+                           obj->transform.rot.z, obj->transform.rot.w);
+    config.rotation = oimo_quat_to_mat3(&q);
+    config.linearDamping = params->linear_damping;
+    config.angularDamping = params->angular_damping;
+    config.autoSleep = params->use_deactivation && (out->final_type == OIMO_RIGID_BODY_DYNAMIC);
+    oimo_rigid_body_init(rb, &config);
+    return true;
+}}
+
+static void setup_shape_common(OimoShape* shape, OimoGeometry* geom, int final_type,
+                               float density, const PhysicsBodyParams* params) {{
+    OimoShapeConfig shapeConfig = oimo_shape_config();
+    shapeConfig.geometry = geom;
+    shapeConfig.friction = params->friction;
+    shapeConfig.restitution = params->restitution;
+    shapeConfig.density = (final_type == OIMO_RIGID_BODY_STATIC) ? 0.0f : density;
+    shapeConfig.collisionGroup = params->collision_group;
+    shapeConfig.collisionMask = params->collision_mask;
+    oimo_shape_init(shape, &shapeConfig);
+    shape->_isTrigger = params->trigger;
+}}
+
+static void finalize_body(OimoRigidBody* rb, ArmObject* obj, int final_type,
+                          const PhysicsBodyParams* params) {{
+    if (final_type == OIMO_RIGID_BODY_DYNAMIC) {{
+        rb->_mass = params->mass;
+        float af = params->angular_friction;
+        if (af < 0.001f) af = 0.001f;
+        rb->_localInertia = oimo_mat3(af, 0, 0, 0, af, 0, 0, 0, af);
+        oimo_rigid_body_complete_mass_data(rb);
+    }}
+    oimo_world_add_rigid_body(&g_world, rb);
+    obj->rigid_body = rb;
+    rb->userData = obj;
+}}
+
+bool physics_create_box_full(ArmObject* obj, int type, float hx, float hy, float hz,
+                             const PhysicsBodyParams* params) {{
+    BodySetupResult setup;
+    if (!setup_body_common(obj, type, params, &setup)) return false;
+
+    oimo_box_geometry_init3(&g_geometries[setup.idx].box, hx, hy, hz);
+    float density = params->mass / (8.0f * hx * hy * hz);
+    setup_shape_common(&g_shapes[setup.idx], &g_geometries[setup.idx].box.base,
+                       setup.final_type, density, params);
+    oimo_rigid_body_add_shape(setup.rb, &g_shapes[setup.idx]);
+    finalize_body(setup.rb, obj, setup.final_type, params);
+    return true;
+}}
+
+bool physics_create_sphere_full(ArmObject* obj, int type, float radius,
+                                const PhysicsBodyParams* params) {{
+    BodySetupResult setup;
+    if (!setup_body_common(obj, type, params, &setup)) return false;
+
+    oimo_sphere_geometry_init(&g_geometries[setup.idx].sphere, radius);
+    float volume = (4.0f / 3.0f) * 3.14159265f * radius * radius * radius;
+    float density = params->mass / volume;
+    setup_shape_common(&g_shapes[setup.idx], &g_geometries[setup.idx].sphere.base,
+                       setup.final_type, density, params);
+    oimo_rigid_body_add_shape(setup.rb, &g_shapes[setup.idx]);
+    finalize_body(setup.rb, obj, setup.final_type, params);
+    return true;
+}}
+
+bool physics_create_capsule_full(ArmObject* obj, int type, float radius, float half_height,
+                                 const PhysicsBodyParams* params) {{
+    BodySetupResult setup;
+    if (!setup_body_common(obj, type, params, &setup)) return false;
+
+    oimo_capsule_geometry_init(&g_geometries[setup.idx].capsule, radius, half_height);
+    float cyl_vol = 3.14159265f * radius * radius * (2.0f * half_height);
+    float sphere_vol = (4.0f / 3.0f) * 3.14159265f * radius * radius * radius;
+    float density = params->mass / (cyl_vol + sphere_vol);
+    setup_shape_common(&g_shapes[setup.idx], &g_geometries[setup.idx].capsule.base,
+                       setup.final_type, density, params);
+    oimo_rigid_body_add_shape(setup.rb, &g_shapes[setup.idx]);
+    finalize_body(setup.rb, obj, setup.final_type, params);
+    return true;
+}}
+
+// Legacy body creation (wraps _full versions)
+bool physics_create_box_ex(ArmObject* obj, int type, float hx, float hy, float hz,
+                           float mass, float friction, float restitution,
+                           int collision_group, int collision_mask) {{
+    PhysicsBodyParams params = physics_body_params_default();
+    params.mass = mass;
+    params.friction = friction;
+    params.restitution = restitution;
+    params.collision_group = collision_group;
+    params.collision_mask = collision_mask;
+    return physics_create_box_full(obj, type, hx, hy, hz, &params);
+}}
+
+bool physics_create_sphere_ex(ArmObject* obj, int type, float radius,
+                              float mass, float friction, float restitution,
+                              int collision_group, int collision_mask) {{
+    PhysicsBodyParams params = physics_body_params_default();
+    params.mass = mass;
+    params.friction = friction;
+    params.restitution = restitution;
+    params.collision_group = collision_group;
+    params.collision_mask = collision_mask;
+    return physics_create_sphere_full(obj, type, radius, &params);
+}}
+
+bool physics_create_capsule_ex(ArmObject* obj, int type, float radius, float half_height,
+                               float mass, float friction, float restitution,
+                               int collision_group, int collision_mask) {{
+    PhysicsBodyParams params = physics_body_params_default();
+    params.mass = mass;
+    params.friction = friction;
+    params.restitution = restitution;
+    params.collision_group = collision_group;
+    params.collision_mask = collision_mask;
+    return physics_create_capsule_full(obj, type, radius, half_height, &params);
+}}
+
+void physics_remove_body(ArmObject* obj) {{
+    if (!g_initialized || !obj || !obj->rigid_body) return;
+
+    oimo_world_remove_rigid_body(&g_world, obj->rigid_body);
+    free_body(obj->rigid_body);
+    obj->rigid_body = NULL;
+}}
+
+// Static mesh collider (full version with all params)
+bool physics_create_mesh_full(ArmObject* obj,
+                              const OimoVec3* vertices, const int16_t* indices,
+                              int vertex_count, int index_count,
+                              const PhysicsBodyParams* params) {{
+    if (!g_initialized || !obj || !params) return false;
+
+    // Find free mesh slot
+    int idx = -1;
+    for (int i = 0; i < MAX_MESH_COLLIDERS; i++) {{
+        if (!g_mesh_used[i]) {{
+            idx = i;
+            break;
+        }}
+    }}
+
+    if (idx < 0) {{
+        debugf("Physics: mesh collider pool exhausted\\n");
+        return false;
+    }}
+
+    // Initialize mesh geometry
+    if (!oimo_static_mesh_geometry_init(&g_mesh_geometries[idx], vertices, indices, vertex_count, index_count)) {{
+        debugf("Physics: failed to create mesh geometry\\n");
+        return false;
+    }}
+
+    // Body config (always static for mesh colliders)
+    OimoRigidBodyConfig config = oimo_rigid_body_config();
+    config.type = OIMO_RIGID_BODY_STATIC;
+    config.position = oimo_vec3(obj->transform.loc.x, obj->transform.loc.y, obj->transform.loc.z);
+    OimoQuat q = oimo_quat(obj->transform.rot.x, obj->transform.rot.y,
+                           obj->transform.rot.z, obj->transform.rot.w);
+    config.rotation = oimo_quat_to_mat3(&q);
+    config.autoSleep = false;
+    oimo_rigid_body_init(&g_mesh_bodies[idx], &config);
+
+    // Shape config
+    OimoShapeConfig shapeConfig = oimo_shape_config();
+    shapeConfig.geometry = &g_mesh_geometries[idx].base;
+    shapeConfig.friction = params->friction;
+    shapeConfig.restitution = params->restitution;
+    shapeConfig.density = 0.0f;  // Static
+    shapeConfig.collisionGroup = params->collision_group;
+    shapeConfig.collisionMask = params->collision_mask;
+
+    oimo_shape_init(&g_mesh_shapes[idx], &shapeConfig);
+    g_mesh_shapes[idx]._isTrigger = params->trigger;
+    oimo_rigid_body_add_shape(&g_mesh_bodies[idx], &g_mesh_shapes[idx]);
+
+    oimo_world_add_rigid_body(&g_world, &g_mesh_bodies[idx]);
+    obj->rigid_body = &g_mesh_bodies[idx];
+    g_mesh_bodies[idx].userData = obj;
+    g_mesh_used[idx] = true;
+
+    return true;
+}}
+
+// Legacy mesh collider (wraps _full version)
+bool physics_create_mesh(ArmObject* obj,
+                         const OimoVec3* vertices, const int16_t* indices,
+                         int vertex_count, int index_count,
+                         float friction, float restitution,
+                         int collision_group, int collision_mask) {{
+    PhysicsBodyParams params = physics_body_params_default();
+    params.friction = friction;
+    params.restitution = restitution;
+    params.collision_group = collision_group;
+    params.collision_mask = collision_mask;
+    return physics_create_mesh_full(obj, vertices, indices, vertex_count, index_count, &params);
+}}
+
+// Transform sync
+void physics_sync_object(ArmObject* obj) {{
+    if (!obj || !obj->rigid_body) return;
+
+    OimoRigidBody* rb = obj->rigid_body;
+    if (rb->_type == OIMO_RIGID_BODY_STATIC || rb->_sleeping) return;
+
+    OimoVec3 pos = oimo_rigid_body_get_position(rb);
+
+    // Check if object has fallen out of world bounds
+    if (!position_in_bounds(pos.x, pos.y, pos.z)) {{
+        // Object fell off world - put it to sleep and hide it
+        oimo_rigid_body_sleep(rb);
+        obj->visible = false;
+        return;
+    }}
+
+    obj->transform.loc.x = pos.x;
+    obj->transform.loc.y = pos.y;
+    obj->transform.loc.z = pos.z;
+
+    OimoQuat rot = oimo_rigid_body_get_orientation(rb);
+    obj->transform.rot.x = rot.x;
+    obj->transform.rot.y = rot.y;
+    obj->transform.rot.z = rot.z;
+    obj->transform.rot.w = rot.w;
+
+    obj->transform.dirty = TRANSFORM_DIRTY_FRAMES;
+}}
+
+// Contact callback management
+void physics_set_contact_callback(PhysicsContactCallback callback, void* user_data) {{
+    g_contact_callback = callback;
+    g_contact_user_data = user_data;
+}}
+
+// Get contacts for a specific rigid body
+int physics_get_contacts(OimoRigidBody* rb, PhysicsContactPair* contacts, int max_contacts) {{
+    if (!g_initialized || !rb || !contacts || max_contacts <= 0) return 0;
+
+    int count = 0;
+    OimoContactLink* link = rb->_contactLinkList;
+
+    while (link != NULL && count < max_contacts) {{
+        OimoContact* contact = link->_contact;
+        if (contact && contact->_touching && contact->_manifold._numPoints > 0) {{
+            OimoManifoldPoint* pt = &contact->_manifold._points[0];
+            if (pt->_depth > 0) {{
+                PhysicsContactPair* pair = &contacts[count];
+
+                // Determine which body is the "other"
+                if (contact->_b1 == rb) {{
+                    pair->obj_a = (ArmObject*)rb->userData;
+                    pair->obj_b = (ArmObject*)contact->_b2->userData;
+                }} else {{
+                    pair->obj_a = (ArmObject*)contact->_b1->userData;
+                    pair->obj_b = (ArmObject*)rb->userData;
+                }}
+
+                pair->pos_a = pt->_pos1;
+                pair->pos_b = pt->_pos2;
+                pair->normal = contact->_manifold._normal;
+                pair->impulse = pt->_impulse.impulseN;
+                count++;
+            }}
+        }}
+        link = link->_next;
+    }}
+
+    return count;
+}}
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/oimo/physics.h b/armorcore/Deployment/n64/src/oimo/physics.h
new file mode 100644
index 0000000000..f5291f2da7
--- /dev/null
+++ b/armorcore/Deployment/n64/src/oimo/physics.h
@@ -0,0 +1,212 @@
+// physics.h - Mini-engine physics wrapper
+#pragma once
+
+#include "../types.h"
+#include "oimo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Maximum static mesh colliders (separate from body pool due to different memory management)
+#define MAX_MESH_COLLIDERS 8
+
+// Physics body parameters (matches Blender's rigid body settings)
+typedef struct PhysicsBodyParams {
+    float mass;
+    float friction;
+    float restitution;
+    float linear_damping;
+    float angular_damping;
+    float angular_friction;      // Rotation inertia (0.1 default)
+    int collision_group;         // Collision group bitmask
+    int collision_mask;          // Collision mask bitmask
+    bool animated;               // If true, use KINEMATIC type
+    bool trigger;                // If true, shape is sensor only
+    bool use_deactivation;       // Enable/disable sleeping
+} PhysicsBodyParams;
+
+// Default physics parameters (matches Blender defaults)
+static inline PhysicsBodyParams physics_body_params_default(void) {
+    PhysicsBodyParams p;
+    p.mass = 1.0f;
+    p.friction = 0.5f;
+    p.restitution = 0.0f;
+    p.linear_damping = 0.04f;
+    p.angular_damping = 0.1f;
+    p.angular_friction = 0.1f;
+    p.collision_group = 1;
+    p.collision_mask = 1;
+    p.animated = false;
+    p.trigger = false;
+    p.use_deactivation = true;
+    return p;
+}
+
+// World management
+void physics_init(void);
+void physics_shutdown(void);
+void physics_reset(void);
+void physics_step(float dt);
+void physics_pause(void);
+void physics_resume(void);
+OimoWorld* physics_get_world(void);
+
+// Gravity
+void physics_set_gravity(float x, float y, float z);
+OimoVec3 physics_get_gravity(void);
+
+// Body creation with full parameters
+bool physics_create_box_full(ArmObject* obj, int type, float hx, float hy, float hz,
+                             const PhysicsBodyParams* params);
+bool physics_create_sphere_full(ArmObject* obj, int type, float radius,
+                                const PhysicsBodyParams* params);
+bool physics_create_capsule_full(ArmObject* obj, int type, float radius, float half_height,
+                                 const PhysicsBodyParams* params);
+
+// Extended versions with collision group/mask (legacy compatibility)
+bool physics_create_box_ex(ArmObject* obj, int type, float hx, float hy, float hz,
+                           float mass, float friction, float restitution,
+                           int collision_group, int collision_mask);
+bool physics_create_sphere_ex(ArmObject* obj, int type, float radius,
+                              float mass, float friction, float restitution,
+                              int collision_group, int collision_mask);
+bool physics_create_capsule_ex(ArmObject* obj, int type, float radius, float half_height,
+                               float mass, float friction, float restitution,
+                               int collision_group, int collision_mask);
+
+// Static mesh collider (always static body type)
+// vertices: array of Vec3 positions
+// indices: array of triangle indices (3 per triangle)
+// vertex_count: number of vertices
+// index_count: number of indices (must be multiple of 3)
+bool physics_create_mesh(ArmObject* obj,
+                         const OimoVec3* vertices, const int16_t* indices,
+                         int vertex_count, int index_count,
+                         float friction, float restitution,
+                         int collision_group, int collision_mask);
+
+// Static mesh with full parameters
+bool physics_create_mesh_full(ArmObject* obj,
+                              const OimoVec3* vertices, const int16_t* indices,
+                              int vertex_count, int index_count,
+                              const PhysicsBodyParams* params);
+
+// Convenience wrappers with default collision group=1, mask=1
+static inline bool physics_create_box(ArmObject* obj, int type, float hx, float hy, float hz,
+                                      float mass, float friction, float restitution) {
+    return physics_create_box_ex(obj, type, hx, hy, hz, mass, friction, restitution, 1, 1);
+}
+static inline bool physics_create_sphere(ArmObject* obj, int type, float radius,
+                                         float mass, float friction, float restitution) {
+    return physics_create_sphere_ex(obj, type, radius, mass, friction, restitution, 1, 1);
+}
+static inline bool physics_create_capsule(ArmObject* obj, int type, float radius, float half_height,
+                                          float mass, float friction, float restitution) {
+    return physics_create_capsule_ex(obj, type, radius, half_height, mass, friction, restitution, 1, 1);
+}
+
+void physics_remove_body(ArmObject* obj);
+
+// Transform sync (call after physics_step)
+void physics_sync_object(ArmObject* obj);
+
+// Contact/collision info
+typedef struct PhysicsContactPair {
+    ArmObject* obj_a;
+    ArmObject* obj_b;
+    OimoVec3 pos_a;
+    OimoVec3 pos_b;
+    OimoVec3 normal;
+    float impulse;
+} PhysicsContactPair;
+
+// Callback for contact events
+typedef void (*PhysicsContactCallback)(const PhysicsContactPair* contact, void* user_data);
+
+// Set contact callback (called for each active contact after physics_step)
+void physics_set_contact_callback(PhysicsContactCallback callback, void* user_data);
+
+// Get contacts for a specific rigid body (returns count, fills contacts array up to max_contacts)
+int physics_get_contacts(OimoRigidBody* rb, PhysicsContactPair* contacts, int max_contacts);
+
+// Damping setters
+static inline void physics_set_linear_damping(OimoRigidBody* rb, float damping) {
+    if (rb) rb->_linearDamping = damping;
+}
+
+static inline void physics_set_angular_damping(OimoRigidBody* rb, float damping) {
+    if (rb) rb->_angularDamping = damping;
+}
+
+static inline float physics_get_linear_damping(const OimoRigidBody* rb) {
+    return rb ? rb->_linearDamping : 0.0f;
+}
+
+static inline float physics_get_angular_damping(const OimoRigidBody* rb) {
+    return rb ? rb->_angularDamping : 0.0f;
+}
+
+// Trigger (sensor) mode
+static inline void physics_set_trigger(OimoRigidBody* rb, int is_trigger) {
+    if (rb && rb->_shapeList) {
+        rb->_shapeList->_isTrigger = is_trigger;
+    }
+}
+
+static inline int physics_is_trigger(const OimoRigidBody* rb) {
+    return (rb && rb->_shapeList) ? rb->_shapeList->_isTrigger : 0;
+}
+
+// Gravity scale
+static inline void physics_set_gravity_scale(OimoRigidBody* rb, float scale) {
+    if (rb) rb->_gravityScale = scale;
+}
+
+// Rigid body helpers
+static inline void physics_apply_force(OimoRigidBody* rb, const OimoVec3* force) {
+    if (rb) oimo_rigid_body_apply_force_to_center(rb, force);
+}
+
+static inline void physics_apply_impulse(OimoRigidBody* rb, const OimoVec3* impulse) {
+    if (rb) {
+        OimoVec3 pos = oimo_rigid_body_get_position(rb);
+        oimo_rigid_body_apply_impulse(rb, impulse, &pos);
+    }
+}
+
+static inline void physics_set_linear_velocity(OimoRigidBody* rb, const OimoVec3* vel) {
+    if (rb) oimo_rigid_body_set_linear_velocity(rb, vel);
+}
+
+static inline OimoVec3 physics_get_linear_velocity(const OimoRigidBody* rb) {
+    return rb ? oimo_rigid_body_get_linear_velocity(rb) : oimo_vec3_zero();
+}
+
+static inline void physics_set_angular_velocity(OimoRigidBody* rb, const OimoVec3* vel) {
+    if (rb) oimo_rigid_body_set_angular_velocity(rb, vel);
+}
+
+static inline OimoVec3 physics_get_angular_velocity(const OimoRigidBody* rb) {
+    return rb ? oimo_rigid_body_get_angular_velocity(rb) : oimo_vec3_zero();
+}
+
+static inline void physics_wake_up(OimoRigidBody* rb) {
+    if (rb) oimo_rigid_body_wake_up(rb);
+}
+
+static inline void physics_disable_sleep(OimoRigidBody* rb) {
+    if (rb) rb->_autoSleep = 0;
+}
+
+static inline void physics_set_mass(OimoRigidBody* rb, float mass) {
+    if (rb) {
+        rb->_mass = mass;
+        oimo_rigid_body_update_mass(rb);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/armorcore/Deployment/n64/src/renderer.c b/armorcore/Deployment/n64/src/renderer.c
new file mode 100644
index 0000000000..2c9ccc27aa
--- /dev/null
+++ b/armorcore/Deployment/n64/src/renderer.c
@@ -0,0 +1,220 @@
+#include <stdint.h>
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmath.h>
+#include <t3d/t3dmodel.h>
+
+#include "engine.h"
+#include "types.h"
+#include "utils.h"
+#include "iron/system/input.h"
+
+#if ENGINE_ENABLE_PHYSICS
+#include "oimo/physics.h"
+#if ENGINE_ENABLE_PHYSICS_DEBUG
+#include "oimo/debug/physics_debug.h"
+#endif
+#endif
+
+static int frameIdx = 0;
+
+void renderer_begin_frame(T3DViewport *viewport, ArmScene *scene)
+{
+    ArmCamera *cam = &scene->cameras[scene->active_camera_id];
+
+    t3d_viewport_set_projection(
+        viewport,
+        T3D_DEG_TO_RAD(cam->fov),
+        cam->near,
+        cam->far
+    );
+
+	t3d_viewport_look_at(
+		viewport,
+        (T3DVec3*)&cam->transform.loc,
+        &cam->target,
+		&(T3DVec3){{0.0f, 1.0f, 0.0f}}
+	);
+}
+
+void renderer_update_objects(ArmScene *scene)
+{
+    for (uint16_t i = 0; i < scene->object_count; i++) {
+        ArmObject *obj = &scene->objects[i];
+
+        // Skip removed objects
+        if (obj->is_removed) {
+            continue;
+        }
+
+        if (obj->transform.dirty == 0) {
+            continue;
+        }
+
+        // Safety check: skip objects with invalid transform values
+        if (!transform_is_safe(obj->transform.loc.v, obj->transform.scale.v)) {
+            obj->transform.loc = (T3DVec3){{0.0f, 0.0f, 0.0f}};
+            obj->visible = false;
+        }
+
+        int mat_idx = obj->is_static ? 0 : frameIdx;
+        t3d_mat4fp_from_srt(
+            &obj->model_mat[mat_idx],
+            obj->transform.scale.v,
+            obj->transform.rot.v,
+            obj->transform.loc.v
+        );
+
+        // Update cached world-space bounds for frustum culling
+        // Only computed when transform is dirty, saving per-frame calculations
+        obj->cached_world_center = (T3DVec3){{
+            obj->transform.loc.v[0] + obj->bounds_center.v[0],
+            obj->transform.loc.v[1] + obj->bounds_center.v[1],
+            obj->transform.loc.v[2] + obj->bounds_center.v[2]
+        }};
+        float max_scale = obj->transform.scale.v[0];
+        if (obj->transform.scale.v[1] > max_scale) max_scale = obj->transform.scale.v[1];
+        if (obj->transform.scale.v[2] > max_scale) max_scale = obj->transform.scale.v[2];
+        obj->cached_world_radius = obj->bounds_radius * max_scale;
+
+        obj->transform.dirty--;
+    }
+}
+
+void renderer_draw_scene(T3DViewport *viewport, ArmScene *scene)
+{
+    frameIdx = (frameIdx + 1) % FB_COUNT;
+    renderer_update_objects(scene);
+
+    surface_t *fb = display_get();
+    rdpq_attach(fb, display_get_zbuf());
+    t3d_frame_start();
+    t3d_viewport_attach(viewport);
+
+    t3d_screen_clear_color(RGBA32(
+        scene->world.clear_color[0],
+        scene->world.clear_color[1],
+        scene->world.clear_color[2],
+        scene->world.clear_color[3]
+    ));
+    t3d_screen_clear_depth();
+
+    t3d_state_set_drawflags(T3D_FLAG_DEPTH | T3D_FLAG_CULL_BACK);
+
+    t3d_light_set_ambient(scene->world.ambient_color);
+    t3d_light_set_count(scene->light_count);
+    for (uint8_t i = 0; i < scene->light_count; i++) {
+        ArmLight *l = &scene->lights[i];
+        t3d_light_set_directional(i, l->color, &l->dir);
+    }
+
+    const T3DFrustum *frustum = &viewport->viewFrustum;
+    int visible_count = 0;
+    int static_rendered = 0;
+
+    // Render batched static objects if available
+    if (scene->static_dpl) {
+        rspq_block_run(scene->static_dpl);
+        static_rendered = scene->static_count;
+        visible_count += static_rendered;
+    }
+
+    // Render dynamic objects (and unbatched static objects if threshold not met)
+    t3d_matrix_push_pos(1);
+    for (uint16_t i = 0; i < scene->object_count; i++) {
+        ArmObject *obj = &scene->objects[i];
+        if (!obj->visible) {
+            continue;
+        }
+
+        // Skip static objects if they were rendered via combined display list
+        if (obj->is_static && scene->static_dpl) {
+            continue;
+        }
+
+        // Use cached world bounds - updated only when transform.dirty > 0
+        if (!t3d_frustum_vs_sphere(frustum, &obj->cached_world_center, obj->cached_world_radius)) {
+            continue;
+        }
+
+        // Skip if display list not loaded (model failed to load)
+        if (!obj->dpl) {
+            continue;
+        }
+
+        visible_count++;
+        int mat_idx = obj->is_static ? 0 : frameIdx;
+        t3d_matrix_set(&obj->model_mat[mat_idx], true);
+        rspq_block_run(obj->dpl);
+    }
+    t3d_matrix_pop(1);
+
+#ifdef ARM_DEBUG_HUD
+    rdpq_sync_pipe();
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 200, 220, "FPS: %.2f", display_get_fps());
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 200, 230, "Obj: %d/%d (S:%d)", visible_count, scene->object_count, scene->static_count);
+
+    // Input debug
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 10, 10, "Stick: %.2f, %.2f", input_stick_x(), input_stick_y());
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 10, 20,
+        "A:%d B:%d Z:%d Start:%d",
+        input_down(N64_BTN_A), input_down(N64_BTN_B), input_down(N64_BTN_Z), input_down(N64_BTN_START));
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 10, 30,
+        "D: %d%d%d%d  C: %d%d%d%d",
+        input_down(N64_BTN_DUP), input_down(N64_BTN_DDOWN), input_down(N64_BTN_DLEFT), input_down(N64_BTN_DRIGHT),
+        input_down(N64_BTN_CUP), input_down(N64_BTN_CDOWN), input_down(N64_BTN_CLEFT), input_down(N64_BTN_CRIGHT));
+    rdpq_text_printf(NULL, FONT_BUILTIN_DEBUG_MONO, 10, 40, "L:%d R:%d", input_down(N64_BTN_L), input_down(N64_BTN_R));
+#endif
+}
+
+void renderer_end_frame(T3DViewport *viewport)
+{
+#if ENGINE_ENABLE_PHYSICS && ENGINE_ENABLE_PHYSICS_DEBUG
+    // Draw physics debug using RDP hardware (while still attached)
+    physics_debug_draw(viewport, physics_get_world());
+#endif
+    rdpq_detach_show();
+}
+
+void renderer_build_static_dpl(ArmScene *scene)
+{
+    // Count static objects
+    uint16_t static_count = 0;
+    for (uint16_t i = 0; i < scene->object_count; i++) {
+        if (scene->objects[i].is_static && scene->objects[i].visible) {
+            static_count++;
+        }
+    }
+    scene->static_count = static_count;
+
+    // Only batch if we have enough static objects to make it worthwhile
+    if (static_count < STATIC_BATCH_THRESHOLD) {
+        scene->static_dpl = NULL;
+        return;
+    }
+
+    // Build combined display list for all static objects
+    // Note: This must be called AFTER initial matrix computation (after first few frames)
+    rspq_block_begin();
+    t3d_matrix_push_pos(1);
+    for (uint16_t i = 0; i < scene->object_count; i++) {
+        ArmObject *obj = &scene->objects[i];
+        if (!obj->is_static || !obj->visible || !obj->dpl) {
+            continue;
+        }
+        // Use frame 0 matrix (all frames should be identical for static objects)
+        t3d_matrix_set(&obj->model_mat[0], true);
+        rspq_block_run(obj->dpl);
+    }
+    t3d_matrix_pop(1);
+    scene->static_dpl = rspq_block_end();
+}
+
+void renderer_free_static_dpl(ArmScene *scene)
+{
+    if (scene->static_dpl) {
+        rspq_block_free(scene->static_dpl);
+        scene->static_dpl = NULL;
+    }
+    scene->static_count = 0;
+}
diff --git a/armorcore/Deployment/n64/src/renderer.h b/armorcore/Deployment/n64/src/renderer.h
new file mode 100644
index 0000000000..8e09f9ef75
--- /dev/null
+++ b/armorcore/Deployment/n64/src/renderer.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "types.h"
+#include <t3d/t3d.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void renderer_begin_frame(T3DViewport *viewport, ArmScene *scene);
+void renderer_update_objects(ArmScene *scene);
+void renderer_draw_scene(T3DViewport *viewport, ArmScene *scene);
+void renderer_end_frame(T3DViewport *viewport);
+void renderer_build_static_dpl(ArmScene *scene);
+void renderer_free_static_dpl(ArmScene *scene);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/scenes/scene.c.j2 b/armorcore/Deployment/n64/src/scenes/scene.c.j2
new file mode 100644
index 0000000000..852e4a8c10
--- /dev/null
+++ b/armorcore/Deployment/n64/src/scenes/scene.c.j2
@@ -0,0 +1,95 @@
+#include <libdragon.h>
+#include <t3d/t3d.h>
+#include <t3d/t3dmodel.h>
+
+#include "../types.h"
+#include "../engine.h"
+#include "../renderer.h"
+#include "../data/models.h"
+#include "../data/traits.h"
+#include "../data/scenes.h"
+
+#if ENGINE_ENABLE_PHYSICS
+#include "../oimo/physics.h"
+#include "../events/physics_events.h"
+#if ENGINE_ENABLE_PHYSICS_DEBUG
+#include "../oimo/debug/physics_debug.h"
+#endif
+#endif
+
+extern rspq_block_t *models_get_dpl(ModelId id);
+
+void scene_{scene_name}_init(ArmScene *scene)
+{{
+    scene->world.clear_color[0] = {cr};
+    scene->world.clear_color[1] = {cg};
+    scene->world.clear_color[2] = {cb};
+    scene->world.clear_color[3] = 0xFF;
+
+    scene->world.ambient_color[0] = {ar};
+    scene->world.ambient_color[1] = {ag};
+    scene->world.ambient_color[2] = {ab};
+    scene->world.ambient_color[3] = 0xFF;
+
+    // Initialize static display list to NULL (will be built after first frames)
+    scene->static_count = 0;
+    scene->static_dpl = NULL;
+
+    static ArmCamera cameras[{camera_count}];
+    scene->cameras = cameras;
+    scene->camera_count = {camera_count};
+    scene->active_camera_id = 0;
+
+{cameras_block}
+
+    static ArmLight lights[{light_count}];
+    scene->lights = lights;
+    scene->light_count = {light_count};
+
+{lights_block}
+
+    static ArmObject objects[{object_count}];
+    scene->objects = objects;
+    scene->object_count = {object_count};
+    scene->active_count = {object_count};  // All objects start active
+
+    // Initialize object pool free list (for runtime recycling)
+    static uint16_t free_list[{object_count}];
+    scene->free_list = free_list;
+    scene->free_count = 0;  // No free slots initially
+    scene->free_capacity = {object_count};
+
+    // Initialize active objects list (objects with traits that need updates)
+    static uint16_t active_objects[{object_count}];
+    scene->active_objects = active_objects;
+    scene->active_trait_count = 0;
+
+{objects_block}
+
+    // Build active objects list and lifecycle flags after objects are initialized
+    for (uint16_t i = 0; i < scene->object_count; i++) {{
+        ArmObject *obj = &scene->objects[i];
+        if (obj->trait_count > 0 && !obj->is_removed) {{
+            // Compute lifecycle flags from traits
+            obj->lifecycle_flags = 0;
+            for (uint8_t t = 0; t < obj->trait_count; t++) {{
+                if (obj->traits[t].on_fixed_update) obj->lifecycle_flags |= ARM_LIFECYCLE_FIXED_UPDATE;
+                if (obj->traits[t].on_update) obj->lifecycle_flags |= ARM_LIFECYCLE_UPDATE;
+                if (obj->traits[t].on_late_update) obj->lifecycle_flags |= ARM_LIFECYCLE_LATE_UPDATE;
+            }}
+            // Add to active list if has any update callbacks
+            if (obj->lifecycle_flags != 0) {{
+                scene->active_objects[scene->active_trait_count++] = i;
+            }}
+        }}
+    }}
+
+#if ENGINE_ENABLE_PHYSICS
+{physics_block}
+{contact_subs_block}
+#endif
+
+    scene->trait_count = {scene_trait_count};
+    scene->lifecycle_flags = 0;
+{scene_traits_block}
+}}
diff --git a/armorcore/Deployment/n64/src/system/signal.c b/armorcore/Deployment/n64/src/system/signal.c
new file mode 100644
index 0000000000..7807bdb58b
--- /dev/null
+++ b/armorcore/Deployment/n64/src/system/signal.c
@@ -0,0 +1,67 @@
+/**
+ * Signal System Implementation
+ * ============================
+ *
+ * Per-instance signals with connect/disconnect/emit support.
+ * Each signal can have up to ARM_SIGNAL_MAX_SUBS subscribers (default 16).
+ *
+ * Memory: Each ArmSignal is ~200 bytes (16 handlers * 12 bytes + count)
+ * Performance: O(n) for all operations where n = subscriber count
+ */
+
+#include "../types.h"
+#include <string.h>
+
+void signal_connect(ArmSignal *signal, ArmSignalHandler handler, void *ctx)
+{
+    if (signal == NULL || handler == NULL) return;
+    if (signal->count >= ARM_SIGNAL_MAX_SUBS) return;  // Full, silently ignore
+
+    // Check if already connected (avoid duplicates)
+    for (uint8_t i = 0; i < signal->count; i++) {
+        ArmSignalEntry *e = &signal->entries[i];
+        if (e->handler == handler && e->ctx == ctx) {
+            return;  // Already connected
+        }
+    }
+
+    // Add new subscriber
+    ArmSignalEntry *entry = &signal->entries[signal->count++];
+    entry->handler = handler;
+    entry->ctx = ctx;
+}
+
+void signal_disconnect(ArmSignal *signal, ArmSignalHandler handler)
+{
+    if (signal == NULL || handler == NULL) return;
+
+    for (uint8_t i = 0; i < signal->count; i++) {
+        if (signal->entries[i].handler == handler) {
+            // Shift remaining entries down (single struct copy per iteration)
+            for (uint8_t j = i; j < signal->count - 1; j++) {
+                signal->entries[j] = signal->entries[j + 1];
+            }
+            signal->count--;
+            return;
+        }
+    }
+}
+
+void signal_emit(ArmSignal *signal, void *payload)
+{
+    if (signal == NULL || signal->count == 0) return;
+
+    // Call all handlers - AoS layout keeps handler+context together for cache efficiency
+    for (uint8_t i = 0; i < signal->count; i++) {
+        ArmSignalEntry *e = &signal->entries[i];
+        if (e->handler != NULL) {
+            e->handler(e->ctx, payload);
+        }
+    }
+}
+
+void signal_clear(ArmSignal *signal)
+{
+    if (signal == NULL) return;
+    memset(signal, 0, sizeof(ArmSignal));
+}
diff --git a/armorcore/Deployment/n64/src/system/signal.h b/armorcore/Deployment/n64/src/system/signal.h
new file mode 100644
index 0000000000..84272f4cb6
--- /dev/null
+++ b/armorcore/Deployment/n64/src/system/signal.h
@@ -0,0 +1,22 @@
+/**
+ * Signal System Header
+ * ====================
+ *
+ * Per-instance signals for event-driven communication between traits.
+ * Similar to Godot's signal system.
+ *
+ * Usage in Haxe traits:
+ *   var onDeath:Signal;                    // Declare signal
+ *   @:n64MaxSubs(8) var onHit:Signal;      // Custom max subscribers (default 16)
+ *
+ *   onDeath.connect(myCallback);           // Subscribe
+ *   onDeath.disconnect(myCallback);        // Unsubscribe
+ *   onDeath.emit(damage, attacker);        // Emit with args (max 4)
+ */
+
+#pragma once
+
+#include "../types.h"
+
+// Functions are declared in types.h since ArmSignal is defined there
+// This header is for documentation and potential future extensions
diff --git a/armorcore/Deployment/n64/src/types.h.j2 b/armorcore/Deployment/n64/src/types.h.j2
new file mode 100644
index 0000000000..e9ed90b492
--- /dev/null
+++ b/armorcore/Deployment/n64/src/types.h.j2
@@ -0,0 +1,246 @@
+/**
+ * N64 Engine Type System
+ * =======================
+ *
+ * COORDINATE SYSTEM
+ * -----------------
+ * Blender uses Z-up, N64/T3D uses Y-up. Conversion is automatic:
+ *   Blender (x, y, z) → N64 (x, z, -y)
+ *
+ * Scale factor: Blender units * 0.015625 = N64 units (1/64 scale)
+ *   - 1 Blender unit = 64 N64 units
+ *   - Typical N64 world scale: -500 to +500 units
+ *
+ * TYPE MAPPING (Haxe/Armory → C)
+ * ------------------------------
+ *   Vec2, Vec3, Vec4    → ArmVec2, ArmVec3, ArmVec4 (value types)
+ *   Object              → ArmObject* (pointer)
+ *   Transform           → ArmTransform (embedded in ArmObject)
+ *   Camera, Light       → ArmCamera*, ArmLight* (pointers)
+ *   Scene               → ArmScene (global)
+ *   Float, Int, Bool    → float, int32_t, bool
+ *   String              → const char*
+ *
+ * MEMORY LIMITS (N64 Hardware)
+ * ----------------------------
+ *   Total RAM:           4 MB (with Expansion Pak), 8 MB addressable
+ *   Heap available:      ~380 KB typical after engine + assets
+ *   Stack size:          8 KB default
+ *   Uncached memory:     Limited - used for DMA, display lists
+ *
+ *   Recommended limits:
+ *     - Objects per scene:     64-128 max
+ *     - Traits per object:     2-4 max
+ *     - Vertices per model:    500-2000 (depending on complexity)
+ *     - Textures:              64x64 or 32x32 preferred
+ *
+ * PHYSICS LIMITS (OimoPhysics)
+ * ----------------------------
+ *   MAX_PHYSICS_BODIES:       32 default (configurable in config.py)
+ *   MAX_CONTACT_BODIES:       16 default
+ *   MAX_CONTACT_SUBSCRIBERS:  4 per body default
+ *
+ *   Collision shapes: box, sphere, capsule, mesh (static only)
+ *   Body types: static, dynamic, kinematic, trigger
+ *
+ * PERFORMANCE NOTES
+ * -----------------
+ *   - Traits are compiled to C functions, not runtime objects
+ *   - Static objects are batched into combined display lists
+ *   - Transform matrices only recomputed when dirty flag set
+ *   - Frustum culling uses cached world-space bounds
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <rspq.h>
+#include <t3d/t3dmath.h>
+#include <t3d/t3dmodel.h>
+
+#ifdef __cplusplus
+extern "C" {{
+#endif
+
+#define FB_COUNT 3 {debug_hud_define}
+
+// Number of frames to keep transform dirty for double/triple buffering
+#define TRANSFORM_DIRTY_FRAMES 3
+
+// Minimum static objects to batch into a combined display list
+#ifndef STATIC_BATCH_THRESHOLD
+#define STATIC_BATCH_THRESHOLD 3
+#endif
+
+struct OimoRigidBody;
+
+typedef struct {{ float x, y; }} ArmVec2;
+typedef struct {{ float x, y, z; }} ArmVec3;
+typedef struct {{ float x, y, z, w; }} ArmVec4;
+
+typedef void (*ArmTraitReadyFn)(void *entity, void *data);
+typedef void (*ArmTraitFixedUpdateFn)(void *entity, float dt, void *data);
+typedef void (*ArmTraitUpdateFn)(void *entity, float dt, void *data);
+typedef void (*ArmTraitLateUpdateFn)(void *entity, float dt, void *data);
+typedef void (*ArmTraitRemoveFn)(void *entity, void *data);
+
+typedef struct {{
+    ArmTraitReadyFn on_ready;
+    ArmTraitFixedUpdateFn on_fixed_update;
+    ArmTraitUpdateFn on_update;
+    ArmTraitLateUpdateFn on_late_update;
+    ArmTraitRemoveFn on_remove;
+    void *data;
+}} ArmTrait;
+
+// =============================================================================
+// Signal System - Per-instance event dispatch
+// =============================================================================
+
+#ifndef ARM_SIGNAL_MAX_SUBS
+#define ARM_SIGNAL_MAX_SUBS 16
+#endif
+
+/**
+ * Signal handler function type.
+ * Called when a signal is emitted with: (context, payload)
+ * Pack all data into a struct and pass its pointer as payload.
+ */
+typedef void (*ArmSignalHandler)(void *ctx, void *payload);
+
+/**
+ * Signal subscriber entry - keeps handler + context together for cache efficiency
+ */
+typedef struct {{
+    ArmSignalHandler handler;
+    void *ctx;  // Handler's context (passed as first arg)
+}} ArmSignalEntry;
+
+/**
+ * ArmSignal - Per-instance signal with up to ARM_SIGNAL_MAX_SUBS subscribers.
+ * Uses array-of-structs (AoS) for better cache locality on N64.
+ *
+ * Usage in traits:
+ *   - Declare: var onDeath:Signal; (Haxe) → ArmSignal onDeath; (C struct member)
+ *   - Connect: onDeath.connect(callback) → signal_connect(&data->onDeath, handler, obj, data)
+ *   - Emit: onDeath.emit(damage) → signal_emit(&data->onDeath, obj, damage)
+ *   - Disconnect: onDeath.disconnect(callback) → signal_disconnect(&data->onDeath, handler)
+ */
+typedef struct {{
+    uint8_t count;
+    ArmSignalEntry entries[ARM_SIGNAL_MAX_SUBS];
+}} ArmSignal;
+
+// Signal functions (implemented in signal.c)
+void signal_connect(ArmSignal *signal, ArmSignalHandler handler, void *ctx);
+void signal_disconnect(ArmSignal *signal, ArmSignalHandler handler);
+void signal_emit(ArmSignal *signal, void *payload);
+void signal_clear(ArmSignal *signal);
+
+typedef struct {{
+    T3DVec3 loc;
+    T3DQuat rot;
+    T3DVec3 scale;
+    uint8_t dirty;
+}} ArmTransform;
+
+/**
+ * ArmObject - Core entity type
+ *
+ * Field layout optimized for cache:
+ *   - Hot data first (accessed every frame): transform, visibility, matrices
+ *   - Cold data after (accessed occasionally): bounds, physics, traits
+ *
+ * Cached world bounds are updated when transform.dirty > 0, avoiding
+ * redundant calculations during frustum culling.
+ */
+typedef struct ArmObject {{
+    // === HOT DATA (accessed every frame) ===
+    ArmTransform transform;       // 44 bytes: position, rotation, scale
+    T3DMat4FP *model_mat;         // 4 bytes: matrix for rendering
+    rspq_block_t *dpl;            // 4 bytes: display list pointer
+    bool visible;                 // 1 byte
+    bool is_static;               // 1 byte
+    bool is_removed;              // 1 byte: object marked for removal
+    uint8_t trait_count;          // 1 byte
+
+    // === CACHED BOUNDS (updated when dirty) ===
+    T3DVec3 cached_world_center;  // 12 bytes: world-space center for culling
+    float cached_world_radius;    // 4 bytes: world-space radius for culling
+
+    // === COLD DATA (accessed occasionally) ===
+    T3DVec3 bounds_center;        // 12 bytes: local-space center
+    float bounds_radius;          // 4 bytes: local-space radius
+    struct OimoRigidBody *rigid_body;  // 4 bytes
+    ArmTrait *traits;             // 4 bytes
+
+    // === LIFECYCLE FLAGS (bitmask for fast dispatch) ===
+    // Bit 0: has on_fixed_update, Bit 1: has on_update, Bit 2: has on_late_update
+    uint8_t lifecycle_flags;      // 1 byte
+}} ArmObject;
+
+// Lifecycle flag bits
+#define ARM_LIFECYCLE_FIXED_UPDATE (1 << 0)
+#define ARM_LIFECYCLE_UPDATE       (1 << 1)
+#define ARM_LIFECYCLE_LATE_UPDATE  (1 << 2)
+
+typedef struct ArmLight {{
+    ArmTransform transform;
+    uint8_t color[4];
+    T3DVec3 dir;
+    uint8_t trait_count;
+    uint8_t lifecycle_flags;
+    ArmTrait *traits;
+}} ArmLight;
+
+typedef struct ArmCamera {{
+    ArmTransform transform;
+    T3DVec3 target;
+    float fov;
+    float near;
+    float far;
+    uint8_t trait_count;
+    uint8_t lifecycle_flags;
+    ArmTrait *traits;
+}} ArmCamera;
+
+typedef struct {{
+    uint8_t clear_color[4];
+    uint8_t ambient_color[4];
+}} ArmWorld;
+
+typedef struct ArmScene {{
+    ArmWorld world;
+
+    uint8_t camera_count;
+    ArmCamera *cameras;
+    uint8_t active_camera_id;
+
+    uint8_t light_count;
+    ArmLight *lights;
+
+    uint16_t object_count;        // Total slots in object array
+    uint16_t active_count;        // Number of active (non-removed) objects
+    ArmObject *objects;
+    uint16_t static_count;        // Number of static objects
+    rspq_block_t *static_dpl;     // Combined display list for static objects
+
+    // Object pool recycling - free list for removed object slots
+    uint16_t *free_list;          // Array of free slot indices
+    uint16_t free_count;          // Number of free slots available
+    uint16_t free_capacity;       // Maximum slots (same as object_count)
+
+    // Active object tracking - indices of objects that need lifecycle updates
+    // Avoids iterating entire object array when most objects have no traits
+    uint16_t *active_objects;     // Array of object indices with active traits
+    uint16_t active_trait_count;  // Count of objects with traits
+
+    uint8_t trait_count;
+    uint8_t lifecycle_flags;      // Scene-level trait lifecycle flags
+    ArmTrait *traits;
+}} ArmScene;
+
+#ifdef __cplusplus
+}}
+#endif
\ No newline at end of file
diff --git a/armorcore/Deployment/n64/src/utils.h b/armorcore/Deployment/n64/src/utils.h
new file mode 100644
index 0000000000..8442b74ec7
--- /dev/null
+++ b/armorcore/Deployment/n64/src/utils.h
@@ -0,0 +1,84 @@
+// utils.h - Engine utility functions
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <math.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Maximum safe coordinate value for fixed-point conversion (avoid overflow)
+#define MAX_SAFE_COORD 32000.0f
+
+// Maximum world bounds for physics (objects beyond this are "off-world")
+#define PHYSICS_WORLD_BOUNDS 1000.0f
+
+/**
+ * Check if a float is finite (not NaN or Inf).
+ * N64/libdragon doesn't provide isfinite(), so we use bit manipulation.
+ */
+static inline bool float_is_finite(float f) {
+    union { float f; uint32_t u; } val;
+    val.f = f;
+    // NaN and Inf have all exponent bits set (0x7F800000)
+    return (val.u & 0x7F800000) != 0x7F800000;
+}
+
+/**
+ * Check if transform values are safe for fixed-point conversion.
+ * Returns false if any value is NaN, Inf, or too large.
+ */
+static inline bool transform_is_safe(const float* loc, const float* scale) {
+    for (int i = 0; i < 3; i++) {
+        if (!float_is_finite(loc[i]) || fabsf(loc[i]) > MAX_SAFE_COORD) return false;
+        if (!float_is_finite(scale[i]) || fabsf(scale[i]) > MAX_SAFE_COORD) return false;
+    }
+    return true;
+}
+
+/**
+ * Check if a position is within world bounds.
+ */
+static inline bool position_in_bounds(float x, float y, float z) {
+    return fabsf(x) <= PHYSICS_WORLD_BOUNDS &&
+           fabsf(y) <= PHYSICS_WORLD_BOUNDS &&
+           fabsf(z) <= PHYSICS_WORLD_BOUNDS;
+}
+
+// =========================================================================
+// String formatting utilities for UI text
+// =========================================================================
+
+#include <stdio.h>
+
+// Static buffer for string formatting (single-threaded, so this is safe)
+// Multiple calls will overwrite previous values - copy if needed
+#define STR_FMT_BUFFER_SIZE 64
+#define STR_FMT_BUFFER_COUNT 4
+static char _str_fmt_buffers[STR_FMT_BUFFER_COUNT][STR_FMT_BUFFER_SIZE];
+static int _str_fmt_buffer_idx = 0;
+
+/**
+ * Get next string buffer (rotates through available buffers)
+ */
+static inline char* _str_get_buffer(void) {
+    char* buf = _str_fmt_buffers[_str_fmt_buffer_idx];
+    _str_fmt_buffer_idx = (_str_fmt_buffer_idx + 1) % STR_FMT_BUFFER_COUNT;
+    return buf;
+}
+
+/**
+ * Format string with sprintf. Returns pointer to static buffer.
+ * Usage: _str_concat("Score: %d", score)
+ */
+#define _str_concat(fmt, ...) ({ \
+    char* _buf = _str_get_buffer(); \
+    snprintf(_buf, STR_FMT_BUFFER_SIZE, fmt, ##__VA_ARGS__); \
+    _buf; \
+})
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/armory.py b/armory.py
index 04ba45acf8..421e3ba7b0 100644
--- a/armory.py
+++ b/armory.py
@@ -147,6 +147,30 @@ def html5_copy_path_update(self, context):
         self.skip_update = True
         self.html5_copy_path = bpy.path.reduce_dirs([bpy.path.abspath(self.html5_copy_path)])[0]
 
+    def n64_toolchain_path_update(self, context):
+        if self.skip_update:
+            return
+        self.skip_update = True
+        self.n64_toolchain_path = bpy.path.reduce_dirs([bpy.path.abspath(self.n64_toolchain_path)])[0]
+
+    def msys2_bash_executable_update(self, context):
+        if self.skip_update:
+            return
+        self.skip_update = True
+        self.msys2_bash_executable = bpy.path.reduce_dirs([bpy.path.abspath(self.msys2_bash_executable)])[0]
+
+    def mingw64_path_update(self, context):
+        if self.skip_update:
+            return
+        self.skip_update = True
+        self.mingw64_path = bpy.path.reduce_dirs([bpy.path.abspath(self.mingw64_path)])[0]
+
+    def ares_emulator_executable_update(self, context):
+        if self.skip_update:
+            return
+        self.skip_update = True
+        self.ares_emulator_executable = bpy.path.reduce_dirs([bpy.path.abspath(self.ares_emulator_executable)])[0]
+
     sdk_path: StringProperty(name="SDK Path", subtype="FILE_PATH", update=sdk_path_update, default="")
     update_submodules: BoolProperty(
         name="Update Submodules", default=True, description=(
@@ -286,6 +310,12 @@ def html5_copy_path_update(self, context):
     link_web_server: StringProperty(name="Url To Web Server", description="Url to the web server that runs the local server", default="http://localhost/", set=set_link_web_server, get=get_link_web_server)
     html5_server_port: IntProperty(name="Web Server Port", description="The port number of the local web server", default=8040, min=1024, max=65535)
     html5_server_log: BoolProperty(name="Enable Http Log", description="Enable logging of http requests to local web server", default=True)
+    # Nintendo 64 Settings
+    n64_toolchain_path: StringProperty(name="N64 Toolchain Path", description="Path to the N64 Toolchain installation directory", default="", subtype="FILE_PATH", update=n64_toolchain_path_update)
+    msys2_bash_executable: StringProperty(name="MSYS2 Bash Executable", description="Path to the MSYS2 Bash executable", default="", subtype="FILE_PATH", update=msys2_bash_executable_update)
+    mingw64_path: StringProperty(name="MinGW64 Path", description="Path to the MinGW64 directory", default="", subtype="FILE_PATH", update=mingw64_path_update)
+    open_n64_rom_directory: BoolProperty(name="Open Nintendo 64 ROM Directory", description="Open the Nintendo 64 ROM directory after successfully build", default=False)
+    ares_emulator_executable: StringProperty(name="Ares Emulator Executable", description="Path to the Ares Emulator executable", default="", subtype="FILE_PATH", update=ares_emulator_executable_update)
 
     # Developer options
     profile_exporter: BoolProperty(
@@ -422,6 +452,19 @@ def draw(self, context):
                 box.prop(self, "html5_server_port")
                 box.prop(self, "html5_server_log")
 
+                box = box_main.column()
+                box.label(text="Nintendo 64 Settings")
+                box.prop(self, "n64_toolchain_path")
+                box.prop(self, "msys2_bash_executable")
+                box.prop(self, "mingw64_path")
+                box.prop(self, "ares_emulator_executable")
+                box.prop(self, "open_n64_rom_directory")
+                box.label(text="Libraries:")
+                row = box.row(align=True)
+                row.operator("arm_addon.install_libdragon_dependencies", icon="IMPORT")
+                row.operator("arm_addon.build_libdragon", icon="MOD_BUILD")
+                row.operator("arm_addon.build_tiny3d", icon="MOD_BUILD")
+
             elif self.tabs == "debugconsole":
                 box.label(text="Debug Console")
                 box.prop(self, "debug_console_auto")
@@ -803,6 +846,157 @@ def execute(self, context):
         return {"FINISHED"}
 
 
+#TODO: refactor common code between the two build buttons
+class ArmAddonInstallLibdragonDependenciesButton(bpy.types.Operator):
+    """Install libdragon dependencies via pacman"""
+    bl_idname = "arm_addon.install_libdragon_dependencies"
+    bl_label = "Install Dependencies"
+    bl_description = "Install libdragon dependencies (base-devel, mingw-w64-x86_64-gcc, mingw-w64-x86_64-make, git)"
+
+    def execute(self, context):
+        sdk_path = get_sdk_path(context)
+        if sdk_path == "":
+            self.report({"ERROR"}, "Configure Armory SDK path first")
+            return {"CANCELLED"}
+
+        prefs = ArmoryAddonPreferences.get_prefs()
+        msys2_exe = prefs.msys2_bash_executable
+        libdragon_path = os.path.abspath(os.path.join(sdk_path, "lib", "libdragon")).replace("\\", "/")
+
+        if not msys2_exe or not os.path.exists(msys2_exe):
+            self.report({'ERROR'}, 'MSYS2 Bash executable not configured in preferences')
+            return {'FINISHED'}
+
+        env = os.environ.copy()
+        env['MSYSTEM'] = 'MINGW64'
+
+        result = subprocess.run(
+            [
+                rf'{msys2_exe}',
+                '--login',
+                '-c',
+                f'pacman -S --needed --noconfirm base-devel mingw-w64-x86_64-gcc mingw-w64-x86_64-make git'
+            ],
+            stdout=None,
+            stderr=None,
+            text=True,
+            env=env
+        )
+
+        if result.returncode == 0:
+            self.report({'INFO'}, 'libdragon dependencies installed successfully.')
+        else:
+            self.report({'WARNING'}, 'libdragon dependencies installation completed with errors. Check console for details.')
+
+        return {'FINISHED'}
+
+
+class ArmAddonBuildLibdragonButton(bpy.types.Operator):
+    """Build libdragon for Nintendo 64"""
+    bl_idname = "arm_addon.build_libdragon"
+    bl_label = "Build libdragon"
+    bl_description = "Build libdragon for Nintendo 64 development"
+
+    def execute(self, context):
+        sdk_path = get_sdk_path(context)
+        if sdk_path == "":
+            self.report({"ERROR"}, "Configure Armory SDK path first")
+            return {"CANCELLED"}
+
+        preferences = context.preferences
+        addon_prefs = preferences.addons["armory"].preferences
+
+        if addon_prefs.msys2_bash_executable == "":
+            self.report({"ERROR"}, "Configure MSYS2 Bash executable path first")
+            return {"CANCELLED"}
+
+        libdragon_path = os.path.abspath(os.path.join(sdk_path, "lib", "libdragon")).replace("\\", "/")
+        msys2_executable = addon_prefs.msys2_bash_executable
+        n64_toolchain_path = os.path.abspath(addon_prefs.n64_toolchain_path).replace("\\", "/")
+        mingw64_path = os.path.abspath(addon_prefs.mingw64_path).replace("\\", "/")
+
+        print('Building libdragon for Nintendo 64, check console for details.')
+
+        # Build environment variables
+        env = os.environ.copy()
+        env['MSYSTEM'] = 'MINGW64'
+        env['N64_INST'] = n64_toolchain_path
+        env['PATH'] = f"{n64_toolchain_path}:{mingw64_path}:{env.get('PATH', '')}"
+
+        result = subprocess.run(
+            [
+                rf'{msys2_executable}',
+                '--login',
+                '-c',
+                f'cd "{libdragon_path}" && ./build.sh'
+            ],
+            stdout=None,
+            stderr=None,
+            text=True,
+            env=env
+        )
+
+        if result.returncode != 0:
+            self.report({"ERROR"}, "Failed building libdragon, check console for details.")
+        else:
+            self.report({'INFO'}, 'libdragon build completed.')
+
+        return {"FINISHED"}
+
+
+class ArmAddonBuildTiny3dButton(bpy.types.Operator):
+    """Build Tiny3D for Nintendo 64"""
+    bl_idname = "arm_addon.build_tiny3d"
+    bl_label = "Build Tiny3D"
+    bl_description = "Build Tiny3D rendering library for Nintendo 64 development"
+
+    def execute(self, context):
+        sdk_path = get_sdk_path(context)
+        if sdk_path == "":
+            self.report({"ERROR"}, "Configure Armory SDK path first")
+            return {"CANCELLED"}
+
+        preferences = context.preferences
+        addon_prefs = preferences.addons["armory"].preferences
+
+        if addon_prefs.msys2_bash_executable == "":
+            self.report({"ERROR"}, "Configure MSYS2 Bash executable path first")
+            return {"CANCELLED"}
+
+        tiny3d_path = os.path.abspath(os.path.join(sdk_path, "lib", "tiny3d")).replace("\\", "/")
+        msys2_executable = addon_prefs.msys2_bash_executable
+        n64_toolchain_path = os.path.abspath(addon_prefs.n64_toolchain_path).replace("\\", "/")
+        mingw64_path = os.path.abspath(addon_prefs.mingw64_path).replace("\\", "/")
+
+        print('Building Tiny3D for Nintendo 64, check console for details.')
+
+        # Build environment variables
+        env = os.environ.copy()
+        env['MSYSTEM'] = 'MINGW64'
+        env['N64_INST'] = n64_toolchain_path
+        env['PATH'] = f"{n64_toolchain_path}:{mingw64_path}:{env.get('PATH', '')}"
+
+        result = subprocess.run(
+            [
+                rf'{msys2_executable}',
+                '--login',
+                '-c',
+                f'cd "{tiny3d_path}" && ./build.sh'
+            ],
+            stdout=None,
+            stderr=None,
+            text=True,
+            env=env
+        )
+
+        if result.returncode != 0:
+            self.report({"ERROR"}, "Failed building Tiny3D, check console for details.")
+        else:
+            self.report({'INFO'}, 'Tiny3D build completed.')
+
+        return {"FINISHED"}
+
+
 def update_armory_py(sdk_path: str, force_relink=False):
     """Ensure that armory.py is up to date by copying it from the
     current SDK path (if 'use_armory_py_symlink' is true, a symlink is
@@ -917,6 +1111,9 @@ def register():
     bpy.utils.register_class(ArmAddonUpdateButton)
     bpy.utils.register_class(ArmAddonRestoreButton)
     bpy.utils.register_class(ArmAddonHelpButton)
+    bpy.utils.register_class(ArmAddonInstallLibdragonDependenciesButton)
+    bpy.utils.register_class(ArmAddonBuildLibdragonButton)
+    bpy.utils.register_class(ArmAddonBuildTiny3dButton)
     bpy.app.handlers.load_post.append(on_load_post)
 
     # Hack to avoid _RestrictContext
@@ -931,6 +1128,9 @@ def unregister():
     bpy.utils.unregister_class(ArmAddonUpdateButton)
     bpy.utils.unregister_class(ArmAddonRestoreButton)
     bpy.utils.unregister_class(ArmAddonHelpButton)
+    bpy.utils.unregister_class(ArmAddonInstallLibdragonDependenciesButton)
+    bpy.utils.unregister_class(ArmAddonBuildLibdragonButton)
+    bpy.utils.unregister_class(ArmAddonBuildTiny3dButton)
     bpy.app.handlers.load_post.remove(on_load_post)
 
 
diff --git a/armory/Sources/armory/logicnode/GetTilesheetFlipNode.hx b/armory/Sources/armory/logicnode/GetTilesheetFlipNode.hx
new file mode 100644
index 0000000000..d2527a1998
--- /dev/null
+++ b/armory/Sources/armory/logicnode/GetTilesheetFlipNode.hx
@@ -0,0 +1,22 @@
+package armory.logicnode;
+
+import iron.object.MeshObject;
+
+class GetTilesheetFlipNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var object: MeshObject = inputs[0].get();
+
+		if (object == null) return null;
+		if (object.tilesheet == null) return null;
+
+		if (from == 0) return object.tilesheet.flipX;
+		if (from == 1) return object.tilesheet.flipY;
+
+		return null;
+	}
+}
diff --git a/armory/Sources/armory/logicnode/GetTilesheetStateNode.hx b/armory/Sources/armory/logicnode/GetTilesheetStateNode.hx
index 16cba09428..39aa31114e 100644
--- a/armory/Sources/armory/logicnode/GetTilesheetStateNode.hx
+++ b/armory/Sources/armory/logicnode/GetTilesheetStateNode.hx
@@ -11,13 +11,13 @@ class GetTilesheetStateNode extends LogicNode {
 	override function get(from: Int): Dynamic {
 		var object: MeshObject = inputs[0].get();
 
-		if (object == null) return null;
+		if (object == null || object.tilesheet == null) return null;
 
-		var tilesheet = object.activeTilesheet;
+		var tilesheet = object.tilesheet;
 
 		return switch (from) {
-			case 0: tilesheet.raw.name;
-			case 1: tilesheet.action.name;
+			case 0: object.name; // Return object name since tilesheet is embedded
+			case 1: tilesheet.action != null ? tilesheet.action.name : null;
 			case 2: tilesheet.getFrameOffset();
 			case 3: tilesheet.frame;
 			case 4: tilesheet.paused;
diff --git a/armory/Sources/armory/logicnode/PauseTilesheetNode.hx b/armory/Sources/armory/logicnode/PauseTilesheetNode.hx
index 13c29262ae..10ba4fe1ec 100644
--- a/armory/Sources/armory/logicnode/PauseTilesheetNode.hx
+++ b/armory/Sources/armory/logicnode/PauseTilesheetNode.hx
@@ -11,9 +11,9 @@ class PauseTilesheetNode extends LogicNode {
 	override function run(from: Int) {
 		var object: MeshObject = inputs[1].get();
 
-		if (object == null) return;
+		if (object == null || object.tilesheet == null) return;
 
-		object.activeTilesheet.pause();
+		object.tilesheet.pause();
 
 		runOutput(0);
 	}
diff --git a/armory/Sources/armory/logicnode/PlayTilesheetNode.hx b/armory/Sources/armory/logicnode/PlayTilesheetNode.hx
index 9bd5785a20..c9c04af915 100644
--- a/armory/Sources/armory/logicnode/PlayTilesheetNode.hx
+++ b/armory/Sources/armory/logicnode/PlayTilesheetNode.hx
@@ -12,9 +12,9 @@ class PlayTilesheetNode extends LogicNode {
 		var object: MeshObject = inputs[1].get();
 		var action: String = inputs[2].get();
 
-		if (object == null) return;
+		if (object == null || object.tilesheet == null) return;
 
-		object.activeTilesheet.play(action, function() {
+		object.tilesheet.play(action, function() {
 			runOutput(1);
 		});
 
diff --git a/armory/Sources/armory/logicnode/ResumeTilesheetNode.hx b/armory/Sources/armory/logicnode/ResumeTilesheetNode.hx
index 5712675c38..676a386f5b 100644
--- a/armory/Sources/armory/logicnode/ResumeTilesheetNode.hx
+++ b/armory/Sources/armory/logicnode/ResumeTilesheetNode.hx
@@ -11,9 +11,9 @@ class ResumeTilesheetNode extends LogicNode {
 	override function run(from: Int) {
 		var object: MeshObject = inputs[1].get();
 
-		if (object == null) return;
+		if (object == null || object.tilesheet == null) return;
 
-		object.activeTilesheet.resume();
+		object.tilesheet.resume();
 
 		runOutput(0);
 	}
diff --git a/armory/Sources/armory/logicnode/SetActiveTilesheetNode.hx b/armory/Sources/armory/logicnode/SetTilesheetFlipNode.hx
similarity index 52%
rename from armory/Sources/armory/logicnode/SetActiveTilesheetNode.hx
rename to armory/Sources/armory/logicnode/SetTilesheetFlipNode.hx
index 0d3eece63b..3a8e7adaa2 100644
--- a/armory/Sources/armory/logicnode/SetActiveTilesheetNode.hx
+++ b/armory/Sources/armory/logicnode/SetTilesheetFlipNode.hx
@@ -1,9 +1,8 @@
 package armory.logicnode;
 
-import iron.Scene;
 import iron.object.MeshObject;
 
-class SetActiveTilesheetNode extends LogicNode {
+class SetTilesheetFlipNode extends LogicNode {
 
 	public function new(tree: LogicTree) {
 		super(tree);
@@ -11,12 +10,14 @@ class SetActiveTilesheetNode extends LogicNode {
 
 	override function run(from: Int) {
 		var object: MeshObject = inputs[1].get();
-		var tilesheet: String = inputs[2].get();
-		var action: String = inputs[3].get();
+		var flipX: Bool = inputs[2].get();
+		var flipY: Bool = inputs[3].get();
 
 		if (object == null) return;
+		if (object.tilesheet == null) return;
 
-		object.setActiveTilesheet(Scene.active.raw.name, tilesheet, action);
+		object.tilesheet.flipX = flipX;
+		object.tilesheet.flipY = flipY;
 
 		runOutput(0);
 	}
diff --git a/armory/Sources/armory/logicnode/SetTilesheetFrameNode.hx b/armory/Sources/armory/logicnode/SetTilesheetFrameNode.hx
index 27eb54765d..4a515346c3 100644
--- a/armory/Sources/armory/logicnode/SetTilesheetFrameNode.hx
+++ b/armory/Sources/armory/logicnode/SetTilesheetFrameNode.hx
@@ -12,9 +12,9 @@ class SetTilesheetFrameNode extends LogicNode {
 		var object: MeshObject = inputs[1].get();
 		var frame: Int = inputs[2].get();
 
-		if (object == null) return;
+		if (object == null || object.tilesheet == null) return;
 
-		object.activeTilesheet.setFrameOffset(frame);
+		object.tilesheet.setFrameOffset(frame);
 
 		runOutput(0);
 	}
diff --git a/armory/Sources/armory/logicnode/SetTilesheetNode.hx b/armory/Sources/armory/logicnode/SetTilesheetNode.hx
new file mode 100644
index 0000000000..5015834555
--- /dev/null
+++ b/armory/Sources/armory/logicnode/SetTilesheetNode.hx
@@ -0,0 +1,21 @@
+package armory.logicnode;
+
+import iron.object.MeshObject;
+
+class SetTilesheetNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function run(from: Int) {
+		var object: MeshObject = inputs[1].get();
+		var action: String = inputs[2].get();
+
+		if (object == null || object.tilesheet == null) return;
+
+		object.setTilesheetAction(action);
+
+		runOutput(0);
+	}
+}
diff --git a/armory/Sources/armory/logicnode/SetTilesheetPausedNode.hx b/armory/Sources/armory/logicnode/SetTilesheetPausedNode.hx
index e267b71995..ee02dda360 100644
--- a/armory/Sources/armory/logicnode/SetTilesheetPausedNode.hx
+++ b/armory/Sources/armory/logicnode/SetTilesheetPausedNode.hx
@@ -12,9 +12,9 @@ class SetTilesheetPausedNode extends LogicNode {
 		var object: MeshObject = inputs[1].get();
 		var paused: Bool = inputs[2].get();
 
-		if (object == null) return;
+		if (object == null || object.tilesheet == null) return;
 
-		paused ? object.activeTilesheet.pause() : object.activeTilesheet.resume();
+		paused ? object.tilesheet.pause() : object.tilesheet.resume();
 
 		runOutput(0);
 	}
diff --git a/armory/Sources/armory/n64/N64LogicNodeMacro.hx b/armory/Sources/armory/n64/N64LogicNodeMacro.hx
new file mode 100644
index 0000000000..57538f97e2
--- /dev/null
+++ b/armory/Sources/armory/n64/N64LogicNodeMacro.hx
@@ -0,0 +1,849 @@
+package armory.n64;
+
+#if macro
+import haxe.macro.Expr;
+import armory.n64.N64TraitMacro.IRNode;
+import armory.n64.N64TraitMacro.TraitMeta;
+import armory.n64.N64TraitMacro.TraitIR;
+
+using haxe.macro.ExprTools;
+using StringTools;
+using Lambda;
+
+/**
+ * N64 Logic Node Macro - Interprets Armory logic node graphs at compile time
+ *
+ * This macro interprets visual logic node graphs and converts them to the same
+ * IR format as regular Haxe traits, so Python codegen handles them identically.
+ *
+ * Pipeline: Logic Node Graph → AST parsing → IR (JSON) → Python → C code
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+typedef LogicNode = {
+    name: String,
+    type: String,
+    props: Map<String, Dynamic>,
+    inputs: Array<{socket: Int, sourceNode: String, sourceSocket: Int}>,
+    outputs: Array<{socket: Int, targetNode: String, targetSocket: Int}>
+}
+
+// ============================================================================
+// Logic Node Interpreter - Parses and interprets logic node graphs
+// ============================================================================
+
+class LogicNodeInterpreter {
+    var className:String;
+    var modulePath:String;
+    var fields:Array<Field>;
+    var cName:String;
+    var events:Map<String, Array<IRNode>>;
+    var meta:TraitMeta;
+
+    // Node graph state
+    var nodes:Map<String, LogicNode>;
+
+    // Node converters
+    var converter:LogicNodeConverter;
+
+    // Counter for generating unique inline node names
+    var inlineNodeCounter:Int;
+
+    public function new(className:String, modulePath:String, fields:Array<Field>) {
+        this.className = className;
+        this.modulePath = modulePath;
+        this.fields = fields;
+
+        // Generate C-safe name
+        var moduleParts = modulePath.split(".");
+        var lastModulePart = moduleParts[moduleParts.length - 1];
+        if (lastModulePart.toLowerCase() == className.toLowerCase()) {
+            this.cName = modulePath.replace(".", "_").toLowerCase();
+        } else {
+            this.cName = (modulePath.replace(".", "_") + "_" + className).toLowerCase();
+        }
+
+        this.events = new Map();
+        this.nodes = new Map();
+        this.inlineNodeCounter = 0;
+        this.meta = {
+            uses_input: false,
+            uses_transform: false,
+            mutates_transform: false,
+            uses_time: false,
+            uses_physics: false,
+            uses_ui: false,
+            buttons_used: [],
+            button_events: [],
+            contact_events: [],
+            signals: [],
+            signal_handlers: [],
+            global_signals: []
+        };
+
+        this.converter = new LogicNodeConverter(this);
+    }
+
+    public function interpret():TraitIR {
+        // Parse the logic node graph from add() function
+        parseNodeGraph();
+
+        // Find entry point nodes (lifecycle nodes) and simulate execution
+        for (nodeName in nodes.keys()) {
+            var node = nodes.get(nodeName);
+            if (isLifecycleNode(node)) {
+                executeLifecycleNode(node);
+            }
+        }
+
+        return {
+            name: className,
+            module: modulePath,
+            cName: cName,
+            needsData: false,
+            members: new Map(),
+            events: events,
+            meta: meta
+        };
+    }
+
+    function parseNodeGraph():Void {
+        for (field in fields) {
+            switch (field.kind) {
+                case FFun(func):
+                    if (field.name == "add" && func.expr != null) {
+                        parseAddFunction(func.expr);
+                    }
+                default:
+            }
+        }
+    }
+
+    function parseAddFunction(expr:Expr):Void {
+        if (expr == null) return;
+
+        switch (expr.expr) {
+            case EBlock(exprs):
+                for (e in exprs) parseAddFunction(e);
+
+            case EVars(vars):
+                for (v in vars) {
+                    if (v.expr != null) {
+                        switch (v.expr.expr) {
+                            case ENew(tp, params):
+                                var nodeType = tp.name;
+                                nodes.set(v.name, {
+                                    name: v.name,
+                                    type: nodeType,
+                                    props: new Map(),
+                                    inputs: [],
+                                    outputs: []
+                                });
+                            default:
+                        }
+                    }
+                }
+
+            case EBinop(OpAssign, left, right):
+                parsePropertyAssignment(left, right);
+
+            case ECall(callExpr, params):
+                parseLinkCreation(callExpr, params);
+                for (p in params) parseAddFunction(p);
+
+            default:
+                expr.iter(function(sub) parseAddFunction(sub));
+        }
+    }
+
+    function parsePropertyAssignment(left:Expr, right:Expr):Void {
+        switch (left.expr) {
+            case EField(obj, fieldName):
+                switch (obj.expr) {
+                    case EConst(CIdent(nodeName)):
+                        if (nodes.exists(nodeName)) {
+                            var node = nodes.get(nodeName);
+                            node.props.set(fieldName, exprToValue(right));
+                        }
+                    default:
+                }
+            default:
+        }
+    }
+
+    function parseLinkCreation(callExpr:Expr, params:Array<Expr>):Void {
+        var funcName = switch (callExpr.expr) {
+            case EField(_, field): field;
+            default: null;
+        };
+
+        if (funcName == "addLink" && params.length >= 4) {
+            var fromName = extractOrCreateNode(params[0]);
+            var toName = extractOrCreateNode(params[1]);
+            var fromIdx = extractInt(params[2]);
+            var toIdx = extractInt(params[3]);
+
+            if (fromName != "" && toName != "" && nodes.exists(fromName) && nodes.exists(toName)) {
+                var fromNode = nodes.get(fromName);
+                var toNode = nodes.get(toName);
+
+                fromNode.outputs.push({socket: fromIdx, targetNode: toName, targetSocket: toIdx});
+                toNode.inputs.push({socket: toIdx, sourceNode: fromName, sourceSocket: fromIdx});
+            }
+        }
+    }
+
+    /**
+     * Extract node name from expression, or create an inline node if it's a `new` expression.
+     * Handles cases like: addLink(new armory.logicnode.FloatNode(this, 10.0), _Vector, 0, 2)
+     */
+    function extractOrCreateNode(e:Expr):String {
+        return switch (e.expr) {
+            case EConst(CIdent(name)): name;
+            case EField(_, fieldName): fieldName;
+            case ENew(tp, params):
+                // Inline node creation - extract type and constructor params
+                var nodeType = tp.name;
+                var uniqueName = "__inline_" + nodeType + "_" + (inlineNodeCounter++);
+
+                var props = new Map<String, Dynamic>();
+
+                // Constructor params after 'this' are property values
+                // e.g., FloatNode(this, 10.0) -> property0 = 10.0
+                //       VectorNode(this, 1.0, 2.0, 3.0) -> property0=1.0, property1=2.0, property2=3.0
+                if (params.length > 1) {
+                    for (i in 1...params.length) {
+                        props.set("property" + (i - 1), exprToValue(params[i]));
+                    }
+                }
+
+                nodes.set(uniqueName, {
+                    name: uniqueName,
+                    type: nodeType,
+                    props: props,
+                    inputs: [],
+                    outputs: []
+                });
+
+                uniqueName;
+            default: "";
+        };
+    }
+
+    function isLifecycleNode(node:LogicNode):Bool {
+        return node.type == "OnUpdateNode" ||
+               node.type == "OnInitNode" ||
+               node.type == "OnRemoveNode";
+    }
+
+    function executeLifecycleNode(node:LogicNode):Void {
+        var eventName = switch (node.type) {
+            case "OnUpdateNode":
+                var updateType = node.props.get("property0");
+                if (updateType == "Late Update") "on_late_update";
+                else if (updateType == "Physics Pre-Update") "on_fixed_update";
+                else "on_update";
+            case "OnInitNode": "on_ready";
+            case "OnRemoveNode": "on_remove";
+            default: null;
+        };
+
+        if (eventName == null) return;
+
+        if (!events.exists(eventName)) {
+            events.set(eventName, []);
+        }
+
+        for (output in node.outputs) {
+            if (output.socket == 0) {
+                executeNodeChain(output.targetNode, events.get(eventName));
+            }
+        }
+    }
+
+    public function executeNodeChain(nodeName:String, statements:Array<IRNode>):Void {
+        if (!nodes.exists(nodeName)) return;
+
+        var node = nodes.get(nodeName);
+        var irNode = converter.convert(node, statements);
+
+        if (irNode != null && irNode.type != "skip") {
+            statements.push(irNode);
+        }
+
+        // Follow execution outputs (socket 0 for most action nodes)
+        // Skip for branching nodes that handle their own flow
+        if (node.type != "BranchNode" && node.type != "IsTrueNode") {
+            for (output in node.outputs) {
+                if (output.socket == 0) {
+                    executeNodeChain(output.targetNode, statements);
+                }
+            }
+        }
+    }
+
+    // ========================================================================
+    // Input Value Resolution
+    // ========================================================================
+
+    public function getInputValue(node:LogicNode, socketIndex:Int):IRNode {
+        for (input in node.inputs) {
+            if (input.socket == socketIndex) {
+                var sourceNode = nodes.get(input.sourceNode);
+                if (sourceNode != null) {
+                    return converter.evaluateValue(sourceNode, input.sourceSocket);
+                }
+            }
+        }
+        // No connection - return a proper default (0.0f for floats, 0 for ints)
+        return { type: "float", value: 0.0 };
+    }
+
+    // Returns null if no connection exists (for optional inputs)
+    public function getInputValueOrNull(node:LogicNode, socketIndex:Int):Null<IRNode> {
+        for (input in node.inputs) {
+            if (input.socket == socketIndex) {
+                var sourceNode = nodes.get(input.sourceNode);
+                if (sourceNode != null) {
+                    return converter.evaluateValue(sourceNode, input.sourceSocket);
+                }
+            }
+        }
+        return null;
+    }
+
+    public function getNode(name:String):LogicNode {
+        return nodes.get(name);
+    }
+
+    public function getMeta():TraitMeta {
+        return meta;
+    }
+
+    // ========================================================================
+    // AST Helpers
+    // ========================================================================
+
+    function extractNodeName(e:Expr):String {
+        return switch (e.expr) {
+            case EConst(CIdent(name)): name;
+            case EField(_, fieldName): fieldName;
+            default: "";
+        };
+    }
+
+    function extractInt(e:Expr):Int {
+        return switch (e.expr) {
+            case EConst(CInt(v)): Std.parseInt(v);
+            default: 0;
+        };
+    }
+
+    function exprToValue(e:Expr):Dynamic {
+        if (e == null) return null;
+        return switch (e.expr) {
+            case EConst(CInt(v)): Std.parseInt(v);
+            case EConst(CFloat(v)): Std.parseFloat(v);
+            case EConst(CString(s)): s;
+            case EConst(CIdent("true")): true;
+            case EConst(CIdent("false")): false;
+            case EArrayDecl(values): [for (v in values) exprToValue(v)];
+            default: ExprTools.toString(e);
+        };
+    }
+}
+
+// ============================================================================
+// Logic Node Converter - Converts individual logic nodes to IR
+// ============================================================================
+
+class LogicNodeConverter {
+    var interpreter:LogicNodeInterpreter;
+
+    public function new(interpreter:LogicNodeInterpreter) {
+        this.interpreter = interpreter;
+    }
+
+    // ========================================================================
+    // Main Conversion Entry Point
+    // ========================================================================
+
+    public function convert(node:LogicNode, statements:Array<IRNode>):IRNode {
+        return switch (node.type) {
+            // === Output/Debug ===
+            case "PrintNode": convertPrint(node);
+
+            // === Control Flow ===
+            case "BranchNode": convertBranch(node, statements);
+            case "IsTrueNode": convertIsTrue(node, statements);
+            case "GateNode": convertGate(node);
+
+            // === Variables ===
+            case "SetVariableNode": convertSetVariable(node);
+            case "SetPropertyNode": convertSetProperty(node);
+            case "CallFunctionNode": convertCallFunction(node);
+
+            // === Physics ===
+            case "ApplyForceNode": convertApplyForce(node);
+            case "ApplyImpulseNode": convertApplyImpulse(node);
+
+            // === Transform ===
+            case "TranslateObjectNode": convertTranslate(node);
+            case "RotateObjectNode": convertRotate(node);
+            case "SetLocationNode": convertSetLocation(node);
+            case "SetRotationNode": convertSetRotation(node);
+
+            // === Sink nodes (not actions, just graph endpoints) ===
+            case "NullNode": { type: "skip" };
+
+            default:
+                trace('[N64] Unsupported logic node type: ${node.type}');
+                { type: "skip" };
+        };
+    }
+
+    // ========================================================================
+    // Value Node Evaluation
+    // ========================================================================
+
+    public function evaluateValue(node:LogicNode, socketIndex:Int):IRNode {
+        return switch (node.type) {
+            // === Constants (with optional input override) ===
+            case "IntegerNode":
+                // IntegerNode: if has input, use it; otherwise use property
+                var inputVal = interpreter.getInputValueOrNull(node, 0);
+                if (inputVal != null) {
+                    inputVal;
+                } else {
+                    var val = node.props.get("property0");
+                    { type: "int", value: val != null ? Std.parseInt(Std.string(val)) : 0 };
+                }
+            case "FloatNode":
+                // FloatNode: if has input, use it; otherwise use property
+                var inputVal = interpreter.getInputValueOrNull(node, 0);
+                if (inputVal != null) {
+                    inputVal;
+                } else {
+                    var val = node.props.get("property0");
+                    { type: "float", value: val != null ? Std.parseFloat(Std.string(val)) : 0.0 };
+                }
+            case "BooleanNode":
+                // BooleanNode: if has input, use it; otherwise use property
+                var inputVal = interpreter.getInputValueOrNull(node, 0);
+                if (inputVal != null) {
+                    inputVal;
+                } else {
+                    { type: "bool", value: node.props.get("property0") == true };
+                }
+            case "StringNode":
+                // StringNode: if has input, use it; otherwise use property
+                var inputVal = interpreter.getInputValueOrNull(node, 0);
+                if (inputVal != null) {
+                    inputVal;
+                } else {
+                    var val = node.props.get("property0");
+                    { type: "string", value: val != null ? Std.string(val) : "" };
+                }
+            case "VectorNode":
+                // VectorNode can have both properties AND input connections
+                // Input connections override properties
+                // Check for input connections first (they override properties)
+                var xInput = interpreter.getInputValueOrNull(node, 0);
+                var yInput = interpreter.getInputValueOrNull(node, 1);
+                var zInput = interpreter.getInputValueOrNull(node, 2);
+
+                // Fall back to properties if no input connection
+                if (xInput == null) {
+                    var xVal = node.props.get("property0");
+                    var x = xVal != null ? Std.parseFloat(Std.string(xVal)) : 0.0;
+                    if (Math.isNaN(x)) x = 0.0;
+                    xInput = { type: "float", value: x };
+                }
+                if (yInput == null) {
+                    var yVal = node.props.get("property1");
+                    var y = yVal != null ? Std.parseFloat(Std.string(yVal)) : 0.0;
+                    if (Math.isNaN(y)) y = 0.0;
+                    yInput = { type: "float", value: y };
+                }
+                if (zInput == null) {
+                    var zVal = node.props.get("property2");
+                    var z = zVal != null ? Std.parseFloat(Std.string(zVal)) : 0.0;
+                    if (Math.isNaN(z)) z = 0.0;
+                    zInput = { type: "float", value: z };
+                }
+
+                // Output Blender coordinates - swizzle happens at consumption (physics_call, transform_call)
+                { type: "new_vec", c_code: "(ArmVec3){{0}, {1}, {2}}", args: [xInput, yInput, zInput] };
+
+            // === Object References ===
+            // Use { type: "ident", value: "object" } to match TraitExtractor output
+            case "SelfNode", "GetObjectNode":
+                { type: "ident", value: "object" };
+            case "ObjectNode":
+                // ObjectNode with empty string means "self", otherwise it's a named object lookup
+                var objectName = node.props.get("property0");
+                if (objectName == null || objectName == "") {
+                    { type: "ident", value: "object" };
+                } else {
+                    // TODO: Named object lookup - for now just use self
+                    { type: "ident", value: "object" };
+                };
+            case "NullNode":
+                // NullNode is used as a sink - just return skip
+                { type: "skip" };
+
+            // === Transform Getters ===
+            case "GetLocationNode":
+                var objInput = interpreter.getInputValue(node, 0);
+                interpreter.getMeta().uses_transform = true;
+                { type: "field", object: objInput, value: "pos" };
+            case "GetRotationNode":
+                var objInput = interpreter.getInputValue(node, 0);
+                interpreter.getMeta().uses_transform = true;
+                { type: "field", object: objInput, value: "rot" };
+
+            // === Vector Decomposition/Composition ===
+            case "SeparateXYZNode", "SeparateVectorNode":
+                var vecInput = interpreter.getInputValue(node, 0);
+                // Returns the component based on which output socket is requested
+                switch (socketIndex) {
+                    case 0: { type: "field", object: vecInput, value: "x" };
+                    case 1: { type: "field", object: vecInput, value: "y" };
+                    case 2: { type: "field", object: vecInput, value: "z" };
+                    default: { type: "field", object: vecInput, value: "x" };
+                };
+            case "CombineXYZNode", "CombineVectorNode":
+                var xInput = interpreter.getInputValue(node, 0);
+                var yInput = interpreter.getInputValue(node, 1);
+                var zInput = interpreter.getInputValue(node, 2);
+                // Output Blender coordinates - swizzle happens at consumption
+                // Use single { for C compound literal - Python replaces {0}, {1}, {2} with args
+                { type: "new_vec", c_code: "(ArmVec3){{0}, {1}, {2}}", args: [xInput, yInput, zInput] };
+
+            // === Math Operations ===
+            case "MathNode":
+                var value1 = interpreter.getInputValue(node, 0);
+                var value2 = interpreter.getInputValue(node, 1);
+                var op = switch (Std.string(node.props.get("property0"))) {
+                    case "Add": "+";
+                    case "Subtract": "-";
+                    case "Multiply": "*";
+                    case "Divide": "/";
+                    default: "+";
+                };
+                { type: "binop", value: op, children: [value1, value2] };
+
+            case "VectorMathNode":
+                // Use vec_call IR type matching TraitExtractor.convertVecCall()
+                var vec1 = interpreter.getInputValue(node, 0);
+                var vec2 = interpreter.getInputValueOrNull(node, 1);
+                var operation = Std.string(node.props.get("property0"));
+                var separatorOut = node.props.get("property1") == true;
+
+                // VectorMathNode has multiple outputs:
+                // socket 0: vector result
+                // socket 1: if separatorOut, x component; else scalar result (Length, Distance, etc.)
+                // socket 2: if separatorOut, y component; else scalar result
+                // socket 3: if separatorOut, z component; else scalar result
+                // socket 4: if separatorOut, scalar result
+
+                // For scalar-returning operations (Length, Distance), socket 1+ returns the scalar
+                var isScalarOp = (operation == "Length" || operation == "Distance" || operation == "Dot Product");
+
+                if (socketIndex == 0) {
+                    // Return vector result
+                    var result:IRNode = switch (operation) {
+                        case "Add":
+                            { type: "vec_call", c_code: "(ArmVec3){{v}.x+({0}).x, {v}.y+({0}).y, {v}.z+({0}).z}", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        case "Subtract":
+                            { type: "vec_call", c_code: "(ArmVec3){{v}.x-({0}).x, {v}.y-({0}).y, {v}.z-({0}).z}", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        case "Multiply":
+                            { type: "vec_call", c_code: "(ArmVec3){{v}.x*({0}).x, {v}.y*({0}).y, {v}.z*({0}).z}", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        case "Divide":
+                            { type: "vec_call", c_code: "(ArmVec3){{v}.x/({0}).x, {v}.y/({0}).y, {v}.z/({0}).z}", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        case "Normalize":
+                            { type: "vec_call", c_code: "{ float _l=sqrtf({v}.x*{v}.x+{v}.y*{v}.y+{v}.z*{v}.z); if(_l>0.0f){ {vraw}.x/=_l; {vraw}.y/=_l; {vraw}.z/=_l; } }", object: vec1, args: [] };
+                        case "Length":
+                            // For socket 0 on Length, just return the input vector
+                            vec1;
+                        case "Cross Product":
+                            { type: "vec_call", c_code: "(ArmVec3){{v}.y*({0}).z - {v}.z*({0}).y, {v}.z*({0}).x - {v}.x*({0}).z, {v}.x*({0}).y - {v}.y*({0}).x}", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        default:
+                            vec1;
+                    };
+                    result;
+                } else if (isScalarOp && !separatorOut) {
+                    // Return scalar result for Length, Distance, Dot Product
+                    switch (operation) {
+                        case "Length":
+                            { type: "vec_call", c_code: "sqrtf({v}.x*{v}.x + {v}.y*{v}.y + {v}.z*{v}.z)", object: vec1, args: [] };
+                        case "Distance":
+                            { type: "vec_call", c_code: "sqrtf(({v}.x-({0}).x)*({v}.x-({0}).x) + ({v}.y-({0}).y)*({v}.y-({0}).y) + ({v}.z-({0}).z)*({v}.z-({0}).z))", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        case "Dot Product":
+                            { type: "vec_call", c_code: "({v}.x*({0}).x + {v}.y*({0}).y + {v}.z*({0}).z)", object: vec1, args: vec2 != null ? [vec2] : [] };
+                        default:
+                            { type: "float", value: 0.0 };
+                    };
+                } else if (separatorOut) {
+                    // Return vector component
+                    switch (socketIndex) {
+                        case 1: { type: "field", object: vec1, value: "x" };
+                        case 2: { type: "field", object: vec1, value: "y" };
+                        case 3: { type: "field", object: vec1, value: "z" };
+                        default: { type: "float", value: 0.0 };
+                    };
+                } else {
+                    { type: "float", value: 0.0 };
+                }
+
+            // === Comparisons ===
+            case "GateNode":
+                convertGate(node);
+            case "CompareNode":
+                var value1 = interpreter.getInputValue(node, 0);
+                var value2 = interpreter.getInputValue(node, 1);
+                var op = switch (Std.string(node.props.get("property0"))) {
+                    case "Equal": "==";
+                    case "Not Equal": "!=";
+                    case "Greater": ">";
+                    case "Greater Equal": ">=";
+                    case "Less": "<";
+                    case "Less Equal": "<=";
+                    default: "==";
+                };
+                { type: "binop", value: op, children: [value1, value2] };
+
+            // === Input ===
+            case "GamepadCoordsNode":
+                interpreter.getMeta().uses_input = true;
+                // N64 only has one analog stick - map left stick outputs to it
+                // GamepadCoordsNode outputs:
+                // 0 = left stick (Vec4 with x,y)
+                // 1 = right stick (Vec4 with x,y)
+                // 2 = left stick movement
+                // 3 = right stick movement
+                // 4 = L2 trigger (float)
+                // 5 = R2 trigger (float)
+                // Return ArmVec3 with z=0 for compatibility with VectorMathNode operations
+                switch (socketIndex) {
+                    case 0, 1, 2, 3:
+                        // All stick outputs map to the N64 analog stick
+                        // Use ArmVec3 for compatibility with 3D vector math operations
+                        { type: "c_literal", c_code: "(ArmVec3){input_stick_x(), input_stick_y(), 0.0f}" };
+                    case 4:
+                        // L2 trigger - map to Z button on N64
+                        { type: "c_literal", c_code: "(input_down(N64_BTN_Z) ? 1.0f : 0.0f)" };
+                    case 5:
+                        // R2 trigger - map to Z button on N64 (only one trigger)
+                        { type: "c_literal", c_code: "(input_down(N64_BTN_Z) ? 1.0f : 0.0f)" };
+                    default:
+                        { type: "c_literal", c_code: "(ArmVec3){input_stick_x(), input_stick_y(), 0.0f}" };
+                };
+
+            default:
+                trace('[N64] Unsupported value node: ${node.type}');
+                { type: "float", value: 0.0 };
+        };
+    }
+
+    // ========================================================================
+    // Action Node Converters
+    // ========================================================================
+
+    function convertPrint(node:LogicNode):IRNode {
+        var valueInput = interpreter.getInputValue(node, 1);
+        return {
+            type: "debug_call",
+            args: [valueInput]
+        };
+    }
+
+    function convertSetVariable(node:LogicNode):IRNode {
+        // TODO: Implement variable assignment
+        return { type: "skip" };
+    }
+
+    function convertSetProperty(node:LogicNode):IRNode {
+        // TODO: Implement property setter
+        return { type: "skip" };
+    }
+
+    function convertCallFunction(node:LogicNode):IRNode {
+        // TODO: Implement function call
+        return { type: "skip" };
+    }
+
+    // ========================================================================
+    // Control Flow Converters
+    // ========================================================================
+
+    function convertBranch(node:LogicNode, parentStatements:Array<IRNode>):IRNode {
+        var condition = interpreter.getInputValue(node, 1);
+
+        var thenStatements:Array<IRNode> = [];
+        var elseStatements:Array<IRNode> = [];
+
+        for (output in node.outputs) {
+            if (output.socket == 0) {
+                interpreter.executeNodeChain(output.targetNode, thenStatements);
+            } else if (output.socket == 1) {
+                interpreter.executeNodeChain(output.targetNode, elseStatements);
+            }
+        }
+
+        return {
+            type: "if",
+            children: [condition],
+            props: {
+                then: thenStatements,
+                else_: elseStatements.length > 0 ? elseStatements : null
+            }
+        };
+    }
+
+    function convertIsTrue(node:LogicNode, statements:Array<IRNode>):IRNode {
+        var condition = interpreter.getInputValue(node, 1);
+
+        var thenStatements:Array<IRNode> = [];
+
+        for (output in node.outputs) {
+            if (output.socket == 0) {
+                interpreter.executeNodeChain(output.targetNode, thenStatements);
+            }
+        }
+
+        return {
+            type: "if",
+            children: [condition],
+            props: {
+                then: thenStatements,
+                else_: null
+            }
+        };
+    }
+
+    function convertGate(node:LogicNode):IRNode {
+        var value1 = interpreter.getInputValue(node, 1);
+        var value2 = interpreter.getInputValue(node, 2);
+        var property0 = node.props.get("property0");
+
+        var op = switch (property0) {
+            case "Equal": "==";
+            case "Not Equal": "!=";
+            case "Greater": ">";
+            case "Greater Or Equal": ">=";
+            case "Less": "<";
+            case "Less Or Equal": "<=";
+            default: "==";
+        };
+
+        return {
+            type: "binop",
+            value: op,
+            children: [value1, value2]
+        };
+    }
+
+    // ========================================================================
+    // Physics Converters
+    // ========================================================================
+
+    function convertApplyForce(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var forceInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_physics = true;
+
+        // Match N64TraitMacro format: coordinate swizzle and rigid_body access
+        return {
+            type: "physics_call",
+            c_code: "{ OimoVec3 _f = (OimoVec3){({0}).x, ({0}).z, -({0}).y}; physics_apply_force({obj}->rigid_body, &_f); }",
+            object: objInput,
+            args: [forceInput]
+        };
+    }
+
+    function convertApplyImpulse(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var impulseInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_physics = true;
+
+        // Match N64TraitMacro format: coordinate swizzle and rigid_body access
+        return {
+            type: "physics_call",
+            c_code: "{ OimoVec3 _i = (OimoVec3){({0}).x, ({0}).z, -({0}).y}; physics_apply_impulse({obj}->rigid_body, &_i); }",
+            object: objInput,
+            args: [impulseInput]
+        };
+    }
+
+    // ========================================================================
+    // Transform Converters
+    // ========================================================================
+
+    function convertTranslate(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var vecInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_transform = true;
+        interpreter.getMeta().mutates_transform = true;
+
+        return {
+            type: "transform_call",
+            c_code: "t3d_vec3_add(&{obj}->pos, &{0})",
+            object: objInput,
+            args: [vecInput]
+        };
+    }
+
+    function convertRotate(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var vecInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_transform = true;
+        interpreter.getMeta().mutates_transform = true;
+
+        return {
+            type: "transform_call",
+            c_code: "arm_rotate({obj}, {0}.x, {0}.y, {0}.z)",
+            object: objInput,
+            args: [vecInput]
+        };
+    }
+
+    function convertSetLocation(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var vecInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_transform = true;
+        interpreter.getMeta().mutates_transform = true;
+
+        return {
+            type: "transform_call",
+            c_code: "{obj}->pos = {0}",
+            object: objInput,
+            args: [vecInput]
+        };
+    }
+
+    function convertSetRotation(node:LogicNode):IRNode {
+        var objInput = interpreter.getInputValue(node, 1);
+        var vecInput = interpreter.getInputValue(node, 2);
+
+        interpreter.getMeta().uses_transform = true;
+        interpreter.getMeta().mutates_transform = true;
+
+        return {
+            type: "transform_call",
+            c_code: "arm_set_rotation({obj}, {0}.x, {0}.y, {0}.z)",
+            object: objInput,
+            args: [vecInput]
+        };
+    }
+}
+
+#end
diff --git a/armory/Sources/armory/n64/N64TraitMacro.hx b/armory/Sources/armory/n64/N64TraitMacro.hx
new file mode 100644
index 0000000000..81336b4f53
--- /dev/null
+++ b/armory/Sources/armory/n64/N64TraitMacro.hx
@@ -0,0 +1,2146 @@
+package armory.n64;
+
+#if macro
+import haxe.macro.Context;
+import haxe.macro.Expr;
+import haxe.macro.Type;
+import haxe.Json;
+import sys.io.File;
+import sys.FileSystem;
+import armory.n64.N64LogicNodeMacro;
+
+using haxe.macro.ExprTools;
+using haxe.macro.TypeTools;
+using StringTools;
+using Lambda;
+
+/**
+ * N64 Trait Macro - Event-Driven Architecture
+ *
+ * Pipeline: Haxe AST → IR (JSON) → Python → C code
+ *
+ * This macro:
+ * 1. Extracts trait members with ctype
+ * 2. Detects event patterns (input, lifecycle) and extracts handlers
+ * 3. Outputs clean JSON IR for Python to emit C code
+ *
+ * The macro is the SINGLE SOURCE OF TRUTH for semantics.
+ * Python only does 1:1 IR→C translation.
+ */
+class N64TraitMacro {
+    static var traitData:Map<String, TraitIR> = new Map();
+    static var initialized:Bool = false;
+
+    macro public static function build():Array<Field> {
+        var defines = Context.getDefines();
+        if (!defines.exists("arm_target_n64")) {
+            return null;
+        }
+
+        if (!initialized) {
+            initialized = true;
+            Context.onAfterTyping(function(_) {
+                writeTraitJson();
+            });
+        }
+
+        var localClass = Context.getLocalClass();
+        if (localClass == null) return null;
+
+        var cls = localClass.get();
+        var className = cls.name;
+        var modulePath = cls.module;
+
+        // Skip internal/engine traits
+        if (modulePath.indexOf("iron.") == 0 || modulePath.indexOf("armory.") == 0) {
+            return null;
+        }
+
+        var fields = Context.getBuildFields();
+
+        // Check if this is a LogicTree subclass - interpret at compile time
+        if (extendsLogicTree(cls)) {
+            var interpreter = new LogicNodeInterpreter(className, modulePath, fields);
+            var traitIR = interpreter.interpret();
+            if (traitIR != null) {
+                traitData.set(className, traitIR);
+            }
+            return null;
+        }
+
+        // Extract regular trait IR
+        var extractor = new TraitExtractor(className, modulePath, fields);
+        var traitIR = extractor.extract();
+
+        if (traitIR != null) {
+            traitData.set(className, traitIR);
+        }
+
+        return null;
+    }
+
+    static function writeTraitJson():Void {
+        if (traitData.keys().hasNext() == false) return;
+
+        var traits:Dynamic = {};
+
+        for (name in traitData.keys()) {
+            var ir = traitData.get(name);
+
+            // Skip empty traits
+            var hasEvents = Lambda.count(ir.events) > 0;
+            if (!hasEvents && !ir.needsData) continue;
+
+            // Convert members
+            var membersArr:Array<Dynamic> = [];
+            for (memberName in ir.members.keys()) {
+                var m = ir.members.get(memberName);
+                membersArr.push({
+                    name: memberName,
+                    type: m.haxeType,
+                    ctype: m.ctype,
+                    default_value: serializeIRNode(m.defaultValue)
+                });
+            }
+
+            // Convert events
+            var eventsObj:Dynamic = {};
+            for (eventName in ir.events.keys()) {
+                var eventNodes = ir.events.get(eventName);
+                Reflect.setField(eventsObj, eventName, [for (n in eventNodes) serializeIRNode(n)]);
+            }
+
+            // Generate struct_type and struct_def for signals with 2+ args
+            for (sig in ir.meta.signals) {
+                var argCount = sig.arg_types.length;
+                if (argCount >= 2) {
+                    sig.struct_type = '${ir.cName}_${sig.name}_payload_t';
+                    // Generate full struct definition
+                    var lines:Array<String> = ['typedef struct {'];
+                    for (i in 0...argCount) {
+                        lines.push('    ${sig.arg_types[i]} arg$i;');
+                    }
+                    lines.push('} ${sig.struct_type};');
+                    sig.struct_def = lines.join('\n');
+                }
+            }
+
+            for (sh in ir.meta.signal_handlers) {
+                // Find the signal this handler connects to
+                for (sig in ir.meta.signals) {
+                    if (sig.name == sh.signal_name) {
+                        var argTypes = sig.arg_types;
+                        var argCount = argTypes.length;
+
+                        // Always cast ctx to data pointer so handler body can use 'data'
+                        var dataType = '${ir.name}Data';
+                        var dataCast = '$dataType* data = ($dataType*)ctx;';
+
+                        if (argCount == 0) {
+                            sh.preamble = '$dataCast (void)payload;';
+                        } else if (argCount == 1) {
+                            sh.preamble = '$dataCast ${argTypes[0]} arg0 = (${argTypes[0]})(uintptr_t)payload; (void)arg0;';
+                        } else {
+                            // Multiple args - cast to struct (use sig.struct_type)
+                            var structType = sig.struct_type;
+                            var lines:Array<String> = [];
+                            lines.push(dataCast);
+                            lines.push('$structType* p = ($structType*)payload;');
+                            for (i in 0...argCount) {
+                                lines.push('${argTypes[i]} arg$i = p->arg$i; (void)arg$i;');
+                            }
+                            sh.preamble = lines.join(" ");
+                        }
+                        break;
+                    }
+                }
+            }
+
+            Reflect.setField(traits, name, {
+                module: ir.module,
+                c_name: ir.cName,
+                members: membersArr,
+                events: eventsObj,
+                meta: ir.meta
+            });
+        }
+
+        var output:Dynamic = {
+            ir_version: 1,
+            traits: traits
+        };
+
+        var json = Json.stringify(output, null, "  ");
+
+        var defines = Context.getDefines();
+        var buildDir = defines.get("arm_build_dir");
+        if (buildDir == null) buildDir = "build";
+
+        var outPath = buildDir + "/n64_traits.json";
+        try {
+            var dir = haxe.io.Path.directory(outPath);
+            if (dir != "" && !FileSystem.exists(dir)) {
+                FileSystem.createDirectory(dir);
+            }
+            File.saveContent(outPath, json);
+        } catch (e:Dynamic) {
+            Context.error('Failed to write n64_traits.json: $e', Context.currentPos());
+        }
+    }
+
+    /**
+     * Check if a class extends armory.logicnode.LogicTree.
+     * Logic trees are interpreted at compile time into standard trait IR (events, members, meta).
+     */
+    static function extendsLogicTree(cls:haxe.macro.Type.ClassType):Bool {
+        var superClass = cls.superClass;
+        while (superClass != null) {
+            var sc = superClass.t.get();
+            if (sc.module == "armory.logicnode.LogicTree" && sc.name == "LogicTree") {
+                return true;
+            }
+            superClass = sc.superClass;
+        }
+        return false;
+    }
+
+    static function serializeIRNode(node:IRNode):Dynamic {
+        if (node == null) return null;
+
+        var obj:Dynamic = { type: node.type };
+
+        if (node.value != null) obj.value = node.value;
+        if (node.children != null && node.children.length > 0) {
+            obj.children = [for (c in node.children) serializeIRNode(c)];
+        }
+        if (node.args != null && node.args.length > 0) {
+            obj.args = [for (a in node.args) serializeIRNode(a)];
+        }
+        if (node.method != null) obj.method = node.method;
+        if (node.object != null) obj.object = serializeIRNode(node.object);
+        if (node.props != null) obj.props = node.props;
+        if (node.c_code != null) obj.c_code = node.c_code;
+        if (node.c_func != null) obj.c_func = node.c_func;
+
+        return obj;
+    }
+}
+
+// ============================================================================
+// IR Types
+// ============================================================================
+
+typedef IRNode = {
+    type: String,
+    ?value: Dynamic,
+    ?children: Array<IRNode>,
+    ?args: Array<IRNode>,
+    ?method: String,
+    ?object: IRNode,
+    ?props: Dynamic,
+    ?c_code: String,
+    ?c_func: String  // Direct C function name for 1:1 translation
+}
+
+typedef MemberIR = {
+    haxeType: String,
+    ctype: String,
+    defaultValue: IRNode
+}
+
+typedef ButtonEventMeta = {
+    event_name: String,      // e.g., "btn_a_started"
+    button: String,          // normalized button name, e.g., "a"
+    c_button: String,        // N64 constant, e.g., "N64_BTN_A"
+    event_type: String       // "started", "released", or "down"
+}
+
+typedef ContactEventMeta = {
+    event_name: String,      // Handler function name, e.g., "onContact"
+    handler_name: String,    // Full C handler name, e.g., "arm_player_player_contact_onContact"
+    subscribe: Bool          // true for notifyOnContact, false for removeContact
+}
+
+typedef SignalMeta = {
+    name: String,            // Signal member name, e.g., "onDeath"
+    arg_types: Array<String>, // C types for emit args, e.g., ["int32_t", "ArmObject*"]
+    max_subs: Int,           // Max subscribers, default 16, configurable via @:n64MaxSubs(N)
+    ?struct_type: String,    // Payload struct type name for 2+ args
+    ?struct_def: String      // Full C struct definition for 2+ args
+}
+
+typedef SignalHandlerMeta = {
+    handler_name: String,    // Function name used as callback, e.g., "onEnemyDeath"
+    signal_name: String,     // Which signal it connects to, e.g., "onDeath"
+    ?preamble: String        // C code for payload unpacking, generated after arg_types known
+}
+
+typedef TraitMeta = {
+    uses_input: Bool,
+    uses_transform: Bool,
+    mutates_transform: Bool,   // True if trait modifies transform (translate, rotate, etc.)
+    uses_time: Bool,
+    uses_physics: Bool,
+    uses_ui: Bool,             // True if trait uses Koui UI elements
+    buttons_used: Array<String>,
+    button_events: Array<ButtonEventMeta>,  // structured button event info
+    contact_events: Array<ContactEventMeta>, // physics contact subscriptions
+    signals: Array<SignalMeta>, // per-instance signal declarations
+    signal_handlers: Array<SignalHandlerMeta>, // functions used as signal callbacks
+    global_signals: Array<String> // global signals used (e.g., "g_gameevents_gemCollected")
+}
+
+typedef TraitIR = {
+    name: String,
+    module: String,
+    cName: String,
+    needsData: Bool,
+    members: Map<String, MemberIR>,
+    events: Map<String, Array<IRNode>>,
+    meta: TraitMeta
+}
+
+// ============================================================================
+// Type Mapping (Haxe → C)
+// ============================================================================
+
+class TypeMap {
+    public static var haxeToCType:Map<String, String> = [
+        "Float" => "float",
+        "float" => "float",
+        "Int" => "int32_t",
+        "int" => "int32_t",
+        "Bool" => "bool",
+        "bool" => "bool",
+        "String" => "const char*",
+        "SceneId" => "SceneId",
+        "SceneFormat" => "SceneId",
+        "TSceneFormat" => "SceneId",
+        "Vec2" => "ArmVec2",
+        "Vec3" => "ArmVec3",
+        "Vec4" => "ArmVec4",
+        // Koui UI elements
+        "Label" => "KouiLabel*",
+    ];
+
+    public static function getCType(haxeType:String):String {
+        return haxeToCType.exists(haxeType) ? haxeToCType.get(haxeType) : "void*";
+    }
+
+    public static function isSupported(haxeType:String):Bool {
+        return haxeToCType.exists(haxeType);
+    }
+}
+
+// ============================================================================
+// Button Mapping (Armory → N64)
+// ============================================================================
+
+class ButtonMap {
+    // Map common button names to N64 button identifiers
+    // Matches config.py BUTTON_MAP
+    public static var map:Map<String, String> = [
+        // PlayStation-style
+        "cross" => "a", "square" => "b", "circle" => "cright", "triangle" => "cleft",
+        // Xbox-style
+        "a" => "a", "b" => "cright", "x" => "b", "y" => "cleft",
+        // Shoulders/Triggers
+        "r1" => "cdown", "r2" => "r", "r3" => "cup",
+        "l1" => "z", "l2" => "l", "l3" => "cup",
+        // System
+        "start" => "start", "options" => "start", "share" => "start",
+        // D-Pad
+        "up" => "dup", "down" => "ddown", "left" => "dleft", "right" => "dright",
+        "dup" => "dup", "ddown" => "ddown", "dleft" => "dleft", "dright" => "dright",
+        // C-Buttons direct
+        "cup" => "cup", "cdown" => "cdown", "cleft" => "cleft", "cright" => "cright",
+        // N64 native
+        "l" => "l", "r" => "r", "z" => "z",
+    ];
+
+    // Map normalized button name to N64_BTN_* constant
+    public static var n64Const:Map<String, String> = [
+        "a" => "N64_BTN_A", "b" => "N64_BTN_B", "z" => "N64_BTN_Z",
+        "start" => "N64_BTN_START", "l" => "N64_BTN_L", "r" => "N64_BTN_R",
+        "dup" => "N64_BTN_DUP", "ddown" => "N64_BTN_DDOWN", "dleft" => "N64_BTN_DLEFT", "dright" => "N64_BTN_DRIGHT",
+        "cup" => "N64_BTN_CUP", "cdown" => "N64_BTN_CDOWN", "cleft" => "N64_BTN_CLEFT", "cright" => "N64_BTN_CRIGHT",
+    ];
+
+    public static function normalize(button:String):String {
+        var lower = button.toLowerCase();
+        return map.exists(lower) ? map.get(lower) : lower;
+    }
+
+    public static function toN64Const(button:String):String {
+        var normalized = normalize(button);
+        return n64Const.exists(normalized) ? n64Const.get(normalized) : "N64_BTN_A";
+    }
+}
+
+// ============================================================================
+// Skip Lists
+// ============================================================================
+
+class SkipList {
+    public static var members:Map<String, Bool> = [
+        "object" => true, "transform" => true, "name" => true,
+        "gamepad" => true, "keyboard" => true, "mouse" => true,
+        "physics" => true, "rb" => true, "rigidBody" => true,
+    ];
+
+    public static var classes:Map<String, Bool> = [
+        "PhysicsWorld" => true, "RigidBody" => true,
+        "Tween" => true, "Audio" => true, "Network" => true,
+        "Graphics" => true,  // kha.graphics2.Graphics - not available on N64
+    ];
+
+    public static function shouldSkipMember(name:String):Bool {
+        return members.exists(name);
+    }
+
+    public static function shouldSkipClass(name:String):Bool {
+        return classes.exists(name);
+    }
+}
+
+// ============================================================================
+// Trait Extractor
+// ============================================================================
+
+class TraitExtractor {
+    var className:String;
+    var modulePath:String;
+    var fields:Array<Field>;
+    var members:Map<String, MemberIR>;
+    var memberNames:Array<String>;
+    var methodMap:Map<String, Function>;
+    var events:Map<String, Array<IRNode>>;
+    var meta:TraitMeta;
+    var localVarTypes:Map<String, String>;  // Track local variable types
+    var memberTypes:Map<String, String>;    // Track member types for signal detection
+    var cName:String;  // C-safe name for this trait
+
+    public function new(className:String, modulePath:String, fields:Array<Field>) {
+        this.className = className;
+        this.modulePath = modulePath;
+        this.fields = fields;
+        this.members = new Map();
+        this.memberNames = [];
+        this.methodMap = new Map();
+        this.events = new Map();
+        this.localVarTypes = new Map();
+        this.memberTypes = new Map();
+        this.meta = {
+            uses_input: false,
+            uses_transform: false,
+            mutates_transform: false,
+            uses_time: false,
+            uses_physics: false,
+            uses_ui: false,
+            buttons_used: [],
+            button_events: [],
+            contact_events: [],
+            signals: [],
+            signal_handlers: [],
+            global_signals: []
+        };
+
+        // Generate C-safe name early so it's available during extraction
+        var moduleParts = modulePath.split(".");
+        var lastModulePart = moduleParts[moduleParts.length - 1];
+        if (lastModulePart.toLowerCase() == className.toLowerCase()) {
+            this.cName = modulePath.replace(".", "_").toLowerCase();
+        } else {
+            this.cName = (modulePath.replace(".", "_") + "_" + className).toLowerCase();
+        }
+    }
+
+    public function extract():TraitIR {
+        // Pass 1: Extract members and methods
+        for (field in fields) {
+            switch (field.kind) {
+                case FVar(t, e):
+                    var haxeType = t != null ? complexTypeToString(t) : "Dynamic";
+                    memberTypes.set(field.name, haxeType);
+
+                    // Signal members are tracked separately, not as regular data members
+                    if (haxeType == "Signal") {
+                        // Check for @:n64MaxSubs(N) metadata, default to 16
+                        var maxSubs = 16;
+                        if (field.meta != null) {
+                            for (m in field.meta) {
+                                if (m.name == ":n64MaxSubs" || m.name == "n64MaxSubs") {
+                                    if (m.params != null && m.params.length > 0) {
+                                        switch (m.params[0].expr) {
+                                            case EConst(CInt(v)): maxSubs = Std.parseInt(v);
+                                            default:
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        meta.signals.push({
+                            name: field.name,
+                            arg_types: [],  // Will be populated when emit() is detected
+                            max_subs: maxSubs
+                        });
+                    } else {
+                        var member = extractMember(field.name, t, e);
+                        if (member != null) {
+                            members.set(field.name, member);
+                            memberNames.push(field.name);
+                        }
+                    }
+                case FFun(func):
+                    methodMap.set(field.name, func);
+                default:
+            }
+        }
+
+        // Pass 2: Find lifecycle registrations and extract events
+        var lifecycles = findLifecycles();
+
+        // Pass 3: Convert lifecycle functions to events
+        if (lifecycles.init != null) {
+            extractEvents("on_ready", lifecycles.init);
+        }
+        if (lifecycles.update != null) {
+            extractEvents("on_update", lifecycles.update);
+        }
+        if (lifecycles.fixed_update != null) {
+            extractEvents("on_fixed_update", lifecycles.fixed_update);
+        }
+        if (lifecycles.late_update != null) {
+            extractEvents("on_late_update", lifecycles.late_update);
+        }
+        if (lifecycles.remove != null) {
+            extractEvents("on_remove", lifecycles.remove);
+        }
+
+        // Generate C-safe name is now done in constructor
+        // cName is available as this.cName
+
+        return {
+            name: className,
+            module: modulePath,
+            cName: cName,
+            needsData: memberNames.length > 0,
+            members: members,
+            events: events,
+            meta: meta
+        };
+    }
+
+    function extractMember(name:String, t:ComplexType, e:Expr):MemberIR {
+        if (SkipList.shouldSkipMember(name)) return null;
+
+        var haxeType = t != null ? complexTypeToString(t) : "Dynamic";
+        if (!TypeMap.isSupported(haxeType)) return null;
+
+        var defaultNode:IRNode = e != null ? exprToIR(e) : null;
+
+        return {
+            haxeType: haxeType,
+            ctype: TypeMap.getCType(haxeType),
+            defaultValue: defaultNode
+        };
+    }
+
+    function complexTypeToString(ct:ComplexType):String {
+        return switch (ct) {
+            case TPath(p): p.name;
+            default: "Dynamic";
+        };
+    }
+
+    function findLifecycles():{init:Expr, update:Expr, fixed_update:Expr, late_update:Expr, remove:Expr} {
+        var result = {init: null, update: null, fixed_update: null, late_update: null, remove: null};
+        var constructor = methodMap.get("new");
+        if (constructor != null && constructor.expr != null) {
+            scanForLifecycles(constructor.expr, result);
+        }
+        return result;
+    }
+
+    function scanForLifecycles(e:Expr, result:{init:Expr, update:Expr, fixed_update:Expr, late_update:Expr, remove:Expr}):Void {
+        if (e == null) return;
+
+        switch (e.expr) {
+            case ECall(callExpr, params):
+                var funcName = getFuncName(callExpr);
+                if (params.length > 0) {
+                    var body = resolveCallback(params[0]);
+                    switch (funcName) {
+                        case "notifyOnInit": result.init = body;
+                        case "notifyOnUpdate": result.update = body;
+                        case "notifyOnFixedUpdate": result.fixed_update = body;
+                        case "notifyOnLateUpdate": result.late_update = body;
+                        case "notifyOnRemove": result.remove = body;
+                        default:
+                    }
+                }
+                for (p in params) scanForLifecycles(p, result);
+            case EBlock(exprs):
+                for (expr in exprs) scanForLifecycles(expr, result);
+            case EFunction(_, f):
+                // Continue scanning inside function body to find nested lifecycle registrations
+                // e.g., notifyOnUpdate(update) inside notifyOnInit(function() { ... })
+                if (f.expr != null) scanForLifecycles(f.expr, result);
+            default:
+                e.iter(function(sub) scanForLifecycles(sub, result));
+        }
+    }
+
+    function getFuncName(e:Expr):String {
+        return switch (e.expr) {
+            case EConst(CIdent(s)): s;
+            case EField(_, field): field;
+            default: null;
+        };
+    }
+
+    function resolveCallback(e:Expr):Expr {
+        return switch (e.expr) {
+            case EFunction(_, f): f.expr;
+            case EField(_, methodName):
+                var method = methodMap.get(methodName);
+                method != null ? method.expr : null;
+            case EConst(CIdent(methodName)):
+                var method = methodMap.get(methodName);
+                method != null ? method.expr : null;
+            default: null;
+        };
+    }
+
+    // ========================================================================
+    // Event Extraction
+    // ========================================================================
+
+    function extractEvents(baseEventName:String, body:Expr):Void {
+        var statements:Array<IRNode> = [];
+
+        switch (body.expr) {
+            case EBlock(exprs):
+                for (expr in exprs) {
+                    processStatement(expr, statements);
+                }
+            default:
+                processStatement(body, statements);
+        }
+
+        // If there are remaining statements after event extraction, add to base event
+        if (statements.length > 0) {
+            if (!events.exists(baseEventName)) events.set(baseEventName, []);
+            for (stmt in statements) {
+                events.get(baseEventName).push(stmt);
+            }
+        }
+    }
+
+    function processStatement(e:Expr, statements:Array<IRNode>):Void {
+        if (e == null) return;
+
+        switch (e.expr) {
+            // Detect: if (gamepad.started("a")) { ... }
+            case EIf(econd, eif, eelse):
+                var inputEvent = detectInputEvent(econd);
+                if (inputEvent != null && eelse == null) {
+                    // Extract body as separate event
+                    var eventName = inputEvent.eventName;
+                    if (!events.exists(eventName)) events.set(eventName, []);
+                    extractEventBody(eif, events.get(eventName));
+
+                    // Track button and meta
+                    if (!Lambda.has(meta.buttons_used, inputEvent.button)) {
+                        meta.buttons_used.push(inputEvent.button);
+                    }
+                    // Add structured button event metadata
+                    meta.button_events.push({
+                        event_name: eventName,
+                        button: inputEvent.button,
+                        c_button: inputEvent.c_button,
+                        event_type: inputEvent.eventType
+                    });
+                    meta.uses_input = true;
+                    return; // Don't add to statements
+                }
+                // Regular if - add to statements
+                statements.push(convertIfToIR(econd, eif, eelse));
+
+            default:
+                var node = exprToIR(e);
+                if (node != null && node.type != "skip") {
+                    statements.push(node);
+                }
+        }
+    }
+
+    function extractEventBody(body:Expr, eventNodes:Array<IRNode>):Void {
+        switch (body.expr) {
+            case EBlock(exprs):
+                for (expr in exprs) {
+                    var node = exprToIR(expr);
+                    if (node != null && node.type != "skip") {
+                        eventNodes.push(node);
+                    }
+                }
+            default:
+                var node = exprToIR(body);
+                if (node != null && node.type != "skip") {
+                    eventNodes.push(node);
+                }
+        }
+    }
+
+    function detectInputEvent(econd:Expr):{eventName:String, button:String, c_button:String, eventType:String} {
+        switch (econd.expr) {
+            case ECall(e, params):
+                switch (e.expr) {
+                    case EField(obj, method):
+                        switch (obj.expr) {
+                            case EConst(CIdent("gamepad")):
+                                if (method == "started" || method == "released" || method == "down") {
+                                    if (params.length > 0) {
+                                        var rawButton = extractStringArg(params[0]);
+                                        if (rawButton != null) {
+                                            var button = ButtonMap.normalize(rawButton);
+                                            var c_button = ButtonMap.toN64Const(rawButton);
+                                            var eventName = 'btn_${button}_$method';
+                                            return {
+                                                eventName: eventName,
+                                                button: button,
+                                                c_button: c_button,
+                                                eventType: method
+                                            };
+                                        }
+                                    }
+                                }
+                            default:
+                        }
+                    default:
+                }
+            default:
+        }
+        return null;
+    }
+
+    function extractStringArg(e:Expr):String {
+        return switch (e.expr) {
+            case EConst(CString(s)): s;
+            case EConst(CIdent(s)): s;
+            default: null;
+        };
+    }
+
+    // ========================================================================
+    // AST → IR Conversion
+    // ========================================================================
+
+    function convertIfToIR(econd:Expr, eif:Expr, eelse:Expr):IRNode {
+        var thenNodes:Array<IRNode> = [];
+        extractEventBody(eif, thenNodes);
+
+        var elseNodes:Array<IRNode> = null;
+        if (eelse != null) {
+            elseNodes = [];
+            extractEventBody(eelse, elseNodes);
+        }
+
+        return {
+            type: "if",
+            children: [exprToIR(econd)],
+            props: {
+                then: [for (n in thenNodes) n],
+                else_: elseNodes != null ? [for (n in elseNodes) n] : null
+            }
+        };
+    }
+
+    function exprToIR(e:Expr):IRNode {
+        if (e == null) return null;
+
+        return switch (e.expr) {
+            // Literals
+            case EConst(CInt(v)): { type: "int", value: Std.parseInt(v) };
+            case EConst(CFloat(v)): { type: "float", value: Std.parseFloat(v) };
+            case EConst(CString(v)): { type: "string", value: v };
+            case EConst(CIdent("true")): { type: "bool", value: true };
+            case EConst(CIdent("false")): { type: "bool", value: false };
+            case EConst(CIdent("null")): { type: "null" };
+            case EConst(CIdent(name)): resolveIdent(name);
+
+            // Binary ops
+            case EBinop(op, e1, e2):
+                var opStr = binopToString(op);
+                if (op == OpAssign) {
+                    // Check if assigning to transform.loc/rot/scale (mutating transform)
+                    checkTransformMutation(e1);
+
+                    // Special case: transform.scale = value -> emit transform_call with it_set_scale()
+                    if (isTransformScaleAssign(e1)) {
+                        var valueIR = exprToIR(e2);
+                        // Swizzle: Blender (x, y, z) → N64 (x, z, y) and multiply by SCALE_FACTOR (0.015625 = 1/64)
+                        {
+                            type: "transform_call",
+                            c_code: "it_set_scale(&((ArmObject*)obj)->transform, ({0}).x * 0.015625f, ({0}).z * 0.015625f, ({0}).y * 0.015625f);",
+                            args: [valueIR]
+                        };
+                    }
+                    // Special case: label.text = value -> koui_label_set_text(label, value)
+                    else if (isLabelTextAssign(e1)) {
+                        var labelObjIR = getLabelFromTextAccess(e1);
+                        var valueIR = exprToIR(e2);
+                        {
+                            type: "call",
+                            value: "koui_label_set_text",
+                            children: [labelObjIR, valueIR]
+                        };
+                    } else {
+                        { type: "assign", children: [exprToIR(e1), exprToIR(e2)] };
+                    }
+                } else if (op == OpAdd) {
+                    // Check if this is string concatenation
+                    var leftType = getExprType(e1);
+                    var rightType = getExprType(e2);
+                    if (leftType == "String" || rightType == "String") {
+                        // String concatenation - use helper class
+                        var builder = new StringConcatBuilder(members, localVarTypes, exprToIR, getExprType);
+                        builder.build(e1, e2);
+                    } else {
+                        { type: "binop", value: opStr, children: [exprToIR(e1), exprToIR(e2)] };
+                    }
+                } else {
+                    { type: "binop", value: opStr, children: [exprToIR(e1), exprToIR(e2)] };
+                }
+
+            // Unary ops
+            case EUnop(op, postFix, operand):
+                { type: "unop", value: unopToString(op), children: [exprToIR(operand)], props: { postfix: postFix } };
+
+            // Field access
+            case EField(obj, field):
+                convertFieldAccess(obj, field);
+
+            // Call
+            case ECall(callExpr, params):
+                convertCall(callExpr, params);
+
+            // Parentheses
+            case EParenthesis(inner):
+                exprToIR(inner);
+
+            // New
+            case ENew(tp, params):
+                convertNew(tp, params);
+
+            // Block
+            case EBlock(exprs):
+                { type: "block", children: [for (expr in exprs) exprToIR(expr)] };
+
+            // If statement (nested ifs)
+            case EIf(econd, eif, eelse):
+                convertIfToIR(econd, eif, eelse);
+
+            // Local variable declaration: var x = value
+            case EVars(vars):
+                var varDecls:Array<IRNode> = [];
+                for (v in vars) {
+                    var varType = v.type != null ? complexTypeToString(v.type) : getExprType(v.expr);
+                    var ctype = TypeMap.getCType(varType);
+                    if (ctype == null) ctype = "float"; // fallback for unknown types
+                    // Track this local variable's type
+                    localVarTypes.set(v.name, varType);
+                    varDecls.push({
+                        type: "var",
+                        value: v.name,
+                        props: { ctype: ctype, haxeType: varType },
+                        children: v.expr != null ? [exprToIR(v.expr)] : null
+                    });
+                }
+                if (varDecls.length == 1) varDecls[0];
+                else { type: "block", children: varDecls };
+
+            // Return statement
+            case EReturn(retExpr):
+                { type: "return", children: retExpr != null ? [exprToIR(retExpr)] : null };
+
+            default:
+                { type: "skip" };
+        };
+    }
+
+    function resolveIdent(name:String):IRNode {
+        if (name == "this" || name == "object") {
+            meta.uses_transform = true;
+            return { type: "ident", value: "object" };
+        }
+        if (name == "dt") {
+            meta.uses_time = true;
+            return { type: "ident", value: "dt" };
+        }
+        if (memberNames.indexOf(name) >= 0) {
+            return { type: "member", value: name };
+        }
+        if (SkipList.shouldSkipMember(name) || SkipList.shouldSkipClass(name)) {
+            return { type: "skip" };
+        }
+        return { type: "ident", value: name };
+    }
+
+    // Check if expression is an assignment to transform properties (loc, rot, scale, dirty)
+    function checkTransformMutation(expr:Expr):Void {
+        switch (expr.expr) {
+            case EField(obj, field):
+                switch (obj.expr) {
+                    // transform.loc = ..., transform.rot = ..., transform.scale = ..., transform.dirty = ...
+                    case EField(_, "transform"), EConst(CIdent("transform")):
+                        if (field == "loc" || field == "rot" || field == "scale" || field == "dirty") {
+                            meta.mutates_transform = true;
+                        }
+                    // transform.loc.x = ... (nested field access)
+                    case EField(innerObj, innerField):
+                        if (innerField == "loc" || innerField == "rot" || innerField == "scale") {
+                            switch (innerObj.expr) {
+                                case EField(_, "transform"), EConst(CIdent("transform")):
+                                    meta.mutates_transform = true;
+                                default:
+                            }
+                        }
+                    default:
+                }
+            default:
+        }
+    }
+
+    // Check if expression is assignment to transform.scale (needs special handling)
+    function isTransformScaleAssign(expr:Expr):Bool {
+        switch (expr.expr) {
+            case EField(obj, "scale"):
+                switch (obj.expr) {
+                    case EField(_, "transform"), EConst(CIdent("transform")):
+                        return true;
+                    default:
+                }
+            default:
+        }
+        return false;
+    }
+
+    // Check if expression is assignment to label.text (needs koui_label_set_text)
+    function isLabelTextAssign(expr:Expr):Bool {
+        switch (expr.expr) {
+            case EField(obj, "text"):
+                var objType = getExprType(obj);
+                return objType == "Label";
+            default:
+        }
+        return false;
+    }
+
+    // Extract the label object from a label.text field access
+    function getLabelFromTextAccess(expr:Expr):IRNode {
+        switch (expr.expr) {
+            case EField(obj, "text"):
+                return exprToIR(obj);
+            default:
+        }
+        return null;
+    }
+
+    function convertFieldAccess(obj:Expr, field:String):IRNode {
+        // Handle transform access
+        switch (obj.expr) {
+            case EField(innerObj, "transform"):
+                meta.uses_transform = true;
+                return { type: "field", object: { type: "ident", value: "object" }, value: "transform." + field };
+            case EConst(CIdent("transform")):
+                meta.uses_transform = true;
+                return { type: "field", object: { type: "ident", value: "object" }, value: "transform." + field };
+            case EConst(CIdent("Time")):
+                if (field == "delta") {
+                    meta.uses_time = true;
+                    return { type: "ident", value: "dt" };
+                }
+            case EConst(CIdent("gamepad")):
+                // gamepad.leftStick, gamepad.rightStick
+                meta.uses_input = true;
+                if (field == "leftStick" || field == "rightStick") {
+                    // Emit inline C struct with input functions
+                    return { type: "c_literal", c_code: "(ArmVec2){input_stick_x(), input_stick_y()}" };
+                }
+            default:
+        }
+
+        // Check if this is a Label field access (label.text, label.posX, etc.)
+        var objType = getExprType(obj);
+        if (objType == "Label") {
+            meta.uses_ui = true;
+            // Map Koui property names to C struct field names
+            var cField = switch (field) {
+                case "posX": "pos_x";
+                case "posY": "pos_y";
+                case "text": "text";
+                case "visible": "visible";
+                default: field;
+            };
+            return { type: "label_field", object: exprToIR(obj), value: cField };
+        }
+
+        // Vec3 component access
+        if (field == "x" || field == "y" || field == "z") {
+            return { type: "field", object: exprToIR(obj), value: field };
+        }
+
+        return { type: "field", object: exprToIR(obj), value: field };
+    }
+
+    /**
+     * Unified type inference from Haxe expressions.
+     * Returns the Haxe type name (Int, Float, String, Vec2, Label, Signal, etc.) or "Dynamic" if unknown.
+     */
+    function getExprType(e:Expr):String {
+        if (e == null) return "Dynamic";
+
+        switch (e.expr) {
+            // Literals
+            case EConst(CInt(_)): return "Int";
+            case EConst(CFloat(_)): return "Float";
+            case EConst(CString(_)): return "String";
+
+            // Constructor: new Vec3() -> "Vec3"
+            case ENew(tp, _):
+                return tp.name;
+
+            // Identifier: variable or member
+            case EConst(CIdent(name)):
+                if (localVarTypes.exists(name)) {
+                    return localVarTypes.get(name);
+                }
+                // Check memberTypes first (includes Signal and all member types)
+                if (memberTypes.exists(name)) {
+                    return memberTypes.get(name);
+                }
+                if (members.exists(name)) {
+                    return members.get(name).haxeType;
+                }
+                return "Dynamic";
+
+            // Field access
+            case EField(innerObj, field):
+                // this.member or object.member
+                switch (innerObj.expr) {
+                    case EConst(CIdent("this")), EConst(CIdent("object")):
+                        // Check memberTypes first (includes Signal)
+                        if (memberTypes.exists(field)) {
+                            return memberTypes.get(field);
+                        }
+                        if (members.exists(field)) {
+                            return members.get(field).haxeType;
+                        }
+                    default:
+                }
+
+                // gamepad.leftStick / gamepad.rightStick -> Vec2
+                switch (innerObj.expr) {
+                    case EConst(CIdent("gamepad")):
+                        if (field == "leftStick" || field == "rightStick") return "Vec2";
+                    // transform.loc/rot/scale -> Vec4
+                    case EField(_, "transform"), EConst(CIdent("transform")):
+                        if (field == "loc" || field == "scale" || field == "rot") return "Vec4";
+                    default:
+                }
+                return "Dynamic";
+
+            // Method calls
+            case ECall(callExpr, _):
+                switch (callExpr.expr) {
+                    case EField(obj, method):
+                        // Std.string/int/parseFloat
+                        switch (obj.expr) {
+                            case EConst(CIdent("Std")):
+                                if (method == "string") return "String";
+                                if (method == "int") return "Int";
+                                if (method == "parseFloat") return "Float";
+                            default:
+                        }
+                        // Vec method calls return same Vec type
+                        var objType = getExprType(obj);
+                        if (objType != null && StringTools.startsWith(objType, "Vec")) {
+                            if (method == "mult" || method == "add" || method == "sub" ||
+                                method == "normalize" || method == "clone" || method == "cross") {
+                                return objType;
+                            }
+                        }
+                    default:
+                }
+                return "Dynamic";
+
+            // Binary operations
+            case EBinop(OpAdd, e1, e2):
+                var t1 = getExprType(e1);
+                var t2 = getExprType(e2);
+                if (t1 == "String" || t2 == "String") return "String";
+                if (t1 == "Float" || t2 == "Float") return "Float";
+                return "Int";
+
+            // Parentheses
+            case EParenthesis(inner):
+                return getExprType(inner);
+
+            default:
+                return "Dynamic";
+        }
+    }
+
+    function convertCall(callExpr:Expr, params:Array<Expr>):IRNode {
+        var args = [for (p in params) exprToIR(p)];
+
+        switch (callExpr.expr) {
+            case EField(obj, method):
+                // FIRST: Check if this is a Vec method call (before specific object checks)
+                // This handles cases like gamepad.leftStick.mult() where the object
+                // is a complex expression that getExprType can resolve
+                var vecMethods = ["mult", "add", "sub", "dot", "normalize", "length", "clone", "cross", "set", "setFrom"];
+                if (Lambda.has(vecMethods, method)) {
+                    var objType = getExprType(obj);
+                    if (objType != null && StringTools.startsWith(objType, "Vec")) {
+                        var objIR = exprToIR(obj);
+                        return convertVecCall(method, objIR, args, objType);
+                    }
+                }
+
+                // SECOND: Check for physics contact subscription methods
+                // rb.notifyOnContact(handler) or rb.removeContact(handler)
+                if (method == "notifyOnContact" || method == "removeContact") {
+                    meta.uses_physics = true;
+                    return convertContactSubscription(method, args, params);
+                }
+
+                // THIRD: Check if this is a physics method call on any object (rigid_body.applyForce, body.applyForce, etc.)
+                var physicsMethods = ["applyForce", "applyImpulse", "setLinearVelocity", "getLinearVelocity",
+                                      "setAngularVelocity", "getAngularVelocity", "setLinearFactor", "setAngularFactor"];
+                if (Lambda.has(physicsMethods, method)) {
+                    meta.uses_physics = true;
+                    // For N64, physics always applies to the current object
+                    return convertPhysicsCall(method, { type: "ident", value: "object" }, args);
+                }
+
+                switch (obj.expr) {
+                    // Scene.setActive("Level_02") -> scene_switch_to(SCENE_X)
+                    case EConst(CIdent("Scene")):
+                        return convertSceneCall(method, args, params);
+
+                    // Koui.init(callback), Koui.add(label), Koui.remove(label), Koui.render(g2)
+                    case EConst(CIdent("Koui")):
+                        return convertKouiStaticCall(method, args, params);
+
+                    // transform.translate(...) -> it_translate(...)
+                    case EField(_, "transform"), EConst(CIdent("transform")):
+                        meta.uses_transform = true;
+                        meta.uses_transform = true;
+                        return convertTransformCall(method, args);
+
+                    // Math.sin(x) -> sinf(x)
+                    case EConst(CIdent("Math")):
+                        return convertMathCall(method, args);
+
+                    // gamepad.started("a") or keyboard/mouse - should be extracted as event
+                    case EConst(CIdent("gamepad")), EConst(CIdent("keyboard")), EConst(CIdent("mouse")), EConst(CIdent("Input")):
+                        meta.uses_input = true;
+                        if (params.length > 0) {
+                            var btn = extractStringArg(params[0]);
+                            if (btn != null) {
+                                var normalized = ButtonMap.normalize(btn);
+                                if (!Lambda.has(meta.buttons_used, normalized)) {
+                                    meta.buttons_used.push(normalized);
+                                }
+                            }
+                        }
+                        return convertInputCall(method, args);
+
+                    // object.physics.applyForce(...) -> physics call on object
+                    case EField(innerObj, "physics"):
+                        meta.uses_physics = true;
+                        var objIR = exprToIR(innerObj);
+                        return convertPhysicsCall(method, objIR, args);
+
+                    // physics.applyForce(...) -> physics call on self (this.physics)
+                    case EConst(CIdent("physics")):
+                        meta.uses_physics = true;
+                        return convertPhysicsCall(method, { type: "ident", value: "object" }, args);
+
+                    // Std.int(), Std.parseFloat(), etc. -> type casts
+                    case EConst(CIdent("Std")):
+                        return convertStdCall(method, args);
+
+                    // object.remove(), object.getTrait(), etc. -> object lifecycle
+                    case EConst(CIdent("object")), EConst(CIdent("this")):
+                        return convertObjectCall(method, args);
+
+                    // Unsupported APIs - explicitly skip with no codegen fallback
+                    case EConst(CIdent("Audio")), EConst(CIdent("Tween")), EConst(CIdent("Network")):
+                        return { type: "skip" };
+
+                    default:
+                        // Check if this is a Signal method call (connect/disconnect/emit)
+                        // First try getExprType, then check memberTypes directly
+                        var objType = getExprType(obj);
+                        if (objType == "Signal") {
+                            return convertSignalCall(method, obj, args, params);
+                        }
+                        // Direct check: if method is connect/disconnect/emit and obj is a member
+                        if (method == "connect" || method == "disconnect" || method == "emit") {
+                            var memberName = switch (obj.expr) {
+                                case EConst(CIdent(name)): name;
+                                case EField(_, fieldName): fieldName;
+                                default: null;
+                            };
+                            if (memberName != null && memberTypes.exists(memberName) && memberTypes.get(memberName) == "Signal") {
+                                return convertSignalCall(method, obj, args, params);
+                            }
+                            // Check for global signal pattern: GameEvents.signalName.method()
+                            // or SomeClass.signalName.method()
+                            switch (obj.expr) {
+                                case EField(classExpr, signalName):
+                                    switch (classExpr.expr) {
+                                        case EConst(CIdent(className)):
+                                            // This is ClassName.signalName.method() - global signal
+                                            return convertGlobalSignalCall(method, className, signalName, args, params);
+                                        default:
+                                    }
+                                default:
+                            }
+                        }
+                        // Check if this is a Label method call
+                        if (objType == "Label") {
+                            return convertLabelCall(method, exprToIR(obj), args);
+                        }
+                        // Fallback: generic call with object
+                        return {
+                            type: "call",
+                            method: method,
+                            object: exprToIR(obj),
+                            args: args
+                        };
+                }
+
+            case EConst(CIdent(funcName)):
+                // Skip lifecycle registration calls - they're handled by scanForLifecycles
+                // notifyOnRender2D is skipped entirely - N64 doesn't have 2D graphics layer
+                if (funcName == "notifyOnInit" || funcName == "notifyOnUpdate" ||
+                    funcName == "notifyOnFixedUpdate" || funcName == "notifyOnLateUpdate" ||
+                    funcName == "notifyOnRemove" || funcName == "notifyOnAdd" ||
+                    funcName == "notifyOnRender2D" || funcName == "notifyOnRender") {
+                    return { type: "skip" };
+                }
+
+                // trace() -> debugf() for N64 debug output
+                if (funcName == "trace") {
+                    return { type: "debug_call", args: args };
+                }
+
+                // Physics methods called directly (applyForce, applyImpulse, etc.)
+                var physicsMethods = ["applyForce", "applyImpulse", "setLinearVelocity", "getLinearVelocity",
+                                      "setAngularVelocity", "getAngularVelocity", "setLinearFactor", "setAngularFactor"];
+                if (Lambda.has(physicsMethods, funcName)) {
+                    meta.uses_physics = true;
+                    return convertPhysicsCall(funcName, { type: "ident", value: "object" }, args);
+                }
+
+                return { type: "call", method: funcName, args: args };
+
+            default:
+                return { type: "skip" };
+        }
+    }
+
+    // =========================================================================
+    // New expression conversion - handles constructor calls
+    // =========================================================================
+
+    function convertNew(tp:TypePath, params:Array<Expr>):IRNode {
+        var typeName = tp.name;
+        var args = [for (p in params) exprToIR(p)];
+
+        // Check for Koui UI elements
+        if (typeName == "Label") {
+            meta.uses_ui = true;
+            // Label constructor: new Label(text) -> koui_create_label(text)
+            return {
+                type: "koui_call",
+                c_func: "koui_create_label",
+                args: args
+            };
+        }
+
+        // Vec constructors: emit C struct literal with placeholders
+        if (typeName == "Vec4") {
+            // {0}, {1}, {2}, {3} will be substituted by Python
+            var argCount = args.length;
+            if (argCount >= 4) {
+                return { type: "new_vec", c_code: "(ArmVec4){{0}, {1}, {2}, {3}}", args: args };
+            } else if (argCount >= 3) {
+                return { type: "new_vec", c_code: "(ArmVec4){{0}, {1}, {2}, 1.0f}", args: args };
+            }
+            return { type: "c_literal", c_code: "(ArmVec4){0, 0, 0, 1.0f}" };
+        }
+        if (typeName == "Vec3") {
+            if (args.length >= 3) {
+                return { type: "new_vec", c_code: "(ArmVec3){{0}, {1}, {2}}", args: args };
+            }
+            return { type: "c_literal", c_code: "(ArmVec3){0, 0, 0}" };
+        }
+        if (typeName == "Vec2") {
+            if (args.length >= 2) {
+                return { type: "new_vec", c_code: "(ArmVec2){{0}, {1}}", args: args };
+            }
+            return { type: "c_literal", c_code: "(ArmVec2){0, 0}" };
+        }
+
+        // Default: generic new expression
+        return {
+            type: "new",
+            value: typeName,
+            args: args
+        };
+    }
+
+    function binopToString(op:Binop):String {
+        return switch (op) {
+            case OpAdd: "+";
+            case OpSub: "-";
+            case OpMult: "*";
+            case OpDiv: "/";
+            case OpMod: "%";
+            case OpEq: "==";
+            case OpNotEq: "!=";
+            case OpLt: "<";
+            case OpLte: "<=";
+            case OpGt: ">";
+            case OpGte: ">=";
+            case OpAnd: "&";      // Bitwise AND
+            case OpOr: "|";       // Bitwise OR
+            case OpBoolAnd: "&&"; // Logical AND
+            case OpBoolOr: "||";  // Logical OR
+            case OpXor: "^";      // Bitwise XOR
+            case OpShl: "<<";     // Shift left
+            case OpShr: ">>";     // Shift right
+            case OpUShr: ">>>";   // Unsigned shift right
+            case OpAssign: "=";
+            case OpAssignOp(op): binopToString(op) + "=";
+            default: "?";
+        };
+    }
+
+    function unopToString(op:Unop):String {
+        return switch (op) {
+            case OpNeg: "-";
+            case OpNot: "!";
+            case OpIncrement: "++";
+            case OpDecrement: "--";
+            default: "?";
+        };
+    }
+
+    // =========================================================================
+    // Physics call conversion - emit ready-to-use C with placeholders
+    // Placeholders: {obj} = object, {0}, {1}, etc. = args
+    // Coord conversion: Blender (X,Y,Z) → N64 (X,Z,-Y)
+    // =========================================================================
+
+    function convertPhysicsCall(method:String, objIR:IRNode, args:Array<IRNode>):IRNode {
+        // Physics calls use OimoVec3 which needs coordinate swizzle
+        // Template uses {obj} for object and {0} for first arg (vec)
+        var c_code = switch (method) {
+            case "applyForce":
+                "{ OimoVec3 _f = (OimoVec3){({0}).x, ({0}).z, -({0}).y}; physics_apply_force({obj}->rigid_body, &_f); }";
+            case "applyImpulse":
+                "{ OimoVec3 _i = (OimoVec3){({0}).x, ({0}).z, -({0}).y}; physics_apply_impulse({obj}->rigid_body, &_i); }";
+            case "setLinearVelocity":
+                "{ OimoVec3 _v = (OimoVec3){({0}).x, ({0}).z, -({0}).y}; physics_set_linear_velocity({obj}->rigid_body, &_v); }";
+            case "getLinearVelocity":
+                "physics_get_linear_velocity({obj}->rigid_body)";
+            default:
+                null;
+        };
+
+        if (c_code == null) return { type: "skip" };
+
+        return {
+            type: "physics_call",
+            c_code: c_code,
+            object: objIR,
+            args: args
+        };
+    }
+
+    // =========================================================================
+    // Contact subscription - notifyOnContact(handler), removeContact(handler)
+    // Records metadata for Python to emit subscription calls at init time
+    // =========================================================================
+
+    function convertContactSubscription(method:String, args:Array<IRNode>, params:Array<Expr>):IRNode {
+        // Extract handler function name from first argument
+        // e.g., rb.notifyOnContact(onContact) -> handler = "onContact"
+        if (params.length == 0) return { type: "skip" };
+
+        var handlerName:String = null;
+        switch (params[0].expr) {
+            case EConst(CIdent(name)):
+                handlerName = name;
+            case EField(_, name):
+                handlerName = name;
+            default:
+        }
+
+        if (handlerName == null) return { type: "skip" };
+
+        // Record the handler method for extraction
+        // The handler will be extracted as a contact event (similar to button events)
+        var isSubscribe = (method == "notifyOnContact");
+
+        // Build full C handler name: {c_name}_contact_{handlerName}
+        var fullHandlerName = cName + "_contact_" + handlerName;
+
+        meta.contact_events.push({
+            event_name: handlerName,
+            handler_name: fullHandlerName,
+            subscribe: isSubscribe
+        });
+
+        // If subscribing, extract the handler method body as an event
+        if (isSubscribe && methodMap.exists(handlerName)) {
+            var func = methodMap.get(handlerName);
+            if (!events.exists("contact_" + handlerName)) {
+                events.set("contact_" + handlerName, []);
+                extractContactHandler(handlerName, func, events.get("contact_" + handlerName));
+            }
+        }
+
+        // Return a no-op - the actual subscription is done at init time by Python
+        return { type: "skip" };
+    }
+
+    function extractContactHandler(name:String, func:Function, eventNodes:Array<IRNode>):Void {
+        // Contact handlers have signature: function onContact(body: RigidBody)
+        // We need to convert this to the C handler signature: (obj, data, other)
+        // The "body" parameter becomes "other" ArmObject in C
+
+        if (func.expr == null) return;
+
+        switch (func.expr.expr) {
+            case EBlock(exprs):
+                for (expr in exprs) {
+                    var node = exprToIR(expr);
+                    if (node != null && node.type != "skip") {
+                        eventNodes.push(node);
+                    }
+                }
+            default:
+                var node = exprToIR(func.expr);
+                if (node != null && node.type != "skip") {
+                    eventNodes.push(node);
+                }
+        }
+    }
+
+    // =========================================================================
+    // Vec call conversion - emit ready-to-use C with placeholders
+    // Placeholders: {v} = vector object, {0}, {1} = args
+    // =========================================================================
+
+    function convertVecCall(method:String, objIR:IRNode, args:Array<IRNode>, vecType:String):IRNode {
+        // Determine C type based on Haxe type
+        var cType = switch (vecType) {
+            case "Vec4": "ArmVec4";
+            case "Vec3": "ArmVec3";
+            default: "ArmVec2";
+        };
+        var is3D = (vecType == "Vec3" || vecType == "Vec4");
+
+        // Template uses {v} for vector, {0} for first arg
+        var c_code = switch (method) {
+            case "length":
+                is3D ? "sqrtf({v}.x*{v}.x + {v}.y*{v}.y + {v}.z*{v}.z)"
+                     : "sqrtf({v}.x*{v}.x + {v}.y*{v}.y)";
+            case "mult":
+                is3D ? "(" + cType + "){{v}.x*({0}), {v}.y*({0}), {v}.z*({0})}"
+                     : "(" + cType + "){{v}.x*({0}), {v}.y*({0})}";
+            case "add":
+                is3D ? "(" + cType + "){{v}.x+({0}).x, {v}.y+({0}).y, {v}.z+({0}).z}"
+                     : "(" + cType + "){{v}.x+({0}).x, {v}.y+({0}).y}";
+            case "sub":
+                is3D ? "(" + cType + "){{v}.x-({0}).x, {v}.y-({0}).y, {v}.z-({0}).z}"
+                     : "(" + cType + "){{v}.x-({0}).x, {v}.y-({0}).y}";
+            case "dot":
+                is3D ? "({v}.x*({0}).x + {v}.y*({0}).y + {v}.z*({0}).z)"
+                     : "({v}.x*({0}).x + {v}.y*({0}).y)";
+            case "normalize":
+                // Note: normalize modifies in-place, needs the original var name
+                // We use {vraw} placeholder for unparenthesized var
+                is3D ? "{ float _l=sqrtf({v}.x*{v}.x+{v}.y*{v}.y+{v}.z*{v}.z); if(_l>0.0f){ {vraw}.x/=_l; {vraw}.y/=_l; {vraw}.z/=_l; } }"
+                     : "{ float _l=sqrtf({v}.x*{v}.x+{v}.y*{v}.y); if(_l>0.0f){ {vraw}.x/=_l; {vraw}.y/=_l; } }";
+            case "clone":
+                // Clone creates a copy - type depends on target
+                // Special case: transform.scale is stored with SCALE_FACTOR (1/64), so multiply by 64 to get Blender values
+                var isScaleClone = (objIR.type == "field" && objIR.value == "transform.scale");
+                if (isScaleClone) {
+                    // Inverse of SCALE_FACTOR (0.015625 = 1/64) = 64
+                    if (cType == "ArmVec4") "(" + cType + "){{v}.x*64.0f, {v}.y*64.0f, {v}.z*64.0f, 1.0f}";
+                    else if (cType == "ArmVec3") "(" + cType + "){{v}.x*64.0f, {v}.y*64.0f, {v}.z*64.0f}";
+                    else "(" + cType + "){{v}.x*64.0f, {v}.y*64.0f}";
+                } else {
+                    if (cType == "ArmVec4") "(" + cType + "){{v}.x, {v}.y, {v}.z, 1.0f}";
+                    else if (cType == "ArmVec3") "(" + cType + "){{v}.x, {v}.y, {v}.z}";
+                    else "(" + cType + "){{v}.x, {v}.y}";
+                }
+            default:
+                null;
+        };
+
+        if (c_code == null) return { type: "skip" };
+
+        return {
+            type: "vec_call",
+            c_code: c_code,
+            object: objIR,
+            args: args,
+            props: {
+                vecType: vecType,
+                cType: cType,
+                is3D: is3D
+            }
+        };
+    }
+
+    // =========================================================================
+    // Scene call conversion - Scene.setActive() -> scene_switch_to()
+    // =========================================================================
+
+    function convertSceneCall(method:String, args:Array<IRNode>, rawParams:Array<Expr>):IRNode {
+        if (method == "setActive" && rawParams.length > 0) {
+            // Try to extract constant scene name first
+            var result = analyzeSceneArg(rawParams[0]);
+
+            switch (result.kind) {
+                case "constant":
+                    // Compile-time known scene: Scene.setActive("Level_01")
+                    var sceneNameUpper = result.value.toUpperCase();
+                    return {
+                        type: "scene_call",
+                        method: "setActive",
+                        c_code: 'scene_switch_to(SCENE_$sceneNameUpper)'
+                    };
+
+                case "current_scene":
+                    // Scene.active.raw.name -> restart current scene
+                    return {
+                        type: "scene_call",
+                        method: "setActive",
+                        c_code: 'scene_switch_to(scene_get_current_id())'
+                    };
+
+                case "member_string":
+                    // Member variable of type String: Scene.setActive(nextLevel)
+                    // Runtime lookup by name - pass member node so Python emits correctly
+                    return {
+                        type: "scene_call",
+                        method: "setActive",
+                        args: [{ type: "member", value: result.value }]
+                    };
+
+                case "expression":
+                    // Fallback: convert the expression to IR and let codegen handle it
+                    // This generates scene_switch_to_by_name with the expression
+                    return {
+                        type: "scene_call",
+                        method: "setActive",
+                        args: args  // Pass the converted argument
+                    };
+            }
+        }
+        return { type: "skip" };
+    }
+
+    /**
+     * Analyze Scene.setActive argument and classify it:
+     * - "constant": compile-time string literal, value = the scene name
+     * - "current_scene": Scene.active.raw.name pattern
+     * - "member_string": identifier that's a String member variable, value = member name
+     * - "expression": anything else, needs runtime lookup
+     */
+    function analyzeSceneArg(expr:Expr):{ kind:String, value:String } {
+        if (expr == null) return { kind: "expression", value: null };
+
+        switch (expr.expr) {
+            // Direct string literal: "Level_01"
+            case EConst(CString(s)):
+                return { kind: "constant", value: s };
+
+            // Identifier - could be a member variable
+            case EConst(CIdent(name)):
+                if (members.exists(name)) {
+                    var member = members.get(name);
+                    // Check type - String members use runtime lookup
+                    if (member.haxeType == "String") {
+                        return { kind: "member_string", value: name };
+                    }
+                    // SceneId type might have constant default
+                    if (member.haxeType == "SceneId" || member.haxeType == "TSceneFormat" || member.haxeType == "SceneFormat") {
+                        var sceneName = extractSceneFromIRNode(member.defaultValue);
+                        if (sceneName != null) {
+                            return { kind: "constant", value: sceneName };
+                        }
+                    }
+                }
+                return { kind: "expression", value: null };
+
+            // Field access chain: Scene.active.raw.name, myScene.raw.name, etc.
+            case EField(innerExpr, fieldName):
+                if (fieldName == "name") {
+                    // Check for .raw.name pattern
+                    switch (innerExpr.expr) {
+                        case EField(innerInner, "raw"):
+                            // Could be Scene.active.raw or memberVar.raw
+                            switch (innerInner.expr) {
+                                case EField(sceneExpr, "active"):
+                                    // Check if it's Scene.active
+                                    switch (sceneExpr.expr) {
+                                        case EConst(CIdent("Scene")):
+                                            return { kind: "current_scene", value: null };
+                                        default:
+                                    }
+                                case EConst(CIdent(memberName)):
+                                    // memberVar.raw.name - check if it's a member
+                                    if (members.exists(memberName)) {
+                                        var member = members.get(memberName);
+                                        var sceneName = extractSceneFromIRNode(member.defaultValue);
+                                        if (sceneName != null) {
+                                            return { kind: "constant", value: sceneName };
+                                        }
+                                    }
+                                default:
+                            }
+                        default:
+                    }
+                }
+                return { kind: "expression", value: null };
+
+            default:
+                return { kind: "expression", value: null };
+        }
+    }
+
+    function extractSceneFromIRNode(node:IRNode):Null<String> {
+        if (node == null) return null;
+        if (node.type == "string" && node.value != null) {
+            return Std.string(node.value);
+        }
+        if (node.type == "ident" && node.value != null) {
+            // Could be a scene enum like Level_01
+            return Std.string(node.value);
+        }
+        return null;
+    }
+
+    // =========================================================================
+    // Koui static call conversion - Koui.init(), Koui.add(), Koui.remove(), Koui.render()
+    // =========================================================================
+
+    function convertKouiStaticCall(method:String, args:Array<IRNode>, rawParams:Array<Expr>):IRNode {
+        meta.uses_ui = true;
+
+        switch (method) {
+            case "init":
+                // Koui.init(callback) - extract callback body, emit statements inline
+                // The callback runs immediately on N64 since we don't have async loading
+                if (rawParams.length > 0) {
+                    var callback = resolveCallback(rawParams[0]);
+                    if (callback != null) {
+                        // Return block of statements from callback
+                        return exprToIR(callback);
+                    }
+                }
+                return { type: "skip" };
+
+            case "add":
+                // Koui.add(label) -> koui_add_label(label)
+                return {
+                    type: "koui_call",
+                    c_func: "koui_add_label",
+                    args: args
+                };
+
+            case "render":
+                // Koui.render(g2) - skip, handled in main loop
+                return { type: "skip" };
+
+            case "remove":
+                // Koui.remove(label) -> koui_remove_label(label)
+                return {
+                    type: "koui_call",
+                    c_func: "koui_remove_label",
+                    args: args
+                };
+
+            default:
+                return { type: "skip" };
+        }
+    }
+
+    // =========================================================================
+    // Label method call conversion - label.setPosition(), label.setText(), etc.
+    // =========================================================================
+
+    function convertLabelCall(method:String, objIR:IRNode, args:Array<IRNode>):IRNode {
+        meta.uses_ui = true;
+
+        switch (method) {
+            case "setPosition":
+                // label.setPosition(x, y) -> koui_label_set_position(label, x, y)
+                return {
+                    type: "koui_call",
+                    c_func: "koui_label_set_position",
+                    object: objIR,
+                    args: args
+                };
+
+            default:
+                return { type: "skip" };
+        }
+    }
+
+    // =========================================================================
+    // Signal call conversion - signal.connect(), signal.disconnect(), signal.emit()
+    // Per-instance signals with max 4 subscribers
+    // =========================================================================
+
+    function convertSignalCall(method:String, signalExpr:Expr, args:Array<IRNode>, params:Array<Expr>):IRNode {
+        // Get the signal member name from the expression
+        var signalName = switch (signalExpr.expr) {
+            case EConst(CIdent(name)): name;
+            case EField(_, fieldName): fieldName;
+            default: null;
+        };
+
+        if (signalName == null) {
+            return { type: "skip" };
+        }
+
+        switch (method) {
+            case "connect":
+                // signal.connect(callback) -> signal_connect(&data->signalName, callback_func, data)
+                if (params.length > 0) {
+                    var callbackName = extractFunctionRef(params[0]);
+                    if (callbackName != null) {
+                        addSignalHandler(callbackName, signalName);
+                        // c_code with {signal_ptr} and {handler} placeholders
+                        return {
+                            type: "signal_call",
+                            value: "connect",
+                            c_code: 'signal_connect({signal_ptr}, {handler}, data);',
+                            props: {
+                                signal_name: signalName,
+                                callback: callbackName
+                            }
+                        };
+                    }
+                }
+                return { type: "skip" };
+
+            case "disconnect":
+                if (params.length > 0) {
+                    var callbackName = extractFunctionRef(params[0]);
+                    if (callbackName != null) {
+                        return {
+                            type: "signal_call",
+                            value: "disconnect",
+                            c_code: 'signal_disconnect({signal_ptr}, {handler});',
+                            props: {
+                                signal_name: signalName,
+                                callback: callbackName
+                            }
+                        };
+                    }
+                }
+                return { type: "skip" };
+
+            case "emit":
+                updateSignalArgTypes(signalName, params);
+                var argCount = params.length;
+
+                // Generate c_code based on arg count
+                var c_code:String;
+                if (argCount == 0) {
+                    c_code = 'signal_emit({signal_ptr}, NULL);';
+                } else if (argCount == 1) {
+                    c_code = 'signal_emit({signal_ptr}, (void*)(uintptr_t)({0}));';
+                } else {
+                    // Multiple args - generate struct init + emit
+                    // {struct_type} _p = {{0}, {1}, ...}; signal_emit({signal_ptr}, &_p);
+                    var argPlaceholders = [for (i in 0...argCount) '{$i}'];
+                    c_code = '{struct_type} _p = {' + argPlaceholders.join(', ') + '}; signal_emit({signal_ptr}, &_p);';
+                }
+
+                return {
+                    type: "signal_call",
+                    value: "emit",
+                    c_code: c_code,
+                    props: {
+                        signal_name: signalName,
+                        arg_count: argCount
+                    },
+                    args: args
+                };
+
+            default:
+                return { type: "skip" };
+        }
+    }
+
+    function convertGlobalSignalCall(method:String, className:String, signalName:String, args:Array<IRNode>, params:Array<Expr>):IRNode {
+        // Handle global/static signals: GameEvents.gemCollected.emit()
+        // These are stored as global ArmSignal structs: g_classname_signalname
+
+        var globalSignalName = 'g_${className.toLowerCase()}_$signalName';
+
+        // Track this global signal for declaration generation
+        if (!Lambda.has(meta.global_signals, globalSignalName)) {
+            meta.global_signals.push(globalSignalName);
+        }
+
+        switch (method) {
+            case "connect":
+                if (params.length > 0) {
+                    var callbackName = extractFunctionRef(params[0]);
+                    if (callbackName != null) {
+                        addSignalHandler(callbackName, signalName);
+                        return {
+                            type: "global_signal_call",
+                            c_code: 'signal_connect({signal_ptr}, {handler}, data);',
+                            props: {
+                                global_signal: globalSignalName,
+                                callback: callbackName
+                            }
+                        };
+                    }
+                }
+                return { type: "skip" };
+
+            case "disconnect":
+                if (params.length > 0) {
+                    var callbackName = extractFunctionRef(params[0]);
+                    if (callbackName != null) {
+                        return {
+                            type: "global_signal_call",
+                            c_code: 'signal_disconnect({signal_ptr}, {handler});',
+                            props: {
+                                global_signal: globalSignalName,
+                                callback: callbackName
+                            }
+                        };
+                    }
+                }
+                return { type: "skip" };
+
+            case "emit":
+                var argCount = params.length;
+                var c_code:String;
+                if (argCount == 0) {
+                    c_code = 'signal_emit({signal_ptr}, NULL);';
+                } else if (argCount == 1) {
+                    c_code = 'signal_emit({signal_ptr}, (void*)(uintptr_t)({0}));';
+                } else {
+                    // Multiple args - for global signals, user should pass a struct pointer
+                    c_code = 'signal_emit({signal_ptr}, (void*){0});';
+                }
+                return {
+                    type: "global_signal_call",
+                    c_code: c_code,
+                    props: {
+                        global_signal: globalSignalName
+                    },
+                    args: args
+                };
+
+            default:
+                return { type: "skip" };
+        }
+    }
+
+    function extractFunctionRef(e:Expr):String {
+        // Extract function name from expression like `onEnemyDeath` or `this.onEnemyDeath`
+        return switch (e.expr) {
+            case EConst(CIdent(name)): name;
+            case EField(_, fieldName): fieldName;
+            default: null;
+        };
+    }
+
+    function updateSignalArgTypes(signalName:String, params:Array<Expr>):Void {
+        // Find the signal in meta and update its arg_types based on emit() call
+        for (signal in meta.signals) {
+            if (signal.name == signalName) {
+                // Only update if not already populated (first emit() wins)
+                if (signal.arg_types.length == 0) {
+                    for (param in params) {
+                        var haxeType = inferExprType(param);
+                        var cType = TypeMap.getCType(haxeType);
+                        signal.arg_types.push(cType);
+                    }
+                }
+                break;
+            }
+        }
+    }
+
+    function inferExprType(e:Expr):String {
+        // Infer the Haxe type of an expression for signal arg typing
+        return switch (e.expr) {
+            case EConst(CInt(_)): "Int";
+            case EConst(CFloat(_)): "Float";
+            case EConst(CString(_)): "String";
+            case EConst(CIdent("true")), EConst(CIdent("false")): "Bool";
+            case EConst(CIdent("object")), EConst(CIdent("this")): "ArmObject";
+            case EConst(CIdent(name)):
+                // Check local vars first, then members
+                if (localVarTypes.exists(name)) localVarTypes.get(name);
+                else if (members.exists(name)) members.get(name).haxeType;
+                else "Dynamic";
+            case EField(obj, field):
+                // Could be object.transform, etc. - simplified for now
+                "Dynamic";
+            default: "Dynamic";
+        };
+    }
+
+    function addSignalHandler(handlerName:String, signalName:String):Void {
+        // Check if already tracked
+        for (h in meta.signal_handlers) {
+            if (h.handler_name == handlerName) return;
+        }
+
+        // Track this handler
+        meta.signal_handlers.push({
+            handler_name: handlerName,
+            signal_name: signalName
+        });
+
+        // Extract the handler method body as an event
+        if (methodMap.exists(handlerName)) {
+            var func = methodMap.get(handlerName);
+            if (!events.exists("signal_" + handlerName)) {
+                events.set("signal_" + handlerName, []);
+                extractSignalHandler(handlerName, func, events.get("signal_" + handlerName));
+            }
+        }
+    }
+
+    function extractSignalHandler(name:String, func:Function, eventNodes:Array<IRNode>):Void {
+        // Signal handlers have signature matching ArmSignalHandler:
+        // void (*)(void* ctx, void* payload)
+        // ctx = the trait data pointer passed to signal_connect
+        // payload = the data pointer passed to signal_emit
+
+        if (func.expr == null) return;
+
+        switch (func.expr.expr) {
+            case EBlock(exprs):
+                for (expr in exprs) {
+                    var node = exprToIR(expr);
+                    if (node != null && node.type != "skip") {
+                        eventNodes.push(node);
+                    }
+                }
+            default:
+                var node = exprToIR(func.expr);
+                if (node != null && node.type != "skip") {
+                    eventNodes.push(node);
+                }
+        }
+    }
+
+    // =========================================================================
+    // Transform call conversion - with coordinate swizzle Blender→N64
+    // Blender: X=right, Y=forward, Z=up
+    // N64/T3D: X=right, Y=up, Z=back (so Y→Z, Z→-Y)
+    // =========================================================================
+
+    function convertTransformCall(method:String, args:Array<IRNode>):IRNode {
+        // Mark as mutating if it's a transform-modifying method
+        if (method == "translate" || method == "rotate" || method == "move" ||
+            method == "setMatrix" || method == "multMatrix" || method == "setRotation" ||
+            method == "buildMatrix" || method == "applyParent" || method == "applyParentInverse" ||
+            method == "reset") {
+            meta.mutates_transform = true;
+        }
+
+        // Template uses {0}, {1}, {2} for args
+        // Coord conversion: Blender (X,Y,Z) → N64 (X,Z,-Y)
+        var c_code = switch (method) {
+            case "translate":
+                // translate(x, y, z) -> it_translate(transform, x, z, -y)
+                "it_translate(&((ArmObject*)obj)->transform, {0}, {2}, -({1}));";
+            case "rotate":
+                // rotate(axis, angle) -> it_rotate_axis_global(transform, axis.x, axis.z, -axis.y, angle)
+                "it_rotate_axis_global(&((ArmObject*)obj)->transform, ({0}).x, ({0}).z, -({0}).y, {1});";
+            case "move":
+                // move(axis, ?scale) -> it_move(transform, axis.x, axis.z, -axis.y, scale)
+                "it_move(&((ArmObject*)obj)->transform, ({0}).x, ({0}).z, -({0}).y, {1});";
+            case "setRotation":
+                // setRotation(x, y, z) -> it_set_rot_euler(transform, x, z, -y)
+                "it_set_rot_euler(&((ArmObject*)obj)->transform, {0}, {2}, -({1}));";
+            case "look":
+                "{ T3DVec3 _dir; it_look(&((ArmObject*)obj)->transform, &_dir); _dir; }";
+            case "right":
+                "{ T3DVec3 _dir; it_right(&((ArmObject*)obj)->transform, &_dir); _dir; }";
+            case "up":
+                "{ T3DVec3 _dir; it_up(&((ArmObject*)obj)->transform, &_dir); _dir; }";
+            case "worldx":
+                "it_world_x(&((ArmObject*)obj)->transform)";
+            case "worldy":
+                // Blender Y -> N64 Z
+                "it_world_z(&((ArmObject*)obj)->transform)";
+            case "worldz":
+                // Blender Z -> N64 -Y
+                "(-it_world_y(&((ArmObject*)obj)->transform))";
+            case "reset":
+                "it_reset(&((ArmObject*)obj)->transform);";
+            case "buildMatrix":
+                // N64 uses dirty flag system - just mark as dirty, matrix rebuilds automatically
+                "((ArmObject*)obj)->transform.dirty = 1;";
+            default:
+                null;
+        };
+
+        if (c_code == null) return { type: "skip" };
+
+        return {
+            type: "transform_call",
+            c_code: c_code,
+            args: args
+        };
+    }
+
+    // =========================================================================
+    // Math call conversion - Math.sin() -> fm_sinf(), etc.
+    // Uses libdragon's fast math functions where available (16x faster)
+    // =========================================================================
+
+    function convertMathCall(method:String, args:Array<IRNode>):IRNode {
+        // Map Haxe Math methods to C math.h functions
+        // Use libdragon's fm_* functions for sin/cos/atan2 (much faster on N64)
+        var cFunc = switch (method) {
+            case "sin": "fm_sinf";      // ~50 ticks vs ~800 ticks for sinf
+            case "cos": "fm_cosf";      // ~50 ticks vs ~800 ticks for cosf
+            case "tan": "tanf";
+            case "asin": "asinf";
+            case "acos": "acosf";
+            case "atan": "atanf";
+            case "atan2": "fm_atan2f";  // libdragon fast version
+            case "sqrt": "sqrtf";
+            case "pow": "powf";
+            case "abs": "fabsf";
+            case "floor": "fm_floorf"; // libdragon fast version
+            case "ceil": "ceilf";
+            case "round": "roundf";
+            case "min": "fminf";
+            case "max": "fmaxf";
+            case "exp": "fm_exp";       // libdragon fast version (~3% error)
+            case "log": "logf";
+            default: method;
+        };
+        return {
+            type: "math_call",
+            value: cFunc,
+            args: args
+        };
+    }
+
+    // =========================================================================
+    // Input call conversion - gamepad.started("a") -> input_started(N64_BTN_A)
+    // =========================================================================
+
+    function convertInputCall(method:String, args:Array<IRNode>):IRNode {
+        // Map button to N64_BTN_* constant
+        var n64Button = "N64_BTN_A"; // default button
+        if (args.length > 0) {
+            var btnArg = args[0];
+            if (btnArg.type == "string") {
+                var btnName = btnArg.value;
+                n64Button = ButtonMap.toN64Const(btnName);
+            }
+        }
+
+        // Emit ready-to-use C code
+        // Note: down() returns float (intensity 0.0-1.0), started/released return bool
+        var cCode = switch(method) {
+            case "started": 'input_started($n64Button)';
+            case "released": 'input_released($n64Button)';
+            case "down": 'input_down($n64Button)';
+            case "getStickX": 'input_stick_x()';
+            case "getStickY": 'input_stick_y()';
+            default: '0'; // unsupported input method - return neutral value
+        };
+
+        return {
+            type: "input_call",
+            c_code: cCode,
+            method: method
+        };
+    }
+
+    // =========================================================================
+    // Std call conversion - Std.int() -> (int32_t), Std.parseFloat() -> strtof()
+    // =========================================================================
+
+    function convertStdCall(method:String, args:Array<IRNode>):IRNode {
+        return switch (method) {
+            case "int":
+                { type: "cast_call", value: "(int32_t)", args: args };
+            case "parseFloat":
+                { type: "math_call", value: "strtof", args: args };  // Note: strtof needs NULL as 2nd arg
+            case "string":
+                // Std.string(value) used standalone (not in concatenation)
+                // In a + expression, StringConcatBuilder handles this
+                // For standalone use, emit sprintf with single arg
+                if (args.length > 0) {
+                    var argType = args[0].type;
+                    var format = switch (argType) {
+                        case "float": "%.2f";
+                        case "int": "%d";
+                        case "member": "%d";  // Assume int for members
+                        default: "%d";
+                    };
+                    { type: "sprintf", value: format, args: args };
+                } else {
+                    { type: "string", value: "" };
+                }
+            default:
+                { type: "skip" };
+        };
+    }
+
+    // =========================================================================
+    // Object call conversion - object.remove(), object.getTrait(), etc.
+    // =========================================================================
+
+    function convertObjectCall(method:String, args:Array<IRNode>):IRNode {
+        return switch (method) {
+            case "remove":
+                // object.remove() -> object_remove((ArmObject*)obj)
+                { type: "object_call", c_code: "object_remove((ArmObject*)obj)" };
+            case "getTrait", "addTrait", "removeTrait":
+                // Trait system not supported on N64 - skip silently
+                { type: "skip" };
+            case "getChildren", "getChild":
+                // Children access not yet supported - skip
+                { type: "skip" };
+            default:
+                // Unknown object method - skip to avoid codegen fallback
+                { type: "skip" };
+        };
+    }
+}
+
+#end
diff --git a/armory/Sources/armory/n64/StringConcatBuilder.hx b/armory/Sources/armory/n64/StringConcatBuilder.hx
new file mode 100644
index 0000000000..2580497ce1
--- /dev/null
+++ b/armory/Sources/armory/n64/StringConcatBuilder.hx
@@ -0,0 +1,141 @@
+package armory.n64;
+
+#if macro
+import haxe.macro.Expr;
+
+using haxe.macro.ExprTools;
+using StringTools;
+
+/**
+ * Helper class to build sprintf-style string concatenation IR nodes.
+ *
+ * Flattens expressions like "Score: " + Std.string(score) + " pts"
+ * into a single sprintf node: { type: "sprintf", value: "Score: %ld pts", args: [score] }
+ */
+class StringConcatBuilder {
+    var members:Map<String, N64TraitMacro.MemberIR>;
+    var localVarTypes:Map<String, String>;
+    var exprToIRFunc:Expr->N64TraitMacro.IRNode;
+    var getExprTypeFunc:Expr->String;
+
+    public function new(
+        members:Map<String, N64TraitMacro.MemberIR>,
+        localVarTypes:Map<String, String>,
+        exprToIRFunc:Expr->N64TraitMacro.IRNode,
+        getExprTypeFunc:Expr->String
+    ) {
+        this.members = members;
+        this.localVarTypes = localVarTypes;
+        this.exprToIRFunc = exprToIRFunc;
+        this.getExprTypeFunc = getExprTypeFunc;
+    }
+
+    /**
+     * Build a flattened string concatenation node.
+     * Collects all parts and emits a single sprintf node.
+     */
+    public function build(e1:Expr, e2:Expr):N64TraitMacro.IRNode {
+        var formatParts:Array<String> = [];
+        var args:Array<N64TraitMacro.IRNode> = [];
+
+        collectParts(e1, formatParts, args);
+        collectParts(e2, formatParts, args);
+
+        return {
+            type: "sprintf",
+            value: formatParts.join(""),
+            args: args
+        };
+    }
+
+    /**
+     * Recursively collect parts of a string concatenation.
+     */
+    function collectParts(e:Expr, formatParts:Array<String>, args:Array<N64TraitMacro.IRNode>):Void {
+        if (e == null) return;
+
+        switch (e.expr) {
+            case EConst(CString(s)):
+                // Literal string - add directly to format
+                formatParts.push(s);
+
+            case EBinop(OpAdd, left, right):
+                // Nested concatenation - recurse if either side is string
+                var leftType = getExprTypeFunc(left);
+                var rightType = getExprTypeFunc(right);
+                if (leftType == "String" || rightType == "String") {
+                    collectParts(left, formatParts, args);
+                    collectParts(right, formatParts, args);
+                } else {
+                    // Not string concat, treat as expression
+                    addExpr(e, formatParts, args);
+                }
+
+            case ECall(callExpr, callArgs):
+                // Check for Std.string(value)
+                switch (callExpr.expr) {
+                    case EField(obj, method):
+                        switch (obj.expr) {
+                            case EConst(CIdent("Std")):
+                                if (method == "string" && callArgs.length > 0) {
+                                    var valueExpr = callArgs[0];
+                                    var valueType = getExprTypeFunc(valueExpr);
+                                    addTyped(valueExpr, valueType, formatParts, args);
+                                    return;
+                                }
+                            default:
+                        }
+                    default:
+                }
+                // Other call - treat as expression
+                addExpr(e, formatParts, args);
+
+            case EParenthesis(inner):
+                collectParts(inner, formatParts, args);
+
+            case EConst(CIdent(name)):
+                // Variable reference
+                var varType = "Dynamic";
+                if (members.exists(name)) {
+                    varType = members.get(name).haxeType;
+                } else if (localVarTypes.exists(name)) {
+                    varType = localVarTypes.get(name);
+                }
+
+                if (varType == "String") {
+                    formatParts.push("%s");
+                    args.push(exprToIRFunc(e));
+                } else {
+                    addTyped(e, varType, formatParts, args);
+                }
+
+            default:
+                addExpr(e, formatParts, args);
+        }
+    }
+
+    /**
+     * Add a typed format specifier for an expression.
+     * Note: On N64, int32_t is 'long int', so we use %ld for integers.
+     */
+    function addTyped(e:Expr, exprType:String, formatParts:Array<String>, args:Array<N64TraitMacro.IRNode>):Void {
+        var format = switch (exprType) {
+            case "Int": "%ld";      // int32_t is long on N64
+            case "Float": "%.2f";
+            case "Bool": "%d";
+            case "String": "%s";
+            default: "%ld";
+        };
+        formatParts.push(format);
+        args.push(exprToIRFunc(e));
+    }
+
+    /**
+     * Add any expression to format (infer type).
+     */
+    function addExpr(e:Expr, formatParts:Array<String>, args:Array<N64TraitMacro.IRNode>):Void {
+        var exprType = getExprTypeFunc(e);
+        addTyped(e, exprType, formatParts, args);
+    }
+}
+#end
diff --git a/armory/Sources/armory/trait/physics/bullet/RigidBody.hx b/armory/Sources/armory/trait/physics/bullet/RigidBody.hx
index 7a4586e755..417d7a887d 100644
--- a/armory/Sources/armory/trait/physics/bullet/RigidBody.hx
+++ b/armory/Sources/armory/trait/physics/bullet/RigidBody.hx
@@ -55,6 +55,10 @@ class RigidBody extends iron.Trait {
 	public var onReady: Void->Void = null;
 	public var onContact: Array<RigidBody->Void> = null;
 	public var heightData: haxe.io.Bytes = null;
+
+	// Compound shape children (baked from exporter)
+	var compoundChildren: Array<CompoundChild> = null;
+
 	#if js
 	static var ammoArray: Int = -1;
 	#end
@@ -144,6 +148,9 @@ class RigidBody extends iron.Trait {
 		this.staticObj = flags.staticObj;
 		this.useDeactivation = flags.useDeactivation;
 
+		// Store compound children data if provided
+		this.compoundChildren = params.compoundChildren;
+
 		notifyOnAdd(init);
 	}
 
@@ -245,6 +252,25 @@ class RigidBody extends iron.Trait {
 			btshape.setLocalScaling(vec1);
 			#end
 		}
+		else if (shape == Shape.Compound) {
+			// Create compound shape and add all child shapes
+			var compound = new bullet.Bt.CompoundShape(true);
+			if (compoundChildren != null) {
+				for (child in compoundChildren) {
+					var childShape = createChildShape(child);
+					if (childShape != null) {
+						// Set child local transform
+						trans2.setIdentity();
+						vec1.setValue(child.posX, child.posY, child.posZ);
+						trans2.setOrigin(vec1);
+						quat1.setValue(child.rotX, child.rotY, child.rotZ, child.rotW);
+						trans2.setRotation(quat1);
+						compound.addChildShape(trans2, childShape);
+					}
+				}
+			}
+			btshape = compound;
+		}
 
 		trans1.setIdentity();
 		vec1.setX(transform.worldx());
@@ -332,6 +358,46 @@ class RigidBody extends iron.Trait {
 		#end
 	}
 
+	/**
+	 * Creates a child collision shape for compound rigidbodies from baked export data.
+	 * @param child The compound child data containing shape type and dimensions
+	 * @return The created Bullet collision shape, or null if shape type is unsupported
+	 */
+	function createChildShape(child: CompoundChild): bullet.Bt.CollisionShape {
+		var childShapeType: Int = child.shape;
+
+		if (childShapeType == Shape.Box) {
+			vec1.setValue(withMargin(child.dimX / 2), withMargin(child.dimY / 2), withMargin(child.dimZ / 2));
+			return new bullet.Bt.BoxShape(vec1);
+		}
+		else if (childShapeType == Shape.Sphere) {
+			return new bullet.Bt.SphereShape(withMargin(child.dimX / 2));
+		}
+		else if (childShapeType == Shape.Cone) {
+			var coneZ = new bullet.Bt.ConeShapeZ(
+				withMargin(child.dimX / 2), // Radius
+				withMargin(child.dimZ));    // Height
+			return coneZ;
+		}
+		else if (childShapeType == Shape.Cylinder) {
+			vec1.setValue(withMargin(child.dimX / 2), withMargin(child.dimY / 2), withMargin(child.dimZ / 2));
+			var cylZ = new bullet.Bt.CylinderShapeZ(vec1);
+			return cylZ;
+		}
+		else if (childShapeType == Shape.Capsule) {
+			var r = child.dimX / 2;
+			var capsZ = new bullet.Bt.CapsuleShapeZ(
+				withMargin(r), // Radius
+				withMargin(child.dimZ - r * 2)); // Height between 2 sphere centers
+			return capsZ;
+		}
+		else {
+			// Unsupported shape type for compound children (ConvexHull, Mesh, Terrain)
+			trace("Warning: Unsupported compound child shape type: " + childShapeType);
+			return null;
+		}
+	}
+
 	function update() {
 		if (interpolate) {
 			var t: Float = Time.fixedStepInterpolation;
@@ -732,6 +798,7 @@ class RigidBody extends iron.Trait {
 	var Cylinder = 5;
 	var Capsule = 6;
 	var Terrain = 7;
+	var Compound = 8;
 }
 
 typedef RigidBodyParams = {
@@ -748,6 +815,21 @@ typedef RigidBodyParams = {
 	var linearDeactivationThreshold: Float;
 	var angularDeactivationThreshold: Float;
 	var deactivationTime: Float;
+	@:optional var compoundChildren: Array<CompoundChild>;
+}
+
+typedef CompoundChild = {
+	var shape: Int;      // 0=Box, 1=Sphere, 2=ConvexHull, 3=Mesh, 4=Cone, 5=Cylinder, 6=Capsule
+	var posX: Float;     // Local position relative to parent
+	var posY: Float;
+	var posZ: Float;
+	var rotX: Float;     // Local rotation quaternion
+	var rotY: Float;
+	var rotZ: Float;
+	var rotW: Float;
+	var dimX: Float;     // Dimensions for shape creation
+	var dimY: Float;
+	var dimZ: Float;
 }
 
 typedef RigidBodyFlags = {
diff --git a/armory/Sources/iron/Scene.hx b/armory/Sources/iron/Scene.hx
index 7aad72da8c..7b07868ca9 100644
--- a/armory/Sources/iron/Scene.hx
+++ b/armory/Sources/iron/Scene.hx
@@ -64,7 +64,6 @@ class Scene {
 	#end
 	public var empties: Array<Object>;
 	public var animations: Array<Animation>;
-	public var tilesheets: Array<Tilesheet>;
 	#if arm_skin
 	public var armatures: Array<Armature>;
 	#end
@@ -78,6 +77,9 @@ class Scene {
 	public var traitRemoves: Array<Void->Void> = [];
 
 	var initializing: Bool; // Is the scene in its initialization phase?
+	var spawnDepth: Int = 0; // Nested spawn counter (defer trait creation while > 0)
+	var spawning(get, never): Bool;
+	inline function get_spawning(): Bool return spawnDepth > 0;
 
 	public function new() {
 		uid = uidCounter++;
@@ -101,7 +103,6 @@ class Scene {
 		#end
 		empties = [];
 		animations = [];
-		tilesheets = [];
 		#if arm_skin
 		armatures = [];
 		#end
@@ -253,10 +254,6 @@ class Scene {
 		if (!ready || RenderPath.active == null) return;
 		framePassed = true;
 
-		for (tilesheet in tilesheets) {
-			tilesheet.update();
-		}
-
 		// Render probes
 		#if rp_probes
 		var activeCamera = camera;
@@ -437,7 +434,7 @@ class Scene {
 		var result = objects.length;
 		for (o in objects) {
 			if (discardNoSpawn && o.spawn != null && o.spawn == false) continue; // Do not count children of non-spawned objects
-			if (o.children != null) result += getObjectsCount(o.children);
+			if (o.children != null) result += getObjectsCount(o.children, discardNoSpawn);
 		}
 		return result;
 	}
@@ -451,11 +448,16 @@ class Scene {
 		@param	srcRaw If not `null`, spawn the object from the given scene data instead of using the scene this function is called on. Useful to spawn objects from other scenes.
 	**/
 	public function spawnObject(name: String, parent: Null<Object>, done: Null<Object->Void>, spawnChildren = true, srcRaw: Null<TSceneFormat> = null) {
+		spawnObjectInternal(name, parent, done, spawnChildren, srcRaw, true);
+	}
+
+	function spawnObjectInternal(name: String, parent: Null<Object>, done: Null<Object->Void>, spawnChildren: Bool, srcRaw: Null<TSceneFormat>, createTraits: Bool) {
 		if (srcRaw == null) srcRaw = raw;
 		var objectsTraversed = 0;
 		var obj = getRawObjectByName(srcRaw, name);
 		var objectsCount = spawnChildren ? getObjectsCount([obj], false) : 1;
 		var rootId = -1;
+		spawnDepth++; // Defer trait creation until all objects are ready
 		function spawnObjectTree(obj: TObj, parent: Object, parentObject: TObj, done: Object->Void) {
 			createObject(obj, srcRaw, parent, parentObject, function(object: Object) {
 				if (rootId == -1) {
@@ -471,6 +473,11 @@ class Scene {
 					while (object.uid != rootId) {
 						object = object.parent;
 					}
+					// Create traits bottom-up after all objects are ready
+					spawnDepth--;
+					if (createTraits) {
+						createTraitsBottomUp(object);
+					}
 					// Then call user callback
 					if (done != null) done(object);
 				}
@@ -604,7 +611,7 @@ class Scene {
 		else {
 			for (object_ref in object_refs) {
 				// Spawn top-level collection objects and their children
-				spawnObject(object_ref, groupOwner, function(spawnedObject: Object) {
+				spawnObjectInternal(object_ref, groupOwner, function(spawnedObject: Object) {
 					// Apply collection/group instance offset to all
 					// top-level parents of that group
 					if (!isObjectInGroup(groupRef, spawnedObject.parent, format)) {
@@ -624,7 +631,7 @@ class Scene {
 						groupOwner.transform.reset();
 						done();
 					}
-				}, true, format);
+				}, true, format, false);
 			}
 		}
 	}
@@ -804,9 +811,9 @@ class Scene {
 				for (ref in o.particle_refs) cast(object, MeshObject).setupParticleSystem(sceneName, ref);
 			}
 			#end
-			// Attach tilesheet
-			if (o.tilesheet_ref != null) {
-				cast(object, MeshObject).setupTilesheet(sceneName, o.tilesheet_ref, o.tilesheet_action_ref);
+			// Attach tilesheet from embedded object data
+			if (o.tilesheet != null) {
+				cast(object, MeshObject).setupTilesheet(o.tilesheet);
 			}
 
 
@@ -874,9 +881,9 @@ class Scene {
 				}
 			}
 
-			// If the scene is still initializing, traits will be created later
+			// If the scene is still initializing or spawning, traits will be created later
 			// to ensure that object references for trait properties are valid
-			if (!active.initializing) createTraits(o.traits, object);
+			if (!active.initializing && !active.spawning) createTraits(o.traits, object);
 		}
 		done(object);
 	}
diff --git a/armory/Sources/iron/Trait.hx b/armory/Sources/iron/Trait.hx
index c316494395..50d77b318a 100644
--- a/armory/Sources/iron/Trait.hx
+++ b/armory/Sources/iron/Trait.hx
@@ -2,6 +2,9 @@ package iron;
 
 import iron.object.Object;
 
+#if arm_target_n64
+@:autoBuild(armory.n64.N64TraitMacro.build())
+#end
 class Trait {
 
 	public var name: String = "";
diff --git a/armory/Sources/iron/data/SceneFormat.hx b/armory/Sources/iron/data/SceneFormat.hx
index d1e61772b6..f0a56f64dc 100644
--- a/armory/Sources/iron/data/SceneFormat.hx
+++ b/armory/Sources/iron/data/SceneFormat.hx
@@ -31,7 +31,6 @@ typedef TSceneFormat = {
 	@:optional public var speaker_datas: Array<TSpeakerData>;
 	@:optional public var world_datas: Array<TWorldData>;
 	@:optional public var world_ref: String;
-	@:optional public var tilesheet_datas: Array<TTilesheetData>;
 	@:optional public var objects: Array<TObj>;
 	@:optional public var groups: Array<TGroup>;
 	@:optional public var gravity: Float32Array;
@@ -161,6 +160,18 @@ typedef TMaterialData = {
 	public var contexts: Array<TMaterialContext>;
 	@:optional public var skip_context: String;
 	@:optional public var override_context: TShaderOverride;
+	@:optional public var tilesheet: TMaterialTilesheet;
+}
+
+#if js
+typedef TMaterialTilesheet = {
+#else
+@:structInit class TMaterialTilesheet {
+#end
+	public var tilesx: Int;
+	public var tilesy: Int;
+	public var framerate: Int;
+	public var actions: Array<TTilesheetAction>;
 }
 
 #if js
@@ -365,26 +376,37 @@ typedef TProbeData = {
 }
 
 #if js
-typedef TTilesheetData = {
+typedef TTilesheetAction = {
 #else
-@:structInit class TTilesheetData {
+@:structInit class TTilesheetAction {
 #end
 	public var name: String;
+	public var start: Int;
+	public var end: Int;
+	public var loop: Bool;
 	public var tilesx: Int;
 	public var tilesy: Int;
 	public var framerate: Int;
-	public var actions: Array<TTilesheetAction>;
+	@:optional public var mesh: String; // Optional mesh to swap to when playing this action
+	@:optional public var events: Array<TTilesheetEvent>; // Optional events triggered on specific frames
 }
 
 #if js
-typedef TTilesheetAction = {
+typedef TTilesheetEvent = {
 #else
-@:structInit class TTilesheetAction {
+@:structInit class TTilesheetEvent {
 #end
-	public var name: String;
-	public var start: Int;
-	public var end: Int;
-	public var loop: Bool;
+	public var name: String; // Event name
+	public var frame: Int; // Frame number when event triggers
+}
+
+#if js
+typedef TTilesheetData = {
+#else
+@:structInit class TTilesheetData {
+#end
+	public var actions: Array<TTilesheetAction>;
+	@:optional public var start_action: String;
 }
 
 #if js
@@ -481,8 +503,7 @@ typedef TObj = {
 	@:optional public var mobile: Null<Bool>;
 	@:optional public var spawn: Null<Bool>; // Auto add object when creating scene
 	@:optional public var local_only: Null<Bool>; // Apply parent matrix
-	@:optional public var tilesheet_ref: String;
-	@:optional public var tilesheet_action_ref: String;
+	@:optional public var tilesheet: TTilesheetData; // Embedded tilesheet data
 	@:optional public var sampled: Null<Bool>; // Object action
 	@:optional public var is_ik_fk_only: Null<Bool>; // Bone IK or FK only
 	@:optional public var relative_bone_constraints: Null<Bool>; // Use parent relative bone constraints
diff --git a/armory/Sources/iron/object/MeshObject.hx b/armory/Sources/iron/object/MeshObject.hx
index cc43325602..9f913076cc 100644
--- a/armory/Sources/iron/object/MeshObject.hx
+++ b/armory/Sources/iron/object/MeshObject.hx
@@ -27,8 +27,7 @@ class MeshObject extends Object {
 	public var cameraList: Array<String> = null;
 	public var screenSize = 0.0;
 	public var frustumCulling = true;
-	public var activeTilesheet: Tilesheet = null;
-	public var tilesheets: Array<Tilesheet> = null;
+	public var tilesheet: Tilesheet = null;
 	public var skip_context: String = null; // Do not draw this context
 	public var force_context: String = null; // Draw only this context
 	static var lastPipeline: PipelineState = null;
@@ -87,8 +86,7 @@ class MeshObject extends Object {
 			particleSystems = null;
 		}
 		#end
-		if (activeTilesheet != null) activeTilesheet.remove();
-		if (tilesheets != null) for (ts in tilesheets) { ts.remove(); }
+		if (tilesheet != null) tilesheet.remove();
 		if (Scene.active != null) Scene.active.meshes.remove(this);
 		data.refcount--;
 		super.remove();
@@ -123,30 +121,14 @@ class MeshObject extends Object {
 	}
 	#end
 
-	public function setupTilesheet(sceneName: String, tilesheet_ref: String, tilesheet_action_ref: String) {
-		activeTilesheet = new Tilesheet(sceneName, tilesheet_ref, tilesheet_action_ref);
-		if(tilesheets == null) tilesheets = new Array<Tilesheet>();
-		tilesheets.push(activeTilesheet);
+	public function setupTilesheet(tilesheetData: iron.data.SceneFormat.TTilesheetData) {
+		tilesheet = new Tilesheet(tilesheetData, this);
 	}
 
-	public function setActiveTilesheet(sceneName: String, tilesheet_ref: String, tilesheet_action_ref: String) {
-		var set = false;
-		// Check if tilesheet already created
-		if (tilesheets != null) {
-			for (ts in tilesheets) {
-				if (ts.raw.name == tilesheet_ref) {
-					activeTilesheet = ts;
-					activeTilesheet.play(tilesheet_action_ref);
-					set = true;
-					break;
-				}
-			}
-		}
-		// If not already created
-		if (!set) {
-			setupTilesheet(sceneName, tilesheet_ref, tilesheet_action_ref);
+	public function setTilesheetAction(actionRef: String) {
+		if (tilesheet != null) {
+			tilesheet.play(actionRef);
 		}
-
 	}
 
 	inline function isLodMaterial(): Bool {
@@ -241,6 +223,11 @@ class MeshObject extends Object {
 		if (cullMesh(context, Scene.active.camera, RenderPath.active.light)) return;
 		var meshContext = raw != null ? context == "mesh" : false;
 
+		// Update tilesheet
+		if (tilesheet != null && meshContext) {
+			tilesheet.update();
+		}
+
 		if (cameraList != null && cameraList.indexOf(Scene.active.camera.name) < 0) return;
 
 		#if arm_gpu_particles
diff --git a/armory/Sources/iron/object/Object.hx b/armory/Sources/iron/object/Object.hx
index 8101935df2..f569666d23 100644
--- a/armory/Sources/iron/object/Object.hx
+++ b/armory/Sources/iron/object/Object.hx
@@ -212,7 +212,7 @@ class Object {
 	public function getTraitFromChildren<T: Trait>(c: Class<T>): T {
 		var t: T = getTrait(c);
 		if (t != null) return t;
-		for (child in getChildren()) {
+		for (child in getChildren(true)) {
 			t = child.getTraitFromChildren(c);
 			if (t != null) return t;
 		}
diff --git a/armory/Sources/iron/object/ParticleSystemGPU.hx b/armory/Sources/iron/object/ParticleSystemGPU.hx
index 6ca6107b8d..0f1d0f18c4 100644
--- a/armory/Sources/iron/object/ParticleSystemGPU.hx
+++ b/armory/Sources/iron/object/ParticleSystemGPU.hx
@@ -141,10 +141,10 @@ class ParticleSystemGPU {
 		dimx = object.transform.dim.x;
 		dimy = object.transform.dim.y;
 
-		if (object.activeTilesheet != null) {
-			tilesx = object.activeTilesheet.raw.tilesx;
-			tilesy = object.activeTilesheet.raw.tilesy;
-			tilesFramerate = object.activeTilesheet.raw.framerate;
+		if (object.tilesheet != null) {
+			tilesx = object.tilesheet.getTilesx();
+			tilesy = object.tilesheet.getTilesy();
+			tilesFramerate = object.tilesheet.action != null ? object.tilesheet.action.framerate : 1;
 		}
 
 		// Animate
diff --git a/armory/Sources/iron/object/Tilesheet.hx b/armory/Sources/iron/object/Tilesheet.hx
index 86328e0c15..7cabe2fbd2 100644
--- a/armory/Sources/iron/object/Tilesheet.hx
+++ b/armory/Sources/iron/object/Tilesheet.hx
@@ -1,53 +1,251 @@
 package iron.object;
 
-import iron.Scene;
-import iron.data.Data;
+import iron.App;
 import iron.data.SceneFormat;
 import iron.system.Time;
 
-@:allow(iron.Scene)
 class Tilesheet {
-
-	public var tileX = 0.0; // Tile offset on tilesheet texture 0-1
-	public var tileY = 0.0;
-
-	public var raw: TTilesheetData;
+	public var tileX: Float = 0.0;
+	public var tileY: Float = 0.0;
+	public var flipX: Bool = false;
+	public var flipY: Bool = false;
+	public var paused: Bool = false;
+	public var frame: Int = 0;
+	public var actions: Array<TTilesheetAction>;
 	public var action: TTilesheetAction = null;
-	var ready: Bool;
 
-	public var paused = false;
-	public var frame = 0;
-	var time = 0.0;
+	public var ready: Bool = false;
+	var time: Float = 0.0;
 	var onActionComplete: Void->Void = null;
+	var onReady: Void->Void = null;
+	var onEvent: String->Void = null; // Callback for tilesheet events
+	var prevFrame: Int = -1; // Track previous frame to detect changes
+	var owner: MeshObject = null;
+	var currentMesh: MeshObject = null;
+	var meshCache: Map<String, MeshObject> = new Map();
+	var pendingAction: String = null;
+	var pendingOnComplete: Void->Void = null;
 
-	public function new(sceneName: String, tilesheet_ref: String, tilesheet_action_ref: String) {
-		ready = false;
-		Data.getSceneRaw(sceneName, function(format: TSceneFormat) {
-			for (ts in format.tilesheet_datas) {
-				if (ts.name == tilesheet_ref) {
-					raw = ts;
-					Scene.active.tilesheets.push(this);
-					play(tilesheet_action_ref);
-					ready = true;
-					break;
+	public function new(tilesheetData: TTilesheetData, ownerObject: MeshObject = null) {
+		owner = ownerObject;
+		actions = tilesheetData.actions;
+
+		pendingAction = tilesheetData.start_action;
+		if ((pendingAction == null || pendingAction == "") && actions.length > 0) {
+			pendingAction = actions[0].name;
+		}
+
+		// If no actions need mesh swapping, ready immediately
+		var hasMeshActions = false;
+		for (a in actions) {
+			if (a.mesh != null && a.mesh != "") {
+				hasMeshActions = true;
+				break;
+			}
+		}
+
+		if (!hasMeshActions) {
+			ready = true;
+			if (pendingAction != null) {
+				playAction(pendingAction);
+				pendingAction = null;
+			}
+			if (onReady != null) onReady();
+		}
+	}
+
+	public function update() {
+		if (App.pauseUpdates) return;
+
+		if (!ready) {
+			if (tryInitialize()) {
+				ready = true;
+				if (pendingAction != null) {
+					playAction(pendingAction, pendingOnComplete);
+					pendingAction = null;
+					pendingOnComplete = null;
+				}
+				if (onReady != null) onReady();
+			}
+			return;
+		}
+
+		if (paused || action == null || action.start >= action.end) return;
+
+		time += Time.renderDelta;
+		var frameTime = 1 / action.framerate;
+		var framesToAdvance = 0;
+
+		while (time >= frameTime) {
+			time -= frameTime;
+			framesToAdvance++;
+		}
+
+		if (framesToAdvance > 0) {
+			setFrame(frame + framesToAdvance);
+		}
+	}
+
+	function tryInitialize(): Bool {
+		if (owner == null) return false;
+
+		// If no children, use the owner mesh itself
+		if (owner.children == null || owner.children.length == 0) {
+			if (owner.data != null && !meshCache.exists(owner.data.name)) {
+				meshCache.set(owner.data.name, owner);
+				// Also cache by object name for flexible lookup
+				if (owner.name != owner.data.name) {
+					meshCache.set(owner.name, owner);
 				}
 			}
-		});
+		} else {
+			// Use child meshes for mesh swapping
+			for (child in owner.children) {
+				if (Std.isOfType(child, MeshObject)) {
+					var meshChild = cast(child, MeshObject);
+					if (meshChild.data != null && !meshCache.exists(meshChild.data.name)) {
+						meshCache.set(meshChild.data.name, meshChild);
+						meshChild.visible = false;
+						// Also cache by object name for flexible lookup
+						if (meshChild.name != meshChild.data.name) {
+							meshCache.set(meshChild.name, meshChild);
+						}
+					}
+				}
+			}
+		}
+
+		for (a in actions) {
+			if (a.mesh != null && a.mesh != "" && !meshCache.exists(a.mesh)) {
+				if (findMatchingMesh(a.mesh) == null) return false;
+			}
+		}
+		return true;
+	}
+
+	/** Find mesh by base name pattern (handles linked objects with different suffixes). */
+	function findMatchingMesh(actionMeshName: String): MeshObject {
+		var baseName = actionMeshName;
+
+		// Strip "Mesh" prefix if present
+		if (StringTools.startsWith(baseName, "Mesh")) {
+			baseName = baseName.substr(4);
+		}
+
+		// Strip suffix after underscore (e.g., "_character.blend")
+		var idx = baseName.indexOf("_");
+		if (idx > 0) baseName = baseName.substr(0, idx);
+
+		for (meshName in meshCache.keys()) {
+			if (meshName.indexOf(baseName) != -1) {
+				var mesh = meshCache.get(meshName);
+				meshCache.set(actionMeshName, mesh); // Cache alias
+				return mesh;
+			}
+		}
+		return null;
 	}
 
 	public function play(action_ref: String, onActionComplete: Void->Void = null) {
-		this.onActionComplete = onActionComplete;
-		for (a in raw.actions) {
+		if (actions == null) return;
+
+		if (!ready) {
+			pendingAction = action_ref;
+			pendingOnComplete = onActionComplete;
+			return;
+		}
+
+		playAction(action_ref, onActionComplete);
+	}
+
+	public function notifyOnReady(callback: Void->Void) {
+		onReady = callback;
+		if (ready) onReady();
+	}
+
+	public function notifyOnEvent(callback: String->Void) {
+		onEvent = callback;
+	}
+
+	function playAction(action_ref: String, onComplete: Void->Void = null) {
+		if (action != null && action.name == action_ref) {
+			paused = false;
+			return;
+		}
+
+		onActionComplete = onComplete;
+
+		for (a in actions) {
 			if (a.name == action_ref) {
 				action = a;
 				break;
 			}
 		}
+
+		if (action == null) return;
+
+		if (action.mesh != null && action.mesh != "") {
+			var targetMesh = meshCache.get(action.mesh);
+			if (targetMesh != null && targetMesh != currentMesh) {
+				swapMesh(targetMesh);
+			}
+		}
+
+		prevFrame = -1; // Reset previous frame for new action
 		setFrame(action.start);
 		paused = false;
 		time = 0.0;
 	}
 
+	function swapMesh(meshObj: MeshObject) {
+		if (owner == null || meshObj == null) return;
+		currentMesh = meshObj;
+		if (meshObj.data != null) owner.setData(meshObj.data);
+		if (meshObj.materials != null) owner.materials = meshObj.materials;
+	}
+
+	function setFrame(f: Int) {
+		frame = f;
+
+		if (frame > action.end && action.start < action.end) {
+			// Check for events on last frame before completing
+			checkEvents(prevFrame, action.end);
+			if (onActionComplete != null) onActionComplete();
+			if (action.loop) {
+				prevFrame = -1; // Reset for loop
+				setFrame(action.start);
+			} else {
+				paused = true;
+			}
+			return;
+		}
+
+		// Check for events between previous frame and current frame
+		checkEvents(prevFrame, frame);
+		prevFrame = frame;
+
+		var tx = frame % action.tilesx;
+		var ty = Std.int(frame / action.tilesx);
+		tileX = tx / action.tilesx;
+		tileY = ty / action.tilesy;
+	}
+
+	/** Check and fire events for frames between fromFrame (exclusive) and toFrame (inclusive). */
+	function checkEvents(fromFrame: Int, toFrame: Int) {
+		if (onEvent == null || action == null || action.events == null) return;
+
+		// Convert to action-relative frame numbers
+		var relativeFrom = fromFrame - action.start;
+		var relativeTo = toFrame - action.start;
+
+		for (evt in action.events) {
+			// Fire event if it falls in the range (fromFrame, toFrame]
+			if (evt.frame > relativeFrom && evt.frame <= relativeTo) {
+				onEvent(evt.name);
+			}
+		}
+	}
+
 	public function pause() {
 		paused = true;
 	}
@@ -57,61 +255,33 @@ class Tilesheet {
 	}
 
 	public function remove() {
-		Scene.active.tilesheets.remove(this);
+		ready = false;
+		action = null;
+		actions = null;
+		owner = null;
+		currentMesh = null;
+		pendingAction = null;
+		pendingOnComplete = null;
+		onEvent = null;
+		prevFrame = -1;
+		meshCache.clear();
 	}
 
-	/**
-	 * Set the frame of the current active tilesheet action. Automatically un-pauses action.
-	 * @param frame Frame offset with 0 as the first frame of the active action.
-	 **/
 	public function setFrameOffset(frame: Int) {
+		if (action == null) return;
 		setFrame(action.start + frame);
 		paused = false;
 	}
 
-	/**
-	 * Returns the current frame.
-	 * @return Frame offset with 0 as the first frame of the active action.
-	 */
 	public function getFrameOffset(): Int {
-		return frame - action.start;
+		return action != null ? frame - action.start : 0;
 	}
 
-	function update() {
-		if (!ready || paused || action.start >= action.end) return;
-
-		time += Time.renderDelta;
-
-		var frameTime = 1 / raw.framerate;
-		var framesToAdvance = 0;
-
-		// Check how many animation frames passed during the last render frame
-		// and catch up if required. The remaining `time` that couldn't fit in
-		// another animation frame will be used in the next `update()`.
-		while (time >= frameTime) {
-			time -= frameTime;
-			framesToAdvance++;
-		}
-
-		if (framesToAdvance != 0) {
-			setFrame(frame + framesToAdvance);
-		}
+	public function getTilesx(): Int {
+		return action != null ? action.tilesx : 1;
 	}
 
-	function setFrame(f: Int) {
-		frame = f;
-
-		// Action end
-		if (frame > action.end && action.start < action.end) {
-			if (onActionComplete != null) onActionComplete();
-			if (action.loop) setFrame(action.start);
-			else paused = true;
-			return;
-		}
-
-		var tx = frame % raw.tilesx;
-		var ty = Std.int(frame / raw.tilesx);
-		tileX = tx * (1 / raw.tilesx);
-		tileY = ty * (1 / raw.tilesy);
+	public function getTilesy(): Int {
+		return action != null ? action.tilesy : 1;
 	}
 }
diff --git a/armory/Sources/iron/object/Uniforms.hx b/armory/Sources/iron/object/Uniforms.hx
index c492cb7279..4e93fe93c0 100644
--- a/armory/Sources/iron/object/Uniforms.hx
+++ b/armory/Sources/iron/object/Uniforms.hx
@@ -1054,14 +1054,19 @@ class Uniforms {
 			var vy: Null<kha.FastFloat> = null;
 			switch (c.link) {
 				case "_tilesheetOffset": {
-					var ts = cast(object, MeshObject).activeTilesheet;
+					var ts = cast(object, MeshObject).tilesheet;
 					vx = ts.tileX;
 					vy = ts.tileY;
 				}
+				case "_tilesheetFlip": {
+					var ts = cast(object, MeshObject).tilesheet;
+					vx = ts.flipX ? 1.0 : 0.0;
+					vy = ts.flipY ? 1.0 : 0.0;
+				}
 				case "_tilesheetTiles": {
-					var ts = cast(object, MeshObject).activeTilesheet;
-					vx = ts.raw.tilesx;
-					vy = ts.raw.tilesy;
+					var ts = cast(object, MeshObject).tilesheet;
+					vx = ts.getTilesx();
+					vy = ts.getTilesy();
 				}
 				#if arm_morph_target
 				case "_morphScaleOffset": {
diff --git a/armory/Sources/iron/system/ArmPack.hx b/armory/Sources/iron/system/ArmPack.hx
index c87cd76c41..7059690883 100644
--- a/armory/Sources/iron/system/ArmPack.hx
+++ b/armory/Sources/iron/system/ArmPack.hx
@@ -136,7 +136,7 @@ class ArmPack {
 			case "speaker_datas": TSpeakerData;
 			case "world_datas": TWorldData;
 			case "terrain_datas": TTerrainData;
-			case "tilesheet_datas": TTilesheetData;
+			case "tilesheet": TMaterialTilesheet;
 			case "objects": TObj;
 			case "children": TObj;
 			case "groups": TGroup;
diff --git a/armory/Sources/iron/system/Time.hx b/armory/Sources/iron/system/Time.hx
index 993299783f..21a8829676 100644
--- a/armory/Sources/iron/system/Time.hx
+++ b/armory/Sources/iron/system/Time.hx
@@ -14,12 +14,12 @@ class Time {
 		return 1 / frequency;
 	}
 
-	static var _fixedStep: Null<Float> = 1 / 60;
+	static var _fixedStep: Null<Float> = 1 / 30;
 	public static var fixedStep(get, never): Float;
 	static function get_fixedStep(): Float {
 		return _fixedStep;
 	}
-	public static function initFixedStep(value: Float = 1 / 60) {
+	public static function initFixedStep(value: Float = 1 / 30) {
 		_fixedStep = value;
 	}
 
diff --git a/armory/blender/arm/assets.py b/armory/blender/arm/assets.py
index 51acce9135..d481879c19 100644
--- a/armory/blender/arm/assets.py
+++ b/armory/blender/arm/assets.py
@@ -55,6 +55,16 @@ def reset():
     shader_cons['voxel_frag'] = []
     shader_cons['voxel_geom'] = []
 
+def reset_shader_cons():
+    # Reset shader comparison arrays to prevent cross-scene shader merging
+    global shader_cons
+    shader_cons['mesh_vert'] = []
+    shader_cons['depth_vert'] = []
+    shader_cons['depth_frag'] = []
+    shader_cons['voxel_vert'] = []
+    shader_cons['voxel_frag'] = []
+    shader_cons['voxel_geom'] = []
+
 def add(asset_file):
     global assets
 
diff --git a/armory/blender/arm/exporter.py b/armory/blender/arm/exporter.py
index 430d852081..19e2a92762 100644
--- a/armory/blender/arm/exporter.py
+++ b/armory/blender/arm/exporter.py
@@ -62,7 +62,14 @@ def get_bobject_type(cls, bobject: bpy.types.Object) -> "NodeType":
         if bobject.type == "MESH":
             if bobject.data.polygons or bobject.data.edges or bobject.data.vertices:
                 return cls.MESH
-        elif bobject.type in ('FONT', 'META'):
+        elif bobject.type in ('FONT', 'META', 'CURVE'): # FIXME: curves with meshes shouldn't be used in modifiers for now.
+            if bobject.type == 'CURVE':
+                mesh = bobject.to_mesh()
+                if mesh is not None:
+                    has_geometry = len(mesh.polygons) > 0
+                    bobject.to_mesh_clear()
+                    if not has_geometry:
+                        return cls.EMPTY
             return cls.MESH
         elif bobject.type == "LIGHT":
             return cls.LIGHT
@@ -557,6 +564,24 @@ def export_material_ref(self, bobject: bpy.types.Object, material, index, o):
             self.material_array.append(material)
         o['material_refs'].append(arm.utils.asset_name(material))
 
+    def link_mesh_from_library(self, library_path: str, mesh_name: str):
+        """Links a mesh from an external library file.
+
+        Returns the linked mesh data or None if not found.
+        """
+        try:
+            # Use link instead of append to maintain the library reference
+            with bpy.data.libraries.load(library_path, link=True) as (data_from, data_to):
+                if mesh_name in data_from.meshes:
+                    data_to.meshes = [mesh_name]
+                else:
+                    return None
+
+            # Return the newly linked mesh
+            return bpy.data.meshes.get(mesh_name)
+        except Exception as e:
+            return None
+
     def export_particle_system_ref(self, psys: bpy.types.ParticleSystem, out_object):
         if psys.settings.instance_object is None or psys.settings.render_type != 'OBJECT' or not psys.settings.instance_object.arm_export:
            return
@@ -645,18 +670,31 @@ def create_material_variants(scene: bpy.types.Scene) -> Tuple[List[bpy.types.Mat
             # Skinning
             if arm.utils.export_bone_data(bobject):
                 variant_suffix = '_armskin'
-            # Tilesheets
-            elif bobject.arm_tilesheet != '':
-                if not bobject.arm_use_custom_tilesheet_node:
+            # Tilesheets - check if object has tilesheet enabled
+            elif bobject.type == 'MESH' and len(bobject.material_slots) > 0:
+                if bobject.arm_tilesheet_enabled:
                     variant_suffix = '_armtile'
-            elif arm.utils.export_morph_targets(bobject):
+            # For collection instances, check objects inside the instanced collection
+            elif bobject.instance_type == 'COLLECTION' and bobject.instance_collection is not None:
+                for cobj in bobject.instance_collection.all_objects:
+                    if cobj.type == 'MESH' and cobj.arm_tilesheet_enabled:
+                        variant_suffix = '_armtile'
+                        break
+            if variant_suffix == '' and arm.utils.export_morph_targets(bobject):
                 variant_suffix = '_armskey'
 
             if variant_suffix == '':
                 continue
 
+            # For regular mesh objects, process their material slots
             for slot in bobject.material_slots:
-                if slot.material is None or slot.material.library is not None:
+                if slot.material is None:
+                    continue
+                # For linked materials, set the flag directly (can't create variants)
+                if slot.material.library is not None:
+                    if variant_suffix == '_armtile':
+                        slot.material.arm_tilesheet_flag = True
+                        slot.material.arm_cached = False
                     continue
                 if slot.material.name.endswith(variant_suffix):
                     continue
@@ -673,6 +711,23 @@ def create_material_variants(scene: bpy.types.Scene) -> Tuple[List[bpy.types.Mat
                     matvars.append(mat)
                 slot.material = mat
 
+            # For collection instances, set tilesheet flag on materials of objects inside the collection
+            # ONLY for objects that have arm_tilesheet_enabled set
+            if bobject.instance_type == 'COLLECTION' and bobject.instance_collection is not None:
+                for cobj in bobject.instance_collection.all_objects:
+                    if cobj.type != 'MESH':
+                        continue
+                    # Only apply tilesheet flag to objects that have it enabled
+                    if not cobj.arm_tilesheet_enabled:
+                        continue
+                    for slot in cobj.material_slots:
+                        if slot.material is None:
+                            continue
+                        # Set the flag and invalidate cache to force shader regeneration
+                        if variant_suffix == '_armtile':
+                            slot.material.arm_tilesheet_flag = True
+                            slot.material.arm_cached = False
+
         # Particle and non-particle objects can not share material
         particle_sys: bpy.types.ParticleSettings
         for particle_sys in bpy.data.particles:
@@ -842,10 +897,39 @@ def export_object(self, bobject: bpy.types.Object, out_parent: Dict = None) -> N
                 out_object['group_ref'] = bobject.instance_collection.name
                 self.referenced_collections.append(bobject.instance_collection)
 
-            if bobject.arm_tilesheet != '':
-                out_object['tilesheet_ref'] = bobject.arm_tilesheet
-                out_object['tilesheet_action_ref'] = bobject.arm_tilesheet_action
-
+            # Export tilesheet data if enabled on this object
+            if bobject.arm_tilesheet_enabled:
+                out_object['tilesheet'] = {
+                    'start_action': bobject.arm_tilesheet_default_action,
+                    'actions': []
+                }
+                for action in bobject.arm_tilesheet_actionlist:
+                    action_data = {
+                        'name': action.name,
+                        'start': action.start_prop,
+                        'end': action.end_prop,
+                        'loop': action.loop_prop,
+                        'tilesx': action.tilesx_prop,
+                        'tilesy': action.tilesy_prop,
+                        'framerate': action.framerate_prop
+                    }
+                    # Mesh swap reference (for later implementation)
+                    if action.mesh_prop != '':
+                        # Look up the actual mesh to get proper name with library suffix if linked
+                        mesh_data = bpy.data.meshes.get(action.mesh_prop)
+                        if mesh_data is not None:
+                            action_data['mesh'] = arm.utils.safestr(arm.utils.asset_name(mesh_data))
+                        else:
+                            action_data['mesh'] = arm.utils.safestr(action.mesh_prop)
+                    # Export events if any
+                    if len(action.events) > 0:
+                        action_data['events'] = []
+                        for evt in action.events:
+                            action_data['events'].append({
+                                'name': evt.name,
+                                'frame': evt.frame_prop
+                            })
+                    out_object['tilesheet']['actions'].append(action_data)
 
             if len(bobject.vertex_groups) > 0:
                 out_object['vertex_groups'] = []
@@ -1913,6 +1997,10 @@ def export_mesh(self, object_ref):
             log.warn(oid + ' was not exported')
             return
 
+        # Warn if a curve was converted but has no faces (no bevel/extrude)
+        if bobject.type == 'CURVE' and len(export_mesh.polygons) == 0:
+            log.warn(oid + ' is a curve with no faces - add bevel or extrude to generate geometry')
+
         if len(export_mesh.uv_layers) > 2:
             log.warn(oid + ' exceeds maximum of 2 UV Maps supported')
 
@@ -2529,26 +2617,6 @@ def extract_props(self, bpy_struct, depth=0, max_depth=2):
 
         return result
 
-    def export_tilesheets(self):
-        wrd = bpy.data.worlds['Arm']
-        if len(wrd.arm_tilesheetlist) > 0:
-            self.output['tilesheet_datas'] = []
-        for ts in wrd.arm_tilesheetlist:
-            o = {}
-            o['name'] = ts.name
-            o['tilesx'] = ts.tilesx_prop
-            o['tilesy'] = ts.tilesy_prop
-            o['framerate'] = ts.framerate_prop
-            o['actions'] = []
-            for tsa in ts.arm_tilesheetactionlist:
-                ao = {}
-                ao['name'] = tsa.name
-                ao['start'] = tsa.start_prop
-                ao['end'] = tsa.end_prop
-                ao['loop'] = tsa.loop_prop
-                o['actions'].append(ao)
-            self.output['tilesheet_datas'].append(o)
-
     def export_world(self):
         """Exports the world of the current scene."""
         world = self.scene.world
@@ -2729,7 +2797,6 @@ def execute(self):
             self.export_particle_systems()
             self.output['world_datas'] = []
             self.export_world()
-            self.export_tilesheets()
 
             if self.scene.world is not None:
                 self.output['world_ref'] = arm.utils.safestr(arm.utils.asset_name(self.scene.world) if self.scene.world.library else self.scene.world.name)
@@ -2929,89 +2996,136 @@ def post_export_object(self, bobject: bpy.types.Object, o, type):
 
         # Rigid body trait
         if bobject.rigid_body is not None and phys_enabled:
-            ArmoryExporter.export_physics = True
-            rb = bobject.rigid_body
-            shape = 0  # BOX
-
-            if rb.collision_shape == 'SPHERE':
-                shape = 1
-            elif rb.collision_shape == 'CONVEX_HULL':
-                shape = 2
-            elif rb.collision_shape == 'MESH':
-                shape = 3
-            elif rb.collision_shape == 'CONE':
-                shape = 4
-            elif rb.collision_shape == 'CYLINDER':
-                shape = 5
-            elif rb.collision_shape == 'CAPSULE':
-                shape = 6
-
-            body_mass = rb.mass
-            is_static = self.rigid_body_static(rb)
-            if is_static:
-                body_mass = 0
-            x = {}
-            x['type'] = 'Script'
-            x['class_name'] = 'armory.trait.physics.' + phys_pkg + '.RigidBody'
-            col_group = ''
-            for b in rb.collision_collections:
-                col_group = ('1' if b else '0') + col_group
-            col_mask = ''
-            for b in bobject.arm_rb_collision_filter_mask:
-                col_mask = ('1' if b else '0') + col_mask
-
-            x['parameters'] = [str(shape), str(body_mass), str(rb.friction), str(rb.restitution), str(int(col_group, 2)), str(int(col_mask, 2)) ]
-            lx = bobject.arm_rb_linear_factor[0]
-            ly = bobject.arm_rb_linear_factor[1]
-            lz = bobject.arm_rb_linear_factor[2]
-            ax = bobject.arm_rb_angular_factor[0]
-            ay = bobject.arm_rb_angular_factor[1]
-            az = bobject.arm_rb_angular_factor[2]
-            if bobject.lock_location[0]:
-                lx = 0
-            if bobject.lock_location[1]:
-                ly = 0
-            if bobject.lock_location[2]:
-                lz = 0
-            if bobject.lock_rotation[0]:
-                ax = 0
-            if bobject.lock_rotation[1]:
-                ay = 0
-            if bobject.lock_rotation[2]:
-                az = 0
-            col_margin = rb.collision_margin if rb.use_margin else 0.0
-            if rb.use_deactivation:
-                deact_lv = rb.deactivate_linear_velocity
-                deact_av = rb.deactivate_angular_velocity
-                deact_time = bobject.arm_rb_deactivation_time
+            # Skip children of compound parents - their shapes are baked into the parent
+            is_compound_child = (bobject.parent is not None and
+                                 bobject.parent.rigid_body is not None and
+                                 bobject.parent.rigid_body.collision_shape == 'COMPOUND')
+            if is_compound_child:
+                pass  # Don't export RigidBody trait for compound children
             else:
-                deact_lv = 0.0
-                deact_av = 0.0
-                deact_time = 0.0
-            body_params = {}
-            body_params['linearDamping'] = rb.linear_damping
-            body_params['angularDamping'] = rb.angular_damping
-            body_params['linearFactorsX'] = lx
-            body_params['linearFactorsY'] = ly
-            body_params['linearFactorsZ'] = lz
-            body_params['angularFactorsX'] = ax
-            body_params['angularFactorsY'] = ay
-            body_params['angularFactorsZ'] = az
-            body_params['angularFriction'] = bobject.arm_rb_angular_friction
-            body_params['collisionMargin'] = col_margin
-            body_params['linearDeactivationThreshold'] = deact_lv
-            body_params['angularDeactivationThrshold'] = deact_av
-            body_params['deactivationTime'] = deact_time
-            body_flags = {}
-            body_flags['animated'] = rb.kinematic
-            body_flags['trigger'] = bobject.arm_rb_trigger
-            body_flags['ccd'] = bobject.arm_rb_ccd
-            body_flags['interpolate'] = bobject.arm_rb_interpolate
-            body_flags['staticObj'] = is_static
-            body_flags['useDeactivation'] = rb.use_deactivation
-            x['parameters'].append(arm.utils.get_haxe_json_string(body_params))
-            x['parameters'].append(arm.utils.get_haxe_json_string(body_flags))
-            o['traits'].append(x)
+                ArmoryExporter.export_physics = True
+                rb = bobject.rigid_body
+                shape = 0  # BOX
+
+                if rb.collision_shape == 'SPHERE':
+                    shape = 1
+                elif rb.collision_shape == 'CONVEX_HULL':
+                    shape = 2
+                elif rb.collision_shape == 'MESH':
+                    shape = 3
+                elif rb.collision_shape == 'CONE':
+                    shape = 4
+                elif rb.collision_shape == 'CYLINDER':
+                    shape = 5
+                elif rb.collision_shape == 'CAPSULE':
+                    shape = 6
+                elif rb.collision_shape == 'COMPOUND':
+                    shape = 8
+
+                body_mass = rb.mass
+                is_static = self.rigid_body_static(rb)
+                if is_static:
+                    body_mass = 0
+                x = {}
+                x['type'] = 'Script'
+                x['class_name'] = 'armory.trait.physics.' + phys_pkg + '.RigidBody'
+                col_group = ''
+                for b in rb.collision_collections:
+                    col_group = ('1' if b else '0') + col_group
+                col_mask = ''
+                for b in bobject.arm_rb_collision_filter_mask:
+                    col_mask = ('1' if b else '0') + col_mask
+
+                x['parameters'] = [str(shape), str(body_mass), str(rb.friction), str(rb.restitution), str(int(col_group, 2)), str(int(col_mask, 2)) ]
+                lx = bobject.arm_rb_linear_factor[0]
+                ly = bobject.arm_rb_linear_factor[1]
+                lz = bobject.arm_rb_linear_factor[2]
+                ax = bobject.arm_rb_angular_factor[0]
+                ay = bobject.arm_rb_angular_factor[1]
+                az = bobject.arm_rb_angular_factor[2]
+                if bobject.lock_location[0]:
+                    lx = 0
+                if bobject.lock_location[1]:
+                    ly = 0
+                if bobject.lock_location[2]:
+                    lz = 0
+                if bobject.lock_rotation[0]:
+                    ax = 0
+                if bobject.lock_rotation[1]:
+                    ay = 0
+                if bobject.lock_rotation[2]:
+                    az = 0
+                col_margin = rb.collision_margin if rb.use_margin else 0.0
+                if rb.use_deactivation:
+                    deact_lv = rb.deactivate_linear_velocity
+                    deact_av = rb.deactivate_angular_velocity
+                    deact_time = bobject.arm_rb_deactivation_time
+                else:
+                    deact_lv = 0.0
+                    deact_av = 0.0
+                    deact_time = 0.0
+                body_params = {}
+                body_params['linearDamping'] = rb.linear_damping
+                body_params['angularDamping'] = rb.angular_damping
+                body_params['linearFactorsX'] = lx
+                body_params['linearFactorsY'] = ly
+                body_params['linearFactorsZ'] = lz
+                body_params['angularFactorsX'] = ax
+                body_params['angularFactorsY'] = ay
+                body_params['angularFactorsZ'] = az
+                body_params['angularFriction'] = bobject.arm_rb_angular_friction
+                body_params['collisionMargin'] = col_margin
+                body_params['linearDeactivationThreshold'] = deact_lv
+                body_params['angularDeactivationThrshold'] = deact_av
+                body_params['deactivationTime'] = deact_time
+
+                # Collect compound children shapes if this is a compound parent
+                if rb.collision_shape == 'COMPOUND':
+                    compound_children = []
+                    for child in bobject.children:
+                        if child.rigid_body is not None:
+                            child_rb = child.rigid_body
+                            # Map child collision shape to int
+                            child_shape = 0  # BOX default
+                            if child_rb.collision_shape == 'SPHERE':
+                                child_shape = 1
+                            elif child_rb.collision_shape == 'CONVEX_HULL':
+                                child_shape = 2
+                            elif child_rb.collision_shape == 'MESH':
+                                child_shape = 3
+                            elif child_rb.collision_shape == 'CONE':
+                                child_shape = 4
+                            elif child_rb.collision_shape == 'CYLINDER':
+                                child_shape = 5
+                            elif child_rb.collision_shape == 'CAPSULE':
+                                child_shape = 6
+
+                            # Get child's local transform relative to parent
+                            local_matrix = bobject.matrix_world.inverted() @ child.matrix_world
+                            loc = local_matrix.to_translation()
+                            rot = local_matrix.to_quaternion()
+
+                            # Get child dimensions
+                            child_dim = child.dimensions
+
+                            compound_children.append({
+                                'shape': child_shape,
+                                'posX': loc.x, 'posY': loc.y, 'posZ': loc.z,
+                                'rotX': rot.x, 'rotY': rot.y, 'rotZ': rot.z, 'rotW': rot.w,
+                                'dimX': child_dim.x, 'dimY': child_dim.y, 'dimZ': child_dim.z
+                            })
+                    body_params['compoundChildren'] = compound_children
+
+                body_flags = {}
+                body_flags['animated'] = rb.kinematic
+                body_flags['trigger'] = bobject.arm_rb_trigger
+                body_flags['ccd'] = bobject.arm_rb_ccd
+                body_flags['interpolate'] = bobject.arm_rb_interpolate
+                body_flags['staticObj'] = is_static
+                body_flags['useDeactivation'] = rb.use_deactivation
+                x['parameters'].append(arm.utils.get_haxe_json_string(body_params))
+                x['parameters'].append(arm.utils.get_haxe_json_string(body_flags))
+                o['traits'].append(x)
 
         # Phys traits
         if phys_enabled:
diff --git a/armory/blender/arm/logicnode/animation/LN_get_tilesheet_flip.py b/armory/blender/arm/logicnode/animation/LN_get_tilesheet_flip.py
new file mode 100644
index 0000000000..267553fb64
--- /dev/null
+++ b/armory/blender/arm/logicnode/animation/LN_get_tilesheet_flip.py
@@ -0,0 +1,18 @@
+from arm.logicnode.arm_nodes import *
+
+class GetTilesheetFlipNode(ArmLogicTreeNode):
+    """Returns the flip state of the tilesheet.
+
+    @output Flip X: Whether the sprite is flipped horizontally.
+    @output Flip Y: Whether the sprite is flipped vertically.
+    """
+    bl_idname = 'LNGetTilesheetFlipNode'
+    bl_label = 'Get Tilesheet Flip'
+    arm_version = 1
+    arm_section = 'tilesheet'
+
+    def arm_init(self, context):
+        self.add_input('ArmNodeSocketObject', 'Object')
+
+        self.add_output('ArmBoolSocket', 'Flip X')
+        self.add_output('ArmBoolSocket', 'Flip Y')
diff --git a/armory/blender/arm/logicnode/animation/LN_get_tilesheet_state.py b/armory/blender/arm/logicnode/animation/LN_get_tilesheet_state.py
index 4472236344..10fd4cea5c 100644
--- a/armory/blender/arm/logicnode/animation/LN_get_tilesheet_state.py
+++ b/armory/blender/arm/logicnode/animation/LN_get_tilesheet_state.py
@@ -2,8 +2,8 @@
 
 class GetTilesheetStateNode(ArmLogicTreeNode):
     """Returns the information about the current tilesheet of the given object.
-    
-    @output Active Tilesheet: Current active tilesheet.
+
+    @output Tilesheet: Tilesheet name.
 
     @output Active Action: Current action in the tilesheet.
 
@@ -15,23 +15,28 @@ class GetTilesheetStateNode(ArmLogicTreeNode):
     """
     bl_idname = 'LNGetTilesheetStateNode'
     bl_label = 'Get Tilesheet State'
-    arm_version = 2
+    arm_version = 4
     arm_section = 'tilesheet'
 
     def arm_init(self, context):
         self.add_input('ArmNodeSocketObject', 'Object')
 
-        self.add_output('ArmStringSocket', 'Active Tilesheet')
+        self.add_output('ArmStringSocket', 'Tilesheet')
         self.add_output('ArmStringSocket', 'Active Action')
         self.add_output('ArmIntSocket', 'Frame')
         self.add_output('ArmIntSocket', 'Absolute Frame')
         self.add_output('ArmBoolSocket', 'Is Paused')
 
     def get_replacement_node(self, node_tree: bpy.types.NodeTree):
-        if self.arm_version not in (0, 1):
-            raise LookupError()
-
-        return NodeReplacement(
-            'LNGetTilesheetStateNode', self.arm_version, 'LNGetTilesheetStateNode', 2,
-            in_socket_mapping={}, out_socket_mapping={0:1, 1:3, 2:4}
-        )
+        if self.arm_version in (0, 1):
+            return NodeReplacement(
+                'LNGetTilesheetStateNode', self.arm_version, 'LNGetTilesheetStateNode', 4,
+                in_socket_mapping={}, out_socket_mapping={0: 1, 1: 3, 2: 4}
+            )
+        elif self.arm_version in (2, 3):
+            # Version 2 and 3 have same outputs, just rename Material to Tilesheet
+            return NodeReplacement(
+                'LNGetTilesheetStateNode', self.arm_version, 'LNGetTilesheetStateNode', 4,
+                in_socket_mapping={0: 0}, out_socket_mapping={0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
+            )
+        raise LookupError()
diff --git a/armory/blender/arm/logicnode/animation/LN_set_active_tilesheet.py b/armory/blender/arm/logicnode/animation/LN_set_active_tilesheet.py
deleted file mode 100644
index 6bc5246a6b..0000000000
--- a/armory/blender/arm/logicnode/animation/LN_set_active_tilesheet.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from arm.logicnode.arm_nodes import *
-
-class SetActiveTilesheetNode(ArmLogicTreeNode):
-    """Set the active tilesheet."""
-    bl_idname = 'LNSetActiveTilesheetNode'
-    bl_label = 'Set Active Tilesheet'
-    arm_version = 1
-    arm_section = 'tilesheet'
-
-    def arm_init(self, context):
-        self.add_input('ArmNodeSocketAction', 'In')
-        self.add_input('ArmNodeSocketObject', 'Object')
-        self.add_input('ArmStringSocket', 'Tilesheet')
-        self.add_input('ArmStringSocket', 'Action')
-
-        self.add_output('ArmNodeSocketAction', 'Out')
\ No newline at end of file
diff --git a/armory/blender/arm/logicnode/animation/LN_set_tilesheet.py b/armory/blender/arm/logicnode/animation/LN_set_tilesheet.py
new file mode 100644
index 0000000000..0fc875e6f1
--- /dev/null
+++ b/armory/blender/arm/logicnode/animation/LN_set_tilesheet.py
@@ -0,0 +1,24 @@
+from arm.logicnode.arm_nodes import *
+
+class SetTilesheetNode(ArmLogicTreeNode):
+    """Sets the tilesheet action for the given object."""
+    bl_idname = 'LNSetTilesheetNode'
+    bl_label = 'Set Tilesheet'
+    arm_version = 2
+    arm_section = 'tilesheet'
+
+    def arm_init(self, context):
+        self.add_input('ArmNodeSocketAction', 'In')
+        self.add_input('ArmNodeSocketObject', 'Object')
+        self.add_input('ArmStringSocket', 'Action')
+
+        self.add_output('ArmNodeSocketAction', 'Out')
+
+    def get_replacement_node(self, node_tree: bpy.types.NodeTree):
+        if self.arm_version != 1:
+            raise LookupError()
+
+        return NodeReplacement(
+            'LNSetTilesheetNode', self.arm_version, 'LNSetTilesheetNode', 2,
+            in_socket_mapping={0: 0, 1: 1, 3: 2}, out_socket_mapping={0: 0}
+        )
\ No newline at end of file
diff --git a/armory/blender/arm/logicnode/animation/LN_set_tilesheet_flip.py b/armory/blender/arm/logicnode/animation/LN_set_tilesheet_flip.py
new file mode 100644
index 0000000000..a5176cd284
--- /dev/null
+++ b/armory/blender/arm/logicnode/animation/LN_set_tilesheet_flip.py
@@ -0,0 +1,21 @@
+from arm.logicnode.arm_nodes import *
+
+class SetTilesheetFlipNode(ArmLogicTreeNode):
+    """Set the flip state of the tilesheet for UV-based sprite flipping.
+    This is useful for billboarded sprites where mesh scaling cannot be used.
+
+    @input Flip X: Flip the sprite horizontally.
+    @input Flip Y: Flip the sprite vertically.
+    """
+    bl_idname = 'LNSetTilesheetFlipNode'
+    bl_label = 'Set Tilesheet Flip'
+    arm_version = 1
+    arm_section = 'tilesheet'
+
+    def arm_init(self, context):
+        self.add_input('ArmNodeSocketAction', 'In')
+        self.add_input('ArmNodeSocketObject', 'Object')
+        self.add_input('ArmBoolSocket', 'Flip X')
+        self.add_input('ArmBoolSocket', 'Flip Y')
+
+        self.add_output('ArmNodeSocketAction', 'Out')
diff --git a/armory/blender/arm/make.py b/armory/blender/arm/make.py
index 2622bf6e6d..634fb67bbd 100644
--- a/armory/blender/arm/make.py
+++ b/armory/blender/arm/make.py
@@ -19,6 +19,7 @@
 
 from arm import assets
 from arm.exporter import ArmoryExporter
+from arm.n64.exporter import N64Exporter
 import arm.lib.make_datas
 import arm.lib.server
 import arm.live_patch as live_patch
@@ -35,6 +36,8 @@
     assets = arm.reload_module(assets)
     arm.exporter = arm.reload_module(arm.exporter)
     from arm.exporter import ArmoryExporter
+    arm.n64.exporter = arm.reload_module(arm.n64.exporter)
+    from arm.n64.exporter import N64Exporter
     arm.lib.make_datas = arm.reload_module(arm.lib.make_datas)
     arm.lib.server = arm.reload_module(arm.lib.server)
     live_patch = arm.reload_module(live_patch)
@@ -258,6 +261,8 @@ def export_data(fp, sdk_path):
 
     for scene in bpy.data.scenes:
         if scene.arm_export:
+            # Reset shader comparison arrays to prevent cross-scene shader merging
+            assets.reset_shader_cons()
             ext = '.lz4' if ArmoryExporter.compress_enabled else '.arm'
             asset_path = build_dir + '/compiled/Assets/' + arm.utils.safestr(scene.name + "_" + os.path.basename(scene.library.filepath).replace(".blend", "") if scene.library else scene.name) + ext
             ArmoryExporter.export_scene(bpy.context, asset_path, scene=scene, depsgraph=depsgraph)
@@ -625,9 +630,13 @@ def build_done():
 
 def runtime_to_target():
     wrd = bpy.data.worlds['Arm']
-    if wrd.arm_runtime == 'Krom':
-        return 'krom'
-    return 'html5'
+    match wrd.arm_runtime:
+        case 'Krom':
+            return 'krom'
+        case 'Browser':
+            return 'html5'
+        case 'Ares':
+            return 'custom'  # N64 uses custom target for Haxe macro execution
 
 def get_khajs_path(target):
     if target == 'krom':
@@ -675,6 +684,21 @@ def build_success():
     log.clear()
     wrd = bpy.data.worlds['Arm']
 
+    # N64 target: Krom build complete, now run N64 exporter
+    if state.is_n64:
+        state.is_n64 = False  # Reset flag
+        if state.is_play:
+            N64Exporter.play_project()
+        elif state.is_publish:
+            N64Exporter.publish_project()
+            if arm.utils.get_open_n64_rom_directory():
+                arm.utils.open_folder(os.path.abspath(arm.utils.build_dir() + '/n64'))
+        else:
+            N64Exporter.export_project()
+            if arm.utils.get_open_n64_rom_directory():
+                arm.utils.open_folder(os.path.abspath(arm.utils.build_dir() + '/n64'))
+        return
+
     if state.is_play:
         cmd = []
         width, height = arm.utils.get_render_resolution(arm.utils.get_active_scene())
diff --git a/armory/blender/arm/make_state.py b/armory/blender/arm/make_state.py
index 289e3834cc..2dd8c1c4f9 100644
--- a/armory/blender/arm/make_state.py
+++ b/armory/blender/arm/make_state.py
@@ -18,3 +18,4 @@
     is_export = False
     is_play = False
     is_publish = False
+    is_n64 = False
diff --git a/armory/blender/arm/make_world.py b/armory/blender/arm/make_world.py
index 4551b7208c..7b49b8bd06 100644
--- a/armory/blender/arm/make_world.py
+++ b/armory/blender/arm/make_world.py
@@ -55,12 +55,12 @@ def build():
         for world in bpy.data.worlds:
             #world = scene.world
 
-            assigned = False;
+            assigned = False
             for scene in bpy.data.scenes:
                 if scene.arm_export and scene.world is not None:
                     if scene.world.name == world.name:
-                        assigned = True;
-                        break;
+                        assigned = True
+                        break
 
             #if scene.arm_export and world is not None and world not in worlds:
             # Only export worlds from enabled scenes and with fake users
diff --git a/armory/blender/arm/material/make_attrib.py b/armory/blender/arm/material/make_attrib.py
index 079a0180f6..a40556cdd1 100644
--- a/armory/blender/arm/material/make_attrib.py
+++ b/armory/blender/arm/material/make_attrib.py
@@ -81,7 +81,13 @@ def write_tex_coords(con_mesh: ShaderContext, vert: Shader, frag: Shader, tese:
                 make_particle.write_tilesheet(vert)
             else:
                 vert.add_uniform('vec2 tilesheetOffset', '_tilesheetOffset')
-                vert.write_attrib('texCoord = tex * texUnpack + tilesheetOffset;')
+                vert.add_uniform('vec2 tilesheetFlip', '_tilesheetFlip')
+                vert.add_uniform('vec2 tilesheetTiles', '_tilesheetTiles')
+                vert.write_attrib('vec2 tileSize = vec2(1.0 / tilesheetTiles.x, 1.0 / tilesheetTiles.y);')
+                vert.write_attrib('vec2 tileUV = tex * texUnpack;')
+                vert.write_attrib('tileUV.x = mix(tileUV.x, tileSize.x - tileUV.x, tilesheetFlip.x);')
+                vert.write_attrib('tileUV.y = mix(tileUV.y, tileSize.y - tileUV.y, tilesheetFlip.y);')
+                vert.write_attrib('texCoord = tileUV + tilesheetOffset;')
         else:
             vert.write_attrib('texCoord = tex * texUnpack;')
 
diff --git a/armory/blender/arm/material/make_mesh.py b/armory/blender/arm/material/make_mesh.py
index 0591398c76..e00b5ae6d7 100644
--- a/armory/blender/arm/material/make_mesh.py
+++ b/armory/blender/arm/material/make_mesh.py
@@ -499,7 +499,13 @@ def make_forward_solid(con_mesh):
         vert.add_uniform('float texUnpack', link='_texUnpack')
         if mat_state.material.arm_tilesheet_flag:
             vert.add_uniform('vec2 tilesheetOffset', '_tilesheetOffset')
-            vert.write('texCoord = tex * texUnpack + tilesheetOffset;')
+            vert.add_uniform('vec2 tilesheetFlip', '_tilesheetFlip')
+            vert.add_uniform('vec2 tilesheetTiles', '_tilesheetTiles')
+            vert.write('vec2 tileSize = vec2(1.0 / tilesheetTiles.x, 1.0 / tilesheetTiles.y);')
+            vert.write('vec2 tileUV = tex * texUnpack;')
+            vert.write('tileUV.x = mix(tileUV.x, tileSize.x - tileUV.x, tilesheetFlip.x);')
+            vert.write('tileUV.y = mix(tileUV.y, tileSize.y - tileUV.y, tilesheetFlip.y);')
+            vert.write('texCoord = tileUV + tilesheetOffset;')
         else:
             vert.write('texCoord = tex * texUnpack;')
 
diff --git a/armory/blender/arm/material/mat_batch.py b/armory/blender/arm/material/mat_batch.py
index 862a189628..299f96ec6b 100644
--- a/armory/blender/arm/material/mat_batch.py
+++ b/armory/blender/arm/material/mat_batch.py
@@ -59,6 +59,7 @@ def get_signature(mat, object: bpy.types.Object):
         sign += mat.arm_billboard
         sign += '_skin' if arm_utils.export_bone_data(object) else '0'
         sign += '_morph' if arm_utils.export_morph_targets(object) else '0'
+        # sign += '_tilesheet' if mat.arm_tilesheet_flag else '0'
         return sign
 
 def traverse_tree2(node, ar):
diff --git a/armory/blender/arm/n64/__init__.py b/armory/blender/arm/n64/__init__.py
new file mode 100644
index 0000000000..e00645e2fe
--- /dev/null
+++ b/armory/blender/arm/n64/__init__.py
@@ -0,0 +1,17 @@
+# N64 export module for Armory3D
+
+import arm
+
+if arm.is_reload(__name__):
+    # Reload submodules
+    from arm.n64 import utils
+    from arm.n64 import codegen
+    from arm.n64 import exporter
+    utils = arm.reload_module(utils)
+    codegen = arm.reload_module(codegen)
+    exporter = arm.reload_module(exporter)
+else:
+    arm.enable_reload(__name__)
+    from arm.n64 import utils
+    from arm.n64 import codegen
+    from arm.n64 import exporter
diff --git a/armory/blender/arm/n64/codegen.py b/armory/blender/arm/n64/codegen.py
new file mode 100644
index 0000000000..79b2979714
--- /dev/null
+++ b/armory/blender/arm/n64/codegen.py
@@ -0,0 +1,1370 @@
+"""
+N64 Code Generator - Thin IR→C Emitter.
+
+This module provides pure 1:1 IR→C mapping. All semantic analysis,
+type resolution, and event extraction happen in the Haxe macro
+(N64TraitMacro.hx).
+
+Pipeline:
+  Haxe Macro (all semantics) → JSON IR → codegen.py (1:1 emit) → C code
+
+Coordinate conversion for trait code (e.g., swizzle x,y,z → x,z,-y) and
+scale factors (0.015625 for Blender→N64, 64.0 for N64→Blender) are handled
+entirely in the Haxe macro via the c_code field. The emit_* functions only
+substitute placeholders like {0}, {1}, {v}, {obj}. The convert_* functions
+in utils.py handle static scene data export only.
+
+The IR schema (version 1):
+  {
+    ir_version: 1,
+    traits: {
+      TraitName: {
+        module: "arm.node.TraitName",
+        c_name: "arm_node_traitname",
+        members: [{name, type, ctype, default_value}],
+        events: {event_name: [IRNode...]},
+        meta: {uses_input, uses_transform, uses_time, buttons_used}
+      }
+    }
+  }
+
+IRNode types (1:1 with emit_* handlers):
+  Literals: int, float, string, bool, null, skip, c_literal
+  Variables: member, ident, field, label_field
+  Operators: assign, binop, unop
+  Control: if, block, var, return
+  Calls: call, scene_call, transform_call, math_call, input_call, physics_call, vec_call
+  Calls: koui_call, signal_call, global_signal_call
+  Utility: cast_call, debug_call, object_call, sprintf
+  Constructors: new, new_vec
+
+TraitMeta fields:
+  uses_input, uses_transform, mutates_transform, uses_time, uses_physics,
+  buttons_used: [str], button_events: [{event_name, button, c_button, event_type}]
+"""
+
+import json
+import os
+import math
+from typing import Dict, List, Optional
+
+from arm.n64.utils import (
+    convert_vec3_list, convert_quat_list, convert_scale_list,
+    SCALE_FACTOR
+)
+
+
+# =============================================================================
+# IR Emitter - Pure 1:1 translation
+# =============================================================================
+
+class IREmitter:
+    """Emits C code from IR nodes. No semantic analysis, just translation."""
+
+    def __init__(self, trait_name: str, c_name: str, member_names: List[str]):
+        self.trait_name = trait_name
+        self.c_name = c_name
+        self.member_names = member_names
+        self.data_type = f"{trait_name}Data"
+
+    def emit(self, node: Optional[Dict]) -> str:
+        """Emit C code for an IR node."""
+        if node is None:
+            return ""
+
+        node_type = node.get("type", "")
+        method_name = f"emit_{node_type}"
+        method = getattr(self, method_name, None)
+
+        if method:
+            return method(node)
+
+        # Unknown node type - log for debugging
+        print(f"[N64] Unknown IR node type: {node_type}")
+        return ""
+
+    def emit_list(self, nodes: List[Dict]) -> List[str]:
+        """Emit list of nodes, filtering out empty results."""
+        return [c for c in (self.emit(n) for n in nodes) if c]
+
+    def emit_statements(self, nodes: List[Dict], indent: str = "    ") -> str:
+        """Emit list of nodes as statements, adding semicolons where needed."""
+        lines = self.emit_list(nodes)
+        result = []
+        for line in lines:
+            # Add semicolon if line doesn't end with ; or } or is empty
+            if line and not line.rstrip().endswith((';', '}', '{')):
+                line = line + ';'
+            result.append(f"{indent}{line}")
+        return "\n".join(result)
+
+    # =========================================================================
+    # Literals
+    # =========================================================================
+
+    def emit_int(self, node: Dict) -> str:
+        return str(node.get("value", 0))
+
+    def emit_float(self, node: Dict) -> str:
+        val = node.get("value", 0.0)
+        # Ensure float format (e.g., 0.0f not 0f)
+        val_str = str(val)
+        if "." not in val_str:
+            val_str = f"{val}.0"
+        return f"{val_str}f"
+
+    def emit_string(self, node: Dict) -> str:
+        val = node.get("value", "")
+        return f'"{val}"' if val else "NULL"
+
+    def emit_sprintf(self, node: Dict) -> str:
+        """Pre-built sprintf from macro: { type: "sprintf", value: "format", args: [...] }
+        The macro has already built the format string and collected typed args.
+        We just translate to C."""
+        format_str = node.get("value", "")
+        args = node.get("args", [])
+
+        if not args:
+            # No args, just a literal string
+            return f'"{format_str}"'
+
+        # Emit each argument
+        arg_codes = [self.emit(arg) for arg in args]
+        args_str = ", ".join(arg_codes)
+
+        return f'_str_concat("{format_str}", {args_str})'
+
+    def emit_bool(self, node: Dict) -> str:
+        return "true" if node.get("value", False) else "false"
+
+    def emit_null(self, node: Dict) -> str:
+        return "NULL"
+
+    def emit_skip(self, node: Dict) -> str:
+        return ""
+
+    # =========================================================================
+    # Variables
+    # =========================================================================
+
+    def emit_member(self, node: Dict) -> str:
+        """Trait member access: data->member_name"""
+        name = node.get("value", "")
+        return f"(({self.data_type}*)data)->{name}"
+
+    def emit_ident(self, node: Dict) -> str:
+        """Identifier: local var, dt, object, etc."""
+        name = node.get("value", "")
+        if name == "object":
+            return "((ArmObject*)obj)"
+        if name == "dt":
+            return "dt"
+        return name
+
+    def emit_field(self, node: Dict) -> str:
+        """Field access: object.field or vec.x"""
+        obj = self.emit(node.get("object"))
+        field = node.get("value", "")
+
+        if not obj:
+            return field
+
+        # Transform field access
+        if "transform." in field:
+            subfield = field.replace("transform.", "")
+            return f"{obj}->transform.{subfield}"
+
+        # Object pointer access (ArmObject*, etc.)
+        if "ArmObject*" in obj or "ArmCamera*" in obj or "ArmLight*" in obj:
+            return f"{obj}->{field}"
+
+        return f"({obj}).{field}"
+
+    def emit_label_field(self, node: Dict) -> str:
+        """Label field access: label->pos_x, label->text, etc.
+        The macro has already mapped Koui names (posX) to C names (pos_x)."""
+        obj = self.emit(node.get("object"))
+        field = node.get("value", "")
+        if obj and field:
+            return f"{obj}->{field}"
+        return ""
+
+    def emit_c_literal(self, node: Dict) -> str:
+        """Literal C code from macro - pure 1:1."""
+        return node.get("c_code", "")
+
+    # =========================================================================
+    # Operators
+    # =========================================================================
+
+    def emit_assign(self, node: Dict) -> str:
+        """Assignment: target = value;"""
+        children = node.get("children", [])
+        if len(children) >= 2:
+            target = self.emit(children[0])
+            value = self.emit(children[1])
+            if target and value:
+                return f"{target} = {value};"
+        return ""
+
+    def emit_binop(self, node: Dict) -> str:
+        """Binary operator: left op right"""
+        op = node.get("value", "+")
+        children = node.get("children", [])
+        if len(children) >= 2:
+            left = self.emit(children[0])
+            right = self.emit(children[1])
+            if left and right:
+                # Compound assignments are statements, need semicolon
+                if op in ("+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="):
+                    return f"{left} {op} {right};"
+                return f"({left} {op} {right})"
+        return ""
+
+    def emit_unop(self, node: Dict) -> str:
+        """Unary operator: ++x or x++"""
+        op = node.get("value", "!")
+        children = node.get("children", [])
+        props = node.get("props", {})
+        postfix = props.get("postfix", False)
+
+        if children:
+            operand = self.emit(children[0])
+            if operand:
+                if postfix:
+                    return f"({operand}{op})"
+                return f"({op}{operand})"
+        return ""
+
+    # =========================================================================
+    # Control Flow
+    # =========================================================================
+
+    def emit_if(self, node: Dict) -> str:
+        """If statement."""
+        children = node.get("children", [])
+        props = node.get("props", {})
+
+        if not children:
+            return ""
+
+        cond = self.emit(children[0])
+        if not cond:
+            return ""
+
+        then_nodes = props.get("then", [])
+        then_code = self.emit_statements(then_nodes, "        ")
+
+        result = f"if ({cond}) {{\n{then_code}\n    }}"
+
+        else_nodes = props.get("else_")
+        if else_nodes:
+            else_code = self.emit_statements(else_nodes, "        ")
+            result += f" else {{\n{else_code}\n    }}"
+
+        return result
+
+    def emit_block(self, node: Dict) -> str:
+        """Block of statements - emit as statements with semicolons."""
+        children = node.get("children", [])
+        # Use emit_statements logic but without extra indent (caller handles indent)
+        lines = self.emit_list(children)
+        result = []
+        for line in lines:
+            # Add semicolon if line doesn't end with ; or } or {
+            if line and not line.rstrip().endswith((';', '}', '{')):
+                line = line + ';'
+            result.append(line)
+        return "\n".join(result)
+
+    def emit_var(self, node: Dict) -> str:
+        """Local variable declaration: ctype name = value;"""
+        name = node.get("value", "")
+        props = node.get("props", {})
+        children = node.get("children", [])
+        ctype = props.get("ctype", "float")
+
+        if children and len(children) > 0:
+            val = self.emit(children[0])
+            if val:
+                return f"{ctype} {name} = {val};"
+        return f"{ctype} {name};"
+
+    def emit_return(self, node: Dict) -> str:
+        """Return statement: return value; or just return;"""
+        children = node.get("children", [])
+        if children and len(children) > 0:
+            val = self.emit(children[0])
+            if val:
+                return f"return {val};"
+        return "return;"
+
+    # =========================================================================
+    # Function Calls
+    # =========================================================================
+
+    def emit_call(self, node: Dict) -> str:
+        """Function call - handles both generic calls and specific patterns."""
+        # Handle generic calls with value + children (from macro)
+        func_name = node.get("value", "")
+        if func_name:
+            children = node.get("children", [])
+            arg_strs = [self.emit(a) for a in children if self.emit(a)]
+            return f"{func_name}({', '.join(arg_strs)});"
+
+        # Legacy: method + args pattern
+        method = node.get("method", "")
+        args = node.get("args", [])
+        arg_strs = [self.emit(a) for a in args if self.emit(a)]
+
+        if method:
+            print(f"[N64 codegen] WARNING: Unhandled call '{method}' - add to macro")
+            return f"{method}({', '.join(arg_strs)})"
+        return ""
+
+    def emit_scene_call(self, node: Dict) -> str:
+        """Scene.setActive() -> scene_switch_to()"""
+        if "c_code" in node:
+            return node["c_code"] + ";"
+        args = node.get("args", [])
+        if args:
+            # Runtime lookup by name string
+            scene_expr = self.emit(args[0])
+            return f"scene_switch_to(scene_get_id_by_name({scene_expr}));"
+        return ""
+
+    def emit_transform_call(self, node: Dict) -> str:
+        """Transform calls - substitute placeholders in macro-provided c_code."""
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+
+        args = node.get("args", [])
+        arg_strs = [self.emit(a) for a in args]
+
+        # Substitute {0}, {1}, {2}, etc. with emitted args
+        # Provide default "1.0f" for missing optional args (e.g., move scale)
+        for i in range(10):
+            placeholder = "{" + str(i) + "}"
+            if placeholder in c_code:
+                val = arg_strs[i] if i < len(arg_strs) else "1.0f"
+                c_code = c_code.replace(placeholder, val)
+
+        return c_code
+
+    def emit_math_call(self, node: Dict) -> str:
+        """Math.sin() -> sinf(), etc."""
+        c_func = node.get("value", "")
+        args = node.get("args", [])
+        arg_strs = [self.emit(a) for a in args if self.emit(a)]
+        return f"{c_func}({', '.join(arg_strs)})"
+
+    def emit_input_call(self, node: Dict) -> str:
+        """Input calls - macro provides C code."""
+        return node.get("c_code", "0")
+
+    def emit_physics_call(self, node: Dict) -> str:
+        """Physics calls - substitute placeholders in macro-provided c_code."""
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+
+        obj_node = node.get("object")
+        args = node.get("args", [])
+
+        # Get object expression
+        obj = self.emit(obj_node) if obj_node else "((ArmObject*)obj)"
+
+        # Emit args
+        arg_strs = [self.emit(a) for a in args]
+
+        # Substitute {obj} and {0}, {1}, etc.
+        c_code = c_code.replace("{obj}", obj)
+        for i, arg in enumerate(arg_strs):
+            c_code = c_code.replace("{" + str(i) + "}", arg)
+
+        return c_code
+
+    def emit_koui_call(self, node: Dict) -> str:
+        """Koui UI calls - pure 1:1 translation from macro-provided c_func."""
+        c_func = node.get("c_func", "")
+        args = node.get("args", [])
+        obj_node = node.get("object")
+
+        if not c_func:
+            print("[N64 codegen] WARNING: koui_call missing c_func")
+            return ""
+
+        # Build argument list: object first (if present), then args
+        arg_strs = []
+        if obj_node:
+            obj = self.emit(obj_node)
+            if obj:
+                arg_strs.append(obj)
+
+        for a in args:
+            emitted = self.emit(a)
+            if emitted:
+                arg_strs.append(emitted)
+
+        return f"{c_func}({', '.join(arg_strs)})"
+
+    def emit_signal_call(self, node: Dict) -> str:
+        """Signal calls - connect/disconnect/emit on per-instance signals.
+
+        Uses c_code template from macro with placeholder substitution.
+        """
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+
+        props = node.get("props", {})
+        signal_name = props.get("signal_name", "")
+        callback = props.get("callback", "")
+
+        # Build signal pointer
+        signal_ptr = f"&(({self.data_type}*)data)->{signal_name}"
+        handler_name = f"{self.c_name}_{callback}" if callback else ""
+        struct_type = f"{self.c_name}_{signal_name}_payload_t"
+
+        # Substitute placeholders
+        c_code = c_code.replace("{signal_ptr}", signal_ptr)
+        c_code = c_code.replace("{handler}", handler_name)
+        c_code = c_code.replace("{struct_type}", struct_type)
+
+        # Substitute arg placeholders {0}, {1}, etc.
+        args = node.get("args", [])
+        for i, arg in enumerate(args):
+            c_code = c_code.replace("{" + str(i) + "}", self.emit(arg))
+
+        return c_code
+
+    def emit_global_signal_call(self, node: Dict) -> str:
+        """Global signal calls - uses c_code template from macro."""
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+
+        props = node.get("props", {})
+        global_signal = props.get("global_signal", "")
+        callback = props.get("callback", "")
+
+        # Build signal pointer and handler name
+        signal_ptr = f"&{global_signal}"
+        handler_name = f"{self.c_name}_{callback}" if callback else ""
+
+        # Substitute placeholders
+        c_code = c_code.replace("{signal_ptr}", signal_ptr)
+        c_code = c_code.replace("{handler}", handler_name)
+
+        # Substitute arg placeholders {0}, {1}, etc.
+        args = node.get("args", [])
+        for i, arg in enumerate(args):
+            c_code = c_code.replace("{" + str(i) + "}", self.emit(arg))
+
+        return c_code
+
+    def emit_cast_call(self, node: Dict) -> str:
+        """Std.int() -> (int32_t)value"""
+        cast = node.get("value", "(int32_t)")
+        args = node.get("args", [])
+        if args:
+            return f"{cast}({self.emit(args[0])})"
+        return ""
+
+    def emit_debug_call(self, node: Dict) -> str:
+        """trace() -> debugf()"""
+        args = node.get("args", [])
+        if not args:
+            return 'debugf("")'
+        arg_strs = [self.emit(a) for a in args if self.emit(a)]
+        if len(arg_strs) == 1:
+            return f'debugf("%s\\n", {arg_strs[0]})'
+        return f'debugf("{", ".join(["%s"] * len(arg_strs))}\\n", {", ".join(arg_strs)})'
+
+    def emit_object_call(self, node: Dict) -> str:
+        """Object calls - return macro-provided c_code."""
+        return node.get("c_code", "")
+
+    def emit_vec_call(self, node: Dict) -> str:
+        """Vec calls - substitute placeholders in macro-provided c_code."""
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+
+        obj_node = node.get("object")
+        args = node.get("args", [])
+
+        # Get the vector object
+        obj = self.emit(obj_node) if obj_node else ""
+        if not obj:
+            return ""
+
+        # Emit args
+        arg_strs = [self.emit(a) for a in args]
+
+        # Determine if we need parentheses around obj
+        is_compound = obj.startswith("(Arm")
+        v = f"({obj})" if is_compound else obj
+
+        # Substitute placeholders
+        c_code = c_code.replace("{v}", v)
+        c_code = c_code.replace("{vraw}", obj)  # Raw var name for normalize
+        for i, arg in enumerate(arg_strs):
+            c_code = c_code.replace("{" + str(i) + "}", arg)
+
+        return c_code
+
+    # =========================================================================
+    # Constructors
+    # =========================================================================
+
+    def emit_new(self, node: Dict) -> str:
+        """Generic constructor - fallback for non-Vec types."""
+        # Vec constructors are now handled by emit_new_vec
+        return ""
+
+    def emit_new_vec(self, node: Dict) -> str:
+        """Vec constructor with c_code template from macro."""
+        c_code = node.get("c_code", "")
+        if not c_code:
+            return ""
+        args = node.get("args", [])
+        arg_strs = [self.emit(a) for a in args]
+        # Substitute {0}, {1}, {2}, {3} with args
+        for i, arg in enumerate(arg_strs):
+            c_code = c_code.replace("{" + str(i) + "}", arg)
+        return c_code
+
+
+# =============================================================================
+# Trait Code Generator
+# =============================================================================
+
+class TraitCodeGenerator:
+    """Generates C code for a single trait from IR.
+
+    Pure 1:1 emitter - all data comes from macro-generated IR.
+    """
+
+    def __init__(self, name: str, ir: Dict, type_overrides: Dict = None):
+        self.name = name
+        self.c_name = ir.get("c_name", "")  # Must be provided by macro
+        self.members = ir.get("members", [])
+        self.events = ir.get("events", {})
+        self.meta = ir.get("meta", {})
+        self.type_overrides = type_overrides or {}
+
+        member_names = [m.get("name") for m in self.members]
+        self.emitter = IREmitter(name, self.c_name, member_names)
+
+    def _get_member_ctype(self, member: Dict) -> str:
+        """Get the C type for a member, applying overrides if present."""
+        name = member.get("name", "unknown")
+        ctype = member.get("ctype", "float")
+        # Apply type override if present
+        if self.name in self.type_overrides:
+            if name in self.type_overrides[self.name]:
+                ctype = self.type_overrides[self.name][name]
+        return ctype
+
+    def generate_data_struct(self) -> str:
+        """Generate the data struct for trait members and signals."""
+        signals = self.meta.get("signals", [])
+
+        if not self.members and not signals:
+            return ""
+
+        lines = [f"typedef struct {{"]
+
+        # Regular members
+        for m in self.members:
+            ctype = self._get_member_ctype(m)
+            name = m.get("name", "unknown")
+            lines.append(f"    {ctype} {name};")
+
+        # Signal members - each signal is an ArmSignal struct
+        for sig in signals:
+            sig_name = sig.get("name", "")
+            if sig_name:
+                lines.append(f"    ArmSignal {sig_name};")
+
+        lines.append(f"}} {self.name}Data;")
+
+        return "\n".join(lines)
+
+    def generate_signal_payload_structs(self) -> str:
+        """Generate payload struct types for signals with 2+ args.
+
+        Uses struct_def from macro-generated metadata.
+        """
+        signals = self.meta.get("signals", [])
+        lines = []
+
+        for sig in signals:
+            struct_def = sig.get("struct_def")
+            if struct_def:
+                lines.append(struct_def)
+                lines.append("")
+
+        return "\n".join(lines)
+
+    def generate_lifecycle_declarations(self) -> List[str]:
+        """Generate declarations for lifecycle event handlers."""
+        decls = []
+        # Match the typedefs in types.h:
+        # ArmTraitReadyFn: (void *entity, void *data) - no dt
+        # ArmTraitFixedUpdateFn: (void *entity, float dt, void *data)
+        # ArmTraitUpdateFn: (void *entity, float dt, void *data)
+        # ArmTraitLateUpdateFn: (void *entity, float dt, void *data)
+        # ArmTraitRemoveFn: (void *entity, void *data) - no dt
+        decls.append(f"void {self.c_name}_on_ready(void* obj, void* data);")
+        decls.append(f"void {self.c_name}_on_fixed_update(void* obj, float dt, void* data);")
+        decls.append(f"void {self.c_name}_on_update(void* obj, float dt, void* data);")
+        decls.append(f"void {self.c_name}_on_late_update(void* obj, float dt, void* data);")
+        decls.append(f"void {self.c_name}_on_remove(void* obj, void* data);")
+        return decls
+
+    def generate_button_event_declarations(self) -> List[str]:
+        """Generate declarations for button event handlers."""
+        decls = []
+        for event_name in self.events.keys():
+            if event_name.startswith("btn_"):
+                # Button events use TraitEventHandler signature: (obj, data, dt)
+                decls.append(f"void {self.c_name}_{event_name}(void* obj, void* data, float dt);")
+        return decls
+
+    def generate_contact_event_declarations(self) -> List[str]:
+        """Generate declarations for contact event handlers."""
+        decls = []
+        for event_name in self.events.keys():
+            if event_name.startswith("contact_"):
+                # Contact events use PhysicsContactHandler signature: (obj, data, other)
+                decls.append(f"void {self.c_name}_{event_name}(void* obj, void* data, ArmObject* other);")
+        return decls
+
+    def generate_signal_handler_declarations(self) -> List[str]:
+        """Generate declarations for signal handler callbacks - reads from events."""
+        decls = []
+        for event_name in self.events.keys():
+            if event_name.startswith("signal_"):
+                handler_name = event_name[7:]  # Strip "signal_" prefix
+                # ArmSignalHandler signature: void (*)(void* ctx, void* payload)
+                decls.append(f"void {self.c_name}_{handler_name}(void* ctx, void* payload);")
+        return decls
+
+    def generate_all_event_implementations(self) -> str:
+        """Generate C implementations for all event handlers."""
+        impl_lines = [f"// ========== {self.name} =========="]
+
+        # on_ready - no dt parameter
+        event_nodes = self.events.get("on_ready", [])
+        body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+        impl_lines.append(f"void {self.c_name}_on_ready(void* obj, void* data) {{")
+        impl_lines.append(body)
+        impl_lines.append("}")
+        impl_lines.append("")
+
+        # on_fixed_update - dt before data (ArmTraitFixedUpdateFn)
+        event_nodes = self.events.get("on_fixed_update", [])
+        body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+        impl_lines.append(f"void {self.c_name}_on_fixed_update(void* obj, float dt, void* data) {{")
+        impl_lines.append(body)
+        impl_lines.append("}")
+        impl_lines.append("")
+
+        # on_update - dt before data (ArmTraitUpdateFn)
+        event_nodes = self.events.get("on_update", [])
+        body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+        impl_lines.append(f"void {self.c_name}_on_update(void* obj, float dt, void* data) {{")
+        impl_lines.append(body)
+        impl_lines.append("}")
+        impl_lines.append("")
+
+        # on_late_update - dt before data (ArmTraitLateUpdateFn)
+        event_nodes = self.events.get("on_late_update", [])
+        body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+        impl_lines.append(f"void {self.c_name}_on_late_update(void* obj, float dt, void* data) {{")
+        impl_lines.append(body)
+        impl_lines.append("}")
+        impl_lines.append("")
+
+        # on_remove - no dt parameter
+        event_nodes = self.events.get("on_remove", [])
+        body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+        impl_lines.append(f"void {self.c_name}_on_remove(void* obj, void* data) {{")
+        impl_lines.append(body)
+        impl_lines.append("}")
+        impl_lines.append("")
+
+        # Button events - data before dt (TraitEventHandler signature)
+        for event_name in self.events.keys():
+            if event_name.startswith("btn_"):
+                event_nodes = self.events.get(event_name, [])
+                body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+                impl_lines.append(f"void {self.c_name}_{event_name}(void* obj, void* data, float dt) {{")
+                impl_lines.append(body)
+                impl_lines.append("}")
+                impl_lines.append("")
+
+        # Contact events - PhysicsContactHandler signature: (obj, data, other)
+        for event_name in self.events.keys():
+            if event_name.startswith("contact_"):
+                event_nodes = self.events.get(event_name, [])
+                body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+                impl_lines.append(f"void {self.c_name}_{event_name}(void* obj, void* data, ArmObject* other) {{")
+                impl_lines.append(f"    (void)other;  // Available as 'other' in body if needed")
+                impl_lines.append(body)
+                impl_lines.append("}")
+                impl_lines.append("")
+
+        # Signal handler events - use preamble from macro
+        signal_handlers = self.meta.get("signal_handlers", [])
+
+        for event_name in self.events.keys():
+            if event_name.startswith("signal_"):
+                event_nodes = self.events.get(event_name, [])
+                body = self.emitter.emit_statements(event_nodes, "    ") if event_nodes else "    // Empty"
+                handler_name = event_name[7:]  # Strip "signal_" prefix
+
+                # Find preamble from signal_handlers meta
+                # Default includes data cast so handler body can use 'data'
+                default_preamble = f"{self.name}Data* data = ({self.name}Data*)ctx; (void)payload;"
+                preamble = default_preamble
+                for sh in signal_handlers:
+                    if sh.get("handler_name") == handler_name:
+                        preamble = sh.get("preamble", default_preamble)
+                        break
+
+                impl_lines.append(f"void {self.c_name}_{handler_name}(void* ctx, void* payload) {{")
+                impl_lines.append(f"    {preamble}")
+                impl_lines.append(body)
+                impl_lines.append("}")
+                impl_lines.append("")
+
+        return "\n".join(impl_lines)
+
+
+# =============================================================================
+# JSON Loading Utilities
+# =============================================================================
+
+def load_traits_json(build_dir: str = None) -> dict:
+    """
+    Load the n64_traits.json file generated by the macro.
+
+    Args:
+        build_dir: Build directory path (defaults to arm.utils.build_dir())
+
+    Returns:
+        Parsed JSON dict with ir_version and traits
+    """
+    import os
+    import arm.utils
+
+    if build_dir is None:
+        build_dir = arm.utils.build_dir()
+
+    possible_paths = [
+        os.path.join(build_dir, "n64_traits.json"),
+        os.path.join(build_dir, "build", "n64_traits.json"),
+        os.path.join(build_dir, "debug", "n64_traits.json"),
+    ]
+
+    for path in possible_paths:
+        if os.path.exists(path):
+            try:
+                with open(path, 'r') as f:
+                    data = json.load(f)
+                    version = data.get("ir_version", 0)
+                    if version != 1:
+                        print(f"[N64] Warning: Expected IR version 1, got {version}")
+                    return data
+            except Exception as e:
+                print(f"[N64] Error loading {path}: {e}")
+
+    return {"ir_version": 0, "traits": {}}
+
+
+def get_trait_info(build_dir: str = None) -> dict:
+    """
+    Load traits JSON and return in expected format.
+
+    This is the main entry point for other code to get trait info.
+    Returns dict with:
+        ir_version: Schema version
+        traits: {TraitName: {module, c_name, members, events, meta}}
+    """
+    return load_traits_json(build_dir)
+
+
+# =============================================================================
+# Scene Data Conversion
+# =============================================================================
+
+def convert_scene_data(scene_data: dict) -> dict:
+    """Apply coordinate conversion to all scene data (modifies in place).
+
+    Converts from Blender coordinates (X=right, Y=forward, Z=up)
+    to N64/T3D coordinates (X=right, Y=up, Z=back).
+    """
+    for scene_name, scene in scene_data.items():
+        # Convert cameras
+        for cam in scene.get('cameras', []):
+            cam['pos'] = convert_vec3_list(cam['pos'])
+            cam['target'] = convert_vec3_list(cam['target'])
+
+        # Convert lights
+        for light in scene.get('lights', []):
+            light['dir'] = convert_vec3_list(light['dir'])
+            # Normalize direction
+            d = light['dir']
+            length = math.sqrt(d[0]**2 + d[1]**2 + d[2]**2)
+            if length > 0:
+                light['dir'] = [d[0]/length, d[1]/length, d[2]/length]
+
+        # Convert objects
+        for obj in scene.get('objects', []):
+            obj['pos'] = convert_vec3_list(obj['pos'])
+            obj['rot'] = convert_quat_list(obj['rot'])
+            obj['scale'] = convert_scale_list(obj['scale'])
+            if 'bounds_center' in obj:
+                obj['bounds_center'] = convert_vec3_list(obj['bounds_center'])
+                obj['bounds_radius'] = obj['bounds_radius'] * SCALE_FACTOR
+
+    return scene_data
+
+
+# =============================================================================
+# Traits File Generation
+# =============================================================================
+
+def write_traits_files(type_overrides: dict = None):
+    """Generate traits.h and traits.c from IR JSON using templates.
+
+    Args:
+        type_overrides: Optional dict of {trait_name: {member_name: ctype}} overrides
+
+    Returns:
+        dict with feature flags: {'has_ui': bool, 'has_physics': bool}
+    """
+    import arm.utils
+
+    build_dir = arm.utils.build_dir()
+
+    # Load traits from Haxe macro JSON
+    data = load_traits_json(build_dir)
+    traits = data.get("traits", {})
+
+    data_dir = os.path.join(build_dir, "n64", "src", "data")
+    os.makedirs(data_dir, exist_ok=True)
+    tmpl_dir = os.path.join(arm.utils.get_n64_deployment_path(), "src", "data")
+
+    if not traits:
+        print("[N64] No traits to generate, creating empty stubs")
+        # Generate empty stub files so Makefile doesn't fail
+        h_path = os.path.join(data_dir, "traits.h")
+        c_path = os.path.join(data_dir, "traits.c")
+        with open(h_path, 'w') as f:
+            f.write("// Auto-generated empty traits header\n#ifndef _TRAITS_H_\n#define _TRAITS_H_\n#endif\n")
+        with open(c_path, 'w') as f:
+            f.write("// Auto-generated empty traits implementation\n#include \"traits.h\"\n")
+        return {'has_ui': False, 'has_physics': False}
+
+    # Generate template substitution data and detect features
+    template_data, features = _prepare_traits_template_data(traits, type_overrides)
+
+    # Generate traits.h from template
+    h_tmpl_path = os.path.join(tmpl_dir, "traits.h.j2")
+    h_path = os.path.join(data_dir, "traits.h")
+    with open(h_tmpl_path, 'r') as f:
+        h_template = f.read()
+    h_content = h_template.format(**template_data)
+    with open(h_path, 'w') as f:
+        f.write(h_content)
+
+    # Generate traits.c from template
+    c_tmpl_path = os.path.join(tmpl_dir, "traits.c.j2")
+    c_path = os.path.join(data_dir, "traits.c")
+    with open(c_tmpl_path, 'r') as f:
+        c_template = f.read()
+    c_content = c_template.format(**template_data)
+    with open(c_path, 'w') as f:
+        f.write(c_content)
+
+    print(f"[N64] Generated {h_path} and {c_path}")
+    return features
+
+
+def _detect_features_in_nodes(nodes) -> dict:
+    """Recursively scan IR nodes for feature usage (UI, physics, etc.)."""
+    features = {'has_ui': False, 'has_physics': False}
+
+    def scan(node):
+        if not node or not isinstance(node, dict):
+            return
+        node_type = node.get("type", "")
+        if node_type == "koui_call" or node_type == "label_field":
+            features['has_ui'] = True
+        elif node_type == "physics_call":
+            features['has_physics'] = True
+
+        # Recursively scan children and args
+        for child in node.get("children", []):
+            scan(child)
+        for arg in node.get("args", []):
+            scan(arg)
+        if node.get("object"):
+            scan(node["object"])
+
+    if isinstance(nodes, list):
+        for n in nodes:
+            scan(n)
+    elif isinstance(nodes, dict):
+        scan(nodes)
+
+    return features
+
+
+def _prepare_traits_template_data(traits: dict, type_overrides: dict = None) -> tuple:
+    """Prepare data for traits.h.j2 and traits.c.j2 templates.
+
+    Uses TraitCodeGenerator for each trait to avoid code duplication.
+
+    Returns:
+        tuple of (template_data dict, features dict)
+    """
+    trait_data_structs = []
+    trait_declarations = []
+    event_handler_declarations = []
+    trait_implementations = []
+    global_signals = set()  # Collect unique global signals
+
+    # Track features across all traits
+    all_features = {'has_ui': False, 'has_physics': False}
+
+    for trait_name, trait_ir in traits.items():
+        gen = TraitCodeGenerator(trait_name, trait_ir, type_overrides)
+
+        # Header data: signal payload structs + data struct + declarations
+        payload_structs = gen.generate_signal_payload_structs()
+        if payload_structs:
+            trait_data_structs.append(payload_structs)
+
+        struct = gen.generate_data_struct()
+        if struct:
+            trait_data_structs.append(struct)
+
+        trait_declarations.extend(gen.generate_lifecycle_declarations())
+        event_handler_declarations.extend(gen.generate_button_event_declarations())
+        event_handler_declarations.extend(gen.generate_contact_event_declarations())
+        event_handler_declarations.extend(gen.generate_signal_handler_declarations())
+
+        # Collect global signals from this trait
+        meta = trait_ir.get("meta", {})
+        for gs in meta.get("global_signals", []):
+            global_signals.add(gs)
+
+        # Implementation data
+        trait_implementations.append(gen.generate_all_event_implementations())
+
+        # Detect features in events
+        events = trait_ir.get("events", {})
+        for event_name, event_nodes in events.items():
+            node_features = _detect_features_in_nodes(event_nodes)
+            if node_features['has_ui']:
+                all_features['has_ui'] = True
+            if node_features['has_physics']:
+                all_features['has_physics'] = True
+
+        # Check members for UI types (e.g., KouiLabel*)
+        members = trait_ir.get("members", [])
+        for m in members:
+            ctype = m.get("ctype", "")
+            if "Koui" in ctype or "Label" in ctype:
+                all_features['has_ui'] = True
+
+    # Generate global signal declarations with explicit zero initialization
+    global_signal_decls = []
+    for gs in sorted(global_signals):
+        global_signal_decls.append(f"ArmSignal {gs} = {{0}};")
+
+    template_data = {
+        "trait_data_structs": "\n\n".join(trait_data_structs),
+        "trait_declarations": "\n".join(trait_declarations),
+        "event_handler_declarations": "\n".join(event_handler_declarations),
+        "trait_implementations": "\n".join(trait_implementations),
+        "global_signals": "\n".join(global_signal_decls),
+    }
+
+    return template_data, all_features
+
+
+# =============================================================================
+# Scene Generation - These combine Blender data with trait IR
+# =============================================================================
+
+def _fmt_vec3(v: List[float]) -> str:
+    """Format a 3-element list as T3DVec3 initializer."""
+    return f'(T3DVec3){{{{ {v[0]:.6f}f, {v[1]:.6f}f, {v[2]:.6f}f }}}}'
+
+
+def generate_transform_block(prefix: str, pos: List[float],
+                             rot: List[float] = None,
+                             scale: List[float] = None,
+                             is_static: bool = False) -> List[str]:
+    """Generate C code for transform initialization."""
+    lines = []
+    lines.append(f'    {prefix}.transform.loc = (T3DVec3){{{{{pos[0]:.6f}f, {pos[1]:.6f}f, {pos[2]:.6f}f}}}};')
+
+    if rot:
+        lines.append(f'    {prefix}.transform.rot = (T3DQuat){{{{{rot[0]:.6f}f, {rot[1]:.6f}f, {rot[2]:.6f}f, {rot[3]:.6f}f}}}};')
+
+    if scale:
+        lines.append(f'    {prefix}.transform.scale = (T3DVec3){{{{{scale[0]:.6f}f, {scale[1]:.6f}f, {scale[2]:.6f}f}}}};')
+        dirty_count = "1" if is_static else "FB_COUNT"
+        lines.append(f'    {prefix}.transform.dirty = {dirty_count};')
+
+    return lines
+
+
+def generate_trait_block(prefix: str, traits: List[Dict],
+                         trait_info: dict, scene_name: str) -> List[str]:
+    """Generate C code for trait initialization on an object.
+
+    Pure 1:1 emitter - all data comes from macro-generated trait_info.
+    """
+    from arm.n64 import utils as n64_utils
+
+    lines = []
+    lines.append(f'    {prefix}.trait_count = {len(traits)};')
+    lines.append(f'    {prefix}.lifecycle_flags = 0;')
+
+    if len(traits) > 0:
+        lines.append(f'    {prefix}.traits = malloc(sizeof(ArmTrait) * {len(traits)});')
+
+        for t_idx, trait in enumerate(traits):
+            trait_class = trait["class_name"]
+
+            # Get trait IR - must exist, macro provides all data
+            trait_ir = trait_info.get("traits", {}).get(trait_class, {})
+            c_name = trait_ir.get("c_name", "")
+            meta = trait_ir.get("meta", {})
+
+            # Lifecycle hooks - use the full c_name
+            lines.append(f'    {prefix}.traits[{t_idx}].on_ready = {c_name}_on_ready;')
+            lines.append(f'    {prefix}.traits[{t_idx}].on_fixed_update = {c_name}_on_fixed_update;')
+            lines.append(f'    {prefix}.traits[{t_idx}].on_update = {c_name}_on_update;')
+            lines.append(f'    {prefix}.traits[{t_idx}].on_late_update = {c_name}_on_late_update;')
+            lines.append(f'    {prefix}.traits[{t_idx}].on_remove = {c_name}_on_remove;')
+
+            # Trait data
+            if n64_utils.trait_needs_data(trait_info, trait_class):
+                struct_name = f'{trait_class}Data'
+                instance_props = trait.get("props", {})
+                type_overrides = trait.get("type_overrides", {})
+                initializer = n64_utils.build_trait_initializer(
+                    trait_info, trait_class, scene_name, instance_props, type_overrides
+                )
+                lines.append(f'    {prefix}.traits[{t_idx}].data = malloc(sizeof({struct_name}));')
+                lines.append(f'    *({struct_name}*){prefix}.traits[{t_idx}].data = ({struct_name}){{{initializer}}};')
+            else:
+                lines.append(f'    {prefix}.traits[{t_idx}].data = NULL;')
+
+            # Subscribe to button events using structured metadata from macro
+            for btn_evt in meta.get("button_events", []):
+                event_name = btn_evt.get("event_name", "")
+                c_button = btn_evt.get("c_button", "N64_BTN_A")
+                event_type = btn_evt.get("event_type", "started")
+
+                handler_name = f"{c_name}_{event_name}"
+                obj_ptr = f"&{prefix}" if not prefix.startswith("&") else prefix
+                data_ptr = f"{prefix}.traits[{t_idx}].data"
+
+                lines.append(f'    trait_events_subscribe_{event_type}({c_button}, {handler_name}, {obj_ptr}, {data_ptr});')
+
+            # Note: Contact event subscriptions are generated separately in generate_contact_subscriptions_block
+            # after physics bodies are created
+    else:
+        lines.append(f'    {prefix}.traits = NULL;')
+
+    return lines
+
+
+def generate_camera_block(cameras: List[Dict], trait_info: dict, scene_name: str) -> str:
+    """Generate C code for all cameras in a scene."""
+    lines = []
+    for i, cam in enumerate(cameras):
+        prefix = f'cameras[{i}]'
+        lines.extend(generate_transform_block(prefix, cam["pos"]))
+        lines.append(f'    {prefix}.target = {_fmt_vec3(cam["target"])};')
+        lines.append(f'    {prefix}.fov = {cam["fov"]:.6f}f;')
+        lines.append(f'    {prefix}.near = {cam["near"]:.6f}f;')
+        lines.append(f'    {prefix}.far = {cam["far"]:.6f}f;')
+
+        lines.extend(generate_trait_block(prefix, cam.get("traits", []), trait_info, scene_name))
+    return '\n'.join(lines)
+
+
+def generate_light_block(lights: List[Dict], trait_info: dict, scene_name: str) -> str:
+    """Generate C code for all lights in a scene."""
+    from arm.n64 import utils as n64_utils
+
+    lines = []
+    for i, light in enumerate(lights):
+        prefix = f'lights[{i}]'
+        lines.append(f'    {prefix}.color[0] = {n64_utils.to_uint8(light["color"][0])};')
+        lines.append(f'    {prefix}.color[1] = {n64_utils.to_uint8(light["color"][1])};')
+        lines.append(f'    {prefix}.color[2] = {n64_utils.to_uint8(light["color"][2])};')
+        lines.append(f'    {prefix}.dir = {_fmt_vec3(light["dir"])};')
+
+        lines.extend(generate_trait_block(prefix, light.get("traits", []), trait_info, scene_name))
+    return '\n'.join(lines)
+
+
+def generate_object_block(objects: List[Dict], trait_info: dict, scene_name: str) -> str:
+    """Generate C code for all objects in a scene."""
+    lines = []
+
+    for i, obj in enumerate(objects):
+        prefix = f'objects[{i}]'
+        is_static = obj.get("is_static", False)
+        lines.extend(generate_transform_block(prefix, obj["pos"], obj["rot"], obj["scale"], is_static))
+        lines.append(f'    models_get({obj["mesh"]});')
+        lines.append(f'    {prefix}.dpl = models_get_dpl({obj["mesh"]});')
+        mat_count = "1" if is_static else "FB_COUNT"
+        lines.append(f'    {prefix}.model_mat = malloc_uncached(sizeof(T3DMat4FP) * {mat_count});')
+        lines.append(f'    {prefix}.visible = {str(obj["visible"]).lower()};')
+        lines.append(f'    {prefix}.is_static = {str(is_static).lower()};')
+        lines.append(f'    {prefix}.is_removed = false;')
+
+        bc = obj.get("bounds_center", [0, 0, 0])
+        br = obj.get("bounds_radius", 1.0)
+        pos = obj["pos"]
+        scale = obj["scale"]
+        lines.append(f'    {prefix}.bounds_center = {_fmt_vec3(bc)};')
+        lines.append(f'    {prefix}.bounds_radius = {br:.6f}f;')
+
+        # Initialize cached world bounds (will be updated when transform.dirty > 0)
+        world_center = [pos[0] + bc[0], pos[1] + bc[1], pos[2] + bc[2]]
+        max_scale = max(scale[0], scale[1], scale[2])
+        world_radius = br * max_scale
+        lines.append(f'    {prefix}.cached_world_center = {_fmt_vec3(world_center)};')
+        lines.append(f'    {prefix}.cached_world_radius = {world_radius:.6f}f;')
+
+        lines.append(f'    {prefix}.rigid_body = NULL;')
+
+        lines.extend(generate_trait_block(prefix, obj.get("traits", []), trait_info, scene_name))
+    return '\n'.join(lines)
+
+
+def generate_physics_block(objects: List[Dict], world_data: dict) -> str:
+    """Generate C code for physics initialization."""
+    lines = []
+
+    gravity = world_data.get("gravity", [0, 0, -9.81])
+    n64_gravity = convert_vec3_list(gravity)
+    lines.append(f'    physics_set_gravity({n64_gravity[0]:.6f}f, {n64_gravity[1]:.6f}f, {n64_gravity[2]:.6f}f);')
+    lines.append('')
+
+    # Physics debug drawing (from Blender's Debug Drawing panel)
+    debug_mode = world_data.get("physics_debug_mode", 0)
+    if debug_mode != 0:
+        lines.append(f'    // Physics debug drawing (from Blender Debug Drawing panel)')
+        lines.append(f'    physics_debug_init();')
+        lines.append(f'    physics_debug_set_mode({debug_mode});')
+        lines.append(f'    physics_debug_enable(true);')
+        lines.append('')
+
+    for i, obj in enumerate(objects):
+        rb = obj.get("rigid_body")
+        if rb is None:
+            continue
+
+        prefix = f'objects[{i}]'
+        obj_name = obj.get("name", f"object_{i}")
+
+        # Extract all physics parameters
+        mass = rb.get("mass", 1.0)
+        friction = rb.get("friction", 0.5)
+        restitution = rb.get("restitution", 0.0)
+        linear_damping = rb.get("linear_damping", 0.04)
+        angular_damping = rb.get("angular_damping", 0.1)
+        is_trigger = rb.get("is_trigger", False)
+        use_deactivation = rb.get("use_deactivation", True)
+        col_group = rb.get("collision_group", 1)
+        col_mask = rb.get("collision_mask", 1)
+
+        # Blender rigid body properties
+        blender_type = rb.get("rb_type", "ACTIVE")  # 'PASSIVE' or 'ACTIVE'
+        is_animated = rb.get("is_animated", False)   # Animated checkbox
+        is_dynamic = rb.get("is_dynamic", True)      # Dynamic checkbox
+
+        # Determine Oimo rigid body type:
+        # Passive -> Static
+        # Passive + Animated -> Kinematic
+        # Active -> Kinematic
+        # Active + Animated -> Kinematic
+        # Active + Animated + Dynamic -> Kinematic
+        # Active + Dynamic -> Dynamic
+        if blender_type == "PASSIVE":
+            if is_animated:
+                rb_type = "OIMO_RIGID_BODY_KINEMATIC"
+            else:
+                rb_type = "OIMO_RIGID_BODY_STATIC"
+        else:  # ACTIVE
+            if is_dynamic and not is_animated:
+                rb_type = "OIMO_RIGID_BODY_DYNAMIC"
+            else:
+                rb_type = "OIMO_RIGID_BODY_KINEMATIC"
+
+        shape = rb.get("shape", "box")
+
+        lines.append(f'    // Rigid body for {obj_name}')
+        lines.append('    {')
+        lines.append(f'        PhysicsBodyParams params = physics_body_params_default();')
+        lines.append(f'        params.mass = {mass:.6f}f;')
+        lines.append(f'        params.friction = {friction:.6f}f;')
+        lines.append(f'        params.restitution = {restitution:.6f}f;')
+        lines.append(f'        params.linear_damping = {linear_damping:.6f}f;')
+        lines.append(f'        params.angular_damping = {angular_damping:.6f}f;')
+        lines.append(f'        params.collision_group = {col_group};')
+        lines.append(f'        params.collision_mask = {col_mask};')
+        lines.append(f'        params.animated = {"true" if is_animated else "false"};')
+        lines.append(f'        params.trigger = {"true" if is_trigger else "false"};')
+        lines.append(f'        params.use_deactivation = {"true" if use_deactivation else "false"};')
+
+        if shape == "box":
+            half_extents = rb.get("half_extents", [0.5, 0.5, 0.5])
+            hx, hy, hz = half_extents[0], half_extents[1], half_extents[2]
+            lines.append(f'        physics_create_box_full(&{prefix}, {rb_type}, {hx:.6f}f, {hy:.6f}f, {hz:.6f}f, &params);')
+        elif shape == "sphere":
+            r = rb.get("radius", 0.5)
+            lines.append(f'        physics_create_sphere_full(&{prefix}, {rb_type}, {r:.6f}f, &params);')
+        elif shape == "capsule":
+            r = rb.get("radius", 0.5)
+            hh = rb.get("half_height", 0.5)
+            lines.append(f'        physics_create_capsule_full(&{prefix}, {rb_type}, {r:.6f}f, {hh:.6f}f, &params);')
+        elif shape == "mesh":
+            mesh_data = rb.get("mesh_data", {})
+            vertices = mesh_data.get("vertices", [])
+            indices = mesh_data.get("indices", [])
+            num_vertices = mesh_data.get("num_vertices", len(vertices))
+            index_count = len(indices)
+
+            if vertices and indices:
+                # Generate static arrays using OimoVec3 for vertices
+                lines.append(f'        static OimoVec3 {obj_name}_col_verts[] = {{')
+                for v_idx, v in enumerate(vertices):
+                    comma = ',' if v_idx < len(vertices) - 1 else ''
+                    lines.append(f'            {{{v[0]:.6f}f, {v[1]:.6f}f, {v[2]:.6f}f}}{comma}')
+                lines.append('        };')
+                lines.append(f'        static int16_t {obj_name}_col_indices[] = {{')
+                for t_idx in range(0, len(indices), 6):
+                    end_idx = min(t_idx + 6, len(indices))
+                    idx_str = ', '.join(str(indices[j]) for j in range(t_idx, end_idx))
+                    comma = ',' if end_idx < len(indices) else ''
+                    lines.append(f'            {idx_str}{comma}')
+                lines.append('        };')
+                lines.append(f'        physics_create_mesh_full(&{prefix}, {obj_name}_col_verts, {obj_name}_col_indices, {num_vertices}, {index_count}, &params);')
+            else:
+                # Fallback to box if mesh data is missing
+                lines.append(f'        physics_create_box_full(&{prefix}, {rb_type}, 0.5f, 0.5f, 0.5f, &params);')
+        else:
+            # Default to box
+            lines.append(f'        physics_create_box_full(&{prefix}, {rb_type}, 0.5f, 0.5f, 0.5f, &params);')
+
+        lines.append('    }')
+        lines.append('')
+
+    return '\n'.join(lines)
+
+
+def generate_contact_subscriptions_block(objects: List[Dict], trait_info: dict) -> str:
+    """Generate physics contact subscription calls after physics bodies exist.
+
+    This must be called AFTER physics bodies are created, so the rigid_body
+    pointers are valid when subscribing.
+
+    Pure 1:1 emitter - handler_name comes directly from macro's contact_events.
+    """
+    lines = []
+    has_subscriptions = False
+
+    for i, obj in enumerate(objects):
+        traits = obj.get("traits", [])
+        prefix = f'objects[{i}]'
+
+        for t_idx, trait in enumerate(traits):
+            trait_class = trait["class_name"]
+            trait_ir = trait_info.get("traits", {}).get(trait_class, {})
+            meta = trait_ir.get("meta", {})
+
+            for contact_evt in meta.get("contact_events", []):
+                handler_name = contact_evt.get("handler_name", "")
+                is_subscribe = contact_evt.get("subscribe", True)
+
+                if is_subscribe and handler_name:
+                    if not has_subscriptions:
+                        lines.append('    // Physics contact event subscriptions')
+                        has_subscriptions = True
+
+                    obj_ptr = f"&{prefix}" if not prefix.startswith("&") else prefix
+                    data_ptr = f"{prefix}.traits[{t_idx}].data"
+                    lines.append(f'    physics_contact_subscribe({prefix}.rigid_body, {handler_name}, {obj_ptr}, {data_ptr});')
+
+    if not has_subscriptions:
+        return ""
+
+    return '\n'.join(lines)
+
+
+def generate_scene_traits_block(traits: List[Dict], trait_info: dict, scene_name: str) -> str:
+    """Generate C code for scene-level traits.
+
+    Pure 1:1 emitter - all data comes from macro-generated trait_info.
+    """
+    if not traits:
+        return "    // No scene-level traits"
+
+    lines = []
+    lines.append(f'    static ArmTrait scene_traits[{len(traits)}];')
+
+    for i, trait in enumerate(traits):
+        trait_class = trait["class_name"]
+
+        # Get trait IR - must exist, macro provides all data
+        trait_ir = trait_info.get("traits", {}).get(trait_class, {})
+        c_name = trait_ir.get("c_name", "")
+        meta = trait_ir.get("meta", {})
+
+        lines.append(f'    scene_traits[{i}].on_ready = {c_name}_on_ready;')
+        lines.append(f'    scene_traits[{i}].on_fixed_update = {c_name}_on_fixed_update;')
+        lines.append(f'    scene_traits[{i}].on_update = {c_name}_on_update;')
+        lines.append(f'    scene_traits[{i}].on_late_update = {c_name}_on_late_update;')
+        lines.append(f'    scene_traits[{i}].on_remove = {c_name}_on_remove;')
+
+        from arm.n64 import utils as n64_utils
+        if n64_utils.trait_needs_data(trait_info, trait_class):
+            struct_name = f'{trait_class}Data'
+            instance_props = trait.get("props", {})
+            type_overrides = trait.get("type_overrides", {})
+            initializer = n64_utils.build_trait_initializer(
+                trait_info, trait_class, scene_name, instance_props, type_overrides
+            )
+            lines.append(f'    scene_traits[{i}].data = malloc(sizeof({struct_name}));')
+            lines.append(f'    *({struct_name}*)scene_traits[{i}].data = ({struct_name}){{{initializer}}};')
+        else:
+            lines.append(f'    scene_traits[{i}].data = NULL;')
+
+        # Subscribe to button events using structured metadata from macro
+        for btn_evt in meta.get("button_events", []):
+            event_name = btn_evt.get("event_name", "")
+            c_button = btn_evt.get("c_button", "N64_BTN_A")
+            event_type = btn_evt.get("event_type", "started")
+
+            handler_name = f"{c_name}_{event_name}"
+            lines.append(f'    trait_events_subscribe_{event_type}({c_button}, {handler_name}, scene, scene_traits[{i}].data);')
+
+    lines.append(f'    scene->traits = scene_traits;')
+    return '\n'.join(lines)
diff --git a/armory/blender/arm/n64/exporter.py b/armory/blender/arm/n64/exporter.py
new file mode 100644
index 0000000000..9d3a436bb5
--- /dev/null
+++ b/armory/blender/arm/n64/exporter.py
@@ -0,0 +1,1020 @@
+import os
+import subprocess
+import math
+import shutil
+import bpy
+
+import arm
+import arm.utils
+import arm.log as log
+
+from arm.n64 import codegen
+from arm.n64 import utils as n64_utils
+
+if arm.is_reload(__name__):
+    arm.utils = arm.reload_module(arm.utils)
+    log = arm.reload_module(log)
+    codegen = arm.reload_module(codegen)
+    n64_utils = arm.reload_module(n64_utils)
+else:
+    arm.enable_reload(__name__)
+
+
+class N64Exporter:
+    """N64 Exporter - Exports Armory scenes to N64 C code."""
+
+    def __init__(self):
+        self.scene_data = {}
+        self.exported_meshes = {}
+        self.exported_fonts = {}    # Track exported fonts: {font_name: font_path}
+        self.trait_info = {}        # Trait metadata from macro JSON
+        self.has_physics = False    # Track if any rigid bodies are exported
+        self.has_ui = False         # Track if any UI elements are used
+
+
+    @classmethod
+    def export_project(cls):
+        exporter = cls()
+        exporter.export()
+
+
+    @classmethod
+    def publish_project(cls):
+        exporter = cls()
+        exporter.publish()
+
+
+    @classmethod
+    def play_project(cls):
+        exporter = cls()
+        exporter.play()
+
+
+    def convert_materials_to_f3d(self):
+        """Convert materials to F3D format (requires Fast64 addon)."""
+        try:
+            # Check if F3D addon is available
+            if not hasattr(bpy.ops.scene, 'f3d_convert_to_bsdf'):
+                log.warn('Fast64 addon not found - skipping F3D material conversion')
+                return False
+
+            bpy.ops.scene.f3d_convert_to_bsdf(
+                direction='F3D',
+                converter_type='All',
+                backup=False,
+                put_alpha_into_color=False,
+                use_recommended=True,
+                lights_for_colors=False,
+                default_to_fog=False,
+                set_rendermode_without_fog=False
+            )
+            return True
+        except Exception as e:
+            log.warn(f'F3D material conversion failed: {e}')
+            return False
+
+
+    def make_directories(self):
+        build_dir = arm.utils.build_dir()
+        os.makedirs(f'{build_dir}/n64', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/assets', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/data', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/events', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/iron', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/iron/object', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/iron/system', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/oimo', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/scenes', exist_ok=True)
+        os.makedirs(f'{build_dir}/n64/src/system', exist_ok=True)
+
+
+    def export_meshes(self):
+        build_dir = arm.utils.build_dir()
+        assets_dir = f'{build_dir}/n64/assets'
+
+        self.exported_meshes = {}
+
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+
+            n64_utils.deselect_from_all_viewlayers()
+            main_scene = bpy.context.scene
+            main_view_layer = bpy.context.view_layer
+
+            for obj in scene.objects:
+                bpy.ops.object.select_all(action='DESELECT')
+                bpy.context.view_layer.update()
+
+                if obj.type != 'MESH':
+                    continue
+
+                mesh = obj.data
+                if mesh in self.exported_meshes:
+                    continue
+
+                mesh_name = arm.utils.safesrc(mesh.name)
+                model_output_path = os.path.join(assets_dir, f'{mesh_name}.gltf')
+
+                orig_loc = obj.location.copy()
+                orig_rot = obj.rotation_euler.copy()
+                orig_scale = obj.scale.copy()
+
+                obj.location = (0.0, 0.0, 0.0)
+                obj.rotation_euler = (0.0, 0.0, 0.0)
+                obj.scale = (1.0, 1.0, 1.0)
+
+                bpy.context.window.scene = scene
+                bpy.context.window.view_layer = scene.view_layers[0]
+
+                bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1) # HACK: force delay to properly export meshes from other scenes
+                bpy.context.view_layer.update()
+
+                obj.select_set(True)
+
+                bpy.ops.export_scene.gltf(
+                    filepath=model_output_path,
+                    export_format='GLTF_SEPARATE',
+                    export_extras=True,
+                    use_selection=True,
+                    export_yup=True
+                )
+
+                obj.location = orig_loc
+                obj.rotation_euler = orig_rot
+                obj.scale = orig_scale
+
+                bpy.context.view_layer.update()
+                self.exported_meshes[mesh] = mesh_name
+
+            bpy.context.window.scene = main_scene
+            bpy.context.window.view_layer = main_view_layer
+
+
+    def _extract_traits(self, obj) -> list:
+        """Extract trait list from a Blender object/scene with property values."""
+        traits = []
+        if hasattr(obj, 'arm_traitlist'):
+            for trait in obj.arm_traitlist:
+                if not trait.enabled_prop:
+                    continue
+
+                # Get class name based on trait type
+                if trait.type_prop == 'Logic Nodes':
+                    if trait.node_tree_prop is not None:
+                        # Logic nodes: class name is the node tree name
+                        class_name = trait.node_tree_prop.name
+                    else:
+                        continue  # No node tree assigned
+                elif trait.type_prop == 'Haxe Script' or trait.type_prop == 'Bundled Script':
+                    if trait.class_name_prop:
+                        class_name = trait.class_name_prop
+                    else:
+                        continue  # No class assigned
+                else:
+                    continue  # Unsupported trait type for N64
+
+                prop_data = n64_utils.extract_blender_trait_props(trait)
+                traits.append({
+                    "class_name": class_name,
+                    "type": trait.type_prop,
+                    "props": prop_data['values'],
+                    "type_overrides": prop_data['types']
+                })
+        return traits
+
+
+    def build_scene_data(self, scene):
+        scene_name = arm.utils.safesrc(scene.name).lower()
+        scene_traits = self._extract_traits(scene)
+
+        # Get gravity from scene (Blender's scene.gravity is the actual gravity vector)
+        gravity = [0.0, -9.81, 0.0]  # Default gravity
+        if hasattr(scene, 'gravity'):
+            gravity = [scene.gravity[0], scene.gravity[1], scene.gravity[2]]
+
+        # Get physics debug draw mode from Armory settings
+        debug_draw_mode = n64_utils.get_physics_debug_mode()
+
+        # Safe access to Fast64 ambient color with fallback
+        try:
+            ambient_color = list(scene.fast64.renderSettings.ambientColor)
+        except (AttributeError, KeyError):
+            ambient_color = [0.2, 0.2, 0.2]  # Default ambient
+
+        self.scene_data[scene_name] = {
+            "world": {
+                "clear_color": n64_utils.get_clear_color(scene),
+                "ambient_color": ambient_color,
+                "gravity": gravity,
+                "physics_debug_mode": debug_draw_mode
+            },
+            "cameras": [],
+            "lights": [],
+            "objects": [],
+            "traits": scene_traits
+        }
+
+        for obj in scene.objects:
+            if obj.type == 'CAMERA':
+                # Raw Blender coordinates - codegen.py will transform later
+                cam_dir = obj.rotation_euler.to_matrix().col[2]
+                cam_target = [
+                    obj.location[0] - cam_dir[0],
+                    obj.location[1] - cam_dir[1],
+                    obj.location[2] - cam_dir[2]
+                ]
+                sensor = max(obj.data.sensor_width, obj.data.sensor_height)
+                cam_fov = math.degrees(2 * math.atan((sensor * 0.5) / obj.data.lens))
+
+                self.scene_data[scene_name]["cameras"].append({
+                    "name": arm.utils.safesrc(obj.name),
+                    "pos": list(obj.matrix_world.to_translation()),  # World position (flattened)
+                    "target": cam_target,
+                    "fov": cam_fov,
+                    "near": obj.data.clip_start,
+                    "far": obj.data.clip_end,
+                    "traits": self._extract_traits(obj)
+                })
+            elif obj.type == 'LIGHT':  # TODO: support multiple light types [Point and Sun]
+                # Raw Blender direction - codegen.py will transform and normalize
+                light_dir = obj.rotation_euler.to_matrix().col[2]
+
+                self.scene_data[scene_name]["lights"].append({
+                    "name": arm.utils.safesrc(obj.name),
+                    "pos": list(obj.matrix_world.to_translation()),
+                    "color": list(obj.data.color),
+                    "dir": list(light_dir),
+                    "traits": self._extract_traits(obj)
+                })
+            elif obj.type == 'MESH':
+                mesh = obj.data
+                if mesh not in self.exported_meshes:
+                    log.warn(f'Object "{obj.name}": mesh not exported, skipping')
+                    continue
+                mesh_name = self.exported_meshes[mesh]
+
+                # Raw Blender coordinates - codegen.py will transform later
+                # Export rotation as quaternion (XYZW order for T3D)
+                quat = obj.matrix_world.to_quaternion()
+
+                # Compute bounding sphere from mesh's bounding box (local space)
+                # bound_box is 8 corners of the AABB in local coordinates
+                bb = obj.bound_box
+                min_corner = [min(v[i] for v in bb) for i in range(3)]
+                max_corner = [max(v[i] for v in bb) for i in range(3)]
+                bounds_center = [
+                    (min_corner[0] + max_corner[0]) * 0.5,
+                    (min_corner[1] + max_corner[1]) * 0.5,
+                    (min_corner[2] + max_corner[2]) * 0.5
+                ]
+                # Radius is distance from center to corner
+                half_extents = [
+                    (max_corner[0] - min_corner[0]) * 0.5,
+                    (max_corner[1] - min_corner[1]) * 0.5,
+                    (max_corner[2] - min_corner[2]) * 0.5
+                ]
+                bounds_radius = math.sqrt(
+                    half_extents[0]**2 + half_extents[1]**2 + half_extents[2]**2
+                )
+
+                # Extract rigid body data (N64 supports box, sphere, and capsule)
+                rigid_body_data = None
+                wrd = bpy.data.worlds['Arm']
+                if obj.rigid_body is not None and wrd.arm_physics != 'Disabled':
+                    rb = obj.rigid_body
+                    shape = rb.collision_shape
+
+                    # N64 supports BOX, SPHERE, CAPSULE, and MESH (static only)
+                    rb_mesh_data = None
+                    if shape == 'SPHERE':
+                        rb_shape = "sphere"
+                        # Calculate sphere radius from bounding box (max half-extent * max scale)
+                        max_scale = max(obj.scale)
+                        rb_radius = max(half_extents) * max_scale
+                        rb_half_extents = None
+                        rb_half_height = None
+                    elif shape == 'CAPSULE':
+                        rb_shape = "capsule"
+                        # Capsule: radius from X/Z, half-height from Y (in Blender coords)
+                        # Blender capsule is aligned along Z, we convert to Y-up for N64
+                        rb_radius = max(half_extents[0], half_extents[1]) * max(obj.scale[0], obj.scale[1])
+                        # Half-height is the cylinder part (total height - 2*radius) / 2
+                        total_height = half_extents[2] * 2.0 * obj.scale[2]
+                        rb_half_height = max(0.0, (total_height - 2.0 * rb_radius) / 2.0)
+                        rb_half_extents = None
+                    elif shape == 'MESH' and rb.type == 'PASSIVE':
+                        # Mesh collision only works for static (passive) bodies
+                        rb_shape = "mesh"
+                        rb_radius = None
+                        rb_half_height = None
+                        rb_half_extents = None
+                        # Extract mesh collision data
+                        rb_mesh_data = n64_utils.extract_collision_mesh(obj)
+                        if rb_mesh_data is None:
+                            log.warn(f'Object "{obj.name}": failed to extract mesh collision data, using BOX')
+                            rb_shape = "box"
+                            rb_half_extents = [
+                                half_extents[0] * obj.scale[0],
+                                half_extents[2] * obj.scale[2],
+                                half_extents[1] * obj.scale[1]
+                            ]
+                    else:
+                        # Everything else becomes a box
+                        rb_shape = "box"
+                        rb_radius = None
+                        rb_half_height = None
+                        # Half extents scaled by object scale
+                        # Convert from Blender (Z-up) to N64 (Y-up): swap Y and Z
+                        rb_half_extents = [
+                            half_extents[0] * obj.scale[0],
+                            half_extents[2] * obj.scale[2],  # Blender Z -> N64 Y
+                            half_extents[1] * obj.scale[1]   # Blender Y -> N64 Z
+                        ]
+                        if shape not in ('BOX', 'SPHERE', 'CAPSULE'):
+                            if shape == 'MESH' and rb.type != 'PASSIVE':
+                                log.warn(f'Object "{obj.name}": MESH collision shape only supported for static (passive) bodies, using BOX')
+                            else:
+                                log.warn(f'Object "{obj.name}": collision shape "{shape}" not supported on N64, using BOX')
+
+                    # Mass (0 = static)
+                    is_static = rb.type == 'PASSIVE'
+                    rb_mass = 0.0 if is_static else rb.mass
+
+                    # Collision groups/masks (convert from Blender's 20-bit to simple int)
+                    col_group = 0
+                    for i, b in enumerate(rb.collision_collections):
+                        if b:
+                            col_group |= (1 << i)
+
+                    col_mask = 0
+                    if hasattr(obj, 'arm_rb_collision_filter_mask'):
+                        for i, b in enumerate(obj.arm_rb_collision_filter_mask):
+                            if b:
+                                col_mask |= (1 << i)
+                    else:
+                        col_mask = 1  # Default mask
+
+                    rigid_body_data = {
+                        "shape": rb_shape,
+                        "mass": rb_mass,
+                        "friction": rb.friction,
+                        "restitution": rb.restitution,
+                        "linear_damping": rb.linear_damping,
+                        "angular_damping": rb.angular_damping,
+                        "collision_group": col_group,
+                        "collision_mask": col_mask,
+                        "is_trigger": getattr(obj, 'arm_rb_trigger', False),
+                        "rb_type": rb.type,  # 'PASSIVE' or 'ACTIVE'
+                        "is_animated": rb.kinematic,  # Animated checkbox
+                        "is_dynamic": rb.enabled,  # Dynamic checkbox
+                        "use_deactivation": rb.use_deactivation
+                    }
+
+                    if rb_shape == "sphere":
+                        rigid_body_data["radius"] = rb_radius
+                    elif rb_shape == "capsule":
+                        rigid_body_data["radius"] = rb_radius
+                        rigid_body_data["half_height"] = rb_half_height
+                    elif rb_shape == "mesh":
+                        rigid_body_data["mesh_data"] = rb_mesh_data
+                    else:
+                        rigid_body_data["half_extents"] = rb_half_extents
+
+                    self.has_physics = True
+
+                obj_data = {
+                    "name": arm.utils.safesrc(obj.name),
+                    "mesh": f'MODEL_{mesh_name.upper()}',
+                    "pos": list(obj.matrix_world.to_translation()),
+                    "rot": [quat.x, quat.y, quat.z, quat.w],
+                    "scale": list(obj.scale),
+                    "visible": not obj.hide_render,
+                    "bounds_center": bounds_center,
+                    "bounds_radius": bounds_radius,
+                    "traits": self._extract_traits(obj),
+                    "is_static": True  # Computed after trait_info is loaded
+                }
+
+                if rigid_body_data is not None:
+                    obj_data["rigid_body"] = rigid_body_data
+
+                self.scene_data[scene_name]["objects"].append(obj_data)
+
+
+    def write_makefile(self):
+        wrd = bpy.data.worlds['Arm']
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'Makefile.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'Makefile')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        scene_lines = []
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+            scene_name = arm.utils.safesrc(scene.name).lower()
+            scene_lines.append(f'    src/scenes/{scene_name}.c')
+        scene_files = '\\\n'.join(scene_lines)
+
+        # Physics source files (only if physics is used)
+        # Note: oimo is header-only, only physics.c and geometry.c need compilation
+        # physics_debug.c is only included if debug drawing is enabled
+        if self.has_physics:
+            physics_debug_mode = n64_utils.get_physics_debug_mode()
+            if physics_debug_mode > 0:
+                physics_sources = '''src +=\\
+    src/events/physics_events.c \\
+    src/oimo/physics.c \\
+    src/oimo/debug/physics_debug.c \\
+    src/oimo/collision/geometry/geometry.c'''
+            else:
+                physics_sources = '''src +=\\
+    src/oimo/physics.c \\
+    src/events/physics_events.c \\
+    src/oimo/collision/geometry/geometry.c'''
+        else:
+            physics_sources = '# No physics'
+
+        # UI source files (only if Koui UI elements are used)
+        if self.has_ui:
+            koui_sources = '''src +=\\
+    src/koui/koui.c \\
+    src/data/fonts.c'''
+        else:
+            koui_sources = '# No UI'
+
+        output = tmpl_content.format(
+            tiny3d_path=os.path.join(arm.utils.get_sdk_path(), 'lib', 'tiny3d').replace('\\', '/'),
+            game_title=arm.utils.safestr(wrd.arm_project_name),
+            scene_files=scene_files,
+            physics_sources=physics_sources,
+            koui_sources=koui_sources
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_types(self):
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'types.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'types.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        wrd = bpy.data.worlds.get('Arm')
+        debug_hud_define = '\n#define ARM_DEBUG_HUD' if wrd and wrd.arm_debug_console else ''
+        output = tmpl_content.format(debug_hud_define=debug_hud_define)
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+    def write_traits(self):
+        # Collect all type overrides from all trait instances across all scenes
+        type_overrides = self._collect_type_overrides()
+        features = codegen.write_traits_files(type_overrides)
+
+        # Update feature flags based on trait analysis
+        if features:
+            if features.get('has_ui'):
+                self.has_ui = True
+            if features.get('has_physics'):
+                self.has_physics = True
+
+    def _collect_type_overrides(self) -> dict:
+        """Collect all type overrides from trait instances across all scenes.
+
+        Returns:
+            dict mapping trait_class -> member_name -> c_type
+        """
+        overrides = {}
+
+        def collect_from_traits(traits):
+            for trait in traits:
+                class_name = trait.get("class_name", "")
+                trait_overrides = trait.get("type_overrides", {})
+                if trait_overrides:
+                    if class_name not in overrides:
+                        overrides[class_name] = {}
+                    overrides[class_name].update(trait_overrides)
+
+        for scene_data in self.scene_data.values():
+            # Scene-level traits
+            collect_from_traits(scene_data.get("traits", []))
+            # Camera traits
+            for cam in scene_data.get("cameras", []):
+                collect_from_traits(cam.get("traits", []))
+            # Light traits
+            for light in scene_data.get("lights", []):
+                collect_from_traits(light.get("traits", []))
+            # Object traits
+            for obj in scene_data.get("objects", []):
+                collect_from_traits(obj.get("traits", []))
+
+        return overrides
+
+
+    def write_engine(self):
+        n64_utils.copy_src('engine.c', 'src')
+
+        # Generate engine.h from template with physics flag
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'engine.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'engine.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        # Calculate physics debug mode from Blender settings
+        physics_debug_mode = n64_utils.get_physics_debug_mode()
+
+        output = tmpl_content.format(
+            enable_physics=1 if self.has_physics else 0,
+            enable_physics_debug=1 if physics_debug_mode > 0 else 0,
+            enable_ui=1 if self.has_ui else 0
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+    def write_koui(self):
+        """Copy Koui UI wrapper files if UI is used."""
+        if not self.has_ui:
+            return
+
+        # Copy koui directory
+        n64_utils.copy_dir('koui', 'src')
+
+    def write_fonts(self):
+        """Copy font files and generate fonts.c/fonts.h if UI is used."""
+        if not self.has_ui:
+            return
+
+        # Copy font files from project's Assets folder to n64/assets
+        project_assets = os.path.join(arm.utils.get_fp(), 'Assets')
+        n64_assets = os.path.join(arm.utils.build_dir(), 'n64', 'assets')
+        os.makedirs(n64_assets, exist_ok=True)
+
+        if os.path.exists(project_assets):
+            import glob
+            # Search recursively in Assets and all subdirectories
+            fonts = glob.glob(os.path.join(project_assets, '**', '*.ttf'), recursive=True)
+            for i, font_path in enumerate(fonts):
+                font_basename = os.path.splitext(os.path.basename(font_path))[0]
+                # Store with index
+                self.exported_fonts[font_basename] = font_basename
+                # Copy with original name
+                dst = os.path.join(n64_assets, f'{font_basename}.ttf')
+                shutil.copy(font_path, dst)
+                log.info(f'Copied font: {font_basename}.ttf')
+
+        # Generate fonts.c and fonts.h
+        if self.exported_fonts:
+            self.write_fonts_c()
+            self.write_fonts_h()
+
+    def write_fonts_c(self):
+        """Generate fonts.c from template."""
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'fonts.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'fonts.c')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        lines = []
+        for font_name in self.exported_fonts.values():
+            lines.append(f'    "rom:/{font_name}.font64"')
+        font_paths = ',\n'.join(lines)
+
+        output = tmpl_content.format(
+            font_paths=font_paths,
+            font_count=len(self.exported_fonts)
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+    def write_fonts_h(self):
+        """Generate fonts.h from template."""
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'fonts.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'fonts.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        lines = []
+        for i, font_name in enumerate(self.exported_fonts.values()):
+            # Create a safe enum name (uppercase, replace special chars with _)
+            enum_name = font_name.upper().replace('-', '_').replace(' ', '_')
+            lines.append(f'    FONT_{enum_name} = {i},')
+        font_enum_entries = '\n'.join(lines)
+
+        output = tmpl_content.format(
+            font_enum_entries=font_enum_entries,
+            font_count=len(self.exported_fonts)
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+    def write_physics(self):
+        """Copy physics engine files if physics is enabled."""
+        if not self.has_physics:
+            return
+
+        # Copy oimo library first (header-only physics engine)
+        # Must be done BEFORE rendering templates, since copy_dir clears the target
+        n64_utils.copy_dir('oimo', 'src')
+
+        # Render physics.c template (after copy_dir so it doesn't get deleted)
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'oimo', 'physics.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'oimo', 'physics.c')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        max_physics_bodies = n64_utils.get_config('max_physics_bodies', 32)
+        output = tmpl_content.format(max_physics_bodies=max_physics_bodies)
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+        # Render physics_events.h template
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'events', 'physics_events.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'events', 'physics_events.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        max_contact_subscribers = n64_utils.get_config('max_contact_subscribers', 4)
+        max_contact_bodies = n64_utils.get_config('max_contact_bodies', 16)
+        output = tmpl_content.format(
+            max_contact_subscribers=max_contact_subscribers,
+            max_contact_bodies=max_contact_bodies
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+        # Copy physics_events.c
+        n64_utils.copy_src('physics_events.c', 'src/events')
+
+        # Copy physics debug drawing files only if debug is enabled
+        if n64_utils.get_physics_debug_mode() > 0:
+            n64_utils.copy_src('physics_debug.h', 'src/oimo/debug')
+            n64_utils.copy_src('physics_debug.c', 'src/oimo/debug')
+
+
+    def write_main(self):
+        wrd = bpy.data.worlds['Arm']
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'main.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'main.c')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        # Get physics fixed timestep from Armory settings (default 0.02 = 50Hz)
+        fixed_timestep = getattr(wrd, 'arm_physics_fixed_step', 0.02)
+
+        # Get physics debug mode
+        physics_debug_mode = n64_utils.get_physics_debug_mode()
+
+        output = tmpl_content.format(
+            initial_scene_id=f'SCENE_{arm.utils.safesrc(wrd.arm_exporterlist[wrd.arm_exporterlist_index].arm_project_scene.name).upper()}',
+            fixed_timestep=fixed_timestep,
+            physics_debug_mode=physics_debug_mode
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_models(self):
+        self.write_models_c()
+        self.write_models_h()
+
+
+    def write_models_c(self):
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'models.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'models.c')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        lines = []
+        for model_name in self.exported_meshes.values():
+            lines.append(f'    "rom:/{model_name}.t3dm"')
+        mesh_paths = ',\n'.join(lines)
+
+        output = tmpl_content.format(
+            mesh_paths=mesh_paths,
+            model_count=len(self.exported_meshes)
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_models_h(self):
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'models.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'models.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        lines = []
+        for i, model_name in enumerate(self.exported_meshes.values()):
+            lines.append(f'    MODEL_{model_name.upper()} = {i},')
+        model_enum_entries = '\n'.join(lines)
+
+        output = tmpl_content.format(
+            model_enum_entries=model_enum_entries,
+            model_count=len(self.exported_meshes)
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_renderer(self):
+        n64_utils.copy_src('renderer.c', 'src')
+        n64_utils.copy_src('renderer.h', 'src')
+        n64_utils.copy_src('utils.h', 'src')
+
+
+    def write_scenes(self):
+        self.write_scenes_c()
+        self.write_scenes_h()
+
+        # Apply coordinate conversion (Blender Z-up → N64 Y-up)
+        codegen.convert_scene_data(self.scene_data)
+
+        # Write converted scene data to C files
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+            self.write_scene_c(scene)
+
+
+    def write_scene_c(self, scene):
+        scene_name = arm.utils.safesrc(scene.name).lower()
+        scene_data = self.scene_data[scene_name]
+
+        clear_color = scene_data['world']['clear_color']
+        ambient_color = scene_data['world']['ambient_color']
+
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'scenes', 'scene.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'scenes', f'{scene_name}.c')
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        scene_traits = scene_data.get('traits', [])
+
+        output = tmpl_content.format(
+            scene_name=scene_name,
+            cr=n64_utils.to_uint8(clear_color[0]),
+            cg=n64_utils.to_uint8(clear_color[1]),
+            cb=n64_utils.to_uint8(clear_color[2]),
+            ar=n64_utils.to_uint8(ambient_color[0]),
+            ag=n64_utils.to_uint8(ambient_color[1]),
+            ab=n64_utils.to_uint8(ambient_color[2]),
+            camera_count=len(scene_data['cameras']),
+            cameras_block=codegen.generate_camera_block(scene_data['cameras'], self.trait_info, scene_name),
+            light_count=len(scene_data['lights']),
+            lights_block=codegen.generate_light_block(scene_data['lights'], self.trait_info, scene_name),
+            object_count=len(scene_data['objects']),
+            objects_block=codegen.generate_object_block(scene_data['objects'], self.trait_info, scene_name),
+            physics_block=codegen.generate_physics_block(scene_data['objects'], scene_data['world']),
+            contact_subs_block=codegen.generate_contact_subscriptions_block(scene_data['objects'], self.trait_info),
+            scene_trait_count=len(scene_traits),
+            scene_traits_block=codegen.generate_scene_traits_block(scene_traits, self.trait_info, scene_name)
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_scenes_c(self):
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'scenes.c.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'scenes.c')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+
+        init_lines = []
+        init_switch_cases_lines = []
+        name_entry_lines = []
+        scene_count = 0
+
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+            scene_name = arm.utils.safesrc(scene.name).lower()
+            init_lines.append(f'    scene_{scene_name}_init(&g_scenes[SCENE_{scene_name.upper()}]);')
+            init_switch_cases_lines.append(f'        case SCENE_{scene_name.upper()}:\n'
+                                           f'            scene_{scene_name}_init(&g_scenes[SCENE_{scene_name.upper()}]);\n'
+                                           f'            break;')
+            # For runtime string -> SceneId lookup
+            name_entry_lines.append(f'    {{"{scene_name}", SCENE_{scene_name.upper()}}},')
+            scene_count += 1
+
+        scene_inits = '\n'.join(init_lines)
+        scene_init_switch_cases = '\n'.join(init_switch_cases_lines)
+        scene_name_entries = '\n'.join(name_entry_lines)
+
+        output = tmpl_content.format(
+            scene_inits=scene_inits,
+            scene_init_switch_cases=scene_init_switch_cases,
+            scene_name_entries=scene_name_entries,
+            scene_count=scene_count
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_scenes_h(self):
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'data', 'scenes.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'data', 'scenes.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        enum_lines = []
+        declaration_lines = []
+        scene_count = 0
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+            scene_name = arm.utils.safesrc(scene.name).lower()
+            enum_lines.append(f'    SCENE_{scene_name.upper()} = {scene_count},')
+            declaration_lines.append(f'void scene_{scene_name.lower()}_init(ArmScene *scene);')
+            scene_count += 1
+        scene_enum_entries = '\n'.join(enum_lines)
+        scene_declarations = '\n'.join(declaration_lines)
+
+        output = tmpl_content.format(
+            scene_enum_entries=scene_enum_entries,
+            scene_declarations=scene_declarations,
+            scene_count=scene_count
+        )
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+
+    def write_iron(self):
+        # Render trait_events.h template
+        tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), 'src', 'events', 'trait_events.h.j2')
+        out_path = os.path.join(arm.utils.build_dir(), 'n64', 'src', 'events', 'trait_events.h')
+
+        with open(tmpl_path, 'r', encoding='utf-8') as f:
+            tmpl_content = f.read()
+
+        max_button_subscribers = n64_utils.get_config('max_button_subscribers', 16)
+        output = tmpl_content.format(max_button_subscribers=max_button_subscribers)
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(output)
+
+        n64_utils.copy_src('events/trait_events.c', 'src')
+        n64_utils.copy_src('iron/object/transform.h', 'src')
+        n64_utils.copy_src('iron/object/transform.c', 'src')
+        n64_utils.copy_src('iron/object/object.h', 'src')
+        n64_utils.copy_src('iron/object/object.c', 'src')
+        n64_utils.copy_src('iron/system/input.c', 'src')
+        n64_utils.copy_src('iron/system/input.h', 'src')
+
+
+    def write_signal(self):
+        n64_utils.copy_src('signal.c', 'src/system')
+        n64_utils.copy_src('signal.h', 'src/system')
+
+
+    def reset_materials_to_bsdf(self):
+        """Reset materials back to BSDF format (requires Fast64 addon)."""
+        try:
+            if not hasattr(bpy.ops.scene, 'f3d_convert_to_bsdf'):
+                return False
+
+            bpy.ops.scene.f3d_convert_to_bsdf(
+                direction='BSDF',
+                converter_type='All',
+                backup=False,
+                put_alpha_into_color=False,
+                use_recommended=True,
+                lights_for_colors=False,
+                default_to_fog=False,
+                set_rendermode_without_fog=False
+            )
+            bpy.ops.outliner.orphans_purge(
+                do_local_ids=True,
+                do_linked_ids=True,
+                do_recursive=True
+            )
+            return True
+        except Exception as e:
+            log.warn(f'BSDF material reset failed: {e}')
+            return False
+
+
+    def run_make(self):
+        msys2_executable = arm.utils.get_msys2_bash_executable()
+        if len(msys2_executable) > 0:
+            try:
+                proc = subprocess.run(
+                    [
+                        msys2_executable,
+                        '--login',
+                        '-c',
+                        (
+                            f'export MSYSTEM=MINGW64; '
+                            f'export N64_INST="{arm.utils.get_n64_toolchain_path()}"; '
+                            f'export PATH="{arm.utils.get_n64_toolchain_path()}:{arm.utils.get_mingw64_path()}:$PATH"; '
+                            f'cd "{os.path.abspath(arm.utils.build_dir())}/n64" && make'
+                        )
+                    ],
+                    stdout=None,
+                    stderr=None,
+                    text=True
+                )
+            except Exception as e:
+                log.error(f'Error running make: {e}')
+                return False
+            if proc.returncode != 0:
+                log.error(f'Make process failed with exit code {proc.returncode}.')
+                return False
+        else:
+            log.error('MSYS2 Bash executable path is not set in Armory preferences.')
+            return False
+        log.info('Info: N64 make process completed successfully.')
+        return True
+
+
+    def export(self):
+        self.trait_info = codegen.get_trait_info()
+        if not self.trait_info.get('traits'):
+            log.warn("No traits found in n64_traits.json. Make sure arm_target_n64 is defined during build.")
+
+        self.convert_materials_to_f3d()
+
+        self.make_directories()
+        self.export_meshes()
+
+        # Build scene data early to determine if physics is needed
+        for scene in bpy.data.scenes:
+            if scene.library:
+                continue
+            self.build_scene_data(scene)
+
+        # Compute is_static for all objects after trait_info is loaded
+        n64_utils.compute_static_flags(self.scene_data, self.trait_info)
+
+        # Write traits FIRST to detect feature usage (UI, physics from traits)
+        self.write_traits()
+
+        self.write_makefile()
+        self.write_types()
+        self.write_engine()
+        self.write_physics()
+        self.write_koui()
+        self.write_fonts()
+        self.write_main()
+        self.write_models()
+        self.write_renderer()
+
+        self.write_scenes()
+        self.write_iron()
+        self.write_signal()
+
+        self.reset_materials_to_bsdf()
+        log.info('Info: N64 export completed.')
+
+
+    def publish(self):
+        self.export()
+        return self.run_make()
+
+
+    def play(self):
+        if not self.publish():
+            return
+
+        ares_emulator_executable = arm.utils.get_ares_emulator_executable()
+
+        if not ares_emulator_executable:
+            log.error('Ares emulator executable path is not set in Armory preferences.')
+            return
+
+        wrd = bpy.data.worlds['Arm']
+        rom_path = os.path.join(arm.utils.build_dir(), 'n64', f'{arm.utils.safestr(wrd.arm_project_name)}.z64')
+
+        subprocess.Popen(
+            [ares_emulator_executable, rom_path],
+            stdout=None,
+            stderr=None,
+            text=True
+        )
diff --git a/armory/blender/arm/n64/utils.py b/armory/blender/arm/n64/utils.py
new file mode 100644
index 0000000000..11d8b4d41e
--- /dev/null
+++ b/armory/blender/arm/n64/utils.py
@@ -0,0 +1,332 @@
+"""N64 Utilities"""
+
+import os
+import shutil
+from typing import List, Optional
+
+import bpy
+import bmesh
+
+import arm.utils
+import arm.log as log
+
+
+# =============================================================================
+# Coordinate Conversion: Blender (X,Y,Z) → N64 (X,Z,-Y)
+# =============================================================================
+
+SCALE_FACTOR: float = 0.015625  # 1/64 - Blender scale 1.0 → N64 scale 0.015625
+
+# Python value conversion
+def convert_vec3_list(vec: List[float]) -> List[float]:
+    return [vec[0], vec[2], -vec[1]]
+
+def convert_quat_list(quat: List[float]) -> List[float]:
+    return [quat[0], quat[2], -quat[1], quat[3]]
+
+def convert_scale_list(vec: List[float], factor: float = SCALE_FACTOR) -> List[float]:
+    return [vec[0] * factor, vec[2] * factor, vec[1] * factor]
+
+def c_float(value) -> str:
+    f = float(value)
+    s = str(f)
+    return f"{s}f" if '.' in s else f"{int(f)}.0f"
+
+
+# =============================================================================
+# Build Helpers
+# =============================================================================
+
+N64_CONFIG = {
+    'max_physics_bodies': 32,
+    'max_button_subscribers': 16,
+    'max_contact_subscribers': 4,   # Max handlers per rigid body
+    'max_contact_bodies': 16,       # Max rigid bodies with contact subscriptions
+}
+
+def get_physics_debug_mode() -> int:
+    wrd = bpy.data.worlds.get('Arm')
+    if wrd is None:
+        return 0
+    flags = [
+        ('arm_physics_dbg_draw_wireframe', 1),
+        ('arm_physics_dbg_draw_aabb', 2),
+        ('arm_physics_dbg_draw_contact_points', 8),
+        ('arm_physics_dbg_draw_constraints', 2048),
+        ('arm_physics_dbg_draw_constraint_limits', 4096),
+        ('arm_physics_dbg_draw_normals', 16384),
+        ('arm_physics_dbg_draw_axis_gizmo', 32768),
+        ('arm_physics_dbg_draw_raycast', 65536),
+    ]
+    return sum(bit for prop, bit in flags if getattr(wrd, prop, False))
+
+def get_config(key, default=None):
+    return N64_CONFIG.get(key, default)
+
+def copy_src(name, path=''):
+    tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), path, name)
+    out_path = os.path.join(arm.utils.build_dir(), 'n64', path, name)
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+    shutil.copyfile(tmpl_path, out_path)
+
+def copy_dir(name, path=''):
+    tmpl_path = os.path.join(arm.utils.get_n64_deployment_path(), path, name)
+    out_path = os.path.join(arm.utils.build_dir(), 'n64', path, name)
+    if os.path.exists(out_path):
+        shutil.rmtree(out_path)
+    shutil.copytree(tmpl_path, out_path)
+
+
+# =============================================================================
+# Blender Data Extraction
+# =============================================================================
+
+def get_clear_color(scene):
+    if scene.world is None:
+        return [0.051, 0.051, 0.051, 1.0]
+    if scene.world.node_tree is None:
+        c = scene.world.color
+        return [c[0], c[1], c[2], 1.0]
+    if 'Background' in scene.world.node_tree.nodes:
+        background_node = scene.world.node_tree.nodes['Background']
+        col = background_node.inputs[0].default_value
+        strength = background_node.inputs[1].default_value
+        ar = [col[0] * strength, col[1] * strength, col[2] * strength, col[3]]
+        return [max(min(v, 1.0), 0.0) for v in ar]
+    return [0.051, 0.051, 0.051, 1.0]
+
+def deselect_from_all_viewlayers():
+    bpy.context.view_layer.objects.active = None
+    bpy.ops.object.select_all(action='DESELECT')
+    for scene in bpy.data.scenes:
+        for view_layer in scene.view_layers:
+            view_layer.objects.active = None
+            for obj in scene.objects:
+                obj.select_set(False, view_layer=view_layer)
+            view_layer.update()
+    bpy.context.view_layer.update()
+
+def to_uint8(value):
+    return int(max(0, min(1, value)) * 255)
+
+def extract_blender_trait_props(trait) -> dict:
+    values = {}
+    types = {}
+    if hasattr(trait, 'arm_traitpropslist'):
+        for prop in trait.arm_traitpropslist:
+            if prop.type == 'Float':
+                values[prop.name] = prop.value_float
+            elif prop.type == 'Int':
+                values[prop.name] = prop.value_int
+            elif prop.type == 'Bool':
+                values[prop.name] = prop.value_bool
+            elif prop.type == 'String':
+                values[prop.name] = prop.value_string
+            elif prop.type == 'TSceneFormat':
+                if prop.value_scene is not None:
+                    values[prop.name] = prop.value_scene.name
+                    types[prop.name] = 'SceneId'
+    return {'values': values, 'types': types}
+
+
+# =============================================================================
+# Trait IR Helpers
+# =============================================================================
+
+def get_trait(trait_info: dict, trait_class: str) -> dict:
+    return trait_info.get("traits", {}).get(trait_class, {})
+
+def trait_needs_data(trait_info: dict, trait_class: str) -> bool:
+    """Check if a trait needs a data struct (has members or signals)."""
+    trait = get_trait(trait_info, trait_class)
+    has_members = len(trait.get("members", [])) > 0
+    has_signals = len(trait.get("meta", {}).get("signals", [])) > 0
+    return has_members or has_signals
+
+def build_trait_initializer(trait_info: dict, trait_class: str, current_scene: str,
+                            instance_props: dict = None, type_overrides: dict = None) -> str:
+    trait = get_trait(trait_info, trait_class)
+    members = trait.get("members", [])
+    signals = trait.get("meta", {}).get("signals", [])
+
+    if not members and not signals:
+        return ""
+
+    init_fields = []
+    instance_props = instance_props or {}
+    type_overrides = type_overrides or {}
+
+    # Initialize regular members
+    for member in members:
+        member_name = member.get("name", "")
+        if not member_name:
+            continue
+        member_ctype = type_overrides.get(member_name, member.get("ctype", "float"))
+        if member_name in instance_props:
+            c_value = to_c_literal(instance_props[member_name], member_ctype)
+        else:
+            c_value = extract_default_value(member.get("default_value"), member_ctype)
+        init_fields.append(f'.{member_name} = {c_value}')
+
+    # Initialize signals with zeroed state (no subscribers)
+    for sig in signals:
+        sig_name = sig.get("name", "")
+        if sig_name:
+            init_fields.append(f'.{sig_name} = {{0}}')
+
+    return ', '.join(init_fields)
+
+
+# =============================================================================
+# C Literal Helpers
+# =============================================================================
+
+def extract_default_value(node, member_ctype: str) -> str:
+    """Convert an IR node to a C literal string."""
+    if node is None:
+        return get_type_default(member_ctype)
+
+    if isinstance(node, dict):
+        node_type = node.get("type", "")
+        value = node.get("value")
+
+        if node_type == "int":
+            return c_float(value) if member_ctype == "float" else str(value)
+        elif node_type == "float":
+            return c_float(value)
+        elif node_type == "string":
+            if member_ctype == "SceneId":
+                return f"SCENE_{arm.utils.safesrc(str(value)).upper()}"
+            return f'"{value}"'
+        elif node_type == "bool":
+            return "true" if value else "false"
+        elif node_type == "null":
+            return "SCENE_UNKNOWN" if member_ctype == "SceneId" else "NULL"
+        elif node_type == "new":
+            return _extract_vec_constructor(value, node.get("args", []))
+
+    if isinstance(node, (int, float, str, bool)):
+        return to_c_literal(node, member_ctype)
+    return get_type_default(member_ctype)
+
+def _extract_vec_constructor(type_name: str, args: list) -> str:
+    def arg(i): return extract_default_value(args[i], "float") if i < len(args) else "0.0f"
+    if type_name == "Vec4":
+        return f"(ArmVec4){{{arg(0)}, {arg(1)}, {arg(2)}, {arg(3)}}}"
+    elif type_name == "Vec3":
+        return f"(ArmVec3){{{arg(0)}, {arg(1)}, {arg(2)}}}"
+    elif type_name == "Vec2":
+        return f"(ArmVec2){{{arg(0)}, {arg(1)}}}"
+    return "0"
+
+TYPE_DEFAULTS = {
+    "float": "0.0f", "int32_t": "0", "int": "0", "bool": "false",
+    "const char*": "NULL", "SceneId": "SCENE_UNKNOWN",
+    "ArmVec2": "(ArmVec2){0, 0}", "ArmVec3": "(ArmVec3){0, 0, 0}",
+    "ArmVec4": "(ArmVec4){0, 0, 0, 0}", "void*": "NULL",
+    "KouiLabel*": "NULL",
+}
+
+def get_type_default(ctype: str) -> str:
+    """Get the default C literal for a given C type."""
+    return TYPE_DEFAULTS.get(ctype, "0")
+
+def to_c_literal(value, ctype: str) -> str:
+    """Convert a Python value to a C literal string."""
+    if ctype == "float":
+        return c_float(value)
+    elif ctype in ("int32_t", "int"):
+        return str(int(value))
+    elif ctype == "bool":
+        return "true" if value else "false"
+    elif ctype == "const char*":
+        return f'"{value}"' if value else "NULL"
+    elif ctype == "SceneId":
+        return f"SCENE_{arm.utils.safesrc(str(value)).upper()}"
+    elif "Vec3" in ctype and isinstance(value, (list, tuple)) and len(value) >= 3:
+        return f"(ArmVec3){{{c_float(value[0])}, {c_float(value[1])}, {c_float(value[2])}}}"
+    elif "Vec2" in ctype and isinstance(value, (list, tuple)) and len(value) >= 2:
+        return f"(ArmVec2){{{c_float(value[0])}, {c_float(value[1])}}}"
+    return str(value)
+
+
+# =============================================================================
+# Static Object Detection
+# =============================================================================
+
+def compute_static_flags(scene_data: dict, trait_info: dict) -> None:
+    """Mark objects as static if no dynamic physics and no transform-mutating traits."""
+    traits_data = trait_info.get('traits', {})
+
+    def trait_mutates_transform(trait_class: str) -> bool:
+        return traits_data.get(trait_class, {}).get('meta', {}).get('mutates_transform', False)
+
+    for scene in scene_data.values():
+        for obj in scene.get("objects", []):
+            rb = obj.get("rigid_body")
+            # Object is NOT static if:
+            # - It has kinematic or dynamic physics (anything except pure Passive)
+            # - Passive + Animated = Kinematic (not static)
+            # - Active (any combo) = Kinematic or Dynamic (not static)
+            if rb:
+                blender_type = rb.get("rb_type", "ACTIVE")
+                is_animated = rb.get("is_animated", False)
+                # Only pure Passive (no Animated) is static for physics
+                is_physics_static = (blender_type == "PASSIVE" and not is_animated)
+            else:
+                is_physics_static = True  # No rigid body = static
+
+            any_trait_mutates = any(
+                trait_mutates_transform(t.get("class_name", ""))
+                for t in obj.get("traits", [])
+            )
+            obj["is_static"] = is_physics_static and not any_trait_mutates
+
+
+# =============================================================================
+# Collision Mesh
+# =============================================================================
+
+def extract_collision_mesh(obj: bpy.types.Object, max_triangles: int = 256) -> Optional[dict]:
+    """Extract triangulated mesh data for physics collision."""
+    if obj.type != 'MESH':
+        return None
+
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    obj_eval = obj.evaluated_get(depsgraph)
+    mesh = obj_eval.to_mesh()
+    if mesh is None:
+        return None
+
+    try:
+        bm = bmesh.new()
+        bm.from_mesh(mesh)
+        bmesh.ops.triangulate(bm, faces=bm.faces[:], quad_method='FIXED')
+
+        scale = obj.scale
+        vertices = []
+        for v in bm.verts:
+            scaled = [v.co.x * scale.x, v.co.y * scale.y, v.co.z * scale.z]
+            vertices.append(convert_vec3_list(scaled))
+
+        indices = []
+        for face in bm.faces:
+            if len(face.verts) == 3:
+                indices.extend([v.index for v in face.verts])
+            else:
+                log.warn(f'Object "{obj.name}": non-triangle face')
+
+        num_triangles = len(indices) // 3
+        if num_triangles > max_triangles:
+            log.warn(f'Object "{obj.name}": {num_triangles} triangles, limiting to {max_triangles}')
+            indices = indices[:max_triangles * 3]
+
+        bm.free()
+        return {
+            "vertices": vertices,
+            "indices": indices,
+            "num_vertices": len(vertices),
+            "num_triangles": len(indices) // 3
+        }
+    finally:
+        obj_eval.to_mesh_clear()
diff --git a/armory/blender/arm/props.py b/armory/blender/arm/props.py
index 89e897940b..956e7d7cdc 100644
--- a/armory/blender/arm/props.py
+++ b/armory/blender/arm/props.py
@@ -206,7 +206,7 @@ def init_properties():
                ('Oimo', 'Oimo', 'Oimo')],
         name="Physics Engine", default='Bullet', update=assets.invalidate_compiler_cache)
     bpy.types.World.arm_physics_fixed_step = FloatProperty(
-        name="Fixed Step", default=1/60, min=0, max=1,
+        name="Fixed Step", default=1/30, min=0, max=1,
         description="Physics steps for fixed update"
     )
     bpy.types.World.arm_physics_dbg_draw_wireframe = BoolProperty(
@@ -325,7 +325,8 @@ def init_properties():
     bpy.types.World.arm_verbose_output = BoolProperty(name="Verbose Output", description="Print additional information to the console during compilation", default=False)
     bpy.types.World.arm_runtime = EnumProperty(
         items=[('Krom', 'Krom', 'Krom'),
-               ('Browser', 'Browser', 'Browser')],
+               ('Browser', 'Browser', 'Browser'),
+               ('Ares', 'Ares', 'Ares')],
         name="Runtime", description="Runtime to use when launching the game", default='Krom', update=assets.invalidate_shader_cache)
     bpy.types.World.arm_loadscreen = BoolProperty(name="Loading Screen", description="Show asset loading progress on published builds", default=True)
     bpy.types.World.arm_vsync = BoolProperty(name="VSync", description="Vertical Synchronization", default=True, update=assets.invalidate_compiler_cache)
@@ -379,9 +380,6 @@ def init_properties():
             subtype='LAYER')
     bpy.types.Object.arm_relative_physics_constraint = BoolProperty(name="Relative Physics Constraint", description="Add physics constraint relative to the parent object or collection when spawned", default=False)
     bpy.types.Object.arm_animation_enabled = BoolProperty(name="Animation", description="Enable skinning & timeline animation", default=True)
-    bpy.types.Object.arm_tilesheet = StringProperty(name="Tilesheet", description="Set tilesheet animation", default='')
-    bpy.types.Object.arm_tilesheet_action = StringProperty(name="Tilesheet Action", description="Set startup action", default='')
-    bpy.types.Object.arm_use_custom_tilesheet_node = BoolProperty(name="Use custom tilesheet node", description="Use custom tilesheet shader node", default=False)
     # For speakers
     bpy.types.Speaker.arm_play_on_start = BoolProperty(name="Play on Start", description="Play this sound automatically", default=False)
     bpy.types.Speaker.arm_loop = BoolProperty(name="Loop", description="Loop this sound", default=False)
@@ -409,6 +407,7 @@ def init_properties():
                ('Mobile', 'Mobile', 'Mobile'),
                ('Max', 'Max', 'Max'),
                ('2D/Baked', '2D/Baked', '2D/Baked'),
+               ('Fast64', 'Fast64', 'Fast64'),
                ],
         name="Preset", description="Render path preset", default='Desktop')
     bpy.types.World.arm_envtex_name = StringProperty(name="Environment Texture", default='')
diff --git a/armory/blender/arm/props_exporter.py b/armory/blender/arm/props_exporter.py
index 9384176090..a23044fcf8 100644
--- a/armory/blender/arm/props_exporter.py
+++ b/armory/blender/arm/props_exporter.py
@@ -62,6 +62,12 @@ def update_gapi_html5(self, context):
     bpy.data.worlds['Arm'].arm_recompile = True
     assets.invalidate_compiled_data(self, context)
 
+def update_gapi_n64(self, context):
+    if os.path.isdir(arm.utils.get_fp_build() + '/n64-build'):
+        shutil.rmtree(arm.utils.get_fp_build() + '/n64-build', onerror=remove_readonly)
+    bpy.data.worlds['Arm'].arm_recompile = True
+    assets.invalidate_compiled_data(self, context)
+
 class ArmExporterListItem(bpy.types.PropertyGroup):
     name: StringProperty(
            name="Name",
@@ -89,6 +95,7 @@ class ArmExporterListItem(bpy.types.PropertyGroup):
                  ('ios-hl', 'iOS (C)', 'ios-hl'),
                  ('android-hl', 'Android (C)', 'android-hl'),
                  ('node', 'Node (JS)', 'node'),
+                 ('n64', 'Nintendo 64', 'n64'),
                  ('custom', 'Custom', 'custom'),],
         name="Target", default='html5', description='Build platform')
 
@@ -132,6 +139,9 @@ class ArmExporterListItem(bpy.types.PropertyGroup):
         items = [('webgl', 'Auto', 'webgl'),
                  ('webgl', 'WebGL2', 'webgl')],
         name="Graphics API", default='webgl', description='Based on currently selected target', update=update_gapi_html5)
+    arm_gapi_n64: EnumProperty(
+        items = [('tiny3d', 'Tiny3D', 'tiny3d')],
+        name="Graphics API", default='tiny3d', description='Based on currently selected target', update=update_gapi_n64)
 
 class ArmExporterAndroidPermissionListItem(bpy.types.PropertyGroup):
     arm_android_permissions: EnumProperty(
diff --git a/armory/blender/arm/props_renderpath.py b/armory/blender/arm/props_renderpath.py
index 19809aa2e8..280af43b64 100644
--- a/armory/blender/arm/props_renderpath.py
+++ b/armory/blender/arm/props_renderpath.py
@@ -206,6 +206,44 @@ def update_preset(self, context):
         rpdat.arm_irradiance = False
         rpdat.arm_radiance = False
         rpdat.rp_pp = False
+    elif self.rp_preset == 'Fast64':
+        rpdat.rp_renderer = 'Forward' # TODO: use 'Fast64' when implemented
+        rpdat.rp_depthprepass = False
+        rpdat.arm_material_model = 'Mobile' # TODO: use 'Fast64' when implemented
+        rpdat.rp_shadows = True
+        rpdat.rp_shadowmap_cube = '256'
+        rpdat.rp_shadowmap_cascade = '512'
+        rpdat.rp_shadowmap_cascades = '1'
+        rpdat.rp_translucency_state = 'Off'
+        rpdat.rp_overlays_state = 'Off'
+        rpdat.rp_decals_state = 'Off'
+        rpdat.rp_sss_state = 'Off'
+        rpdat.rp_blending_state = 'Off'
+        rpdat.rp_depth_texture_state = 'Off'
+        rpdat.rp_draw_order = 'Auto'
+        rpdat.rp_hdr = False
+        rpdat.rp_background = 'Clear'
+        rpdat.rp_stereo = False
+        rpdat.rp_voxels = 'Off'
+        rpdat.rp_render_to_texture = False
+        rpdat.rp_supersampling = '1'
+        rpdat.rp_antialiasing = 'Off'
+        rpdat.rp_compositornodes = False
+        rpdat.rp_volumetriclight = False
+        rpdat.rp_ssgi = 'Off'
+        rpdat.arm_ssrs = False
+        rpdat.arm_micro_shadowing = False
+        rpdat.rp_ssr = False
+        rpdat.rp_bloom = False
+        rpdat.arm_bloom_quality = 'low'
+        rpdat.arm_bloom_anti_flicker = False
+        rpdat.rp_autoexposure = False
+        rpdat.rp_motionblur = 'Off'
+        rpdat.arm_rp_resolution = 'Display'
+        rpdat.arm_texture_filter = 'Linear'
+        rpdat.arm_irradiance = False
+        rpdat.arm_radiance = False
+        rpdat.rp_pp = False
     update_renderpath(self, context)
 
 def update_renderpath(self, context):
diff --git a/armory/blender/arm/props_tilesheet.py b/armory/blender/arm/props_tilesheet.py
index d625087d3b..37b4744878 100644
--- a/armory/blender/arm/props_tilesheet.py
+++ b/armory/blender/arm/props_tilesheet.py
@@ -1,84 +1,124 @@
 import bpy
 from bpy.props import *
 
+
+class ArmTilesheetEventListItem(bpy.types.PropertyGroup):
+    """An event triggered on a specific frame within a tilesheet action."""
+    name: StringProperty(
+        name="Event Name",
+        description="Name of the event to trigger",
+        default="event")
+
+    frame_prop: IntProperty(
+        name="Frame",
+        description="Frame number when this event triggers",
+        default=0,
+        min=0)
+
+
 class ArmTilesheetActionListItem(bpy.types.PropertyGroup):
+    """An action (animation sequence) within a tilesheet with per-action properties."""
     name: StringProperty(
         name="Name",
-        description="A name for this item",
+        description="Name of this tilesheet action",
         default="Untitled")
 
     start_prop: IntProperty(
         name="Start",
-        description="A name for this item",
+        description="Starting frame index",
         default=0)
 
     end_prop: IntProperty(
         name="End",
-        description="A name for this item",
+        description="Ending frame index",
         default=0)
 
     loop_prop: BoolProperty(
         name="Loop",
-        description="A name for this item",
+        description="Whether this action should loop",
         default=True)
 
+    tilesx_prop: IntProperty(
+        name="Tiles X",
+        description="Number of horizontal tiles for this action",
+        default=1,
+        min=1)
+
+    tilesy_prop: IntProperty(
+        name="Tiles Y",
+        description="Number of vertical tiles for this action",
+        default=1,
+        min=1)
+
+    framerate_prop: IntProperty(
+        name="Frame Rate",
+        description="Animation frame rate for this action (frames per second)",
+        default=4,
+        min=1)
+
+    mesh_prop: StringProperty(
+        name="Mesh",
+        description="Optional mesh data to swap to when playing this action (brings its own material/texture/UVs)",
+        default="")
+
+    # Events list for this action
+    events: CollectionProperty(type=ArmTilesheetEventListItem)
+    events_index: IntProperty(name="Event Index", default=0)
+
+
 class ARM_UL_TilesheetActionList(bpy.types.UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        # We could write some code to decide which icon to use here...
-        custom_icon = 'OBJECT_DATAMODE'
+        custom_icon = 'PLAY'
 
-        # Make sure your code supports all 3 layout types
         if self.layout_type in {'DEFAULT', 'COMPACT'}:
             layout.prop(item, "name", text="", emboss=False, icon=custom_icon)
-
         elif self.layout_type in {'GRID'}:
             layout.alignment = 'CENTER'
-            layout.label(text="", icon = custom_icon)
+            layout.label(text="", icon=custom_icon)
+
 
 class ArmTilesheetActionListNewItem(bpy.types.Operator):
-    # Add a new item to the list
+    """Add a new action to the tilesheet"""
     bl_idname = "arm_tilesheetactionlist.new_item"
-    bl_label = "Add a new item"
+    bl_label = "Add Action"
 
     def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        trait.arm_tilesheetactionlist.add()
-        trait.arm_tilesheetactionlist_index = len(trait.arm_tilesheetactionlist) - 1
-        return{'FINISHED'}
+        obj = context.object
+        if obj is None:
+            return {'CANCELLED'}
+        obj.arm_tilesheet_actionlist.add()
+        obj.arm_tilesheet_actionlist_index = len(obj.arm_tilesheet_actionlist) - 1
+        return {'FINISHED'}
+
 
 class ArmTilesheetActionListDeleteItem(bpy.types.Operator):
-    """Delete the selected item from the list"""
+    """Delete the selected action from the tilesheet"""
     bl_idname = "arm_tilesheetactionlist.delete_item"
-    bl_label = "Deletes an item"
+    bl_label = "Delete Action"
 
     @classmethod
-    def poll(self, context):
-        """Enable if there's something in the list"""
-        wrd = bpy.data.worlds['Arm']
-        if len(wrd.arm_tilesheetlist) == 0:
-            return False
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        return len(trait.arm_tilesheetactionlist) > 0
+    def poll(cls, context):
+        obj = context.object
+        return obj is not None and len(obj.arm_tilesheet_actionlist) > 0
 
     def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        list = trait.arm_tilesheetactionlist
-        index = trait.arm_tilesheetactionlist_index
+        obj = context.object
+        action_list = obj.arm_tilesheet_actionlist
+        index = obj.arm_tilesheet_actionlist_index
 
-        list.remove(index)
+        action_list.remove(index)
 
         if index > 0:
             index = index - 1
 
-        trait.arm_tilesheetactionlist_index = index
-        return{'FINISHED'}
+        obj.arm_tilesheet_actionlist_index = index
+        return {'FINISHED'}
+
 
 class ArmTilesheetActionListMoveItem(bpy.types.Operator):
-    """Move an item in the list"""
+    """Move an action in the list"""
     bl_idname = "arm_tilesheetactionlist.move_item"
-    bl_label = "Move an item in the list"
+    bl_label = "Move Action"
     bl_options = {'INTERNAL'}
 
     direction: EnumProperty(
@@ -88,183 +128,162 @@ class ArmTilesheetActionListMoveItem(bpy.types.Operator):
         ))
 
     @classmethod
-    def poll(self, context):
-        """Enable if there's something in the list"""
-        wrd = bpy.data.worlds['Arm']
-        if len(wrd.arm_tilesheetlist) == 0:
-            return False
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        return len(trait.arm_tilesheetactionlist) > 0
-
-    def move_index(self):
-        # Move index of an item render queue while clamping it
-        wrd = bpy.data.worlds['Arm']
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        index = trait.arm_tilesheetactionlist_index
-        list_length = len(trait.arm_tilesheetactionlist) - 1
-        new_index = 0
-
-        if self.direction == 'UP':
-            new_index = index - 1
-        elif self.direction == 'DOWN':
-            new_index = index + 1
-
-        new_index = max(0, min(new_index, list_length))
-        trait.arm_tilesheetactionlist.move(index, new_index)
-        trait.arm_tilesheetactionlist_index = new_index
+    def poll(cls, context):
+        obj = context.object
+        return obj is not None and len(obj.arm_tilesheet_actionlist) > 0
 
     def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        trait = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-        list = trait.arm_tilesheetactionlist
-        index = trait.arm_tilesheetactionlist_index
-
-        if self.direction == 'DOWN':
-            neighbor = index + 1
-            self.move_index()
-
-        elif self.direction == 'UP':
-            neighbor = index - 1
-            self.move_index()
-        else:
-            return{'CANCELLED'}
-        return{'FINISHED'}
-
-class ArmTilesheetListItem(bpy.types.PropertyGroup):
-    name: StringProperty(
-        name="Name",
-        description="A name for this item",
-        default="Untitled")
-
-    tilesx_prop: IntProperty(
-        name="Tiles X",
-        description="A name for this item",
-        default=0)
+        obj = context.object
+        action_list = obj.arm_tilesheet_actionlist
+        index = obj.arm_tilesheet_actionlist_index
+        list_length = len(action_list) - 1
 
-    tilesy_prop: IntProperty(
-        name="Tiles Y",
-        description="A name for this item",
-        default=0)
+        if self.direction == 'UP':
+            new_index = max(0, index - 1)
+        else:  # DOWN
+            new_index = min(list_length, index + 1)
 
-    framerate_prop: FloatProperty(
-        name="Frame Rate",
-        description="A name for this item",
-        default=4.0)
+        action_list.move(index, new_index)
+        obj.arm_tilesheet_actionlist_index = new_index
+        return {'FINISHED'}
 
-    arm_tilesheetactionlist: CollectionProperty(type=ArmTilesheetActionListItem)
-    arm_tilesheetactionlist_index: IntProperty(name="Index for arm_tilesheetactionlist", default=0)
 
-class ARM_UL_TilesheetList(bpy.types.UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        # We could write some code to decide which icon to use here...
-        custom_icon = 'OBJECT_DATAMODE'
+class ArmTilesheetEventListNewItem(bpy.types.Operator):
+    """Add a new event to the current action"""
+    bl_idname = "arm_tilesheetactionlist.new_event"
+    bl_label = "Add Event"
 
-        # Make sure your code supports all 3 layout types
-        if self.layout_type in {'DEFAULT', 'COMPACT'}:
-            layout.prop(item, "name", text="", emboss=False, icon=custom_icon)
-
-        elif self.layout_type in {'GRID'}:
-            layout.alignment = 'CENTER'
-            layout.label(text="", icon=custom_icon)
-
-class ArmTilesheetListNewItem(bpy.types.Operator):
-    """Add a new item to the list"""
-    bl_idname = "arm_tilesheetlist.new_item"
-    bl_label = "Add a new item"
+    @classmethod
+    def poll(cls, context):
+        obj = context.object
+        return obj is not None and len(obj.arm_tilesheet_actionlist) > 0
 
     def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        wrd.arm_tilesheetlist.add()
-        wrd.arm_tilesheetlist_index = len(wrd.arm_tilesheetlist) - 1
-        return{'FINISHED'}
+        obj = context.object
+        if obj.arm_tilesheet_actionlist_index < 0:
+            return {'CANCELLED'}
+        action = obj.arm_tilesheet_actionlist[obj.arm_tilesheet_actionlist_index]
+        action.events.add()
+        action.events_index = len(action.events) - 1
+        return {'FINISHED'}
 
-class ArmTilesheetListDeleteItem(bpy.types.Operator):
-    """Delete the selected item from the list"""
-    bl_idname = "arm_tilesheetlist.delete_item"
-    bl_label = "Deletes an item"
+
+class ArmTilesheetEventListDeleteItem(bpy.types.Operator):
+    """Delete the selected event from the current action"""
+    bl_idname = "arm_tilesheetactionlist.delete_event"
+    bl_label = "Delete Event"
 
     @classmethod
-    def poll(self, context):
-        """ Enable if there's something in the list """
-        wrd = bpy.data.worlds['Arm']
-        return len(wrd.arm_tilesheetlist) > 0
+    def poll(cls, context):
+        obj = context.object
+        if obj is None or len(obj.arm_tilesheet_actionlist) == 0:
+            return False
+        if obj.arm_tilesheet_actionlist_index < 0:
+            return False
+        action = obj.arm_tilesheet_actionlist[obj.arm_tilesheet_actionlist_index]
+        return len(action.events) > 0
 
     def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        list = wrd.arm_tilesheetlist
-        index = wrd.arm_tilesheetlist_index
+        obj = context.object
+        action = obj.arm_tilesheet_actionlist[obj.arm_tilesheet_actionlist_index]
+        events = action.events
+        index = action.events_index
 
-        list.remove(index)
+        events.remove(index)
 
         if index > 0:
-            index = index - 1
+            action.events_index = index - 1
 
-        wrd.arm_tilesheetlist_index = index
-        return{'FINISHED'}
+        return {'FINISHED'}
 
-class ArmTilesheetListMoveItem(bpy.types.Operator):
-    """Move an item in the list"""
-    bl_idname = "arm_tilesheetlist.move_item"
-    bl_label = "Move an item in the list"
-    bl_options = {'INTERNAL'}
 
-    direction: EnumProperty(
-        items=(
-            ('UP', 'Up', ""),
-            ('DOWN', 'Down', "")
-        ))
+class ARM_PT_TilesheetPanel(bpy.types.Panel):
+    bl_label = "Armory Tilesheet"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "object"
+    bl_options = {'DEFAULT_CLOSED'}
 
     @classmethod
-    def poll(self, context):
-        """ Enable if there's something in the list. """
-        wrd = bpy.data.worlds['Arm']
-        return len(wrd.arm_tilesheetlist) > 0
-
-    def move_index(self):
-        # Move index of an item render queue while clamping it
-        wrd = bpy.data.worlds['Arm']
-        index = wrd.arm_tilesheetlist_index
-        list_length = len(wrd.arm_tilesheetlist) - 1
-        new_index = 0
-
-        if self.direction == 'UP':
-            new_index = index - 1
-        elif self.direction == 'DOWN':
-            new_index = index + 1
-
-        new_index = max(0, min(new_index, list_length))
-        wrd.arm_tilesheetlist.move(index, new_index)
-        wrd.arm_tilesheetlist_index = new_index
-
-    def execute(self, context):
-        wrd = bpy.data.worlds['Arm']
-        list = wrd.arm_tilesheetlist
-        index = wrd.arm_tilesheetlist_index
-
-        if self.direction == 'DOWN':
-            neighbor = index + 1
-            self.move_index()
-
-        elif self.direction == 'UP':
-            neighbor = index - 1
-            self.move_index()
-        else:
-            return{'CANCELLED'}
-        return{'FINISHED'}
+    def poll(cls, context):
+        return context.object is not None and context.object.type == 'MESH'
+
+    def draw_header(self, context):
+        obj = context.object
+        self.layout.prop(obj, "arm_tilesheet_enabled", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+        obj = context.object
+
+        layout.enabled = obj.arm_tilesheet_enabled
+
+        # Default action dropdown
+        layout.prop_search(obj, "arm_tilesheet_default_action", obj, "arm_tilesheet_actionlist", text="Default Action")
+
+        # Actions list
+        layout.separator()
+        layout.label(text="Actions")
+        rows = 2
+        if len(obj.arm_tilesheet_actionlist) > 1:
+            rows = 4
+        row = layout.row()
+        row.template_list("ARM_UL_TilesheetActionList", "The_List", obj, "arm_tilesheet_actionlist", obj, "arm_tilesheet_actionlist_index", rows=rows)
+        col = row.column(align=True)
+        col.operator("arm_tilesheetactionlist.new_item", icon='ADD', text="")
+        col.operator("arm_tilesheetactionlist.delete_item", icon='REMOVE', text="")
+
+        if len(obj.arm_tilesheet_actionlist) > 1:
+            col.separator()
+            op = col.operator("arm_tilesheetactionlist.move_item", icon='TRIA_UP', text="")
+            op.direction = 'UP'
+            op = col.operator("arm_tilesheetactionlist.move_item", icon='TRIA_DOWN', text="")
+            op.direction = 'DOWN'
+
+        # Selected action details (per-action properties)
+        if obj.arm_tilesheet_actionlist_index >= 0 and len(obj.arm_tilesheet_actionlist) > 0:
+            adat = obj.arm_tilesheet_actionlist[obj.arm_tilesheet_actionlist_index]
+            box = layout.box()
+            # Grid dimensions
+            row = box.row(align=True)
+            row.prop(adat, "tilesx_prop")
+            row.prop(adat, "tilesy_prop")
+            # Frame range
+            row = box.row(align=True)
+            row.prop(adat, "start_prop")
+            row.prop(adat, "end_prop")
+            # Framerate and loop
+            box.prop(adat, "framerate_prop")
+            box.prop(adat, "loop_prop")
+            # Optional mesh (dropdown from bpy.data.meshes)
+            box.prop_search(adat, "mesh_prop", bpy.data, "meshes", text="Mesh")
+
+            # Events section
+            box.separator()
+            box.label(text="Events")
+            row = box.row()
+            col = row.column()
+            for i, evt in enumerate(adat.events):
+                evt_row = col.row(align=True)
+                evt_row.prop(evt, "name", text="")
+                evt_row.prop(evt, "frame_prop", text="Frame")
+            row = box.row(align=True)
+            row.operator("arm_tilesheetactionlist.new_event", icon='ADD', text="Add Event")
+            row.operator("arm_tilesheetactionlist.delete_event", icon='REMOVE', text="Remove Event")
 
 
 __REG_CLASSES = (
+    ArmTilesheetEventListItem,
     ArmTilesheetActionListItem,
     ARM_UL_TilesheetActionList,
     ArmTilesheetActionListNewItem,
     ArmTilesheetActionListDeleteItem,
     ArmTilesheetActionListMoveItem,
-
-    ArmTilesheetListItem,
-    ARM_UL_TilesheetList,
-    ArmTilesheetListNewItem,
-    ArmTilesheetListDeleteItem,
-    ArmTilesheetListMoveItem,
+    ArmTilesheetEventListNewItem,
+    ArmTilesheetEventListDeleteItem,
+    ARM_PT_TilesheetPanel,
 )
 __reg_classes, unregister = bpy.utils.register_classes_factory(__REG_CLASSES)
 
@@ -272,5 +291,18 @@ def execute(self, context):
 def register():
     __reg_classes()
 
-    bpy.types.World.arm_tilesheetlist = CollectionProperty(type=ArmTilesheetListItem)
-    bpy.types.World.arm_tilesheetlist_index = IntProperty(name="Index for arm_tilesheetlist", default=0)
+    # Tilesheet properties on Object (one tilesheet per object)
+    bpy.types.Object.arm_tilesheet_enabled = BoolProperty(
+        name="Tilesheet",
+        description="Enable tilesheet animation for this object",
+        default=False)
+
+    bpy.types.Object.arm_tilesheet_default_action = StringProperty(
+        name="Default Action",
+        description="Default action to play on start",
+        default="")
+
+    bpy.types.Object.arm_tilesheet_actionlist = CollectionProperty(type=ArmTilesheetActionListItem)
+    bpy.types.Object.arm_tilesheet_actionlist_index = IntProperty(
+        name="Action Index",
+        default=0)
diff --git a/armory/blender/arm/props_ui.py b/armory/blender/arm/props_ui.py
index 18b3c7439d..4bcb528bfe 100644
--- a/armory/blender/arm/props_ui.py
+++ b/armory/blender/arm/props_ui.py
@@ -12,6 +12,7 @@
 import arm.api
 import arm.assets as assets
 from arm.exporter import ArmoryExporter
+from arm.n64.exporter import N64Exporter
 import arm.log as log
 import arm.logicnode.replacement
 import arm.make as make
@@ -73,16 +74,6 @@ def draw(self, context):
 
         if obj.type == 'MESH':
             layout.prop(obj, 'arm_instanced')
-            wrd = bpy.data.worlds['Arm']
-            layout.prop_search(obj, "arm_tilesheet", wrd, "arm_tilesheetlist", text="Tilesheet")
-            if obj.arm_tilesheet != '':
-                selected_ts = None
-                for ts in wrd.arm_tilesheetlist:
-                    if ts.name == obj.arm_tilesheet:
-                        selected_ts = ts
-                        break
-                layout.prop_search(obj, "arm_tilesheet_action", selected_ts, "arm_tilesheetactionlist", text="Action")
-                layout.prop(obj, "arm_use_custom_tilesheet_node")
 
         # Properties list
         arm.props_properties.draw_properties(layout, obj)
@@ -1259,6 +1250,11 @@ def execute(self, context):
 
         arm.utils.check_default_props()
 
+        wrd = bpy.data.worlds['Arm']
+        if wrd.arm_runtime == 'Ares':
+            state.is_n64 = True
+            if not wrd.arm_cache_build:
+                bpy.ops.arm.clean_project()
         assets.invalidate_enabled = False
         if wrd.arm_clear_on_compile:
             os.system("cls")
@@ -1319,11 +1315,16 @@ def execute(self, context):
             if wrd.arm_rplist[i].name == item.arm_project_rp:
                 wrd.arm_rplist_index = i
                 break
+
         assets.invalidate_shader_cache(None, None)
         assets.invalidate_enabled = False
         if wrd.arm_clear_on_compile:
             os.system("cls")
-        make.build(item.arm_project_target, is_export=True)
+        if item.arm_project_target == 'n64':
+            state.is_n64 = True
+            if not wrd.arm_cache_build:
+                bpy.ops.arm.clean_project()
+        make.build('custom' if item.arm_project_target == 'n64' else item.arm_project_target, is_export=True)
         make.compile()
         wrd.arm_rplist_index = rplist_index
         assets.invalidate_enabled = True
@@ -1370,8 +1371,12 @@ def execute(self, context):
         make.clean()
         assets.invalidate_enabled = False
         if wrd.arm_clear_on_compile:
-            os.system("cls")
-        make.build(item.arm_project_target, is_publish=True, is_export=True)
+                os.system("cls")
+        if item.arm_project_target == 'n64':
+            state.is_n64 = True
+            if not wrd.arm_cache_build:
+                bpy.ops.arm.clean_project()
+        make.build('custom' if item.arm_project_target == 'n64' else item.arm_project_target, is_publish=True, is_export=True)
         make.compile()
         wrd.arm_rplist_index = rplist_index
         assets.invalidate_enabled = True
@@ -2311,64 +2316,6 @@ def draw(self, context):
         layout.operator('arm.generate_terrain')
         layout.prop(scn, 'arm_terrain_object')
 
-class ARM_PT_TilesheetPanel(bpy.types.Panel):
-    bl_label = "Armory Tilesheet"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "material"
-    bl_options = {'DEFAULT_CLOSED'}
-
-    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
-        layout.use_property_decorate = False
-        wrd = bpy.data.worlds['Arm']
-
-        rows = 2
-        if len(wrd.arm_tilesheetlist) > 1:
-            rows = 4
-        row = layout.row()
-        row.template_list("ARM_UL_TilesheetList", "The_List", wrd, "arm_tilesheetlist", wrd, "arm_tilesheetlist_index", rows=rows)
-        col = row.column(align=True)
-        col.operator("arm_tilesheetlist.new_item", icon='ADD', text="")
-        col.operator("arm_tilesheetlist.delete_item", icon='REMOVE', text="")
-
-        if len(wrd.arm_tilesheetlist) > 1:
-            col.separator()
-            op = col.operator("arm_tilesheetlist.move_item", icon='TRIA_UP', text="")
-            op.direction = 'UP'
-            op = col.operator("arm_tilesheetlist.move_item", icon='TRIA_DOWN', text="")
-            op.direction = 'DOWN'
-
-        if wrd.arm_tilesheetlist_index >= 0 and len(wrd.arm_tilesheetlist) > 0:
-            dat = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index]
-            layout.prop(dat, "tilesx_prop")
-            layout.prop(dat, "tilesy_prop")
-            layout.prop(dat, "framerate_prop")
-
-            layout.label(text='Actions')
-            rows = 2
-            if len(dat.arm_tilesheetactionlist) > 1:
-                rows = 4
-            row = layout.row()
-            row.template_list("ARM_UL_TilesheetList", "The_List", dat, "arm_tilesheetactionlist", dat, "arm_tilesheetactionlist_index", rows=rows)
-            col = row.column(align=True)
-            col.operator("arm_tilesheetactionlist.new_item", icon='ADD', text="")
-            col.operator("arm_tilesheetactionlist.delete_item", icon='REMOVE', text="")
-
-            if len(dat.arm_tilesheetactionlist) > 1:
-                col.separator()
-                op = col.operator("arm_tilesheetactionlist.move_item", icon='TRIA_UP', text="")
-                op.direction = 'UP'
-                op = col.operator("arm_tilesheetactionlist.move_item", icon='TRIA_DOWN', text="")
-                op.direction = 'DOWN'
-
-            if dat.arm_tilesheetactionlist_index >= 0 and len(dat.arm_tilesheetactionlist) > 0:
-                adat = dat.arm_tilesheetactionlist[dat.arm_tilesheetactionlist_index]
-                layout.prop(adat, "start_prop")
-                layout.prop(adat, "end_prop")
-                layout.prop(adat, "loop_prop")
-
 class ArmPrintTraitsButton(bpy.types.Operator):
     bl_idname = 'arm.print_traits'
     bl_label = 'Print All Traits'
@@ -2934,7 +2881,6 @@ def draw_multiline_with_icon(layout: bpy.types.UILayout, layout_width_px: int, i
     ARM_PT_LodPanel,
     ArmGenTerrainButton,
     ARM_PT_TerrainPanel,
-    ARM_PT_TilesheetPanel,
     ArmPrintTraitsButton,
     ARM_PT_MaterialNodePanel,
     ARM_OT_UpdateFileSDK,
diff --git a/armory/blender/arm/utils.py b/armory/blender/arm/utils.py
index 2325f48943..7f2fd0160f 100644
--- a/armory/blender/arm/utils.py
+++ b/armory/blender/arm/utils.py
@@ -188,9 +188,15 @@ def get_gapi():
     wrd = bpy.data.worlds['Arm']
     if state.is_export:
         item = wrd.arm_exporterlist[wrd.arm_exporterlist_index]
+        # N64 uses Krom build with standard graphics API, not tiny3d
+        if item.arm_project_target == 'n64':
+            return 'direct3d11' if get_os() == 'win' else 'opengl'
         return getattr(item, target_to_gapi(item.arm_project_target))
     if wrd.arm_runtime == 'Browser':
         return 'webgl'
+    # N64/Ares uses Krom build with standard graphics API
+    if wrd.arm_runtime == 'Ares':
+        return 'direct3d11' if get_os() == 'win' else 'opengl'
     return 'direct3d11' if get_os() == 'win' else 'opengl'
 
 
@@ -1026,6 +1032,8 @@ def target_to_gapi(arm_project_target: str) -> str:
         return 'arm_gapi_ios'
     elif arm_project_target == 'node':
         return 'arm_gapi_html5'
+    elif arm_project_target == 'n64':
+        return 'arm_gapi_n64'
     else: # html5, custom
         return 'arm_gapi_' + arm_project_target
 
@@ -1136,6 +1144,32 @@ def get_link_web_server():
     addon_prefs = get_arm_preferences()
     return '' if not hasattr(addon_prefs, 'link_web_server') else addon_prefs.link_web_server
 
+def get_n64_toolchain_path():
+    if os.getenv('N64_INST') == None:
+        addon_prefs = get_arm_preferences()
+        return '' if not hasattr(addon_prefs, 'n64_toolchain_path') else addon_prefs.n64_toolchain_path.replace('C:', '/c').replace('\\', '/')
+    else:
+        return os.getenv('N64_INST')
+
+def get_msys2_bash_executable():
+    addon_prefs = get_arm_preferences()
+    return '' if not hasattr(addon_prefs, 'msys2_bash_executable') else addon_prefs.msys2_bash_executable
+
+def get_mingw64_path():
+    addon_prefs = get_arm_preferences()
+    return '' if not hasattr(addon_prefs, 'mingw64_path') else addon_prefs.mingw64_path.replace('C:', '/c').replace('\\', '/')
+
+def get_ares_emulator_executable():
+    addon_prefs = get_arm_preferences()
+    return '' if not hasattr(addon_prefs, 'ares_emulator_executable') else addon_prefs.ares_emulator_executable
+
+def get_open_n64_rom_directory():
+    addon_prefs = get_arm_preferences()
+    return False if not hasattr(addon_prefs, 'open_n64_rom_directory') else addon_prefs.open_n64_rom_directory
+
+def get_n64_deployment_path():
+    return os.path.join(arm.utils.get_sdk_path(), 'armorcore', 'Deployment', 'n64')
+
 
 def get_file_arm_version_tuple() -> tuple[int]:
     wrd = bpy.data.worlds['Arm']
diff --git a/armory/blender/arm/write_data.py b/armory/blender/arm/write_data.py
index 0e2464bf09..5eff1ee301 100644
--- a/armory/blender/arm/write_data.py
+++ b/armory/blender/arm/write_data.py
@@ -264,6 +264,11 @@ def write_khafilejs(is_play, export_physics: bool, export_navigation: bool, expo
         if state.target.startswith('krom'):
             assets.add_khafile_def('js-es=6')
 
+        if state.is_n64:
+            assets.add_khafile_def('arm_target_n64')
+            # Tell the N64 trait macro where to write the traits JSON file
+            assets.add_khafile_def('arm_build_dir=../' + arm.utils.build_dir())
+
         if export_physics:
             assets.add_khafile_def('arm_physics')
             if wrd.arm_physics_engine == 'Bullet':
diff --git a/lib/libdragon b/lib/libdragon
new file mode 160000
index 0000000000..73e98469d5
--- /dev/null
+++ b/lib/libdragon
@@ -0,0 +1 @@
+Subproject commit 73e98469d55d32098bfa803ce86145c315f28599
diff --git a/lib/tiny3d b/lib/tiny3d
new file mode 160000
index 0000000000..e09ccae0ba
--- /dev/null
+++ b/lib/tiny3d
@@ -0,0 +1 @@
+Subproject commit e09ccae0ba750848418dfa49621dec7503868902