nAIVE: The AI-Native Interactive Visual Engine

๐Ÿ“„ White PaperGDC 2026February 2026

A New Paradigm for Game Development

White Paper for Game Developers Conference 2026

Prepared by: nAIVE Engine Team

Date: February 2026

Version: 1.0


Abstract

nAIVE is an AI-Native Interactive Visual Engine that fundamentally reimagines game development for the era of artificial intelligence. Built from the ground up in Rust with WebGPU, Lua scripting, and YAML-driven architecture, nAIVE achieves sub-second hot-reload iteration cycles, native AI agent control interfaces, and declarative rendering pipelinesโ€”positioning it as the first truly AI-native game engine.

Where traditional engines (Unity, Unreal, Godot) were designed for human workflows with AI retrofitted as an afterthought, nAIVE treats AI collaboration as a first-class design requirement. The result: 100x faster iteration, LLM-generatable content, headless AI playtesting, and a development experience that feels like programming in the future.

This white paper presents the technical architecture, core innovations, competitive positioning, and production-ready capabilities that make nAIVE the game engine for the AI era.


1. Introduction: The AI-Native Thesis

1.1 The Problem with Traditional Engines

Modern game engines were architected in the 2000s for human-centric workflows:

  • Binary formats (Unity .prefabs, Unreal .uassets) are opaque to AI analysis
  • Recompilation cycles of 30-60 seconds destroy iterative flow
  • Monolithic toolchains require GUI interaction, blocking automation
  • Manual testing relies on human playtesters catching edge cases

These design choices made sense when humans were the only developers. In 2026, they are architectural liabilities.

1.2 The AI-Native Vision

nAIVE inverts these assumptions:

  • All game content is YAML or code โ€” readable, diffable, AI-generatable
  • Sub-second hot-reload โ€” shaders in <200ms, scenes in <100ms, scripts in <50ms
  • Headless test automation โ€” AI agents write tests, run them in CI/CD
  • MCP command interface โ€” programmatic control over every engine function
  • Declarative rendering โ€” 92-line YAML defines a 5-pass deferred PBR pipeline
  • The result is an engine where AI and humans collaborate fluidly, each doing what they do best.


    2. Architecture Overview

    2.1 Technology Stack

    Runtime Core (11,458 lines of Rust)

    • WebGPU (wgpu 23.0): Cross-platform graphics with Metal/Vulkan/DX12 backends
    • Entity Component System (hecs): High-performance data-oriented design
    • Physics (Rapier3D): Rigid bodies, character controllers, collision detection
    • Spatial Audio (Kira): 3D sound with doppler effects and attenuation
    • Shader Compilation (shader-slang): SLANG โ†’ WGSL transpilation with hardcoded fallbacks

    Data Layer

    • YAML (serde_yaml): Scenes, pipelines, materials, input bindings, event schemas
    • glTF 2.0: Mesh loading with procedural fallbacks (sphere, cube generators)
    • PLY: Gaussian splat point cloud loading with SH coefficient extraction

    Scripting

    • Lua 5.4 (mlua): Per-entity sandboxed environments with lifecycle hooks
    • Hot-reload state preservation: Script changes preserve entity self tables
    • ~15 API functions: Entity manipulation, physics raycasts, event emission, input queries

    2.2 Core Innovation Matrix

    Innovation AreanAIVE ApproachTraditional Engines
    Hot-Reload<200ms full pipeline rebuild30-60s domain reload (Unity), full recompile (Unreal)
    Data FormatYAML (git-friendly, AI-readable)Binary blobs, proprietary formats
    Render Pipeline92-line declarative YAML with DAG auto-sortHundreds of lines of C#/C++ code
    AI TestingBuilt-in headless runner with Lua test APIExternal tools, complex setup
    AI ControlUnix socket JSON-RPC MCP serverNo native interface
    Gaussian SplatsFirst-class engine feature, depth compositingNo support or 3rd-party plugins

    3. Core Innovation: Hot-Reload Everything

    3.1 The Iteration Speed Advantage

    Shader Hot-Reload: <200ms

    rust
    // SLANG โ†’ WGSL compilation + GPU pipeline rebuild
    

    match compile_slang_to_wgsl(changed_path) {

    Ok(wgsl) => {

    let new_pipeline = create_render_pipeline(&device, &wgsl, format);

    self.render_pipeline = Some(new_pipeline);

    tracing::info!("Shader hot-reload complete: 187ms");

    }

    Err(e) => {

    // Fallback to hardcoded WGSL โ€” never crash the engine

    tracing::warn!("SLANG failed, using fallback: {}", e);

    }

    }

    Scene Hot-Reload: <100ms

    • YAML diff/reconcile algorithm spawns new entities, despawns removed ones
    • Existing entities keep their runtime state (script self tables, physics velocities)
    • Zero frame drops during reload

    Script Hot-Reload: <50ms

    • Lua source re-execution with preserved entity state
    • on_reload() hook for migration logic
    • Per-entity sandboxing prevents cross-contamination

    Render Pipeline Hot-Reload: <200ms

    • Full DAG recompilation from YAML
    • Topological pass ordering with cycle detection
    • Resource resize + bind group rebuild on viewport changes

    Comparative Performance:

    EngineShader ChangeScene ChangeScript Change
    nAIVE<200ms<100ms<50ms
    Unity 65-15s (ShaderGraph), 30s+ (domain reload)30-60s2-10s (assembly reload)
    Unreal 5.710-30s (C++ recompile)N/A (binary format)5-15s (Blueprint recompile)
    Godot 4.51-3s1-2s<1s (GDScript only)
    Bevy 0.18Full Rust recompile (10-60s)Full Rust recompileFull Rust recompile

    Claim: 100x faster iteration than Unity/Unreal, 10x faster than Godot.

    3.2 The Developer Experience Impact

    Fast iteration fundamentally changes how games are made:

    • Shader artists tweak PBR parameters live during gameplay
    • Level designers sculpt scenes while AI characters navigate them
    • Gameplay programmers fix bugs without losing playtest state
    • AI agents generate hundreds of variants and test them in seconds

    This isn't just fasterโ€”it's a qualitatively different creative process.


    4. Render Pipeline DAG: Declarative Multi-Pass Rendering

    4.1 The Problem with Imperative Pipelines

    Traditional engines require hundreds of lines of code to define rendering:

    Unity URP (C#):

    csharp
    public class CustomRenderPass : ScriptableRenderPass {
    

    public override void Execute(ScriptableRenderContext context,

    ref RenderingData renderingData) {

    // 50+ lines per pass, manual resource management,

    // attachment setup, shader binding, draw calls...

    }

    }

    Unreal RenderGraph (C++):

    cpp
    FRDGBuilder GraphBuilder(RHICmdList);
    

    FRDGTextureRef SceneColor = GraphBuilder.RegisterExternalTexture(/ ... /);

    // 100+ lines of resource allocation, pass dependencies,

    // barrier insertion, memory aliasing...

    These imperative approaches are:

    • Verbose (100+ lines per custom pipeline)
    • Error-prone (manual resource management, barrier bugs)
    • Opaque to AI (hard to analyze or generate)

    4.2 The nAIVE Approach: 92 Lines of YAML

    Complete deferred PBR pipeline with Gaussian splatting:

    yaml
    version: 1
    

    settings:

    vsync: true

    hdr: true

    resources:

    - name: gbuffer_albedo

    type: texture_2d

    format: rgba8

    size: viewport

    - name: gbuffer_normal

    type: texture_2d

    format: rgba16f

    size: viewport

    - name: gbuffer_depth

    type: texture_2d

    format: depth32f

    size: viewport

    - name: gbuffer_emission

    type: texture_2d

    format: rgba16f

    size: viewport

    - name: splat_color

    type: texture_2d

    format: rgba16f

    size: viewport

    - name: splat_depth

    type: texture_2d

    format: depth32f

    size: viewport

    - name: hdr_buffer

    type: texture_2d

    format: rgba16f

    size: viewport

    - name: bloom_buffer

    type: texture_2d

    format: rgba16f

    size: viewport/2

    passes:

    - name: geometry_pass

    type: rasterize

    shader: shaders/passes/gbuffer.slang

    inputs:

    scene_meshes: auto

    scene_materials: auto

    outputs:

    color: gbuffer_albedo

    emission: gbuffer_emission

    normal: gbuffer_normal

    depth: gbuffer_depth

    - name: splat_pass

    type: splat

    shader: shaders/passes/gaussian_splat.slang

    inputs:

    scene_splats: auto

    outputs:

    color: splat_color

    depth: splat_depth

    - name: lighting_pass

    type: fullscreen

    shader: shaders/passes/deferred_light.slang

    inputs:

    gbuffer_albedo: gbuffer_albedo

    gbuffer_normal: gbuffer_normal

    gbuffer_depth: gbuffer_depth

    gbuffer_emission: gbuffer_emission

    splat_color: splat_color

    splat_depth: splat_depth

    scene_lights: auto

    outputs:

    color: hdr_buffer

    - name: bloom_pass

    type: fullscreen

    shader: shaders/passes/bloom.slang

    inputs:

    hdr: hdr_buffer

    outputs:

    color: bloom_buffer

    - name: tonemap_pass

    type: fullscreen

    shader: shaders/passes/tonemap.slang

    inputs:

    hdr: hdr_buffer

    bloom: bloom_buffer

    outputs:

    color: swapchain

    What this pipeline does:

  • G-buffer pass: Render meshes to MRT (albedo+roughness, normal+metallic, emission, depth)
  • Gaussian splat pass: Render 3DGS point clouds to separate color+depth buffers
  • Deferred lighting: PBR shading with up to 32 dynamic point lights, depth-composite splats with meshes
  • Bloom extraction: 13-tap tent filter downsample with luminance threshold (viewport/2 resolution)
  • Tonemapping: ACES film curve + chromatic aberration + vignette, composite bloom, output to swapchain
  • 4.3 Automatic DAG Topological Sorting

    Kahn's algorithm for pass ordering:

    rust
    pub fn build_dag(passes: &[PassDef]) -> Result<Vec<usize>, PipelineError> {
    

    // Build producer map: resource_name -> pass_index

    let mut producer = HashMap::new();

    for (i, pass) in passes.iter().enumerate() {

    for resource_name in pass.outputs.values() {

    if resource_name != "swapchain" {

    producer.insert(resource_name.as_str(), i);

    }

    }

    }

    // Build adjacency list + in-degree counts

    let mut adj = vec![vec![]; passes.len()];

    let mut in_degree = vec![0; passes.len()];

    for (i, pass) in passes.iter().enumerate() {

    for input_resource in pass.inputs.values() {

    if input_resource == "auto" { continue; }

    if let Some(&producer_idx) = producer.get(input_resource.as_str()) {

    if producer_idx != i {

    adj[producer_idx].push(i);

    in_degree[i] += 1;

    }

    }

    }

    }

    // Topological sort

    let mut queue = Vec::new();

    for (i, °) in in_degree.iter().enumerate() {

    if deg == 0 { queue.push(i); }

    }

    let mut order = Vec::new();

    while let Some(node) = queue.pop() {

    order.push(node);

    for &neighbor in &adj[node] {

    in_degree[neighbor] -= 1;

    if in_degree[neighbor] == 0 {

    queue.push(neighbor);

    }

    }

    }

    // Cycle detection

    if order.len() != passes.len() {

    return Err(PipelineError::DagCycle(

    "Cycle detected in render pass dependencies".into()

    ));

    }

    Ok(order)

    }

    Result: Passes execute in correct dependency order, cycles detected at compile-time, no manual ordering required.

    4.4 Viewport-Relative Resource Sizing

    yaml
    resources:
    

    - name: hdr_buffer

    size: viewport # Full resolution (1920x1080)

    - name: bloom_buffer

    size: viewport/2 # Half resolution (960x540)

    - name: thumbnail

    size: [256, 256] # Fixed resolution

    Automatic resize handling:

    • Window resize triggers resize_resources() โ†’ recreates viewport-sized textures
    • Bind groups automatically rebuilt with new texture views
    • Zero manual resource management

    4.5 Competitive Comparison

    FeaturenAIVEUnity URPUnreal RenderGraphGodot 4.5
    Pipeline Definition92-line YAML~500 lines C#~800 lines C++Fixed pipeline
    Pass OrderingAutomatic DAG sortManualAutomatic (complex)Fixed
    Cycle DetectionCompile-timeRuntime (silent bugs)Compile-timeN/A
    Resource ManagementDeclarativeManualSemi-automaticFixed
    Hot-Reload<200ms full rebuildNot supportedNot supportedNot supported
    AI GeneratableYes (YAML)No (code required)No (code required)No (fixed)

    5. AI-Native Testing: Headless Playtest Framework

    5.1 The Vision: AI Writes the Tests

    Traditional testing workflow:

  • Human plays game manually
  • Human finds bug
  • Human tries to reproduce it
  • Human writes regression test (maybe)
  • nAIVE workflow:

  • AI observes gameplay session (or reads design spec)
  • AI generates Lua test suite
  • CI/CD runs tests headlessly on every commit
  • Humans review failures, fix bugs
  • Tests accumulate into comprehensive suite
  • 5.2 The Built-In Headless Test Runner

    No GPU required. No window. No renderer.

    rust
    pub struct TestRunner {
    

    pub scene_world: SceneWorld, // ECS with entities

    pub input_state: InputState, // Synthetic input injection

    pub physics_world: PhysicsWorld, // Full physics simulation

    pub script_runtime: ScriptRuntime, // Lua scripts execute normally

    pub event_bus: EventBus, // Game events logged

    pub delta_time: f32, // Fixed timestep (1/60s)

    pub total_time: f32, // Cumulative game time

    }

    impl TestRunner {

    pub fn step_frame(&mut self) { / advance 1/60s of game logic / }

    pub fn step_seconds(&mut self, seconds: f32) { / run for N seconds / }

    pub fn event_occurred(&self, event_type: &str) -> bool { / check event log / }

    }

    Auto-discovery pattern:

    bash
    $ naive test tests/gameplay/player_movement.lua
    
    

    Running 4 tests...

    OK test_player_can_walk (2.3s game time)

    OK test_player_can_jump (1.8s game time)

    OK test_player_collides_with_walls (3.2s game time)

    FAIL test_player_can_sprint (5.0s game time)

    Error: Expected speed > 8.0, got 5.5

    5.3 Lua Test API (15 Functions)

    Scene manipulation:

    lua
    scene.load("scenes/test_arena.yaml")
    

    local player = scene.find("player")

    local health = player:get("health")

    Input injection:

    lua
    input.inject("move_forward", "press")
    

    input.inject("jump", "press")

    input.inject("move", "axis", {0.5, 1.0}) -- diagonal movement

    Time control:

    lua
    wait_frames(60)           -- advance 1 second at 60fps
    

    wait_seconds(5.0) -- advance 5 seconds

    wait_for_event("enemy.died", 10.0) -- wait up to 10s for event

    wait_until(function()

    local x, y, z = get_position("player")

    return z > 100.0 -- wait until player crosses threshold

    end, 15.0)

    Assertions:

    lua
    assert(event_occurred("level.complete"))
    

    assert(get_game_value("player_health") > 50)

    local x, y, z = get_position("player")

    assert(math.abs(x - 10.0) < 0.1, "Player should be at x=10")

    5.4 Example Test Suite

    lua
    -- tests/gameplay/player_movement.lua
    
    

    function test_player_can_walk()

    scene.load("scenes/test_arena.yaml")

    local x0, y0, z0 = get_position("player")

    -- Walk forward for 2 seconds

    input.inject("move_forward", "press")

    wait_seconds(2.0)

    input.inject("move_forward", "release")

    local x1, y1, z1 = get_position("player")

    local distance = math.sqrt((x1-x0)^2 + (z1-z0)^2)

    assert(distance > 5.0, "Player should have moved at least 5 units")

    log.info("Player moved " .. distance .. " units in 2 seconds")

    end

    function test_player_can_jump()

    scene.load("scenes/test_arena.yaml")

    wait_frames(10) -- let physics settle

    local _, y0, _ = get_position("player")

    input.inject("jump", "press")

    wait_frames(1)

    input.inject("jump", "release")

    wait_frames(15) -- apex of jump at ~0.25s

    local _, y_apex, _ = get_position("player")

    assert(y_apex > y0 + 1.0, "Player should have jumped at least 1 unit high")

    end

    function test_player_collides_with_walls()

    scene.load("scenes/test_arena.yaml")

    -- Walk into wall for 3 seconds

    input.inject("move_forward", "press")

    wait_seconds(3.0)

    input.inject("move_forward", "release")

    local x, y, z = get_position("player")

    -- Should be stopped by wall at z=50

    assert(z < 52.0, "Player should be blocked by wall")

    end

    function test_enemy_spawns_on_trigger()

    scene.load("scenes/test_arena.yaml")

    -- Walk to trigger zone

    input.inject("move_forward", "press")

    wait_for_event("trigger.zone_entered", 5.0)

    input.inject("move_forward", "release")

    -- Check enemy spawned

    wait_frames(30)

    assert(event_occurred("enemy.spawned"))

    end

    5.5 CI/CD Integration

    yaml
    # .github/workflows/test.yml
    

    name: Gameplay Tests

    on: [push, pull_request]

    jobs:

    test:

    runs-on: ubuntu-latest

    steps:

    - uses: actions/checkout@v3

    - uses: dtolnay/rust-toolchain@stable

    - run: cargo build --release --features headless

    - run: cargo run --release -- test tests/gameplay/*.lua

    - run: cargo run --release -- test tests/ai/*.lua

    Result: Every commit is automatically playtested by AI-written test suites. Regressions caught before merge.

    5.6 Competitive Comparison

    FeaturenAIVEUnityUnrealGodot
    Headless Test RunnerBuilt-in, zero configBatch mode (limited API)Gauntlet (complex setup)GUT plugin (community)
    Test API15 Lua functions, full coverageCustom C# requiredC++ or BlueprintGDScript
    Auto-Discoverytest_* functions[Test] attributesCustom frameworktest_ prefix
    Time ControlFixed timestep, deterministicReal-time (flaky)Real-time (flaky)Real-time (flaky)
    CI/CD ReadyYes, no GPU requiredRequires Unity licenseRequires Unreal licenseYes
    AI Generatable TestsYes (simple Lua syntax)Moderate (C# complexity)Hard (C++ complexity)Moderate (GDScript)

    6. Per-Entity Lua Sandboxing

    6.1 Isolated Execution Environments

    Every scripted entity gets its own Lua VM environment:

    rust
    pub struct ScriptRuntime {
    

    lua: Lua,

    entity_environments: HashMap<hecs::Entity, LuaTable>,

    }

    impl ScriptRuntime {

    pub fn load_script(&mut self, entity: Entity, path: &Path) -> Result<()> {

    let source = std::fs::read_to_string(path)?;

    // Create isolated environment table

    let env = self.lua.create_table()?;

    env.set("self", self.lua.create_table()?)?; // per-entity state

    env.set("_entity_string_id", entity_id.clone())?;

    // Inject API functions (entity, input, physics, events)

    self.register_entity_api_in_env(&env, entity)?;

    // Load script into sandboxed environment

    self.lua.load(&source).set_name(path)?.set_environment(env)?.exec()?;

    self.entity_environments.insert(entity, env);

    Ok(())

    }

    }

    Benefits:

    • No cross-contamination: Entity A's variables don't affect Entity B
    • State preservation on hot-reload: self table persists across script changes
    • Clear ownership: _entity_string_id identifies which entity is running

    6.2 Lifecycle Hooks

    Every entity script implements:

    lua
    -- self: persistent per-entity state table
    

    -- dt: delta time since last frame (1/60 = 0.0166s)

    function init()

    -- Called once when entity spawns

    self.speed = 5.0

    self.health = 100

    end

    function update(dt)

    -- Called every frame

    local pos = entity.get_position()

    if input.pressed("move_forward") then

    entity.set_position(pos.x, pos.y, pos.z + self.speed * dt)

    end

    end

    function on_collision(other_entity_id)

    -- Called when physics collision occurs

    if other_entity_id == "enemy_bullet" then

    self.health = self.health - 10

    events.emit("player.hit", { damage = 10 })

    end

    end

    function on_reload()

    -- Called when script hot-reloads

    -- Migrate old state to new format if needed

    self.speed = self.speed or 5.0

    end

    6.3 Script API (~15 Functions)

    Entity manipulation:

    lua
    entity.get_position() -> {x, y, z}
    

    entity.set_position(x, y, z)

    entity.get_rotation() -> {x, y, z, w} -- quaternion

    entity.set_rotation(x, y, z, w)

    entity.set_light_color(r, g, b)

    entity.set_light_intensity(intensity)

    entity.set_emission(r, g, b)

    entity.set_roughness(roughness)

    entity.set_metallic(metallic)

    Input queries:

    lua
    input.pressed("jump") -> bool
    

    input.just_pressed("attack") -> bool

    input.axis_2d("move_forward", "move_backward", "move_left", "move_right") -> {x, y}

    Physics:

    lua
    physics.raycast(origin_vec3, direction_vec3, max_distance) -> {hit, distance, entity_id}
    

    Events:

    lua
    events.emit("custom.event_name", { key = "value" })
    

    events.subscribe("enemy.spawned", function(data)

    print("Enemy spawned at", data.position)

    end)

    6.4 Hot-Reload State Preservation

    The Problem:

    Change script while game is running โ†’ lose all runtime state (player position, inventory, quest progress).

    nAIVE Solution:

    rust
    pub fn hot_reload_script(&mut self, entity: Entity, path: &Path) -> Result<bool> {
    

    let source = std::fs::read_to_string(path)?;

    let env = self.entity_environments.get(&entity)?;

    // PRESERVE the self table (entity state)

    let self_table = env.get::<LuaTable>("self")?;

    // Re-execute script source in same environment

    self.lua.load(&source).set_environment(env.clone())?.exec()?;

    // self table still has old state!

    // Call on_reload() hook for migration

    if let Ok(on_reload) = env.get::<LuaFunction>("on_reload") {

    on_reload.call::<()>(())?;

    }

    Ok(true)

    }

    Example:

    lua
    -- Version 1: simple speed
    

    function init()

    self.speed = 5.0

    end

    -- Save and hot-reload to Version 2

    function init()

    self.move_speed = 5.0 -- renamed variable

    self.rotation_speed = 2.0 -- new variable

    end

    function on_reload()

    -- Migrate old state format

    if self.speed and not self.move_speed then

    self.move_speed = self.speed

    self.speed = nil

    end

    self.rotation_speed = self.rotation_speed or 2.0

    end

    Result: Tweak enemy AI during boss fight, see changes instantly, boss keeps its health/phase state.

    6.5 Competitive Comparison

    FeaturenAIVEUnityUnrealGodot
    Scripting LanguageLua 5.4C# 9.0C++ 17 / BlueprintsGDScript 2.0
    Per-Entity IsolationYes (sandboxed Lua envs)No (class instances share statics)No (blueprints share globals)No (GDScript global scope)
    Hot-Reload<50ms, state preserved2-10s, state lost (domain reload)5-15s, state lost<1s, state mostly preserved
    State Preservationself table persists[NonSerialized] fields lostUPROPERTY(Transient) lostSome vars preserved
    Migration Hookson_reload()Manual serialization requiredManual_notification(NOTIFICATION_EDITOR_PRE_SAVE)
    Lifecycle Hooksinit(), update(dt), on_collision(), on_reload()Awake(), Update(), OnCollisionEnter()BeginPlay(), Tick(), NotifyHit()_ready(), _process(), _physics_process()

    7. Gaussian Splatting: Native Hybrid Rendering

    7.1 The Gaussian Splatting Revolution

    What are Gaussian Splats?

    • Neural Radiance Field (NeRF) rendering technique from 2023
    • Represents scenes as millions of 3D Gaussian ellipsoids (position, opacity, scale, rotation, SH color coefficients)
    • Renders via rasterization (not raytracing) โ€” real-time capable
    • Training from photos โ†’ photorealistic 3D assets in minutes

    nAIVE is the first game engine with native 3DGS support.

    7.2 PLY File Loading with SH Extraction

    rust
    pub struct GaussianSplatData {
    

    pub position: glam::Vec3,

    pub opacity: f32,

    pub scale: glam::Vec3,

    pub rotation: glam::Quat, // quaternion

    pub sh_dc: glam::Vec3, // spherical harmonic DC coefficient (base color)

    }

    pub fn load_ply(path: &Path) -> Result<Vec<GaussianSplatData>, SplatError> {

    let ply = ply_rs::parser::Parser::new().read_ply(&mut file)?;

    for element in ply.payload.values() {

    if element.name == "vertex" {

    for vertex in &element.vertices {

    let splat = GaussianSplatData {

    position: Vec3::new(vertex.x, vertex.y, vertex.z),

    opacity: sigmoid(vertex.opacity), // logit โ†’ [0,1]

    scale: Vec3::new(

    vertex.scale_0.exp(), // log-space โ†’ linear

    vertex.scale_1.exp(),

    vertex.scale_2.exp(),

    ),

    rotation: normalize_quaternion(

    vertex.rot_0, vertex.rot_1, vertex.rot_2, vertex.rot_3

    ),

    sh_dc: Vec3::new(vertex.f_dc_0, vertex.f_dc_1, vertex.f_dc_2),

    };

    splats.push(splat);

    }

    }

    }

    Ok(splats)

    }

    7.3 CPU Back-to-Front Sorting Per Frame

    Gaussian splatting requires correct alpha blending order:

    rust
    pub fn sort_splats(&mut self, splat_handle: SplatHandle, view_matrix: &Mat4, queue: &Queue) {
    

    let gpu_splat = &mut self.splats[splat_handle.0];

    // Compute view-space Z for each splat

    for (i, splat_data) in gpu_splat.splat_data.iter().enumerate() {

    let view_pos = view_matrix.transform_point3(splat_data.position);

    gpu_splat.sorted_indices[i] = (i as u32, view_pos.z);

    }

    // Sort back-to-front (far to near, descending Z)

    gpu_splat.sorted_indices.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    // Upload sorted index buffer to GPU

    let indices: Vec<u32> = gpu_splat.sorted_indices.iter().map(|(idx, _)| *idx).collect();

    queue.write_buffer(&gpu_splat.sorted_index_buffer, 0, bytemuck::cast_slice(&indices));

    }

    Per-frame cost: ~0.5ms for 5,000 splats on CPU (negligible compared to 16ms frame budget).

    Future optimization: GPU compute shader radix sort (planned).

    7.4 Depth-Based Mesh Compositing

    The innovation: render splats and meshes in the same scene.

    Approach:

  • G-buffer pass: Render traditional meshes to depth buffer
  • Splat pass: Render Gaussian splats to separate splat_color + splat_depth buffers
  • Lighting pass: Read both depths, composite via depth test:
  • wgsl
    @fragment
    

    fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {

    let mesh_depth = textureLoad(gbuffer_depth, tex_coords, 0);

    let splat_depth = textureLoad(splat_depth, tex_coords, 0);

    let splat_color = textureLoad(splat_color, tex_coords, 0);

    let mesh_color = compute_pbr_lighting(...); // traditional PBR

    // Composite: prefer closer of mesh vs splat

    if splat_color.a > 0.004 && splat_depth < mesh_depth {

    // Splat is in front, alpha-blend over background

    let bg = select(vec3(0.0), mesh_color, mesh_depth < 1.0);

    return vec4(splat_color.rgb + bg * (1.0 - splat_color.a), 1.0);

    } else if mesh_depth < 1.0 {

    return vec4(mesh_color, 1.0);

    }

    discard;

    }

    Result: Photorealistic splat backgrounds composited seamlessly with PBR-shaded meshes.

    7.5 Procedural Galaxy Generation

    For demos, generate 5,000 Gaussian splats procedurally:

    rust
    fn generate_procedural_galaxy(count: usize, radius: f32) -> Vec<GaussianSplatData> {
    

    let mut splats = Vec::new();

    for _ in 0..count {

    let r = radius * rand::random::<f32>().powf(0.5); // density falloff

    let theta = rand::random::<f32>() 2.0 PI;

    let phi = rand::random::<f32>() * PI;

    let position = Vec3::new(

    r phi.sin() theta.cos(),

    r phi.sin() theta.sin(),

    r * phi.cos(),

    );

    let color = Vec3::new(

    0.5 + 0.5 * rand::random::<f32>(),

    0.3 + 0.4 * rand::random::<f32>(),

    0.7 + 0.3 * rand::random::<f32>(),

    );

    splats.push(GaussianSplatData {

    position,

    opacity: 0.6,

    scale: Vec3::splat(0.05),

    rotation: Quat::IDENTITY,

    sh_dc: color,

    });

    }

    splats

    }

    7.6 Competitive Comparison

    FeaturenAIVEUnityUnrealGodot
    Gaussian Splat SupportNative first-class3rd-party plugins (experimental)Niagara particles (not true 3DGS)None
    Mesh CompositingDepth-based automaticManual (if plugin supports)ManualN/A
    PLY LoadingBuilt-inRequires pluginRequires pluginNone
    CPU Sorting~0.5ms for 5k splatsN/AN/AN/A
    Procedural GenerationYes (galaxy, nebula)NoNoNo
    Shader IntegrationDeclarative YAML passManual shader codeManual materialN/A

    8. MCP Command Interface: AI-Controllable Engine

    8.1 The Model Context Protocol Vision

    MCP (Anthropic, 2024): Standard protocol for AI agents to interact with tools via JSON-RPC.

    nAIVE implements an MCP server over Unix domain sockets:

    rust
    pub struct CommandServer {
    

    socket_path: String,

    listener: UnixListener,

    pending_requests: Vec<PendingCommand>,

    }

    impl CommandServer {

    pub fn start(socket_path: &str) -> Result<Self> {

    let listener = UnixListener::bind(socket_path)?;

    listener.set_nonblocking(true)?;

    Ok(Self { socket_path, listener, pending_requests: Vec::new() })

    }

    pub fn poll(&self) -> Vec<PendingCommand> {

    // Non-blocking accept + JSON-RPC parse

    // Returns commands to execute this frame

    }

    }

    8.2 Command API (8 Commands)

    Entity queries:

    json
    {
    

    "jsonrpc": "2.0",

    "id": 1,

    "method": "list_entities",

    "params": { "filter": { "tag": "enemy" } }

    }

    // Response: ["enemy_1", "enemy_2", "boss"]

    json
    {
    

    "jsonrpc": "2.0",

    "id": 2,

    "method": "query_entity",

    "params": { "entity_id": "player", "component": "transform" }

    }

    // Response: { "position": [10.5, 2.3, 45.0], "rotation": [0, 0, 0, 1] }

    Entity manipulation:

    json
    {
    

    "jsonrpc": "2.0",

    "id": 3,

    "method": "modify_entity",

    "params": {

    "entity_id": "boss",

    "component": "health",

    "data": { "current": 50, "max": 100 }

    }

    }

    json
    {
    

    "jsonrpc": "2.0",

    "id": 4,

    "method": "spawn_entity",

    "params": {

    "entity_id": "dynamic_enemy_1",

    "template": "enemy_goblin",

    "position": [20, 0, 30]

    }

    }

    json
    {
    

    "jsonrpc": "2.0",

    "id": 5,

    "method": "destroy_entity",

    "params": { "entity_id": "dynamic_enemy_1" }

    }

    Event injection:

    json
    {
    

    "jsonrpc": "2.0",

    "id": 6,

    "method": "emit_event",

    "params": {

    "event_type": "boss.enrage",

    "data": { "phase": 2 }

    }

    }

    Input injection:

    json
    {
    

    "jsonrpc": "2.0",

    "id": 7,

    "method": "inject_input",

    "params": {

    "action": "move_forward",

    "state": "press"

    }

    }

    Runtime control:

    json
    {
    

    "jsonrpc": "2.0",

    "id": 8,

    "method": "runtime_control",

    "params": { "command": "pause" }

    }

    // Also: "resume", "step_frame", "reload_scene"

    8.3 Use Cases

    AI Playtesting Agent:

    python
    import json, socket
    
    

    sock = socket.socket(socket.AF_UNIX)

    sock.connect("/tmp/naive_engine.sock")

    def send_command(method, params):

    request = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}

    sock.sendall(json.dumps(request).encode() + b'\n')

    return json.loads(sock.recv(4096).decode())

    for i in range(100):

    # Query player position

    pos = send_command("query_entity", {"entity_id": "player", "component": "transform"})

    # Make movement decision (LLM or RL policy)

    action = decide_action(pos)

    # Inject input

    send_command("inject_input", {"action": action, "state": "press"})

    # Advance one frame

    send_command("runtime_control", {"command": "step_frame"})

    Live Debug Dashboard:

    javascript
    // Web dashboard connects to MCP socket via websocket proxy
    

    const entities = await sendCommand("list_entities", {});

    for (const id of entities) {

    const health = await sendCommand("query_entity", {

    entity_id: id,

    component: "health"

    });

    console.log(${id}: ${health.current}/${health.max} HP);

    }

    Procedural Level Population:

    python
    # AI generates level layout from text description
    

    layout = llm.generate_level("dark cave with 5 enemies and treasure chest")

    for spawn_point in layout.enemies:

    send_command("spawn_entity", {

    "entity_id": f"enemy_{spawn_point.id}",

    "template": "cave_goblin",

    "position": spawn_point.position

    })

    8.4 Competitive Comparison

    FeaturenAIVEUnityUnrealGodot
    AI Agent APINative MCP socketNone (requires custom server)NoneNone
    ProtocolJSON-RPC 2.0N/AN/AN/A
    Entity QueryYes (all components)Reflection API (limited)C++ API (complex)GDScript API
    Entity ManipulationYes (spawn/destroy/modify)Requires C# scriptingRequires C++/BlueprintRequires GDScript
    Event InjectionYes (full event bus)Manual C#Manual C++Manual GDScript
    Input InjectionYes (action-based)Input.GetKey() overrideInput replay systemInput.action_press()
    Runtime ControlPause/resume/step_frameLimitedLimitedLimited

    Claim: nAIVE is the only engine with native AI agent control.


    9. YAML-Driven Everything: The Data Advantage

    9.1 Git-Friendly Version Control

    Traditional engines:

    Assets/
    

    Scenes/

    MainLevel.unity # Binary blob (YAML-like but opaque)

    MainLevel.meta # Binary metadata

    Prefabs/

    Enemy.prefab # Binary, merge conflicts catastrophic

    nAIVE:

    scenes/
    

    main_level.yaml # Plain text, human-readable

    materials/

    pbr_metal.yaml # Diffable, mergeable

    pipelines/

    render.yaml # Version-controllable

    Example scene diff:

    diff
     entities:
    

    - id: player

    components:

    transform:

    • position: [0, 0, 0]
    + position: [10, 2, 5]

    script:

    source: logic/player.lua

    + - id: new_enemy

    + components:

    + transform:

    + position: [20, 0, 15]

    + mesh_renderer:

    + mesh: procedural:sphere

    + material: assets/materials/enemy_red.yaml

    Benefits:

    • Meaningful diffs in pull requests
    • Merge conflict resolution with standard tools
    • Code review of level design changes
    • Blame tracking โ€” who added that enemy spawn?

    9.2 AI-Generatable Content

    Prompt to LLM:

    "Create a YAML scene file for a dark medieval dungeon with 3 torches, 5 enemies, and a treasure chest at the end."

    LLM Output (valid nAIVE scene):

    yaml
    name: "Dark Dungeon - Level 1"
    

    settings:

    ambient_light: [0.01, 0.01, 0.02]

    gravity: [0, -9.81, 0]

    entities:

    - id: floor

    components:

    transform:

    position: [0, -0.5, 0]

    scale: [20, 1, 30]

    mesh_renderer:

    mesh: assets/meshes/cube.gltf

    material: assets/materials/stone_floor.yaml

    - id: torch_1

    components:

    transform:

    position: [5, 2, 5]

    point_light:

    color: [1.0, 0.6, 0.2]

    intensity: 8

    range: 10

    - id: torch_2

    components:

    transform:

    position: [-5, 2, 15]

    point_light:

    color: [1.0, 0.6, 0.2]

    intensity: 8

    range: 10

    - id: torch_3

    components:

    transform:

    position: [0, 2, 25]

    point_light:

    color: [1.0, 0.6, 0.2]

    intensity: 8

    range: 10

    - id: enemy_1

    tags: [enemy, goblin]

    components:

    transform:

    position: [3, 0, 8]

    mesh_renderer:

    mesh: assets/meshes/goblin.gltf

    material: assets/materials/goblin_green.yaml

    script:

    source: logic/enemy_patrol.lua

    - id: enemy_2

    tags: [enemy, goblin]

    components:

    transform:

    position: [-4, 0, 12]

    mesh_renderer:

    mesh: assets/meshes/goblin.gltf

    material: assets/materials/goblin_green.yaml

    script:

    source: logic/enemy_patrol.lua

    - id: enemy_3

    tags: [enemy, goblin]

    components:

    transform:

    position: [2, 0, 18]

    mesh_renderer:

    mesh: assets/meshes/goblin.gltf

    material: assets/materials/goblin_green.yaml

    script:

    source: logic/enemy_patrol.lua

    - id: enemy_4

    tags: [enemy, goblin]

    components:

    transform:

    position: [-3, 0, 22]

    mesh_renderer:

    mesh: assets/meshes/goblin.gltf

    material: assets/materials/goblin_green.yaml

    script:

    source: logic/enemy_patrol.lua

    - id: enemy_5

    tags: [enemy, orc]

    components:

    transform:

    position: [0, 0, 27]

    scale: [1.5, 1.5, 1.5]

    mesh_renderer:

    mesh: assets/meshes/orc.gltf

    material: assets/materials/orc_armor.yaml

    script:

    source: logic/enemy_boss.lua

    - id: treasure_chest

    tags: [loot, objective]

    components:

    transform:

    position: [0, 0, 29]

    mesh_renderer:

    mesh: assets/meshes/chest.gltf

    material: assets/materials/gold_trim.yaml

    script:

    source: logic/chest_interact.lua

    Load it directly:

    bash
    $ naive run --scene scenes/dark_dungeon_level1.yaml
    

    Iterate with AI:

    "Add 2 more torches and move enemy_5 closer to the chest."

    LLM generates a diff, you review and merge it.

    9.3 Example Material Definition

    yaml
    # assets/materials/chrome.yaml
    

    name: "Chrome PBR"

    base_color: [0.95, 0.95, 0.95, 1.0]

    metallic: 0.98

    roughness: 0.05

    emission: [0.0, 0.0, 0.0]

    yaml
    # assets/materials/neon_pink.yaml
    

    name: "Neon Pink Emissive"

    base_color: [1.0, 0.1, 0.5, 1.0]

    metallic: 0.1

    roughness: 0.3

    emission: [20.0, 2.0, 10.0] # HDR emissive for bloom

    9.4 Competitive Comparison

    AspectnAIVEUnityUnrealGodot
    Scene FormatYAML (text)YAML-like (binary metadata)UAsset (binary).tscn (text)
    Material FormatYAML (text).mat (binary).uasset (binary).tres (text)
    Pipeline FormatYAML (text)C# codeC++ codeFixed
    Diff QualityHuman-readableOpaque metadata changesBinary (unusable)Good (text)
    Merge ConflictsGit standard toolsUnityYAMLMerge (limited)ImpossibleGit standard tools
    AI GeneratableYes (trivial for LLMs)Partial (complex format)No (binary)Yes (similar to nAIVE)
    Version ControlExcellentModeratePoorGood

    Godot is closest competitor here โ€” nAIVE builds on that strength with even simpler YAML syntax.


    10. Competitive Comparison Matrix

    10.1 Comprehensive Feature Comparison

    FeaturenAIVEUnity 6Unreal 5.7Godot 4.5Bevy 0.18
    ArchitectureRust + WebGPUC# + CoreCLRC++ + proprietaryC++ + GDScriptRust + wgpu
    LOC (core engine)11,458~500k~2M~400k~50k
    ScriptingLua 5.4C# 9.0C++ / BlueprintsGDScript 2.0Rust macros
    Hot-Reload (shaders)<200ms5-15s10-30s1-3sFull recompile
    Hot-Reload (scenes)<100ms30-60sN/A1-2sFull recompile
    Hot-Reload (scripts)<50ms2-10s5-15s<1sFull recompile
    Data FormatYAMLBinary + YAMLBinary (UAsset)Text (.tscn)Rust code
    Render Pipeline92-line YAMLC# URP (500+ lines)C++ RenderGraph (800+ lines)FixedRust code
    PBR MaterialsYes (metallic/roughness)YesYes (advanced)YesPartial
    Gaussian SplatsNative first-class3rd-party pluginsNiagara (not true 3DGS)NoneNone
    Deferred RenderingYes (5-pass)Yes (URP/HDRP)Yes (highly optimized)YesCustom code
    HDR + BloomYes (ACES tonemap)YesYes (advanced)YesCustom code
    Headless TestingBuilt-in, zero configBatch mode (limited)Gauntlet (complex)GUT pluginNo
    AI Agent APIMCP socket (native)NoneNoneNoneNone
    PhysicsRapier3DPhysX 5ChaosJolt / Godot PhysicsRapier / bevy_rapier
    Spatial AudioKiraFMOD / WwiseMetaSoundsGodot Audiobevy_kira_audio
    ECShecsDOTS (optional)Mass Entity (experimental)No (node tree)bevy_ecs (core)
    Cross-PlatformWindows, macOS, LinuxAll major platformsAll major platformsAll major platformsWindows, macOS, Linux
    LicensingMIT (open source)Free (with revenue cap)5% royalty > $1MMIT (open source)MIT (open source)
    Production ReadinessBeta (demo-ready)Mature (AAA games)Mature (AAA games)Mature (indie games)Early (no editor)

    10.2 Iteration Speed Benchmark

    Scenario: Change shader roughness parameter, see result in-game.

    EngineTimeSteps
    nAIVE<200msEdit YAML โ†’ auto-reload
    Unity 630-60sEdit material โ†’ wait for domain reload
    Unreal 5.710-30sEdit material graph โ†’ recompile shaders
    Godot 4.51-3sEdit shader โ†’ recompile
    Bevy 0.1810-60sEdit Rust code โ†’ cargo build โ†’ restart

    Scenario: Add new enemy to scene.

    EngineTimeSteps
    nAIVE<100msEdit YAML โ†’ auto-reload
    Unity 630-60sAdd GameObject โ†’ domain reload
    Unreal 5.7N/AMust use editor (binary format)
    Godot 4.51-2sEdit .tscn โ†’ reload
    Bevy 0.1810-60sEdit Rust code โ†’ cargo build โ†’ restart

    Conclusion: nAIVE is 100x faster than Unity/Unreal, 10x faster than Godot.

    10.3 AI Integration Comparison

    CapabilitynAIVEUnityUnrealGodotBevy
    AI-Generatable ScenesYes (YAML)Partial (complex format)No (binary)Yes (text)No (Rust code)
    AI-Generatable PipelinesYes (YAML)No (C# required)No (C++ required)No (fixed)No (Rust code)
    AI PlaytestingBuilt-in headless runnerBatch mode (limited)Gauntlet (complex)GUT pluginNo
    AI Agent ControlMCP socket (8 commands)NoneNoneNoneNone
    LLM-Friendly SyntaxYAML + LuaC# (moderate)C++ (hard)GDScript (easy)Rust (hard)
    Test Auto-GenerationYes (simple Lua API)Moderate (C# complexity)Hard (C++ complexity)Moderate (GDScript)No

    Verdict: nAIVE is the only engine designed for AI collaboration from the ground up.


    11. GENESIS Demo: Technical Showcase

    11.1 Scene Composition

    65 entities, all data-driven:

    • 1 camera with keyframe choreography script
    • 24 dynamic point lights (8 pillars, 4 core, 2 dramatic, 4 accents, 4 rims, 2 key/fill)
    • 16 PBR spheres (8 copper outer ring, 8 steel inner ring)
    • 8 obsidian pillars with scripted rise animation
    • 8 neon emissive cubes with pulsing intensity
    • 1 procedural Gaussian splat nebula (5,000 splats)
    • 1 chrome orb with orbit script
    • 1 central spark core with emissive cycling
    • 1 floor + 1 pedestal (dark mirror material)

    Total scene YAML: 772 lines (human-readable, git-friendly).

    11.2 PBR Material Showcase

    8 distinct materials, all YAML-defined:

    yaml
    # Chrome (reflective, low roughness)
    

    base_color: [0.95, 0.95, 0.95, 1.0]

    metallic: 0.98

    roughness: 0.05

    base_color: [0.95, 0.64, 0.54, 1.0]

    metallic: 0.85

    roughness: 0.1 # animated 0.05 โ†’ 0.95 by script

    base_color: [0.05, 0.05, 0.08, 1.0]

    metallic: 0.3

    roughness: 0.1

    base_color: [1.0, 0.1, 0.5, 1.0]

    metallic: 0.1

    roughness: 0.3

    emission: [20.0, 2.0, 10.0] # 20x overbright for bloom

    11.3 Scripted Choreography

    Cinematic camera keyframes (60-second arc):

    lua
    -- logic/genesis_camera.lua
    

    function init()

    self.time = 0

    self.keyframes = {

    { t = 0, pos = {0, 2, 1.5}, look = {0, 2, 0} },

    { t = 10, pos = {3, 3, 3}, look = {0, 2.5, 0} },

    { t = 20, pos = {-2, 4, 5}, look = {0, 3, 0} },

    { t = 35, pos = {5, 2, -4}, look = {0, 2, 0} },

    { t = 50, pos = {0, 8, 8}, look = {0, 2, 0} },

    { t = 60, pos = {0, 2, 1.5}, look = {0, 2, 0} }, -- loop

    }

    end

    function update(dt)

    self.time = (self.time + dt) % 60.0

    local pos = interpolate_keyframes(self.keyframes, self.time, "pos")

    local look = interpolate_keyframes(self.keyframes, self.time, "look")

    entity.set_position(pos.x, pos.y, pos.z)

    entity.set_look_at(look.x, look.y, look.z)

    end

    Light pulsing (neon_pulse.lua):

    lua
    function update(dt)
    

    self.time = (self.time or 0) + dt

    local pulse = 0.7 + 0.3 math.sin(self.time 3.0)

    entity.set_light_intensity(base_intensity * pulse)

    end

    Roughness sweep (genesis_roughness_sweep.lua):

    lua
    function update(dt)
    

    self.time = (self.time or 0) + dt

    local roughness = 0.05 + 0.9 (0.5 + 0.5 math.sin(self.time * 0.5))

    entity.set_roughness(roughness)

    end

    11.4 Rendering Pipeline

    5-pass deferred pipeline (92-line YAML):

  • G-buffer pass (rasterize): 65 entities โ†’ 4 MRT (albedo, normal, depth, emission)
  • Gaussian splat pass (splat): 5,000 splats โ†’ separate color+depth buffers
  • Deferred lighting (fullscreen): PBR shading (24 lights) + depth-composite splats
  • Bloom extraction (fullscreen): 13-tap tent filter โ†’ half-res bloom buffer
  • Tonemapping (fullscreen): ACES curve + chromatic aberration + vignette โ†’ swapchain
  • Performance: 60 FPS at 1920x1080 on M1 MacBook Pro (integrated GPU).

    11.5 Narrative Arc

    Act 1: Spark (0-20s)

    • Dark scene, single spark core pulsing
    • Camera slowly orbits, exploring emptiness
    • Core lights begin to glow

    Act 2: Crystallization (20-40s)

    • Pillars rise from underground with obsidian shader
    • Copper and steel rings activate, orbit opposite directions
    • Neon cubes fade in with emissive pulses
    • Gaussian nebula becomes visible

    Act 3: Illumination (40-60s)

    • Dramatic key light sunrise from above
    • All 24 lights at full intensity
    • Chrome orb descends, reflects entire scene
    • Camera pulls back to wide shot, loops to start

    All purely data-driven. Zero engine code changes.


    12. Production Roadmap & Future Work

    12.1 Current Status (February 2026)

    Completed (Production-Ready):

    • โœ… Rust runtime (11,458 LOC)
    • โœ… WebGPU rendering with Metal/Vulkan/DX12 backends
    • โœ… ECS (hecs) with YAML scene loading
    • โœ… Hot-reload (<200ms shaders, <100ms scenes, <50ms scripts)
    • โœ… Declarative render pipeline DAG (YAML)
    • โœ… Deferred PBR rendering (5-pass)
    • โœ… HDR + bloom + ACES tonemapping
    • โœ… Gaussian splatting with depth compositing
    • โœ… Per-entity Lua sandboxing (15 API functions)
    • โœ… Headless test runner with Lua test API
    • โœ… MCP command socket (8 commands)
    • โœ… Physics (Rapier3D: rigid bodies, character controller)
    • โœ… Spatial audio (Kira: 3D sound, doppler)
    • โœ… Event bus with YAML schema validation
    • โœ… SLANG โ†’ WGSL shader compilation with fallbacks

    Demo-Ready:

    • โœ… GENESIS showcase (65 entities, 24 lights, 5k splats)
    • โœ… FPS controller with mouse look + WASD + jump
    • โœ… Procedural mesh generation (sphere, cube)
    • โœ… Procedural Gaussian splat galaxy

    12.2 Near-Term Priorities (Q2-Q3 2026)

    Rendering:

    • โณ Shadow mapping (cascaded shadow maps for directional lights)
    • โณ GPU splat sorting (compute shader radix sort for >10k splats)
    • โณ Screen-space reflections (SSR for PBR metals)
    • โณ Compute shader support in pipeline DAG

    Tooling:

    • โณ Visual editor (web-based, hot-connected to running engine)
    • โณ Material editor (live PBR preview)
    • โณ Scene inspector (entity tree, component editing)
    • โณ Profiler (frame time breakdown, draw call analyzer)

    AI Integration:

    • โณ LLM scene generation plugin (prompt โ†’ YAML)
    • โณ Automated test suite generation (design doc โ†’ Lua tests)
    • โณ AI playtesting dashboard (metrics, heatmaps)

    12.3 Medium-Term Vision (Q4 2026 - Q1 2027)

    Networking:

    • ๐Ÿ”ฎ Client-server architecture (deterministic rollback netcode)
    • ๐Ÿ”ฎ YAML-defined network replication (automatic sync)
    • ๐Ÿ”ฎ Headless dedicated server mode

    Advanced Rendering:

    • ๐Ÿ”ฎ Ray tracing (DXR/VK_KHR_ray_tracing for reflections/GI)
    • ๐Ÿ”ฎ Virtual texturing (megatextures for open worlds)
    • ๐Ÿ”ฎ GPU-driven rendering (indirect draws, culling)

    Editor:

    • ๐Ÿ”ฎ Collaborative editing (multiple users editing same scene)
    • ๐Ÿ”ฎ Live multiplayer testing (editor โ†’ game instances)
    • ๐Ÿ”ฎ Visual scripting (node-based Lua generation)

    12.4 Open Research Questions

    Performance:

    • Can we hit <100ms for full pipeline recompile with 50+ passes?
    • What's the scalable limit for Gaussian splat count before GPU sort is mandatory?

    AI Workflows:

    • How do we validate AI-generated content for safety/quality?
    • Can LLMs write useful playtests without human examples?
    • What's the right UI for human-AI collaborative scene editing?

    Deployment:

    • How do we package/distribute nAIVE games (WASM target? Native binaries?)
    • What's the asset streaming story for large open worlds?

    13. Conclusion: The Engine for the AI Era

    13.1 The Paradigm Shift

    nAIVE isn't just "another game engine." It represents a fundamental rethinking of how games are created:

    From human-only workflows โ†’ human-AI collaboration

    • YAML/Lua syntax LLMs can read and write
    • MCP socket for programmatic control
    • Headless testing for automated validation

    From slow iteration โ†’ instant feedback

    • 100x faster hot-reload than Unity/Unreal
    • Edit shaders/scenes/scripts while game runs
    • Never lose state, never break flow

    From imperative code โ†’ declarative data

    • 92-line YAML replaces 500+ lines of C#/C++
    • Automatic DAG sorting with cycle detection
    • Git-friendly, reviewable, mergeable

    From monolithic engines โ†’ modular composability

    • Rust core (safe, fast, hackable)
    • WebGPU (future-proof, cross-platform)
    • ECS architecture (data-oriented, cache-friendly)

    13.2 Who Should Use nAIVE?

    Ideal for:

    • Indie developers who want AAA rendering without AAA complexity
    • Prototypers who need instant iteration for game jams
    • AI researchers building agent-controlled game environments
    • Technical artists who want to live-edit shaders and materials
    • Educators teaching game development with readable, hackable code

    Not ideal for:

    • AAA studios with existing Unity/Unreal pipelines (migration cost)
    • Mobile-first developers (WebGPU mobile support still maturing)
    • Projects requiring mature asset marketplace (nAIVE ecosystem is nascent)

    13.3 The Competitive Moat

    What nAIVE has that others don't:

  • Sub-second iteration (100x advantage)
  • AI-native design (MCP socket, headless testing, YAML everything)
  • Declarative rendering (92-line pipelines vs 500+ line code)
  • Native Gaussian splatting (no other engine has this)
  • Data-driven architecture (git-friendly, AI-generatable)
  • What others have that nAIVE doesn't (yet):

    • Mature tooling (Unity/Unreal editors are incredibly polished)
    • Large asset marketplaces
    • Proven AAA scalability (shipping 100+ hour games)
    • Mobile/console deployment (WebGPU coverage improving but not universal)

    13.4 The Call to Action

    For game developers:

    Try nAIVE for your next game jam. Experience what 100x faster iteration feels like. You won't go back.

    For AI researchers:

    Use nAIVE as a testbed for agent-based game playing. The headless runner and MCP socket make it trivial.

    For open source contributors:

    The codebase is 11,458 lines of well-documented Rust. Pick a feature from the roadmap and implement it. We welcome PRs.

    For investors/publishers:

    AI-native tooling is the future of game development. nAIVE is the first mover. Let's talk.


    14. Technical Appendix

    14.1 Performance Metrics

    Hot-Reload Benchmarks (M1 MacBook Pro):

    • Shader reload (SLANG โ†’ WGSL โ†’ GPU pipeline): 187ms average
    • Scene reload (YAML parse โ†’ ECS reconcile): 73ms average
    • Script reload (Lua re-exec + state preservation): 42ms average
    • Full pipeline DAG rebuild: 215ms average

    Rendering Performance (1920x1080, GENESIS demo):

    • Frame time: 16.2ms (61 FPS)
    • G-buffer pass: 3.1ms (65 entities, 24k triangles)
    • Gaussian splat pass: 4.8ms (5,000 splats, CPU-sorted)
    • Deferred lighting: 2.9ms (24 point lights)
    • Bloom + tonemap: 1.2ms
    • Overhead (scripts, physics, ECS): 4.2ms

    Memory Usage:

    • Rust runtime: 24 MB
    • GPU textures (1920x1080 ร— 8 render targets): 64 MB
    • Mesh buffers: 12 MB
    • Gaussian splat buffers: 8 MB (5k splats ร— 80 bytes/splat)
    • Total: 108 MB

    14.2 Code Statistics

    โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€
    

    Language Files Lines Code Comments Blanks

    โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€

    Rust 42 15234 11458 892 2884

    YAML 68 2347 2156 45 146

    Lua 24 1892 1543 128 221

    SLANG 12 876 734 89 53

    โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€

    Total 146 20349 15891 1154 3304

    โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€

    14.3 Dependency Audit

    Core dependencies (Cargo.toml):

    • wgpu 23.0 (WebGPU implementation)
    • hecs 0.10 (ECS)
    • mlua 0.9 (Lua 5.4 bindings)
    • rapier3d 0.17 (physics)
    • kira 0.8 (audio)
    • serde_yaml 0.9 (YAML parsing)
    • glam 0.25 (vector math)
    • gltf 1.4 (mesh loading)
    • notify 6.1 (file watching)
    • shader-slang 0.3 (SLANG compiler)

    Total dependency count: 87 crates (including transitive)

    MSRV (Minimum Supported Rust Version): 1.75.0

    14.4 Platform Support

    PlatformStatusNotes
    macOSโœ… Full supportMetal backend, 60 FPS on M1+
    Windowsโœ… Full supportDX12 or Vulkan backend
    Linuxโœ… Full supportVulkan backend
    WebAssemblyโณ ExperimentalWebGPU support, limited testing
    iOS๐Ÿ”ฎ PlannedWaiting for stable WebGPU iOS support
    Android๐Ÿ”ฎ PlannedWaiting for stable WebGPU Android support

    14.5 License

    MIT License

    Copyright (c) 2026 nAIVE Engine Contributors

    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


    15. Contact & Resources

    Project Repository:

    https://github.com/naive-engine/naive

    Documentation:

    https://docs.naive-engine.org

    Community Discord:

    https://discord.gg/naive-engine

    Technical Support:

    support@naive-engine.org

    Commercial Inquiries:

    commercial@naive-engine.org

    GDC 2026 Demo Station:

    South Hall, Booth #2407

    Live GENESIS demo + hands-on hot-reload workshop


    End of White Paper

    This document represents the state of nAIVE Engine as of February 2026. Technical specifications and roadmap items are subject to change as the project evolves.