diff --git a/assets/registry.toml b/assets/registry.toml
index a577f87..0d52586 100644
--- a/assets/registry.toml
+++ b/assets/registry.toml
@@ -7,3 +7,9 @@ type = "primitive"
 primitive = "torus"
 params = [0.5, 1, 16, 8]
 
+[[model]]
+key = "demo_cube"
+type = "primitive"
+primitive = "cube"
+params = [1, 1, 1]
+
diff --git a/docs/Editor.md b/docs/Editor.md
index e0197de..6ddff2e 100644
--- a/docs/Editor.md
+++ b/docs/Editor.md
@@ -53,7 +53,7 @@ This document outlines the in-app editor UI, its panels, and common workflows.
 - Tag: rename the entity.
 - Transform: position, scale, rotation (degrees in UI).
 - Velocity: linear and angular velocity.
-- Sprite: model id, shader id, color, outline.
+- Model Renderer: model id, shader id, color, outline.
 - Texture: texture id.
 - UV Transform: scale, offset, rotation (radians).
 - Script: per-entity script path and enabled toggle.
diff --git a/docs/Scenegraph.md b/docs/Scenegraph.md
index edca096..62c5a5a 100644
--- a/docs/Scenegraph.md
+++ b/docs/Scenegraph.md
@@ -24,7 +24,7 @@ Computed each frame from the hierarchy and local transform. Rendering uses `Worl
 
 1. Systems update local transforms (e.g., velocity system).
 2. `UpdateWorldTransforms()` traverses the hierarchy and computes `WorldTransform`.
-3. Rendering draws from `WorldTransform` + `Sprite`.
+3. Rendering draws from `WorldTransform` + `ModelRenderer`.
 
 ## Script API
 
@@ -94,7 +94,7 @@ shader_fs = "shaders/toon.fs"
 - `model_size` (vec3) for cubes/planes
 - `radius`, `rings`, `slices` for spheres
 - `color` — hex `0xRRGGBBAA` (matches script colors)
-- `outline_size` — optional sprite outline
+- `outline_size` — optional model outline
 - `shader_vs`, `shader_fs` — optional shader paths
 - `shader_asset` (string) — asset key for shaders
 - `shader_id` (int) — numeric shader id
diff --git a/docs/Scripting.md b/docs/Scripting.md
index 9273631..0309cc5 100644
--- a/docs/Scripting.md
+++ b/docs/Scripting.md
@@ -49,8 +49,8 @@ Asset::LoadCube("unit_cube", 1.0f, 1.0f, 1.0f);
 Asset::CreateMaterial("toon_mat", Asset::GetShaderId("toon"), 255, 255, 255, 255);
 
 uint e = ECS::CreateEntity();
-ECS::AddSprite(e, int(Asset::GetModelId("unit_cube")), 0xFFFFFFFF, 0.0f);
-ECS::SetSpriteShader(e, Asset::GetShaderId("toon"));
+ECS::AddModelRenderer(e, int(Asset::GetModelId("unit_cube")), 0xFFFFFFFF, 0.0f);
+ECS::SetModelRendererShader(e, Asset::GetShaderId("toon"));
 ECS::AddTexture(e, Asset::GetTextureId("grid"));
 ECS::AddMaterial(e, Asset::GetMaterialId("toon_mat"));
 ```
diff --git a/imgui.ini b/imgui.ini
index d34daa6..2b194ed 100644
--- a/imgui.ini
+++ b/imgui.ini
@@ -21,27 +21,27 @@ Collapsed=0
 DockId=0x00000002,0
 
 [Window][##TOAST0]
-Pos=1035,637
-Size=225,63
+Pos=1060,637
+Size=200,63
 Collapsed=0
 
 [Window][##TOAST1]
-Pos=1035,564
-Size=225,63
+Pos=1060,564
+Size=200,63
 Collapsed=0
 
 [Window][##TOAST2]
-Pos=1704,762
-Size=196,63
+Pos=1060,491
+Size=200,63
 Collapsed=0
 
 [Window][##TOAST3]
-Pos=1704,689
-Size=196,63
+Pos=1060,418
+Size=200,63
 Collapsed=0
 
 [Window][##TOAST4]
-Pos=1704,616
+Pos=1064,345
 Size=196,63
 Collapsed=0
 
@@ -115,5 +115,5 @@ DockSpace       ID=0x9076BACA Window=0x34F970D7 Pos=8,28 Size=1264,684 Split=Y S
       DockNode  ID=0x00000003 Parent=0x00000005 SizeRef=222,684 Selected=0xE601B12F
       DockNode  ID=0x00000004 Parent=0x00000005 SizeRef=663,684 CentralNode=1 Selected=0x27A02DAA
     DockNode    ID=0x00000006 Parent=0x00000001 SizeRef=375,684 Selected=0x36DC96AB
-  DockNode      ID=0x00000002 Parent=0x9076BACA SizeRef=1264,274 Selected=0x42C24103
+  DockNode      ID=0x00000002 Parent=0x9076BACA SizeRef=1264,274 Selected=0xBEDDA0C1
 
diff --git a/include/ECSComponents.h b/include/ECSComponents.h
index e466527..46e018c 100644
--- a/include/ECSComponents.h
+++ b/include/ECSComponents.h
@@ -41,20 +41,20 @@ struct Velocity {
         : linear(lin), angular(ang) {}
 };
 
-// Sprite component - visual representation
-struct Sprite {
+// ModelRenderer component - 3D model rendering data
+struct ModelRenderer {
     size_t modelId;          // Index into models array
     Color color;          // Tint color
     float outlineSize;    // Outline thickness
     unsigned int shaderId;   // Shader to use (0 = no shader)
     
-    Sprite() 
+    ModelRenderer() 
         : modelId(0)
         , color(WHITE)
         , outlineSize(0.0f)
         , shaderId(0) {}
     
-    Sprite(int model, Color col = WHITE, float outline = 0.0f, unsigned int shader = 0)
+    ModelRenderer(int model, Color col = WHITE, float outline = 0.0f, unsigned int shader = 0)
         : modelId(model), color(col), outlineSize(outline), shaderId(shader) {}
 };
 
diff --git a/scenes/demo.toml b/scenes/demo.toml
index 5364bed..621380c 100644
--- a/scenes/demo.toml
+++ b/scenes/demo.toml
@@ -1,3 +1,5 @@
+scene_script = "scripts/demo_scene.as"
+
 [[entity]]
 id = "entity_1"
 tag = "Root"
diff --git a/scripts/as.predefined b/scripts/as.predefined
index 00e35bc..af7f20d 100644
--- a/scripts/as.predefined
+++ b/scripts/as.predefined
@@ -57,14 +57,14 @@ namespace ECS {
     bool HasVelocity(uint entity);
     void RemoveVelocity(uint entity);
     
-    // Sprite component
-    void AddSprite(uint entity, int modelId, uint color, float outlineSize = 0.0f);
-    void SetSpriteColor(uint entity, uint color);
-    void SetSpriteModel(uint entity, int modelId);
-    void SetSpriteOutline(uint entity, float outlineSize);
-    void SetSpriteShader(uint entity, uint shaderId);
-    bool HasSprite(uint entity);
-    void RemoveSprite(uint entity);
+    // ModelRenderer component
+    void AddModelRenderer(uint entity, int modelId, uint color, float outlineSize = 0.0f);
+    void SetModelRendererColor(uint entity, uint color);
+    void SetModelRendererModel(uint entity, int modelId);
+    void SetModelRendererOutline(uint entity, float outlineSize);
+    void SetModelRendererShader(uint entity, uint shaderId);
+    bool HasModelRenderer(uint entity);
+    void RemoveModelRenderer(uint entity);
 
     // Texture component
     void AddTexture(uint entity, uint textureId);
diff --git a/scripts/demo_scene.as b/scripts/demo_scene.as
new file mode 100644
index 0000000..0b23fdc
--- /dev/null
+++ b/scripts/demo_scene.as
@@ -0,0 +1,52 @@
+// Demo scene script with input-driven behavior.
+class SceneScript {
+    uint sceneRoot = 0;
+    uint camera = 0;
+    uint light = 0;
+    uint cube = 0;
+    float time = 0.0f;
+    bool highlight = false;
+
+    void Init() {
+        Log(LOG_INFO, "Demo scene script init");
+
+        cube = ECS::CreateEntity();
+        ECS::AddTransform(cube, 0.0f, 1.5f, 0.0f);
+        uint modelId = Asset::GetModelId("demo_cube");
+        if (modelId == 0) {
+            modelId = Asset::LoadCube("demo_cube", 1.0f, 1.0f, 1.0f);
+        }
+        ECS::AddModelRenderer(cube, int(modelId), 0xFFAA00FF, 0.0f);
+        ECS::AddTag(cube, "InputCube");
+    }
+
+    void Shutdown() {
+        Log(LOG_INFO, "Demo scene script shutdown");
+    }
+
+    void Update(float dt) {
+        time += dt;
+
+        if (ECS::IsValid(cube) && ECS::HasTransform(cube)) {
+            ECS::SetRotationEuler(cube, 0.0f, time, time * 0.5f);
+        }
+
+        if (IsActionPressed("jump")) {
+            highlight = !highlight;
+            if (highlight) {
+                ECS::SetModelRendererColor(cube, 0x00FF88FF);
+                ECS::SetModelRendererOutline(cube, 2.0f);
+                Toast::Info("Highlight on");
+            } else {
+                ECS::SetModelRendererColor(cube, 0xFFAA00FF);
+                ECS::SetModelRendererOutline(cube, 0.0f);
+                Toast::Info("Highlight off");
+            }
+        }
+
+        if (IsActionPressed("attack")) {
+            ECS::SetLightDirection(light, -0.5f, 0.7f, -0.3f);
+            Toast::Success("Light toggled");
+        }
+    }
+}
diff --git a/scripts/example_rendering.as b/scripts/example_rendering.as
index a6ebcd0..1c2ea78 100644
--- a/scripts/example_rendering.as
+++ b/scripts/example_rendering.as
@@ -53,7 +53,7 @@ void Init() {
     // === Create Cube with Outline ===
     cube = ECS::CreateEntity();
     ECS::AddTransform(cube, -1.5, 0.5, 0.0);
-    ECS::AddSprite(cube, cubeModel, 0xFFFFFFFF, 0.0);
+    ECS::AddModelRenderer(cube, cubeModel, 0xFFFFFFFF, 0.0);
     ECS::AddMaterial(cube, redMaterial);
     ECS::AddTag(cube, "Cube");
     ECS::AddVelocity(cube, 0.0, 0.0, 0.0, 1.0); // rotating
@@ -64,7 +64,7 @@ void Init() {
     // === Create Sphere ===
     sphere = ECS::CreateEntity();
     ECS::AddTransform(sphere, 1.5, 0.5, 0.0);
-    ECS::AddSprite(sphere, sphereModel, 0xFFFFFFFF, 0.0);
+    ECS::AddModelRenderer(sphere, sphereModel, 0xFFFFFFFF, 0.0);
     ECS::AddMaterial(sphere, blueMaterial);
     ECS::AddTag(sphere, "Sphere");
     ECS::AddVelocity(sphere, 0.5, 0.0, 0.2, 0.5); // moving and rotating
diff --git a/src/Application.cpp b/src/Application.cpp
index ad248ca..21f9612 100644
--- a/src/Application.cpp
+++ b/src/Application.cpp
@@ -718,14 +718,14 @@ void Application::RenderScene()
     BeginMode3D(camera);
     DrawGrid(10, 1);
 
-    // Render all entities with WorldTransform and Sprite components
-    auto view = registry.view<WorldTransform, Sprite>();
-    view.each([&](auto entity, auto& transform, auto& sprite) {
-        if (sprite.modelId <= 0) {
+    // Render all entities with WorldTransform and ModelRenderer components
+    auto view = registry.view<WorldTransform, ModelRenderer>();
+    view.each([&](auto entity, auto& transform, auto& renderer) {
+        if (renderer.modelId <= 0) {
             return;
         }
 
-        Model* model = modelManager.Get(static_cast<unsigned int>(sprite.modelId));
+        Model* model = modelManager.Get(static_cast<unsigned int>(renderer.modelId));
         if (!model) {
             return;
         }
@@ -743,9 +743,9 @@ void Application::RenderScene()
             }
         }
 
-        // If sprite has a shader, apply it with uniforms
-        if (sprite.shaderId > 0) {
-            Shader* shader = shaderManager.Get(static_cast<unsigned int>(sprite.shaderId));
+        // If model renderer has a shader, apply it with uniforms
+        if (renderer.shaderId > 0) {
+            Shader* shader = shaderManager.Get(static_cast<unsigned int>(renderer.shaderId));
             if (shader) {
                 // Set shader uniforms
                 int albedoLoc = GetShaderLocation(*shader, "albedo");
@@ -753,10 +753,10 @@ void Application::RenderScene()
 
                 if (albedoLoc != -1) {
                     Vector4 albedo = {
-                        sprite.color.r / 255.0f,
-                        sprite.color.g / 255.0f,
-                        sprite.color.b / 255.0f,
-                        sprite.color.a / 255.0f
+                        renderer.color.r / 255.0f,
+                        renderer.color.g / 255.0f,
+                        renderer.color.b / 255.0f,
+                        renderer.color.a / 255.0f
                     };
                     SetShaderValue(*shader, albedoLoc, &albedo, SHADER_UNIFORM_VEC4);
                 }
@@ -792,7 +792,7 @@ void Application::RenderScene()
             }
         }
 
-        // Draw model using Sprite.color as the tint
+        // Draw model using ModelRenderer.color as the tint
         Quaternion rotation = QuaternionFromEuler(transform.rotation.x, transform.rotation.y, transform.rotation.z);
         Vector3 axis = {0.0f, 1.0f, 0.0f};
         float angle = 0.0f;
@@ -804,8 +804,8 @@ void Application::RenderScene()
         }
 
         DrawModelEx(*model, transform.position, axis,
-                   angle * RAD2DEG, transform.scale,
-                   sprite.color);
+               angle * RAD2DEG, transform.scale,
+               renderer.color);
 
         if (restoreTexture) {
             model->materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = originalTexture;
diff --git a/src/SceneLoader.cpp b/src/SceneLoader.cpp
index 2d69842..9d5967b 100644
--- a/src/SceneLoader.cpp
+++ b/src/SceneLoader.cpp
@@ -70,7 +70,7 @@ struct SceneEntityDef {
     Vector3 scale{1.0f, 1.0f, 1.0f};
     Vector3 rotation{0.0f, 0.0f, 0.0f};
 
-    bool hasSprite = false;
+    bool hasModelRenderer = false;
     std::string model;
     std::string modelAsset;
     unsigned int modelId = 0;
@@ -504,15 +504,15 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
             }
         } else if (key == "model") {
             ParseString(value, current->model);
-            current->hasSprite = true;
+            current->hasModelRenderer = true;
         } else if (key == "model_asset") {
             if (ParseString(value, current->modelAsset)) {
-                current->hasSprite = true;
+                current->hasModelRenderer = true;
             }
         } else if (key == "model_id") {
             current->modelId = static_cast<unsigned int>(std::stoul(value, nullptr, 0));
             current->hasModelId = true;
-            current->hasSprite = true;
+            current->hasModelRenderer = true;
         } else if (key == "model_size") {
             ParseVec3(value, current->modelSize);
         } else if (key == "radius") {
@@ -523,7 +523,7 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
             current->slices = std::stoi(value);
         } else if (key == "color") {
             ParseHexColor(value, current->color);
-            current->hasSprite = true;
+            current->hasModelRenderer = true;
         } else if (key == "outline_size") {
             current->outlineSize = std::stof(value);
         } else if (key == "shader_vs") {
@@ -532,12 +532,12 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
             ParseString(value, current->shaderFs);
         } else if (key == "shader_asset") {
             if (ParseString(value, current->shaderAsset)) {
-                current->hasSprite = true;
+                current->hasModelRenderer = true;
             }
         } else if (key == "shader_id") {
             current->shaderId = static_cast<unsigned int>(std::stoul(value, nullptr, 0));
             current->hasShaderId = true;
-            current->hasSprite = true;
+            current->hasModelRenderer = true;
         } else if (key == "material_asset") {
             if (ParseString(value, current->materialAsset)) {
                 current->hasMaterial = true;
@@ -631,13 +631,20 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
             g_sceneRegistry->emplace<Tag>(entity, def.id);
         }
 
-        if (def.hasTransform || def.hasSprite) {
+        if (def.hasTransform || def.hasModelRenderer) {
             g_sceneRegistry->emplace<ECSTransform>(entity, def.position, def.scale, def.rotation);
         }
 
-        if (def.hasSprite) {
+        if (def.hasModelRenderer) {
             unsigned int modelId = 0;
-            if (!def.model.empty()) {
+            if (g_sceneAssetManager && !def.modelAsset.empty()) {
+                modelId = g_sceneAssetManager->GetModelId(def.modelAsset);
+                if (modelId == 0 && def.hasModelId) {
+                    g_sceneAssetManager->RegisterModel(def.modelAsset, def.modelId, "id");
+                    modelId = def.modelId;
+                }
+            }
+            if (modelId == 0 && !def.model.empty()) {
                 modelId = LoadModelFor(def, modelCache);
             }
             if (modelId == 0 && def.hasModelId) {
@@ -650,13 +657,20 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
                 static_cast<unsigned char>(def.color & 0xFF)
             };
             unsigned int shaderId = 0;
-            if (!def.shaderVs.empty() && !def.shaderFs.empty()) {
+            if (g_sceneAssetManager && !def.shaderAsset.empty()) {
+                shaderId = g_sceneAssetManager->GetShaderId(def.shaderAsset);
+                if (shaderId == 0 && def.hasShaderId) {
+                    g_sceneAssetManager->RegisterShader(def.shaderAsset, def.shaderId, "id");
+                    shaderId = def.shaderId;
+                }
+            }
+            if (shaderId == 0 && !def.shaderVs.empty() && !def.shaderFs.empty()) {
                 shaderId = LoadShaderFor(def, shaderCache);
             }
             if (shaderId == 0 && def.hasShaderId) {
                 shaderId = def.shaderId;
             }
-            g_sceneRegistry->emplace<Sprite>(entity, static_cast<int>(modelId), col, def.outlineSize, shaderId);
+            g_sceneRegistry->emplace<ModelRenderer>(entity, static_cast<int>(modelId), col, def.outlineSize, shaderId);
         }
 
         if (def.hasMaterial) {
@@ -676,7 +690,14 @@ entt::entity LoadSceneFromFile(const std::string& path, bool clearExisting) {
 
         if (def.hasTexture) {
             unsigned int textureId = 0;
-            if (!def.texturePath.empty()) {
+            if (g_sceneAssetManager && !def.textureAsset.empty()) {
+                textureId = g_sceneAssetManager->GetTextureId(def.textureAsset);
+                if (textureId == 0 && def.hasTextureId) {
+                    g_sceneAssetManager->RegisterTexture(def.textureAsset, def.textureId, "id");
+                    textureId = def.textureId;
+                }
+            }
+            if (textureId == 0 && !def.texturePath.empty()) {
                 textureId = LoadTextureFor(def, textureCache);
             }
             if (textureId == 0 && def.hasTextureId) {
@@ -805,16 +826,16 @@ bool SaveSceneToFile(const std::string& path) {
             file << "rotation_deg = " << Vec3ToString(rotDeg) << "\n";
         }
 
-        if (auto* sprite = registry.try_get<Sprite>(entity)) {
+        if (auto* renderer = registry.try_get<ModelRenderer>(entity)) {
             bool wroteModel = false;
-            if (g_sceneAssetManager && sprite->modelId > 0) {
-                const std::string& modelKey = g_sceneAssetManager->GetModelKey(static_cast<unsigned int>(sprite->modelId));
+            if (g_sceneAssetManager && renderer->modelId > 0) {
+                const std::string& modelKey = g_sceneAssetManager->GetModelKey(static_cast<unsigned int>(renderer->modelId));
                 if (!modelKey.empty()) {
                     file << "model_asset = \"" << EscapeString(modelKey) << "\"\n";
                 }
             }
-            if (g_sceneModelManager && sprite->modelId > 0) {
-                const ModelSource* source = g_sceneModelManager->GetSource(static_cast<unsigned int>(sprite->modelId));
+            if (g_sceneModelManager && renderer->modelId > 0) {
+                const ModelSource* source = g_sceneModelManager->GetSource(static_cast<unsigned int>(renderer->modelId));
                 if (source) {
                     switch (source->type) {
                         case ModelSourceType::Path:
@@ -849,28 +870,28 @@ bool SaveSceneToFile(const std::string& path) {
                 }
             }
 
-            if (!wroteModel && sprite->modelId > 0) {
-                file << "model_id = " << sprite->modelId << "\n";
+            if (!wroteModel && renderer->modelId > 0) {
+                file << "model_id = " << renderer->modelId << "\n";
             }
-            file << "color = " << ColorToHexString(sprite->color) << "\n";
-            file << "outline_size = " << FloatToString(sprite->outlineSize) << "\n";
+            file << "color = " << ColorToHexString(renderer->color) << "\n";
+            file << "outline_size = " << FloatToString(renderer->outlineSize) << "\n";
             bool wroteShader = false;
-            if (g_sceneAssetManager && sprite->shaderId > 0) {
-                const std::string& shaderKey = g_sceneAssetManager->GetShaderKey(sprite->shaderId);
+            if (g_sceneAssetManager && renderer->shaderId > 0) {
+                const std::string& shaderKey = g_sceneAssetManager->GetShaderKey(renderer->shaderId);
                 if (!shaderKey.empty()) {
                     file << "shader_asset = \"" << EscapeString(shaderKey) << "\"\n";
                 }
             }
-            if (g_sceneShaderManager && sprite->shaderId > 0) {
-                const ShaderSource* source = g_sceneShaderManager->GetSource(sprite->shaderId);
+            if (g_sceneShaderManager && renderer->shaderId > 0) {
+                const ShaderSource* source = g_sceneShaderManager->GetSource(renderer->shaderId);
                 if (source && !source->vsPath.empty() && !source->fsPath.empty()) {
                     file << "shader_vs = \"" << EscapeString(source->vsPath) << "\"\n";
                     file << "shader_fs = \"" << EscapeString(source->fsPath) << "\"\n";
                     wroteShader = true;
                 }
             }
-            if (!wroteShader && sprite->shaderId > 0) {
-                file << "shader_id = " << sprite->shaderId << "\n";
+            if (!wroteShader && renderer->shaderId > 0) {
+                file << "shader_id = " << renderer->shaderId << "\n";
             }
         }
 
diff --git a/src/gui/GuiManager.cpp b/src/gui/GuiManager.cpp
index b2a6cad..a0639e2 100644
--- a/src/gui/GuiManager.cpp
+++ b/src/gui/GuiManager.cpp
@@ -1018,7 +1018,7 @@ void GuiManager::RenderInspectorWindow()
         {"Tag", 0},
         {"Transform", 1},
         {"Velocity", 2},
-        {"Sprite", 3},
+        {"Model Renderer", 3},
         {"Script", 4},
         {"Camera", 5},
         {"Light", 6},
@@ -1033,7 +1033,7 @@ void GuiManager::RenderInspectorWindow()
             case 0: return registry.any_of<Tag>(selectedEntity);
             case 1: return registry.any_of<ECSTransform>(selectedEntity);
             case 2: return registry.any_of<Velocity>(selectedEntity);
-            case 3: return registry.any_of<Sprite>(selectedEntity);
+            case 3: return registry.any_of<ModelRenderer>(selectedEntity);
             case 4: return registry.any_of<ScriptComponent>(selectedEntity);
             case 5: return registry.any_of<Camera3DComponent>(selectedEntity);
             case 6: return registry.any_of<LightComponent>(selectedEntity);
@@ -1090,7 +1090,7 @@ void GuiManager::RenderInspectorWindow()
                 registry.emplace<Velocity>(selectedEntity, Vector3{0.0f, 0.0f, 0.0f}, 0.0f);
                 break;
             case 3:
-                registry.emplace<Sprite>(selectedEntity, 0, WHITE, 0.0f, 0);
+                registry.emplace<ModelRenderer>(selectedEntity, 0, WHITE, 0.0f, 0);
                 break;
             case 4:
                 registry.emplace<ScriptComponent>(selectedEntity);
@@ -1224,11 +1224,11 @@ void GuiManager::RenderInspectorWindow()
         ImGui::EndDisabled();
     }
 
-    // Sprite
-    if (registry.any_of<Sprite>(selectedEntity)) {
-        auto& sprite = registry.get<Sprite>(selectedEntity);
+    // Model Renderer
+    if (registry.any_of<ModelRenderer>(selectedEntity)) {
+        auto& renderer = registry.get<ModelRenderer>(selectedEntity);
         ImGui::Separator();
-        ImGui::Text("Sprite");
+        ImGui::Text("Model Renderer");
 
         auto modelKeys = assets.ListModelKeys();
         std::sort(modelKeys.begin(), modelKeys.end());
@@ -1245,7 +1245,7 @@ void GuiManager::RenderInspectorWindow()
         }
 
         int modelIndex = 0;
-        std::string currentModelKey = assets.GetModelKey(static_cast<unsigned int>(sprite.modelId));
+        std::string currentModelKey = assets.GetModelKey(static_cast<unsigned int>(renderer.modelId));
         if (!currentModelKey.empty()) {
             auto it = std::find(modelKeys.begin(), modelKeys.end(), currentModelKey);
             if (it != modelKeys.end()) {
@@ -1255,15 +1255,15 @@ void GuiManager::RenderInspectorWindow()
         int selectedModelIndex = modelIndex;
         if (ImGui::Combo("Model Asset", &selectedModelIndex, modelLabelPtrs.data(), static_cast<int>(modelLabelPtrs.size()))) {
             if (selectedModelIndex == 0) {
-                sprite.modelId = 0;
+                renderer.modelId = 0;
             } else {
-                sprite.modelId = assets.GetModelId(modelKeys[selectedModelIndex - 1]);
+                renderer.modelId = assets.GetModelId(modelKeys[selectedModelIndex - 1]);
             }
         }
 
-        int modelId = static_cast<int>(sprite.modelId);
+        int modelId = static_cast<int>(renderer.modelId);
         if (ImGui::InputInt("Model Id", &modelId)) {
-            sprite.modelId = modelId < 0 ? 0 : static_cast<size_t>(modelId);
+            renderer.modelId = modelId < 0 ? 0 : static_cast<size_t>(modelId);
         }
 
         auto shaderKeys = assets.ListShaderKeys();
@@ -1281,7 +1281,7 @@ void GuiManager::RenderInspectorWindow()
         }
 
         int shaderIndex = 0;
-        std::string currentShaderKey = assets.GetShaderKey(sprite.shaderId);
+        std::string currentShaderKey = assets.GetShaderKey(renderer.shaderId);
         if (!currentShaderKey.empty()) {
             auto it = std::find(shaderKeys.begin(), shaderKeys.end(), currentShaderKey);
             if (it != shaderKeys.end()) {
@@ -1291,34 +1291,34 @@ void GuiManager::RenderInspectorWindow()
         int selectedShaderIndex = shaderIndex;
         if (ImGui::Combo("Shader Asset", &selectedShaderIndex, shaderLabelPtrs.data(), static_cast<int>(shaderLabelPtrs.size()))) {
             if (selectedShaderIndex == 0) {
-                sprite.shaderId = 0;
+                renderer.shaderId = 0;
             } else {
-                sprite.shaderId = assets.GetShaderId(shaderKeys[selectedShaderIndex - 1]);
+                renderer.shaderId = assets.GetShaderId(shaderKeys[selectedShaderIndex - 1]);
             }
         }
 
-        int shaderId = static_cast<int>(sprite.shaderId);
+        int shaderId = static_cast<int>(renderer.shaderId);
         if (ImGui::InputInt("Shader Id", &shaderId)) {
-            sprite.shaderId = shaderId < 0 ? 0 : static_cast<unsigned int>(shaderId);
+            renderer.shaderId = shaderId < 0 ? 0 : static_cast<unsigned int>(shaderId);
         }
 
         float color[4] = {
-            sprite.color.r / 255.0f,
-            sprite.color.g / 255.0f,
-            sprite.color.b / 255.0f,
-            sprite.color.a / 255.0f
+            renderer.color.r / 255.0f,
+            renderer.color.g / 255.0f,
+            renderer.color.b / 255.0f,
+            renderer.color.a / 255.0f
         };
         if (ImGui::ColorEdit4("Color", color)) {
-            sprite.color.r = static_cast<unsigned char>(color[0] * 255.0f);
-            sprite.color.g = static_cast<unsigned char>(color[1] * 255.0f);
-            sprite.color.b = static_cast<unsigned char>(color[2] * 255.0f);
-            sprite.color.a = static_cast<unsigned char>(color[3] * 255.0f);
+            renderer.color.r = static_cast<unsigned char>(color[0] * 255.0f);
+            renderer.color.g = static_cast<unsigned char>(color[1] * 255.0f);
+            renderer.color.b = static_cast<unsigned char>(color[2] * 255.0f);
+            renderer.color.a = static_cast<unsigned char>(color[3] * 255.0f);
         }
 
-        ImGui::DragFloat("Outline", &sprite.outlineSize, 0.05f, 0.0f, 10.0f);
+        ImGui::DragFloat("Outline", &renderer.outlineSize, 0.05f, 0.0f, 10.0f);
 
-        if (ImGui::Button("Remove Sprite")) {
-            registry.remove<Sprite>(selectedEntity);
+        if (ImGui::Button("Remove Model Renderer")) {
+            registry.remove<ModelRenderer>(selectedEntity);
         }
     }
 
diff --git a/src/scripting/ECSBindings.cpp b/src/scripting/ECSBindings.cpp
index 77ff808..0737509 100644
--- a/src/scripting/ECSBindings.cpp
+++ b/src/scripting/ECSBindings.cpp
@@ -135,57 +135,57 @@ void AS_RemoveVelocity(uint32_t entity) {
     registry->remove<Velocity>((entt::entity)entity);
 }
 
-// === Sprite Component ===
+// === ModelRenderer Component ===
 
-void AS_AddSprite(uint32_t entity, int modelId, uint32_t color, float outlineSize) {
+void AS_AddModelRenderer(uint32_t entity, int modelId, uint32_t color, float outlineSize) {
     if (!registry) return;
     Color col;
     col.r = (color >> 24) & 0xFF;
     col.g = (color >> 16) & 0xFF;
     col.b = (color >> 8) & 0xFF;
     col.a = color & 0xFF;
-    registry->emplace<Sprite>((entt::entity)entity, modelId, col, outlineSize);
+    registry->emplace<ModelRenderer>((entt::entity)entity, modelId, col, outlineSize);
 }
 
-void AS_SetSpriteColor(uint32_t entity, uint32_t color) {
+void AS_SetModelRendererColor(uint32_t entity, uint32_t color) {
     if (!registry) return;
-    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
-        s->color.r = (color >> 24) & 0xFF;
-        s->color.g = (color >> 16) & 0xFF;
-        s->color.b = (color >> 8) & 0xFF;
-        s->color.a = color & 0xFF;
+    if (auto* renderer = registry->try_get<ModelRenderer>((entt::entity)entity)) {
+        renderer->color.r = (color >> 24) & 0xFF;
+        renderer->color.g = (color >> 16) & 0xFF;
+        renderer->color.b = (color >> 8) & 0xFF;
+        renderer->color.a = color & 0xFF;
     }
 }
 
-void AS_SetSpriteModel(uint32_t entity, int modelId) {
+void AS_SetModelRendererModel(uint32_t entity, int modelId) {
     if (!registry) return;
-    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
-        s->modelId = modelId;
+    if (auto* renderer = registry->try_get<ModelRenderer>((entt::entity)entity)) {
+        renderer->modelId = modelId;
     }
 }
 
-void AS_SetSpriteOutline(uint32_t entity, float outlineSize) {
+void AS_SetModelRendererOutline(uint32_t entity, float outlineSize) {
     if (!registry) return;
-    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
-        s->outlineSize = outlineSize;
+    if (auto* renderer = registry->try_get<ModelRenderer>((entt::entity)entity)) {
+        renderer->outlineSize = outlineSize;
     }
 }
 
-void AS_SetSpriteShader(uint32_t entity, unsigned int shaderId) {
+void AS_SetModelRendererShader(uint32_t entity, unsigned int shaderId) {
     if (!registry) return;
-    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
-        s->shaderId = shaderId;
+    if (auto* renderer = registry->try_get<ModelRenderer>((entt::entity)entity)) {
+        renderer->shaderId = shaderId;
     }
 }
 
-bool AS_HasSprite(uint32_t entity) {
+bool AS_HasModelRenderer(uint32_t entity) {
     if (!registry) return false;
-    return registry->all_of<Sprite>((entt::entity)entity);
+    return registry->all_of<ModelRenderer>((entt::entity)entity);
 }
 
-void AS_RemoveSprite(uint32_t entity) {
+void AS_RemoveModelRenderer(uint32_t entity) {
     if (!registry) return;
-    registry->remove<Sprite>((entt::entity)entity);
+    registry->remove<ModelRenderer>((entt::entity)entity);
 }
 
 // === Texture Component ===
@@ -568,33 +568,33 @@ void RegisterECSBindings(asIScriptEngine *engine) {
                                        asFUNCTION(AS_RemoveVelocity), asCALL_CDECL);
     assert(r >= 0);
 
-    // Sprite component
-    r = engine->RegisterGlobalFunction("void AddSprite(uint, int, uint, float = 0.0f)",
-                                       asFUNCTION(AS_AddSprite), asCALL_CDECL);
+    // ModelRenderer component
+    r = engine->RegisterGlobalFunction("void AddModelRenderer(uint, int, uint, float = 0.0f)",
+                                       asFUNCTION(AS_AddModelRenderer), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("void SetSpriteColor(uint, uint)",
-                                       asFUNCTION(AS_SetSpriteColor), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("void SetModelRendererColor(uint, uint)",
+                                       asFUNCTION(AS_SetModelRendererColor), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("void SetSpriteModel(uint, int)",
-                                       asFUNCTION(AS_SetSpriteModel), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("void SetModelRendererModel(uint, int)",
+                                       asFUNCTION(AS_SetModelRendererModel), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("void SetSpriteOutline(uint, float)",
-                                       asFUNCTION(AS_SetSpriteOutline), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("void SetModelRendererOutline(uint, float)",
+                                       asFUNCTION(AS_SetModelRendererOutline), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("void SetSpriteShader(uint, uint)",
-                                       asFUNCTION(AS_SetSpriteShader), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("void SetModelRendererShader(uint, uint)",
+                                       asFUNCTION(AS_SetModelRendererShader), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("bool HasSprite(uint)",
-                                       asFUNCTION(AS_HasSprite), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("bool HasModelRenderer(uint)",
+                                       asFUNCTION(AS_HasModelRenderer), asCALL_CDECL);
     assert(r >= 0);
 
-    r = engine->RegisterGlobalFunction("void RemoveSprite(uint)",
-                                       asFUNCTION(AS_RemoveSprite), asCALL_CDECL);
+    r = engine->RegisterGlobalFunction("void RemoveModelRenderer(uint)",
+                                       asFUNCTION(AS_RemoveModelRenderer), asCALL_CDECL);
     assert(r >= 0);
 
     // Texture component
diff --git a/tests/scenegraph_tests.cpp b/tests/scenegraph_tests.cpp
index 9b6dc0a..5cc09c7 100644
--- a/tests/scenegraph_tests.cpp
+++ b/tests/scenegraph_tests.cpp
@@ -164,8 +164,8 @@ void test_scene_loader_basic(void) {
         if (childHierarchy) {
             TEST_CHECK(childHierarchy->parent == parentEntity);
         }
-        TEST_CHECK(registry.all_of<Sprite>(parentEntity));
-        TEST_CHECK(registry.all_of<Sprite>(childEntity));
+        TEST_CHECK(registry.all_of<ModelRenderer>(parentEntity));
+        TEST_CHECK(registry.all_of<ModelRenderer>(childEntity));
     }
 
     std::filesystem::remove(scenePath);