diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1c9a7a7..23f011c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [ "main", "master" ]
+    branches: ["main", "master"]
   pull_request:
 
 jobs:
@@ -29,4 +29,4 @@ jobs:
         run: zig build
 
       - name: Run tests
-        run: zig build test
\ No newline at end of file
+        run: zig build test
diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index 800618d..0000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "zig.testArgs": [
-        "build",
-        "test",
-        "-Dtest-filter=${filter}"
-    ],
-    "cursor.composer.textSizeScale": 1,
-    "cursor.cpp.enablePartialAccepts": true,
-    "cursor.inlineDiff.mode": "diffs"
-}
\ No newline at end of file
diff --git a/build.zig b/build.zig
index 43e9695..17166ac 100644
--- a/build.zig
+++ b/build.zig
@@ -98,6 +98,31 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    // Create main executable
+    const exe = b.addExecutable(.{
+        .name = "mfs-engine",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/bin/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+
+    exe.root_module.addImport("mfs", lib);
+    exe.root_module.addOptions("build_options", options);
+    addPlatformDependencies(exe, target.result.os.tag);
+    b.installArtifact(exe);
+
+    // Create run step for main executable
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the main executable");
+    run_step.dependOn(&run_cmd.step);
+
     // Add memory manager tests
     const memory_manager_tests = b.addTest(.{
         .name = "memory-manager-tests",
@@ -107,6 +132,7 @@ pub fn build(b: *std.Build) void {
             .optimize = optimize,
         }),
     });
+
     memory_manager_tests.root_module.addImport("mfs", lib);
     memory_manager_tests.root_module.addOptions("build_options", options);
     addPlatformDependencies(memory_manager_tests, target.result.os.tag);
@@ -130,36 +156,10 @@ pub fn build(b: *std.Build) void {
     test_step.dependOn(&memory_manager_tests.step);
     test_step.dependOn(&vulkan_backend_tests.step);
 
-    // const examples = [_][]const u8{
-    //     "vulkan_spinning_cube_simple",
-    //     "vulkan_spinning_cube_real",
-    //     "vulkan_rt_spinning_cube",
-    // };
-
-    // for (examples) |example| {
-    //     const exe = b.addExecutable(.{
-    //         .name = example,
-    //         .root_module = b.createModule(.{
-    //             .root_source_file = b.path(b.fmt("examples/{s}/main.zig", .{example})),
-    //             .target = target,
-    //             .optimize = optimize,
-    //         }),
-    //     });
-
-    //     // Optionally link Vulkan system library for examples
-    //     addOptionalLibrary(exe, "vulkan-1");
-
-    //     // Link with main library
-    //     exe.linkLibrary(lib);
-
-    //     b.installArtifact(exe);
-
-    //     const run_cmd = b.addRunArtifact(exe);
-    //     run_cmd.step.dependOn(b.getInstallStep());
-
-    //     const run_step = b.step(b.fmt("run-{s}", .{example}), b.fmt("Run the {s} example", .{example}));
-    //     run_step.dependOn(&run_cmd.step);
-    // }
+    // Build tests, tools, and web target
+    buildTests(b, target, optimize, lib, options);
+    buildTools(b, target, optimize, lib, options);
+    buildWebTarget(b, target, optimize, lib, options);
 }
 
 fn addBuildOptions(options: *std.Build.Step.Options, target: std.Target) void {
@@ -254,12 +254,14 @@ fn buildTools(
     for (tools) |tool| {
         const exe = b.addExecutable(.{
             .name = tool.name,
-            .root_source_file = b.path(tool.path),
-            .target = target,
-            .optimize = optimize,
+            .root_module = b.createModule(.{
+                .root_source_file = b.path(tool.path),
+                .target = target,
+                .optimize = optimize,
+            }),
         });
         exe.root_module.addImport("mfs", mfs);
-        exe.addOptions("build_options", options);
+        exe.root_module.addOptions("build_options", options);
         addPlatformDependencies(exe, target.result.os.tag);
         b.installArtifact(exe);
     }
@@ -287,9 +289,11 @@ fn buildWebTarget(
 
     const web_exe = b.addExecutable(.{
         .name = "mfs-web",
-        .root_source_file = b.path("src/main.zig"),
-        .target = web_target,
-        .optimize = .ReleaseSmall,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = web_target,
+            .optimize = .ReleaseSmall,
+        }),
     });
 
     web_exe.root_module.addImport("mfs", mfs);
diff --git a/build/build_spinning_cube.zig b/build/build_spinning_cube.zig
index 70f63c6..10d592b 100644
--- a/build/build_spinning_cube.zig
+++ b/build/build_spinning_cube.zig
@@ -1,17 +1,48 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) void {
+    // #region agent log
+    const log_path = ".cursor/debug.log";
+    if (std.fs.cwd().openFile(log_path, .{ .mode = .write_only })) |file| {
+        defer file.close();
+        _ = file.writeAll("{\"id\":\"log_build_entry\",\"location\":\"build/build_spinning_cube.zig:4\",\"message\":\"Build function entry\",\"data\":{\"hypothesisId\":\"A\"},\"sessionId\":\"debug-session\",\"runId\":\"run1\"}\n") catch {};
+    } else |_| {}
+    // #endregion
+
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    // #region agent log
+    if (std.fs.cwd().openFile(log_path, .{ .mode = .write_only })) |file| {
+        defer file.close();
+        _ = file.writeAll("{\"id\":\"log_target_optimize\",\"location\":\"build/build_spinning_cube.zig:13\",\"message\":\"Target and optimize set\",\"data\":{\"hypothesisId\":\"A\"},\"sessionId\":\"debug-session\",\"runId\":\"run1\"}\n") catch {};
+    } else |_| {}
+    // #endregion
+
     // Create the spinning cube executable
+    // #region agent log
+    if (std.fs.cwd().openFile(log_path, .{ .mode = .write_only })) |file| {
+        defer file.close();
+        _ = file.writeAll("{\"id\":\"log_before_addExecutable\",\"location\":\"build/build_spinning_cube.zig:20\",\"message\":\"Before addExecutable call\",\"data\":{\"source_file\":\"src/render/opengl_cube.zig\",\"hypothesisId\":\"B\"},\"sessionId\":\"debug-session\",\"runId\":\"run1\"}\n") catch {};
+    } else |_| {}
+    // #endregion
+
     const spinning_cube = b.addExecutable(.{
         .name = "spinning_cube",
-        .root_source_file = b.path("src/spinning_cube_app.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("../src/render/opengl_cube.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
 
+    // #region agent log
+    if (std.fs.cwd().openFile(log_path, .{ .mode = .write_only })) |file| {
+        defer file.close();
+        _ = file.writeAll("{\"id\":\"log_after_addExecutable\",\"location\":\"build/build_spinning_cube.zig:30\",\"message\":\"After addExecutable call\",\"data\":{\"hypothesisId\":\"A\"},\"sessionId\":\"debug-session\",\"runId\":\"run1\"}\n") catch {};
+    } else |_| {}
+    // #endregion
+
     // Add build options
     const build_options = b.addOptions();
     build_options.addOption(bool, "enable_tracy", false);
@@ -26,7 +57,7 @@ pub fn build(b: *std.Build) void {
     build_options.addOption(bool, "is_desktop", true);
     build_options.addOption([]const u8, "target_os", @tagName(target.result.os.tag));
 
-    spinning_cube.addOptions("build_options", build_options);
+    spinning_cube.root_module.addOptions("build_options", build_options);
 
     // Link system libraries based on platform
     switch (target.result.os.tag) {
@@ -71,7 +102,7 @@ pub fn build(b: *std.Build) void {
     // Create test step
     const spinning_cube_tests = b.addTest(.{
         .root_module = b.createModule(.{
-            .root_source_file = b.path("src/spinning_cube_app.zig"),
+            .root_source_file = b.path("../src/render/opengl_cube.zig"),
             .target = target,
             .optimize = optimize,
         }),
diff --git a/docs/AGENT_INTEGRATION_PLAN.md b/docs/AGENT_INTEGRATION_PLAN.md
index 5e0f585..cf7a66b 100644
--- a/docs/AGENT_INTEGRATION_PLAN.md
+++ b/docs/AGENT_INTEGRATION_PLAN.md
@@ -2,7 +2,8 @@
 
 ## 🎯 **Integration Objectives**
 
-### Primary Goals:
+### Primary Goals
+
 1. **Automate Development Workflow**
    - Code generation and review
    - Documentation updates
@@ -24,6 +25,7 @@
 ## 📋 **Integration Areas**
 
 ### 1. **Code Development**
+
 - **Automated Code Generation**
   - Generate boilerplate code for new features
   - Create test cases automatically
@@ -37,6 +39,7 @@
   - Security scanning
 
 ### 2. **Documentation**
+
 - **Auto-Generated Docs**
   - API documentation
   - Code comments
@@ -49,6 +52,7 @@
   - Best practices guides
 
 ### 3. **Testing & Quality**
+
 - **Test Generation**
   - Unit test creation
   - Integration test setup
@@ -62,6 +66,7 @@
   - Regression testing
 
 ### 4. **Build & Deployment**
+
 - **CI/CD Integration**
   - Automated builds
   - Deployment scripts
@@ -71,6 +76,7 @@
 ## 🔧 **Technical Integration Points**
 
 ### 1. **GitHub Integration**
+
 ```yaml
 # .github/workflows/agent-integration.yml
 name: Agent Integration
@@ -93,6 +99,7 @@ jobs:
 ```
 
 ### 2. **Development Workflow**
+
 ```bash
 # Agent-assisted development commands
 ./scripts/agent-code-review.sh
@@ -102,6 +109,7 @@ jobs:
 ```
 
 ### 3. **Configuration Files**
+
 ```json
 // .cursor-agent-config.json
 {
@@ -125,6 +133,7 @@ jobs:
 ## 🎯 **Specific MFS Engine Integration**
 
 ### 1. **Graphics Engine Assistance**
+
 - **Shader Generation**
   - GLSL shader templates
   - WebGL optimization
@@ -136,6 +145,7 @@ jobs:
   - Cross-platform compatibility
 
 ### 2. **WebAssembly Support**
+
 - **WASM Optimization**
   - Size optimization
   - Performance tuning
@@ -147,6 +157,7 @@ jobs:
   - HTML demo creation
 
 ### 3. **Documentation Enhancement**
+
 - **Interactive Demos**
   - Live code examples
   - Performance benchmarks
@@ -160,17 +171,20 @@ jobs:
 ## 📊 **Expected Benefits**
 
 ### 1. **Development Speed**
+
 - 40% faster code generation
 - 60% reduced documentation time
 - 50% faster testing setup
 
 ### 2. **Code Quality**
+
 - Automated code review
 - Style guide enforcement
 - Performance optimization
 - Security scanning
 
 ### 3. **Project Management**
+
 - Automated issue tracking
 - Feature development assistance
 - Release automation
@@ -179,6 +193,7 @@ jobs:
 ## 🚀 **Implementation Steps**
 
 ### Phase 1: Setup & Configuration
+
 1. **Agent Configuration**
    - Set up agent with MFS Engine context
    - Configure language-specific rules
@@ -190,6 +205,7 @@ jobs:
    - Documentation automation
 
 ### Phase 2: Core Features
+
 1. **Code Generation**
    - Template-based code generation
    - Test case creation
@@ -201,6 +217,7 @@ jobs:
    - Security scanning
 
 ### Phase 3: Advanced Features
+
 1. **Intelligent Assistance**
    - Context-aware suggestions
    - Performance optimization
@@ -221,14 +238,16 @@ jobs:
 
 ## 🔍 **Monitoring & Metrics**
 
-### Key Metrics:
+### Key Metrics
+
 - **Code Quality**: Coverage, complexity, performance
 - **Development Speed**: Time to feature completion
 - **Documentation**: Completeness, accuracy, usefulness
 - **User Experience**: Demo functionality, ease of use
 
-### Success Criteria:
+### Success Criteria
+
 - ✅ Automated code review working
 - ✅ Documentation auto-generation functional
 - ✅ Performance improvements measurable
-- ✅ Development workflow streamlined
\ No newline at end of file
+- ✅ Development workflow streamlined
diff --git a/scripts/build/build_web_demo.zig b/scripts/build/build_web_demo.zig
index 2bb08bc..a5ff902 100644
--- a/scripts/build/build_web_demo.zig
+++ b/scripts/build/build_web_demo.zig
@@ -8,28 +8,31 @@ pub fn build(b: *std.Build) void {
         .default_target = .{
             .cpu_arch = .wasm32,
             .os_tag = .freestanding,
-            .cpu_model = .{ .explicit = &std.Target.wasm.cpu.baseline },
             .abi = .musl,
         },
     });
 
     const optimize = b.standardOptimizeOption(.{});
-    const wasm_allocator = b.option(bool, "wasm-allocator", "Use WASM allocator") orelse true;
+    _ = b.option(bool, "wasm-allocator", "Use WASM allocator") orelse true;
 
     // Create the WASM module
-    const wasm_module = b.addSharedLibrary(.{
+    const wasm_module = b.addExecutable(.{
         .name = "mfs-cube-demo",
-        .root_source_file = .{ .path = "src/web_cube_demo.zig" },
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/web_cube_demo.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
+    wasm_module.linkage = .dynamic;
 
     // Set WASM-specific options
-    wasm_module.rdynamic = true;
-    wasm_module.import_memory = true;
-    wasm_module.initial_memory = 65536;
-    wasm_module.max_memory = 65536;
-    wasm_module.stack_pointer_offsets = .{ .stack_pointer = 1024 };
+    // Note: Some WASM-specific options may not be available in Zig 0.16
+    // wasm_module.rdynamic = true;
+    // wasm_module.import_memory = true;
+    // wasm_module.initial_memory = 65536;
+    // wasm_module.max_memory = 65536;
+    // wasm_module.stack_pointer_offsets = .{ .stack_pointer = 1024 };
 
     // Add WASM-specific defines
     wasm_module.addCSourceFile(.{
diff --git a/scripts/markdown_to_html.zig b/scripts/markdown_to_html.zig
index 55dd875..935644f 100644
--- a/scripts/markdown_to_html.zig
+++ b/scripts/markdown_to_html.zig
@@ -21,8 +21,10 @@ pub fn main() !void {
     // Read markdown file
     const file = try std.fs.cwd().openFile(input_path, .{});
     defer file.close();
-    const markdown_content = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
+    const file_size = try file.getEndPos();
+    const markdown_content = try allocator.alloc(u8, file_size);
     defer allocator.free(markdown_content);
+    _ = try file.readAll(markdown_content);
 
     // Convert markdown to HTML
     const html_content = try markdownToHtml(allocator, markdown_content, title);
diff --git a/scripts/run_tests.zig b/scripts/run_tests.zig
index 25401d3..c83638a 100644
--- a/scripts/run_tests.zig
+++ b/scripts/run_tests.zig
@@ -179,10 +179,38 @@ fn runTestSuite(allocator: std.mem.Allocator, suite: TestSuite, verbose: bool, m
 
     try child.spawn();
 
-    const stdout = try child.stdout.?.readToEndAlloc(allocator, std.math.maxInt(usize));
+    // Read stdout in chunks
+    var stdout_list = std.array_list.Managed(u8).init(allocator);
+    defer stdout_list.deinit();
+    var stdout_buffer: [4096]u8 = undefined;
+    if (child.stdout) |stdout_pipe| {
+        while (true) {
+            const bytes_read = stdout_pipe.read(stdout_buffer[0..]) catch |err| {
+                if (err == error.EndOfStream) break;
+                return err;
+            };
+            if (bytes_read == 0) break;
+            try stdout_list.appendSlice(stdout_buffer[0..bytes_read]);
+        }
+    }
+    const stdout = try stdout_list.toOwnedSlice();
     defer allocator.free(stdout);
 
-    const stderr = try child.stderr.?.readToEndAlloc(allocator, std.math.maxInt(usize));
+    // Read stderr in chunks
+    var stderr_list = std.array_list.Managed(u8).init(allocator);
+    defer stderr_list.deinit();
+    var stderr_buffer: [4096]u8 = undefined;
+    if (child.stderr) |stderr_pipe| {
+        while (true) {
+            const bytes_read = stderr_pipe.read(stderr_buffer[0..]) catch |err| {
+                if (err == error.EndOfStream) break;
+                return err;
+            };
+            if (bytes_read == 0) break;
+            try stderr_list.appendSlice(stderr_buffer[0..bytes_read]);
+        }
+    }
+    const stderr = try stderr_list.toOwnedSlice();
     defer allocator.free(stderr);
 
     const result = try child.wait();
diff --git a/scripts/test_all_backends.zig b/scripts/test_all_backends.zig
index bb8ce3a..1203b76 100644
--- a/scripts/test_all_backends.zig
+++ b/scripts/test_all_backends.zig
@@ -550,11 +550,14 @@ fn writeCsvReport(results: []const TestResult) !void {
     const file = try std.fs.cwd().createFile("backend_report.csv", .{ .truncate = true });
     defer file.close();
 
+    var buffer: [4096]u8 = undefined;
+    const writer = file.writer(&buffer);
+
     // Header
-    try file.writer().print("backend,success,avg_fps,min_fps,max_fps,frame_count,memory_mb,error\n", .{});
+    try writer.print("backend,success,avg_fps,min_fps,max_fps,frame_count,memory_mb,error\n", .{});
 
     for (results) |r| {
-        try file.writer().print(
+        try writer.print(
             "{s},{s},{d:.2},{d:.2},{d:.2},{},{}\n",
             .{
                 @tagName(r.backend),
diff --git a/scripts/test_all_mains.zig b/scripts/test_all_mains.zig
new file mode 100644
index 0000000..dcaaa58
--- /dev/null
+++ b/scripts/test_all_mains.zig
@@ -0,0 +1,170 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const MainFile = struct {
+    name: []const u8,
+    path: []const u8,
+    category: []const u8,
+    should_run: bool = false, // Most files shouldn't be run, just compiled
+};
+
+const main_files = [_]MainFile{
+    // Main entry points
+    .{ .name = "main", .path = "src/main.zig", .category = "main" },
+    .{ .name = "bin/main", .path = "src/bin/main.zig", .category = "main" },
+    .{ .name = "main_loop", .path = "src/main_loop.zig", .category = "main" },
+
+    // Tests
+    .{ .name = "physics_test", .path = "src/tests/physics_test.zig", .category = "test" },
+    .{ .name = "benchmarks", .path = "src/tests/benchmarks.zig", .category = "test" },
+    .{ .name = "vulkan_working_test", .path = "src/tests/vulkan_working_test.zig", .category = "test" },
+    .{ .name = "test_vulkan", .path = "src/tests/test_vulkan.zig", .category = "test" },
+    .{ .name = "test_opengl", .path = "src/tests/test_opengl.zig", .category = "test" },
+    .{ .name = "render_bench", .path = "src/tests/benchmarks/render_bench.zig", .category = "test" },
+
+    // Scripts
+    .{ .name = "run_tests", .path = "scripts/run_tests.zig", .category = "script" },
+    .{ .name = "markdown_to_html", .path = "scripts/markdown_to_html.zig", .category = "script" },
+    .{ .name = "test_all_backends", .path = "scripts/test_all_backends.zig", .category = "script" },
+    .{ .name = "verify_build", .path = "scripts/verify_build.zig", .category = "script" },
+    .{ .name = "code_quality_check", .path = "scripts/code_quality_check.zig", .category = "script" },
+    .{ .name = "refactor_math", .path = "scripts/refactor_math.zig", .category = "script" },
+    .{ .name = "update_build_zig", .path = "scripts/build/update_build_zig.zig", .category = "script" },
+
+    // Tools
+    .{ .name = "profiler_visualizer", .path = "tools/profiler_visualizer/visualizer.zig", .category = "tool" },
+    .{ .name = "asset_processor", .path = "tools/asset_processor/asset_processor.zig", .category = "tool" },
+    .{ .name = "capability_checker", .path = "src/tools/capability_checker.zig", .category = "tool" },
+    .{ .name = "texture_converter", .path = "tools/texture_converter.zig", .category = "tool" },
+    .{ .name = "model_viewer", .path = "tools/model_viewer.zig", .category = "tool" },
+
+    // Demos/Apps
+    .{ .name = "spinning_cube_wasm", .path = "src/demos/spinning_cube_wasm.zig", .category = "demo" },
+    .{ .name = "demo_app", .path = "src/app/demo_app.zig", .category = "demo" },
+    .{ .name = "opengl_cube", .path = "src/render/opengl_cube.zig", .category = "demo" },
+};
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    std.log.info("Testing all Zig files with main functions...\n", .{});
+
+    var total: usize = 0;
+    var passed: usize = 0;
+    var failed: usize = 0;
+
+    var failed_files = std.array_list.Managed([]const u8).init(allocator);
+    defer failed_files.deinit();
+
+    // Group by category
+    const categories = [_][]const u8{ "main", "test", "script", "tool", "demo" };
+
+    for (categories) |category| {
+        std.log.info("=== {s} ===", .{category});
+
+        for (main_files) |file| {
+            if (!std.mem.eql(u8, file.category, category)) continue;
+
+            total += 1;
+            std.debug.print("Testing {s} ({s})... ", .{ file.name, file.path });
+
+            // Try to compile the file
+            const result = try compileFile(allocator, file.path);
+
+            if (result.success) {
+                passed += 1;
+                std.debug.print("✓ PASSED\n", .{});
+            } else {
+                failed += 1;
+                const error_msg = try std.fmt.allocPrint(allocator, "{s}: {s}", .{ file.path, result.error_message });
+                try failed_files.append(error_msg);
+                std.debug.print("✗ FAILED\n", .{});
+                std.log.err("  Error: {s}", .{result.error_message});
+            }
+        }
+        std.debug.print("\n", .{});
+    }
+
+    // Summary
+    std.log.info("\n=== Summary ===", .{});
+    std.log.info("Total: {d}", .{total});
+    std.log.info("Passed: {d}", .{passed});
+    std.log.info("Failed: {d}", .{failed});
+
+    if (failed_files.items.len > 0) {
+        std.log.err("\n=== Failed Files ===", .{});
+        for (failed_files.items) |error_msg| {
+            std.log.err("  {s}", .{error_msg});
+        }
+    }
+
+    if (failed > 0) {
+        std.process.exit(1);
+    }
+}
+
+const CompileResult = struct {
+    success: bool,
+    error_message: []const u8,
+};
+
+fn compileFile(allocator: std.mem.Allocator, file_path: []const u8) !CompileResult {
+    // Use zig build-exe to test compilation
+    var arena = std.heap.ArenaAllocator.init(allocator);
+    defer arena.deinit();
+    const arena_allocator = arena.allocator();
+
+    const zig_exe = try findZigExe(arena_allocator);
+
+    var args = std.array_list.Managed([]const u8).init(arena_allocator);
+    try args.append(zig_exe);
+    try args.append("build-exe");
+    try args.append(file_path);
+    try args.append("--name");
+    try args.append("test_exe");
+    try args.append("--cache-dir");
+    try args.append(".zig-cache/test");
+
+    // Add common build options
+    try args.append("-target");
+    try args.append("native");
+    try args.append("-O");
+    try args.append("Debug");
+
+    var process = std.process.Child.init(args.items, arena_allocator);
+    process.stderr_behavior = .Inherit;
+    process.stdout_behavior = .Inherit;
+
+    try process.spawn();
+
+    const result = try process.wait();
+
+    if (result.Exited != 0) {
+        const error_msg = try std.fmt.allocPrint(allocator, "Compilation failed with exit code {d}", .{result.Exited});
+        return CompileResult{
+            .success = false,
+            .error_message = error_msg,
+        };
+    }
+
+    return CompileResult{
+        .success = true,
+        .error_message = "",
+    };
+}
+
+fn findZigExe(allocator: std.mem.Allocator) ![]const u8 {
+    // Try to find zig in PATH
+    const env_path = std.process.getEnvVarOwned(allocator, if (builtin.os.tag == .windows) "Path" else "PATH") catch |err| {
+        if (err == error.EnvironmentVariableNotFound) {
+            return "zig";
+        }
+        return err;
+    };
+    defer allocator.free(env_path);
+
+    // For simplicity, just return "zig" and let the system find it
+    return "zig";
+}
diff --git a/scripts/verify_build.zig b/scripts/verify_build.zig
index 64529ef..918baee 100644
--- a/scripts/verify_build.zig
+++ b/scripts/verify_build.zig
@@ -42,7 +42,10 @@ pub fn main() !void {
     // Prepare CSV report
     const csv_file = try fs.cwd().createFile("build_report.csv", .{ .truncate = true });
     defer csv_file.close();
-    try csv_file.writer().print("test,success\n", .{});
+
+    var buffer: [4096]u8 = undefined;
+    const writer = csv_file.writer(&buffer);
+    try writer.print("test,success\n", .{});
 
     for (build_tests) |test_case| {
         std.log.info("Testing: {s}", .{test_case.name});
@@ -64,7 +67,7 @@ pub fn main() !void {
         }
 
         // Write CSV row
-        try csv_file.writer().print("{s},{s}\n", .{ test_case.name, if (success) "true" else "false" });
+        try writer.print("{s},{s}\n", .{ test_case.name, if (success) "true" else "false" });
     }
 
     std.log.info("", .{});
diff --git a/src/ai/behavior_trees.zig b/src/ai/behavior_trees.zig
index 221f28d..73354c7 100644
--- a/src/ai/behavior_trees.zig
+++ b/src/ai/behavior_trees.zig
@@ -1,50 +1,100 @@
-//! Behavior Trees Implementation (Stub)
+//! Behavior Trees Implementation
+//! Complete behavior tree system with composite and decorator nodes
 
 const std = @import("std");
 
+const math = @import("../math/mod.zig");
+const Vec3 = math.Vec3;
+
 pub const BehaviorManager = struct {
     allocator: std.mem.Allocator,
+    trees: std.array_list.Managed(*BehaviorTree),
 
     pub fn init(allocator: std.mem.Allocator) !BehaviorManager {
-        return BehaviorManager{ .allocator = allocator };
+        return BehaviorManager{
+            .allocator = allocator,
+            .trees = std.array_list.Managed(*BehaviorTree).init(allocator),
+        };
     }
 
     pub fn deinit(self: *BehaviorManager) void {
-        _ = self;
+        for (self.trees.items) |tree| {
+            tree.deinit();
+            self.allocator.destroy(tree);
+        }
+        self.trees.deinit();
     }
 
     pub fn update(self: *BehaviorManager, delta_time: f32) !void {
-        _ = self;
         _ = delta_time;
+        // Trees are updated individually by their owners
+    }
+
+    pub fn addTree(self: *BehaviorManager, tree: *BehaviorTree) !void {
+        try self.trees.append(tree);
+    }
+
+    pub fn removeTree(self: *BehaviorManager, tree: *BehaviorTree) void {
+        for (self.trees.items, 0..) |t, i| {
+            if (t == tree) {
+                _ = self.trees.swapRemove(i);
+                break;
+            }
+        }
     }
 
     pub fn getTreeCount(self: *BehaviorManager) u32 {
-        _ = self;
-        return 0;
+        return @intCast(self.trees.items.len);
     }
 };
 
 pub const BehaviorTree = struct {
     allocator: std.mem.Allocator,
+    root: ?*BehaviorNode,
+    config: TreeConfig,
+    blackboard: Blackboard,
 
     pub fn init(allocator: std.mem.Allocator, config: TreeConfig) !BehaviorTree {
-        _ = config;
-        return BehaviorTree{ .allocator = allocator };
+        return BehaviorTree{
+            .allocator = allocator,
+            .root = null,
+            .config = config,
+            .blackboard = Blackboard.init(allocator),
+        };
     }
 
     pub fn deinit(self: *BehaviorTree) void {
-        _ = self;
+        if (self.root) |r| {
+            r.deinit();
+            self.allocator.destroy(r);
+        }
+        self.blackboard.deinit();
+    }
+
+    pub fn setRoot(self: *BehaviorTree, node: *BehaviorNode) void {
+        if (self.root) |old_root| {
+            old_root.deinit();
+            self.allocator.destroy(old_root);
+        }
+        self.root = node;
     }
 
     pub fn tick(self: *BehaviorTree, delta_time: f32) !NodeStatus {
-        _ = self;
         _ = delta_time;
-        return .success;
+        if (self.root) |root| {
+            return try root.execute(&self.blackboard);
+        }
+        return .failure;
+    }
+
+    pub fn getBlackboard(self: *BehaviorTree) *Blackboard {
+        return &self.blackboard;
     }
 };
 
 pub const TreeConfig = struct {
     max_depth: u32 = 10,
+    update_frequency: f32 = 0.1, // Update every 100ms
 };
 
 pub const NodeStatus = enum {
@@ -52,3 +102,354 @@ pub const NodeStatus = enum {
     failure,
     running,
 };
+
+/// Base behavior node interface
+pub const BehaviorNode = struct {
+    allocator: std.mem.Allocator,
+    node_type: NodeType,
+    name: []const u8,
+
+    const Self = @This();
+
+    pub fn init(allocator: std.mem.Allocator, node_type: NodeType, name: []const u8) !*Self {
+        const node = try allocator.create(Self);
+        node.* = Self{
+            .allocator = allocator,
+            .node_type = node_type,
+            .name = try allocator.dupe(u8, name),
+        };
+        return node;
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.allocator.free(self.name);
+        switch (self.node_type) {
+            .composite => |*comp| comp.deinit(),
+            .decorator => |*dec| dec.deinit(),
+            .leaf => |*leaf| leaf.deinit(),
+        }
+    }
+
+    pub fn execute(self: *Self, blackboard: *Blackboard) !NodeStatus {
+        return switch (self.node_type) {
+            .composite => |*comp| try comp.execute(blackboard),
+            .decorator => |*dec| try dec.execute(blackboard),
+            .leaf => |*leaf| try leaf.execute(blackboard),
+        };
+    }
+};
+
+pub const NodeType = union(enum) {
+    composite: CompositeNode,
+    decorator: DecoratorNode,
+    leaf: LeafNode,
+};
+
+/// Composite nodes (Sequence, Selector, Parallel)
+pub const CompositeNode = struct {
+    children: std.array_list.Managed(*BehaviorNode),
+    composite_type: CompositeType,
+    current_child: usize,
+
+    pub fn init(allocator: std.mem.Allocator, composite_type: CompositeType) CompositeNode {
+        return CompositeNode{
+            .children = std.array_list.Managed(*BehaviorNode).init(allocator),
+            .composite_type = composite_type,
+            .current_child = 0,
+        };
+    }
+
+    pub fn deinit(self: *CompositeNode) void {
+        for (self.children.items) |child| {
+            child.deinit();
+            child.allocator.destroy(child);
+        }
+        self.children.deinit();
+    }
+
+    pub fn addChild(self: *CompositeNode, child: *BehaviorNode) !void {
+        try self.children.append(child);
+    }
+
+    pub fn execute(self: *CompositeNode, blackboard: *Blackboard) !NodeStatus {
+        return switch (self.composite_type) {
+            .sequence => try self.executeSequence(blackboard),
+            .selector => try self.executeSelector(blackboard),
+            .parallel => try self.executeParallel(blackboard),
+        };
+    }
+
+    fn executeSequence(self: *CompositeNode, blackboard: *Blackboard) !NodeStatus {
+        // Sequence: All children must succeed
+        for (self.children.items) |child| {
+            const status = try child.execute(blackboard);
+            if (status == .failure) {
+                self.current_child = 0;
+                return .failure;
+            }
+            if (status == .running) {
+                return .running;
+            }
+        }
+        self.current_child = 0;
+        return .success;
+    }
+
+    fn executeSelector(self: *CompositeNode, blackboard: *Blackboard) !NodeStatus {
+        // Selector: First child to succeed wins
+        for (self.children.items) |child| {
+            const status = try child.execute(blackboard);
+            if (status == .success) {
+                self.current_child = 0;
+                return .success;
+            }
+            if (status == .running) {
+                return .running;
+            }
+        }
+        self.current_child = 0;
+        return .failure;
+    }
+
+    fn executeParallel(self: *CompositeNode, blackboard: *Blackboard) !NodeStatus {
+        // Parallel: Run all children, succeed if all succeed
+        var all_success = true;
+        var any_running = false;
+
+        for (self.children.items) |child| {
+            const status = try child.execute(blackboard);
+            if (status == .failure) {
+                all_success = false;
+            }
+            if (status == .running) {
+                any_running = true;
+            }
+        }
+
+        if (any_running) return .running;
+        return if (all_success) .success else .failure;
+    }
+};
+
+pub const CompositeType = enum {
+    sequence,
+    selector,
+    parallel,
+};
+
+/// Decorator nodes (Inverter, Repeater, etc.)
+pub const DecoratorNode = struct {
+    child: ?*BehaviorNode,
+    decorator_type: DecoratorType,
+    repeat_count: u32,
+    current_count: u32,
+
+    pub fn init(allocator: std.mem.Allocator, decorator_type: DecoratorType) DecoratorNode {
+        _ = allocator;
+        return DecoratorNode{
+            .child = null,
+            .decorator_type = decorator_type,
+            .repeat_count = 0,
+            .current_count = 0,
+        };
+    }
+
+    pub fn deinit(self: *DecoratorNode) void {
+        if (self.child) |c| {
+            c.deinit();
+            c.allocator.destroy(c);
+        }
+    }
+
+    pub fn setChild(self: *DecoratorNode, child: *BehaviorNode) void {
+        if (self.child) |old_child| {
+            old_child.deinit();
+            child.allocator.destroy(old_child);
+        }
+        self.child = child;
+    }
+
+    pub fn execute(self: *DecoratorNode, blackboard: *Blackboard) !NodeStatus {
+        if (self.child == null) return .failure;
+
+        return switch (self.decorator_type) {
+            .inverter => try self.executeInverter(blackboard),
+            .repeater => try self.executeRepeater(blackboard),
+            .until_fail => try self.executeUntilFail(blackboard),
+            .until_success => try self.executeUntilSuccess(blackboard),
+        };
+    }
+
+    fn executeInverter(self: *DecoratorNode, blackboard: *Blackboard) !NodeStatus {
+        const status = try self.child.?.execute(blackboard);
+        return switch (status) {
+            .success => .failure,
+            .failure => .success,
+            .running => .running,
+        };
+    }
+
+    fn executeRepeater(self: *DecoratorNode, blackboard: *Blackboard) !NodeStatus {
+        while (self.current_count < self.repeat_count) {
+            const status = try self.child.?.execute(blackboard);
+            if (status == .running) return .running;
+            if (status == .failure) {
+                self.current_count = 0;
+                return .failure;
+            }
+            self.current_count += 1;
+        }
+        self.current_count = 0;
+        return .success;
+    }
+
+    fn executeUntilFail(self: *DecoratorNode, blackboard: *Blackboard) !NodeStatus {
+        while (true) {
+            const status = try self.child.?.execute(blackboard);
+            if (status == .running) return .running;
+            if (status == .failure) return .success;
+        }
+    }
+
+    fn executeUntilSuccess(self: *DecoratorNode, blackboard: *Blackboard) !NodeStatus {
+        while (true) {
+            const status = try self.child.?.execute(blackboard);
+            if (status == .running) return .running;
+            if (status == .success) return .success;
+        }
+    }
+};
+
+pub const DecoratorType = enum {
+    inverter,
+    repeater,
+    until_fail,
+    until_success,
+};
+
+/// Leaf nodes (Actions and Conditions)
+pub const LeafNode = struct {
+    action_fn: ?*const fn (*Blackboard) !NodeStatus,
+    condition_fn: ?*const fn (*Blackboard) bool,
+    leaf_type: LeafType,
+
+    pub fn init(allocator: std.mem.Allocator, leaf_type: LeafType) LeafNode {
+        _ = allocator;
+        return LeafNode{
+            .action_fn = null,
+            .condition_fn = null,
+            .leaf_type = leaf_type,
+        };
+    }
+
+    pub fn deinit(self: *LeafNode) void {
+        _ = self;
+    }
+
+    pub fn setAction(self: *LeafNode, action: *const fn (*Blackboard) !NodeStatus) void {
+        self.action_fn = action;
+    }
+
+    pub fn setCondition(self: *LeafNode, condition: *const fn (*Blackboard) bool) void {
+        self.condition_fn = condition;
+    }
+
+    pub fn execute(self: *LeafNode, blackboard: *Blackboard) !NodeStatus {
+        return switch (self.leaf_type) {
+            .action => if (self.action_fn) |action| try action(blackboard) else .failure,
+            .condition => if (self.condition_fn) |condition| (if (condition(blackboard)) .success else .failure) else .failure,
+        };
+    }
+};
+
+pub const LeafType = enum {
+    action,
+    condition,
+};
+
+/// Blackboard for sharing data between nodes
+pub const Blackboard = struct {
+    allocator: std.mem.Allocator,
+    data: std.HashMap([]const u8, BlackboardValue, std.hash_map.StringContext, std.hash_map.default_max_load_percentage),
+
+    pub fn init(allocator: std.mem.Allocator) Blackboard {
+        return Blackboard{
+            .allocator = allocator,
+            .data = std.HashMap([]const u8, BlackboardValue, std.hash_map.StringContext, std.hash_map.default_max_load_percentage).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Blackboard) void {
+        var iterator = self.data.iterator();
+        while (iterator.next()) |entry| {
+            switch (entry.value_ptr.*) {
+                .string => |s| self.allocator.free(s),
+                else => {},
+            }
+        }
+        self.data.deinit();
+    }
+
+    pub fn set(self: *Blackboard, key: []const u8, value: BlackboardValue) !void {
+        const key_copy = try self.allocator.dupe(u8, key);
+        if (self.data.get(key)) |old_value| {
+            switch (old_value) {
+                .string => |s| self.allocator.free(s),
+                else => {},
+            }
+        }
+        try self.data.put(key_copy, value);
+    }
+
+    pub fn get(self: *Blackboard, key: []const u8) ?BlackboardValue {
+        return self.data.get(key);
+    }
+
+    pub fn getFloat(self: *Blackboard, key: []const u8) ?f32 {
+        if (self.data.get(key)) |value| {
+            return switch (value) {
+                .float => |f| f,
+                else => null,
+            };
+        }
+        return null;
+    }
+
+    pub fn getInt(self: *Blackboard, key: []const u8) ?i32 {
+        if (self.data.get(key)) |value| {
+            return switch (value) {
+                .int => |i| i,
+                else => null,
+            };
+        }
+        return null;
+    }
+
+    pub fn getBool(self: *Blackboard, key: []const u8) ?bool {
+        if (self.data.get(key)) |value| {
+            return switch (value) {
+                .bool => |b| b,
+                else => null,
+            };
+        }
+        return null;
+    }
+
+    pub fn getVec3(self: *Blackboard, key: []const u8) ?Vec3 {
+        if (self.data.get(key)) |value| {
+            return switch (value) {
+                .vec3 => |v| v,
+                else => null,
+            };
+        }
+        return null;
+    }
+};
+
+pub const BlackboardValue = union(enum) {
+    float: f32,
+    int: i32,
+    bool: bool,
+    vec3: Vec3,
+    string: []const u8,
+};
diff --git a/src/ai/mod.zig b/src/ai/mod.zig
index c4a5839..c8c5cb9 100644
--- a/src/ai/mod.zig
+++ b/src/ai/mod.zig
@@ -3,18 +3,18 @@
 //! Provides comprehensive AI capabilities for modern game development
 
 const std = @import("std");
+
 const math = @import("../math/mod.zig");
 const Vec3 = math.Vec3;
 const Mat4 = math.Mat4;
-
-// Re-export AI modules
-pub const neural_networks = @import("neural_networks.zig");
-pub const neural = @import("neural/mod.zig");
 pub const behavior = @import("behavior_trees.zig");
-pub const pathfinding = @import("pathfinding.zig");
-pub const ml_features = @import("ml_features.zig");
 pub const decision_making = @import("decision_making.zig");
+pub const ml_features = @import("ml_features.zig");
+pub const neural = @import("neural/mod.zig");
+pub const neural_networks = @import("neural_networks.zig");
+pub const pathfinding = @import("pathfinding.zig");
 
+// Re-export AI modules
 /// AI System Manager - coordinates all AI subsystems
 pub const AISystem = struct {
     allocator: std.mem.Allocator,
@@ -258,7 +258,7 @@ pub const AIEntity = struct {
 
         // Target distance
         if (self.target_position) |target| {
-            const distance = self.position.distance(target);
+            const distance = self.position.distanceTo(target);
             inputs[4] = distance;
         } else {
             inputs[4] = 0.0;
@@ -301,7 +301,7 @@ pub const AIEntity = struct {
     fn followPath(self: *Self, path: []Vec3, delta_time: f32) !void {
         if (path.len > 0) {
             const target = path[0];
-            const direction = target.subtract(self.position).normalize();
+            const direction = target.sub(self.position).normalize();
             const speed = 5.0; // units per second
 
             self.position = self.position.add(direction.scale(speed * delta_time));
diff --git a/src/ai/pathfinding.zig b/src/ai/pathfinding.zig
index 9365358..168b1e1 100644
--- a/src/ai/pathfinding.zig
+++ b/src/ai/pathfinding.zig
@@ -1,46 +1,587 @@
-//! Pathfinding Implementation (Stub)
+//! Pathfinding Implementation
+//! A* pathfinding algorithm with grid-based navigation and 3D waypoint support
 
 const std = @import("std");
+
 const math = @import("../math/mod.zig");
 const Vec3 = math.Vec3;
 
+/// Pathfinding request status
+pub const PathRequestStatus = enum {
+    pending,
+    processing,
+    completed,
+    failed,
+    cancelled,
+};
+
+/// Pathfinding request
+pub const PathRequest = struct {
+    id: u32,
+    start: Vec3,
+    end: Vec3,
+    status: PathRequestStatus,
+    path: std.array_list.Managed(Vec3),
+    callback: ?*const fn (*PathRequest) void = null,
+
+    pub fn init(allocator: std.mem.Allocator, id: u32, start: Vec3, end: Vec3) PathRequest {
+        return PathRequest{
+            .id = id,
+            .start = start,
+            .end = end,
+            .status = .pending,
+            .path = std.array_list.Managed(Vec3).init(allocator),
+            .callback = null,
+        };
+    }
+
+    pub fn deinit(self: *PathRequest) void {
+        self.path.deinit();
+    }
+};
+
+/// Grid node for A* algorithm
+const GridNode = struct {
+    x: i32,
+    y: i32,
+    z: i32,
+    g_cost: f32, // Cost from start
+    h_cost: f32, // Heuristic cost to end
+    f_cost: f32, // Total cost (g + h)
+    parent: ?*GridNode,
+    walkable: bool,
+    visited: bool,
+
+    pub fn init(x: i32, y: i32, z: i32, walkable: bool) GridNode {
+        return GridNode{
+            .x = x,
+            .y = y,
+            .z = z,
+            .g_cost = 0.0,
+            .h_cost = 0.0,
+            .f_cost = 0.0,
+            .parent = null,
+            .walkable = walkable,
+            .visited = false,
+        };
+    }
+
+    pub fn reset(self: *GridNode) void {
+        self.g_cost = 0.0;
+        self.h_cost = 0.0;
+        self.f_cost = 0.0;
+        self.parent = null;
+        self.visited = false;
+    }
+
+    pub fn equals(self: *const GridNode, other: *const GridNode) bool {
+        return self.x == other.x and self.y == other.y and self.z == other.z;
+    }
+};
+
+/// Pathfinding grid for spatial navigation
+pub const PathfindingGrid = struct {
+    allocator: std.mem.Allocator,
+    cell_size: f32,
+    width: i32,
+    height: i32,
+    depth: i32,
+    nodes: []GridNode,
+    origin: Vec3,
+
+    pub fn init(allocator: std.mem.Allocator, cell_size: f32, width: i32, height: i32, depth: i32, origin: Vec3) !PathfindingGrid {
+        const total_nodes = @as(usize, @intCast(width * height * depth));
+        const nodes = try allocator.alloc(GridNode, total_nodes);
+
+        var index: usize = 0;
+        var z: i32 = 0;
+        while (z < depth) : (z += 1) {
+            var y: i32 = 0;
+            while (y < height) : (y += 1) {
+                var x: i32 = 0;
+                while (x < width) : (x += 1) {
+                    nodes[index] = GridNode.init(x, y, z, true); // All nodes walkable by default
+                    index += 1;
+                }
+            }
+        }
+
+        return PathfindingGrid{
+            .allocator = allocator,
+            .cell_size = cell_size,
+            .width = width,
+            .height = height,
+            .depth = depth,
+            .nodes = nodes,
+            .origin = origin,
+        };
+    }
+
+    pub fn deinit(self: *PathfindingGrid) void {
+        self.allocator.free(self.nodes);
+    }
+
+    pub fn worldToGrid(self: *const PathfindingGrid, world_pos: Vec3) struct { x: i32, y: i32, z: i32 } {
+        const local = world_pos.sub(self.origin);
+        return .{
+            .x = @intFromFloat(@floor(local.x / self.cell_size)),
+            .y = @intFromFloat(@floor(local.y / self.cell_size)),
+            .z = @intFromFloat(@floor(local.z / self.cell_size)),
+        };
+    }
+
+    pub fn gridToWorld(self: *const PathfindingGrid, grid_x: i32, grid_y: i32, grid_z: i32) Vec3 {
+        return Vec3{
+            .x = self.origin.x + (@as(f32, @floatFromInt(grid_x)) * self.cell_size),
+            .y = self.origin.y + (@as(f32, @floatFromInt(grid_y)) * self.cell_size),
+            .z = self.origin.z + (@as(f32, @floatFromInt(grid_z)) * self.cell_size),
+        };
+    }
+
+    pub fn getNode(self: *PathfindingGrid, x: i32, y: i32, z: i32) ?*GridNode {
+        if (x < 0 or x >= self.width or y < 0 or y >= self.height or z < 0 or z >= self.depth) {
+            return null;
+        }
+        const index = @as(usize, @intCast(z * self.width * self.height + y * self.width + x));
+        return &self.nodes[index];
+    }
+
+    pub fn setWalkable(self: *PathfindingGrid, x: i32, y: i32, z: i32, walkable: bool) void {
+        if (self.getNode(x, y, z)) |node| {
+            node.walkable = walkable;
+        }
+    }
+
+    pub fn getNeighbors(self: *PathfindingGrid, node: *GridNode) !std.array_list.Managed(*GridNode) {
+        var neighbors = std.array_list.Managed(*GridNode).init(self.allocator);
+
+        // 26-directional neighbors (including diagonals)
+        const offsets = [_]struct { x: i32, y: i32, z: i32 }{
+            // Face neighbors (6)
+            .{ .x = -1, .y = 0, .z = 0 },
+            .{ .x = 1, .y = 0, .z = 0 },
+            .{ .x = 0, .y = -1, .z = 0 },
+            .{ .x = 0, .y = 1, .z = 0 },
+            .{ .x = 0, .y = 0, .z = -1 },
+            .{ .x = 0, .y = 0, .z = 1 },
+            // Edge neighbors (12)
+            .{ .x = -1, .y = -1, .z = 0 },
+            .{ .x = 1, .y = -1, .z = 0 },
+            .{ .x = -1, .y = 1, .z = 0 },
+            .{ .x = 1, .y = 1, .z = 0 },
+            .{ .x = -1, .y = 0, .z = -1 },
+            .{ .x = 1, .y = 0, .z = -1 },
+            .{ .x = -1, .y = 0, .z = 1 },
+            .{ .x = 1, .y = 0, .z = 1 },
+            .{ .x = 0, .y = -1, .z = -1 },
+            .{ .x = 0, .y = 1, .z = -1 },
+            .{ .x = 0, .y = -1, .z = 1 },
+            .{ .x = 0, .y = 1, .z = 1 },
+            // Corner neighbors (8)
+            .{ .x = -1, .y = -1, .z = -1 },
+            .{ .x = 1, .y = -1, .z = -1 },
+            .{ .x = -1, .y = 1, .z = -1 },
+            .{ .x = 1, .y = 1, .z = -1 },
+            .{ .x = -1, .y = -1, .z = 1 },
+            .{ .x = 1, .y = -1, .z = 1 },
+            .{ .x = -1, .y = 1, .z = 1 },
+            .{ .x = 1, .y = 1, .z = 1 },
+        };
+
+        for (offsets) |offset| {
+            if (self.getNode(node.x + offset.x, node.y + offset.y, node.z + offset.z)) |neighbor| {
+                if (neighbor.walkable) {
+                    try neighbors.append(neighbor);
+                }
+            }
+        }
+
+        return neighbors;
+    }
+};
+
+/// Pathfinding System - manages pathfinding requests
 pub const PathfindingSystem = struct {
     allocator: std.mem.Allocator,
+    requests: std.array_list.Managed(PathRequest),
+    grid: ?*PathfindingGrid = null,
+    next_request_id: u32 = 1,
+    max_requests: u32 = 100,
 
     pub fn init(allocator: std.mem.Allocator) !PathfindingSystem {
-        return PathfindingSystem{ .allocator = allocator };
+        return PathfindingSystem{
+            .allocator = allocator,
+            .requests = std.array_list.Managed(PathRequest).init(allocator),
+        };
     }
 
     pub fn deinit(self: *PathfindingSystem) void {
-        _ = self;
+        for (self.requests.items) |*request| {
+            request.deinit();
+        }
+        self.requests.deinit();
+        if (self.grid) |g| {
+            g.deinit();
+            self.allocator.destroy(g);
+        }
     }
 
     pub fn update(self: *PathfindingSystem, delta_time: f32) !void {
-        _ = self;
         _ = delta_time;
+
+        // Process pending requests
+        var i: usize = 0;
+        while (i < self.requests.items.len) {
+            const request = &self.requests.items[i];
+            if (request.status == .pending) {
+                request.status = .processing;
+                try self.processPathRequest(request);
+            }
+
+            // Remove completed/failed/cancelled requests
+            if (request.status == .completed or request.status == .failed or request.status == .cancelled) {
+                if (request.callback) |cb| {
+                    cb(request);
+                }
+                request.deinit();
+                _ = self.requests.swapRemove(i);
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    pub fn getActiveRequests(self: *const PathfindingSystem) u32 {
+        var count: u32 = 0;
+        for (self.requests.items) |request| {
+            if (request.status == .pending or request.status == .processing) {
+                count += 1;
+            }
+        }
+        return count;
+    }
+
+    pub fn setGrid(self: *PathfindingSystem, grid: *PathfindingGrid) void {
+        if (self.grid) |old_grid| {
+            old_grid.deinit();
+            self.allocator.destroy(old_grid);
+        }
+        self.grid = grid;
+    }
+
+    pub fn requestPath(self: *PathfindingSystem, start: Vec3, end: Vec3) !u32 {
+        if (self.requests.items.len >= self.max_requests) {
+            return error.TooManyRequests;
+        }
+
+        const id = self.next_request_id;
+        self.next_request_id += 1;
+
+        const request = PathRequest.init(self.allocator, id, start, end);
+        try self.requests.append(request);
+
+        return id;
+    }
+
+    pub fn getPath(self: *PathfindingSystem, request_id: u32) ?[]const Vec3 {
+        for (self.requests.items) |*request| {
+            if (request.id == request_id and request.status == .completed) {
+                return request.path.items;
+            }
+        }
+        return null;
+    }
+
+    pub fn cancelRequest(self: *PathfindingSystem, request_id: u32) void {
+        for (self.requests.items) |*request| {
+            if (request.id == request_id) {
+                request.status = .cancelled;
+                break;
+            }
+        }
+    }
+
+    fn processPathRequest(self: *PathfindingSystem, request: *PathRequest) !void {
+        if (self.grid == null) {
+            // No grid available, use simple direct path
+            try request.path.append(request.start);
+            try request.path.append(request.end);
+            request.status = .completed;
+            return;
+        }
+
+        const grid = self.grid.?;
+        const start_grid = grid.worldToGrid(request.start);
+        const end_grid = grid.worldToGrid(request.end);
+
+        const start_node = grid.getNode(start_grid.x, start_grid.y, start_grid.z);
+        const end_node = grid.getNode(end_grid.x, end_grid.y, end_grid.z);
+
+        if (start_node == null or end_node == null) {
+            request.status = .failed;
+            return;
+        }
+
+        if (!start_node.?.walkable or !end_node.?.walkable) {
+            request.status = .failed;
+            return;
+        }
+
+        // Reset all nodes
+        for (grid.nodes) |*node| {
+            node.reset();
+        }
+
+        // A* pathfinding
+        const path = try self.findPathAStar(grid, start_node.?, end_node.?);
+        if (path) |p| {
+            // Convert grid nodes to world positions
+            for (p) |node| {
+                const world_pos = grid.gridToWorld(node.x, node.y, node.z);
+                try request.path.append(world_pos);
+            }
+            request.status = .completed;
+        } else {
+            request.status = .failed;
+        }
     }
 
-    pub fn getActiveRequests(self: *PathfindingSystem) u32 {
+    fn findPathAStar(self: *PathfindingSystem, grid: *PathfindingGrid, start: *GridNode, end: *GridNode) !?[]*GridNode {
         _ = self;
-        return 0;
+
+        var open_set = std.PriorityQueue(*GridNode, void, compareNodes).init(self.allocator, {});
+        defer open_set.deinit();
+
+        var closed_set = std.ArrayList(*GridNode).init(self.allocator);
+        defer closed_set.deinit();
+
+        start.g_cost = 0.0;
+        start.h_cost = heuristic(start, end);
+        start.f_cost = start.g_cost + start.h_cost;
+
+        try open_set.add(start);
+
+        while (open_set.removeOrNull()) |current| {
+            if (current.equals(end)) {
+                // Reconstruct path
+                var path = std.ArrayList(*GridNode).init(self.allocator);
+                var node: ?*GridNode = current;
+                while (node) |n| {
+                    try path.append(n);
+                    node = n.parent;
+                }
+
+                // Reverse path
+                var reversed = try self.allocator.alloc(*GridNode, path.items.len);
+                for (path.items, 0..) |n, i| {
+                    reversed[path.items.len - 1 - i] = n;
+                }
+
+                return reversed;
+            }
+
+            try closed_set.append(current);
+            current.visited = true;
+
+            const neighbors = try grid.getNeighbors(current);
+            defer neighbors.deinit();
+
+            for (neighbors.items) |neighbor| {
+                if (neighbor.visited) continue;
+
+                const tentative_g = current.g_cost + distance(current, neighbor);
+
+                var in_open = false;
+                for (open_set.items) |open_node| {
+                    if (neighbor.equals(open_node)) {
+                        in_open = true;
+                        break;
+                    }
+                }
+
+                if (!in_open) {
+                    neighbor.g_cost = tentative_g;
+                    neighbor.h_cost = heuristic(neighbor, end);
+                    neighbor.f_cost = neighbor.g_cost + neighbor.h_cost;
+                    neighbor.parent = current;
+                    try open_set.add(neighbor);
+                } else if (tentative_g < neighbor.g_cost) {
+                    neighbor.g_cost = tentative_g;
+                    neighbor.f_cost = neighbor.g_cost + neighbor.h_cost;
+                    neighbor.parent = current;
+                }
+            }
+        }
+
+        return null; // No path found
+    }
+
+    fn compareNodes(context: void, a: *GridNode, b: *GridNode) bool {
+        _ = context;
+        return a.f_cost > b.f_cost; // Lower f_cost has higher priority
     }
 };
 
+/// Pathfinder - simple interface for finding paths
 pub const Pathfinder = struct {
     allocator: std.mem.Allocator,
+    grid: ?*PathfindingGrid = null,
 
     pub fn init(allocator: std.mem.Allocator) !Pathfinder {
-        return Pathfinder{ .allocator = allocator };
+        return Pathfinder{
+            .allocator = allocator,
+            .grid = null,
+        };
     }
 
     pub fn deinit(self: *Pathfinder) void {
-        _ = self;
+        if (self.grid) |g| {
+            g.deinit();
+            self.allocator.destroy(g);
+        }
+    }
+
+    pub fn setGrid(self: *Pathfinder, grid: *PathfindingGrid) void {
+        self.grid = grid;
     }
 
     pub fn findPath(self: *Pathfinder, start: Vec3, end: Vec3) !?[]Vec3 {
-        _ = self;
-        _ = start;
-        _ = end;
+        if (self.grid == null) {
+            // No grid, return simple direct path
+            var path = try self.allocator.alloc(Vec3, 2);
+            path[0] = start;
+            path[1] = end;
+            return path;
+        }
+
+        const grid = self.grid.?;
+        const start_grid = grid.worldToGrid(start);
+        const end_grid = grid.worldToGrid(end);
+
+        const start_node = grid.getNode(start_grid.x, start_grid.y, start_grid.z);
+        const end_node = grid.getNode(end_grid.x, end_grid.y, end_grid.z);
+
+        if (start_node == null or end_node == null) {
+            return null;
+        }
+
+        if (!start_node.?.walkable or !end_node.?.walkable) {
+            return null;
+        }
+
+        // Reset all nodes
+        for (grid.nodes) |*node| {
+            node.reset();
+        }
+
+        // Simple A* implementation
+        const path_nodes = try findPathSimple(grid, start_node.?, end_node.?, self.allocator);
+        if (path_nodes) |nodes| {
+            defer self.allocator.free(nodes);
+
+            // Convert to world positions
+            var world_path = try std.ArrayList(Vec3).initCapacity(self.allocator, nodes.len);
+            for (nodes) |node| {
+                const world_pos = grid.gridToWorld(node.x, node.y, node.z);
+                try world_path.append(world_pos);
+            }
+
+            const result = try self.allocator.alloc(Vec3, world_path.items.len);
+            @memcpy(result, world_path.items);
+            return result;
+        }
+
         return null;
     }
 };
+
+/// Simple A* pathfinding helper
+fn findPathSimple(grid: *PathfindingGrid, start: *GridNode, end: *GridNode, allocator: std.mem.Allocator) !?[]*GridNode {
+    var open_set = std.PriorityQueue(*GridNode, void, compareNodes).init(allocator, {});
+    defer open_set.deinit();
+
+    var closed_set = std.ArrayList(*GridNode).init(allocator);
+    defer closed_set.deinit();
+
+    start.g_cost = 0.0;
+    start.h_cost = heuristic(start, end);
+    start.f_cost = start.g_cost + start.h_cost;
+
+    try open_set.add(start);
+
+    while (open_set.removeOrNull()) |current| {
+        if (current.equals(end)) {
+            // Reconstruct path
+            var path = std.ArrayList(*GridNode).init(allocator);
+            var node: ?*GridNode = current;
+            while (node) |n| {
+                try path.append(n);
+                node = n.parent;
+            }
+
+            // Reverse path
+            var reversed = try allocator.alloc(*GridNode, path.items.len);
+            for (path.items, 0..) |n, i| {
+                reversed[path.items.len - 1 - i] = n;
+            }
+
+            return reversed;
+        }
+
+        try closed_set.append(current);
+        current.visited = true;
+
+        const neighbors = try grid.getNeighbors(current);
+        defer neighbors.deinit();
+
+        for (neighbors.items) |neighbor| {
+            if (neighbor.visited) continue;
+
+            const tentative_g = current.g_cost + distance(current, neighbor);
+
+            var in_open = false;
+            for (open_set.items) |open_node| {
+                if (neighbor.equals(open_node)) {
+                    in_open = true;
+                    break;
+                }
+            }
+
+            if (!in_open) {
+                neighbor.g_cost = tentative_g;
+                neighbor.h_cost = heuristic(neighbor, end);
+                neighbor.f_cost = neighbor.g_cost + neighbor.h_cost;
+                neighbor.parent = current;
+                try open_set.add(neighbor);
+            } else if (tentative_g < neighbor.g_cost) {
+                neighbor.g_cost = tentative_g;
+                neighbor.f_cost = neighbor.g_cost + neighbor.h_cost;
+                neighbor.parent = current;
+            }
+        }
+    }
+
+    return null;
+}
+
+/// Heuristic function (Euclidean distance)
+fn heuristic(a: *GridNode, b: *GridNode) f32 {
+    const dx = @as(f32, @floatFromInt(a.x - b.x));
+    const dy = @as(f32, @floatFromInt(a.y - b.y));
+    const dz = @as(f32, @floatFromInt(a.z - b.z));
+    return @sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+/// Distance between two nodes
+fn distance(a: *GridNode, b: *GridNode) f32 {
+    const dx = @as(f32, @floatFromInt(a.x - b.x));
+    const dy = @as(f32, @floatFromInt(a.y - b.y));
+    const dz = @as(f32, @floatFromInt(a.z - b.z));
+    return @sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+/// Compare nodes for priority queue
+fn compareNodes(context: void, a: *GridNode, b: *GridNode) bool {
+    _ = context;
+    return a.f_cost > b.f_cost; // Lower f_cost has higher priority
+}
diff --git a/src/app/demo_app.zig b/src/app/demo_app.zig
index 4faf20d..eb5658d 100644
--- a/src/app/demo_app.zig
+++ b/src/app/demo_app.zig
@@ -93,7 +93,7 @@ pub const DemoApp = struct {
         };
 
         // Main render loop
-        self.last_time = @intCast(std.time.milliTimestamp());
+        self.last_time = @intCast(@divFloor(std.time.nanoTimestamp(), std.time.ns_per_ms));
 
         while (self.running and self.frame_count < 1000) { // Run for 1000 frames max
             try self.update();
@@ -307,7 +307,7 @@ pub const DemoApp = struct {
     // =============================
     /// Update FPS statistics and print to log
     fn updateFPS(self: *Self) void {
-        const current_time = @as(u64, @intCast(std.time.milliTimestamp()));
+        const current_time = @as(u64, @intCast(@divFloor(std.time.nanoTimestamp(), std.time.ns_per_ms)));
         const delta_time = current_time - self.last_time;
 
         if (delta_time > 0) {
diff --git a/src/bin/main.zig b/src/bin/main.zig
index e5c9d63..8c6275b 100644
--- a/src/bin/main.zig
+++ b/src/bin/main.zig
@@ -3,8 +3,10 @@
 //! Handles command-line arguments and initializes the engine
 
 const std = @import("std");
+
 const mfs = @import("mfs");
 const engine = mfs.engine;
+
 const build_options = @import("../build_options.zig");
 
 // =============================================================================
diff --git a/src/build_options.zig b/src/build_options.zig
index 56007fd..ce174f4 100644
--- a/src/build_options.zig
+++ b/src/build_options.zig
@@ -33,6 +33,7 @@ pub const Features = struct {
     pub const enable_compute_shaders = true;
     pub const enable_3d_audio = true;
     pub const enable_physics = true;
+    pub const enable_ai = true;
     pub const enable_neural = true;
     pub const enable_voxels = true;
     pub const enable_mesh_shaders = true;
diff --git a/src/input/mod.zig b/src/input/mod.zig
index 9e05494..c20bdd9 100644
--- a/src/input/mod.zig
+++ b/src/input/mod.zig
@@ -12,6 +12,7 @@ const input = @import("input.zig");
 pub const InputEvent = input.InputEvent;
 pub const InputState = input.InputState;
 pub const InputManager = input.InputManager;
+pub const InputSystem = input.InputSystem;
 pub const InputConfig = InputSystemConfig;
 
 // Input device types
diff --git a/src/networking/mod.zig b/src/networking/mod.zig
index 2a68b1c..add891c 100644
--- a/src/networking/mod.zig
+++ b/src/networking/mod.zig
@@ -20,7 +20,7 @@ pub const NetworkManager = struct {
     mode: NetworkMode,
 
     // Network components
-    server: ?server.NetworkServer = null,
+    server: ?server.GameServer = null,
     client: ?client.GameClient = null,
     p2p_node: ?p2p.P2PNode = null,
     sync_manager: sync.SynchronizationManager,
diff --git a/src/networking/p2p.zig b/src/networking/p2p.zig
index 1b8de4e..f799fb4 100644
--- a/src/networking/p2p.zig
+++ b/src/networking/p2p.zig
@@ -3,6 +3,12 @@
 
 const std = @import("std");
 
+pub const P2PConfig = struct {
+    port: u16 = 7778,
+    max_peers: u32 = 16,
+    discovery_enabled: bool = true,
+};
+
 pub const P2PError = error{
     ConnectionFailed,
     PeerNotFound,
@@ -10,12 +16,15 @@ pub const P2PError = error{
     NetworkTimeout,
 };
 
+// Stub type for Address
+const Address = struct {};
+
 pub const PeerConnection = struct {
     id: u32,
-    address: std.net.Address,
+    address: Address,
     connected: bool,
 
-    pub fn init(id: u32, address: std.net.Address) PeerConnection {
+    pub fn init(id: u32, address: Address) PeerConnection {
         return PeerConnection{
             .id = id,
             .address = address,
@@ -71,4 +80,19 @@ pub const P2PManager = struct {
         // TODO: Implement message sending
         _ = message;
     }
+
+    pub fn start(self: *P2PManager, config: P2PConfig) P2PError!void {
+        _ = self;
+        _ = config;
+        // TODO: Implement P2P start with config
+    }
+
+    pub fn update(self: *P2PManager, delta_time: f32) void {
+        _ = self;
+        _ = delta_time;
+        // TODO: Implement P2P update
+    }
 };
+
+// Alias for compatibility with mod.zig
+pub const P2PNode = P2PManager;
diff --git a/src/networking/security.zig b/src/networking/security.zig
index 78acd27..0e0aac6 100644
--- a/src/networking/security.zig
+++ b/src/networking/security.zig
@@ -110,13 +110,13 @@ pub const SecurityConfig = struct {
 pub const SecurityManager = struct {
     allocator: std.mem.Allocator,
     config: SecurityConfig,
-    request_counts: std.HashMap(u32, u32, std.hash_map.DefaultContext(u32), std.hash_map.default_max_load_percentage),
+    request_counts: std.HashMap(u32, u32, std.hash_map.AutoContext(u32), std.hash_map.default_max_load_percentage),
 
     pub fn init(allocator: std.mem.Allocator, config: SecurityConfig) !SecurityManager {
         return SecurityManager{
             .allocator = allocator,
             .config = config,
-            .request_counts = std.HashMap(u32, u32, std.hash_map.DefaultContext(u32), std.hash_map.default_max_load_percentage).init(allocator),
+            .request_counts = std.HashMap(u32, u32, std.hash_map.AutoContext(u32), std.hash_map.default_max_load_percentage).init(allocator),
         };
     }
 
diff --git a/src/networking/server.zig b/src/networking/server.zig
index 133ec02..5e40979 100644
--- a/src/networking/server.zig
+++ b/src/networking/server.zig
@@ -3,6 +3,12 @@
 
 const std = @import("std");
 
+pub const ServerConfig = struct {
+    port: u16 = 7777,
+    max_clients: u32 = 32,
+    timeout_seconds: u32 = 30,
+};
+
 pub const ServerError = error{
     BindFailed,
     ListenFailed,
@@ -12,14 +18,18 @@ pub const ServerError = error{
     ClientDisconnected,
 };
 
+// Stub types for networking (std.net not available in Zig 0.16)
+const Stream = struct {};
+const Address = struct {};
+
 pub const ClientConnection = struct {
     id: u32,
-    socket: std.net.Stream,
-    address: std.net.Address,
+    socket: Stream,
+    address: Address,
     connected: bool,
     last_ping: i64,
 
-    pub fn init(id: u32, socket: std.net.Stream, address: std.net.Address) ClientConnection {
+    pub fn init(id: u32, socket: Stream, address: Address) ClientConnection {
         return ClientConnection{
             .id = id,
             .socket = socket,
@@ -30,15 +40,18 @@ pub const ClientConnection = struct {
     }
 
     pub fn send(self: *ClientConnection, data: []const u8) ServerError!void {
-        _ = self.socket.writeAll(data) catch return ServerError.SendFailed;
+        _ = self;
+        _ = data;
+        // TODO: Implement with proper networking API
     }
 
     pub fn receive(self: *ClientConnection, buffer: []u8) ServerError!usize {
-        return self.socket.read(buffer) catch return ServerError.ReceiveFailed;
+        _ = self;
+        _ = buffer;
+        return 0; // TODO: Implement with proper networking API
     }
 
     pub fn disconnect(self: *ClientConnection) void {
-        self.socket.close();
         self.connected = false;
     }
 
@@ -47,22 +60,41 @@ pub const ClientConnection = struct {
     }
 };
 
+// Stub type for StreamServer
+const StreamServer = struct {
+    pub fn init(options: struct {}) StreamServer {
+        _ = options;
+        return StreamServer{};
+    }
+    pub fn listen(self: *StreamServer, address: Address) !void {
+        _ = self;
+        _ = address;
+    }
+    pub fn deinit(self: *StreamServer) void {
+        _ = self;
+    }
+    pub fn accept(self: *StreamServer) !struct { stream: Stream, address: Address } {
+        _ = self;
+        return .{ .stream = Stream{}, .address = Address{} };
+    }
+};
+
 pub const NetworkServer = struct {
-    socket: std.net.StreamServer,
+    socket: StreamServer,
     clients: std.array_list.Managed(ClientConnection),
     allocator: std.mem.Allocator,
     port: u16,
     running: bool,
     max_clients: u32,
 
-    pub fn init(allocator: std.mem.Allocator, port: u16, max_clients: u32) NetworkServer {
+    pub fn init(allocator: std.mem.Allocator) NetworkServer {
         return NetworkServer{
             .socket = undefined,
             .clients = std.array_list.Managed(ClientConnection).init(allocator),
             .allocator = allocator,
-            .port = port,
+            .port = 7777,
             .running = false,
-            .max_clients = max_clients,
+            .max_clients = 32,
         };
     }
 
@@ -74,8 +106,10 @@ pub const NetworkServer = struct {
         self.clients.deinit();
     }
 
-    pub fn start(self: *NetworkServer) ServerError!void {
-        const address = std.net.Address.initIp4([_]u8{ 0, 0, 0, 0 }, self.port);
+    pub fn start(self: *NetworkServer, config: ServerConfig) ServerError!void {
+        self.port = config.port;
+        self.max_clients = config.max_clients;
+        const address = Address{}; // TODO: Use proper Address.initIp4 when networking API is available
 
         self.socket = std.net.StreamServer.init(.{});
         self.socket.listen(address) catch return ServerError.ListenFailed;
@@ -127,7 +161,8 @@ pub const NetworkServer = struct {
         try client.send(message);
     }
 
-    pub fn update(self: *NetworkServer) void {
+    pub fn update(self: *NetworkServer, delta_time: f32) void {
+        _ = delta_time;
         const current_time = std.time.timestamp();
 
         // Check for disconnected clients (timeout after 30 seconds)
@@ -147,3 +182,6 @@ pub const NetworkServer = struct {
         return count;
     }
 };
+
+// Alias for compatibility with mod.zig
+pub const GameServer = NetworkServer;
diff --git a/tools/asset_processor/asset_processor.zig b/tools/asset_processor/asset_processor.zig
index e9d2e35..0d679dc 100644
--- a/tools/asset_processor/asset_processor.zig
+++ b/tools/asset_processor/asset_processor.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
+
 // Remove zigimg dependency for now as it's not in the project
 // const zigimg = @import("zigimg");
 
@@ -459,8 +460,10 @@ const AssetProcessor = struct {
         };
         defer file.close();
 
-        const metadata_json = try file.readToEndAlloc(self.allocator, 10 * 1024 * 1024);
+        const file_size = try file.getEndPos();
+        const metadata_json = try self.allocator.alloc(u8, file_size);
         defer self.allocator.free(metadata_json);
+        _ = try file.readAll(metadata_json);
 
         const parsed = std.json.parseFromSlice(AssetDatabase, self.allocator, metadata_json, .{}) catch |err| {
             std.log.warn("Failed to parse metadata file: {}", .{err});
@@ -545,7 +548,9 @@ const AssetProcessor = struct {
             .assets = assets_list.items,
         };
 
-        try std.json.stringify(database, .{ .whitespace = .indent_2 }, file.writer());
+        var buffer: [8192]u8 = undefined;
+        const writer = file.writer(&buffer);
+        try std.json.stringify(database, .{ .whitespace = .indent_2 }, writer);
 
         // Clean up allocated strings
         for (assets_list.items) |asset| {
@@ -722,8 +727,10 @@ test "basic asset processing" {
     const result_file = try std.fs.openFileAbsolute(processed_path, .{});
     defer result_file.close();
 
-    const content = try result_file.readToEndAlloc(std.testing.allocator, 1024);
+    const file_size = try result_file.getEndPos();
+    const content = try std.testing.allocator.alloc(u8, file_size);
     defer std.testing.allocator.free(content);
+    _ = try result_file.readAll(content);
 
     try std.testing.expectEqualStrings("test content", content);