Open Source Game Engine · v0.1.23

The Game Engine
Built for the AI Era

nAIVE is an AI-Native Interactive Visual Engine. Rust + WebGPU core, YAML-driven pipelines, Lua scripting, sub-second hot-reload — designed so AI and humans can build games together.

🦀 Rust 🔺 WebGPU 🌙 Lua 5.4 📄 YAML 🧠 MCP Interface
<50ms
Script Hot-Reload
<200ms
Shader Rebuild
50K
GPU Units at ~1,000 fps
49K
Lines of Rust
19 built-in
Embedded Demos

Install in One Line

Homebrew builds the CLI and the standalone player from the release source. Prebuilt player and demo-app downloads for Apple silicon are on GitHub Releases.

terminal
$ brew install poro/tap/naive
$ naive init my-game && cd my-game
$ naive edit     # open the AI scene editor (MCP socket)
$ naive test     # run Lua playtests headlessly, no GPU
$ naive build    # ship a standalone .app or Linux bundle
$ naive demo     # browse the 19 built-in demos

AI-Native by Design

Every architectural decision in nAIVE was made to enable AI collaboration. Not as a plugin — as the foundation.

⚡

Sub-Second Hot-Reload

Shaders in <200ms, scenes in <100ms, scripts in <50ms. Zero frame drops. State preserved across reloads. 100x faster than Unity/Unreal.

📄

YAML-Driven Everything

Scenes, render pipelines, materials, input bindings — all human-readable YAML. Git-friendly, diffable, and trivially generatable by LLMs.

🧠

MCP Command Interface

20 typed tools over a Unix socket: spawn and edit entities, run Lua, capture frames and diff screenshots, run tests, benchmark, undo. Claude, GPT, or your own agent drives the running engine.

🧪

Headless AI Playtesting

The simulation lives in its own GPU-free crate, so tests run the same construction, physics and Lua as the game — no GPU, no window. Fixed timestep, supervised runs with hard deadlines.

🔺

Declarative Render DAG

One YAML file defines the deferred PBR pipeline: shadows, G-buffer, Gaussian splats, lighting, bloom, tonemap, FXAA. Topological sorting and cycle detection built in.

🌐

Gaussian Splats (3DGS)

First-class engine feature. PLY loading, depth compositing with mesh geometry, hardware-accelerated rendering. Not a plugin — built in.

💥

Dynamic Physics

entity.spawn_dynamic() for runtime physics bodies. Physics materials with restitution/friction, CCD for fast projectiles, impulse/force/velocity API.

🎮

19 Embedded Demos

Run naive demo to browse and launch any of 19 demos across 6 categories — no downloads needed. Getting Started, Physics, Visual, Gameplay, Stress Test, Showcase.

🐜

GPU Swarms

50,000 units moving, separating, path-finding on flow fields and fighting in GPU compute — about 1,000 fps on an M4 Max. Driven from Lua with the swarm API.

🌗

Shadows & Sky Lighting

Cascaded shadow maps, frustum culling, and an optional sky with image-based lighting — all from the YAML pipeline and scene settings.

📦

Standalone Games

naive build packages a macOS app or Linux bundle with a player built without the shader compiler; shaders are precompiled to WGSL.

🛡️

Sandboxed Lua

Every script call runs under CPU, memory and time limits — including pattern matching and library calls — so agent-written code cannot freeze the editor.

Dev Feedback Loop

Every AI-built game is a test case. Zero-cost feedback. Structured, not narrative.

Every naive init project includes a structured dev.log template. AI agents maintain it throughout development (instructed via CLAUDE.md), recording what worked, what broke, and what's missing. When done, naive submit-log posts it as a GitHub Issue with the dev-log label. The engine agent reads all dev.logs worldwide and evolutionarily improves the engine. The more games built, the better the engine gets.

naive init

Project + dev.log template

→

Build Game

AI maintains dev.log

→

submit-log

GitHub Issue · dev-log label

→

Triage

Engine agent reads all logs

→

Improve

Engine evolves

→

Release

Better engine for all

19 Demos. One Command.

Run naive demo to browse and launch any embedded demo. No downloads, no setup — everything is compiled into the binary via include_str!().

🚀 Getting Started

Hello Cube, basic scene setup — get running in seconds.

⚡ Physics

Rigid bodies, collisions, physics materials, CCD, spawn_dynamic().

🎨 Visual

PBR materials, lighting, Gaussian splats, camera effects.

🎮 Gameplay

Health/damage, projectiles, third-person camera, input handling.

🔥 Stress Test

Push the engine to its limits — mass spawning, particle storms.

🏆 Showcase

Complete mini-games demonstrating full engine capabilities.

terminal
$ naive demo
Available demos (19):
  Getting Started · Physics · Visual
  Gameplay · Stress Test · Showcase

$ naive demo physics_materials
▶ Running: Physics Materials Demo...

One File. Full PBR.

A complete deferred pipeline — cascaded shadows, Gaussian splats, PBR lighting with sky IBL, bloom and tonemapping — defined in YAML. Use the engine's shaders by name, or point any pass at your own Slang shader.

G-Buffer

Albedo · Normal · Depth · Emission

→

Splat Pass

3DGS Point Clouds

→

Deferred Light

PBR · 32 Lights · Compositing

→

Bloom

13-tap Tent Filter

→

Tonemap

ACES · Vignette · Output

pipeline.yaml
version: 2
settings:
  vsync: true
  hdr: true

resources:
  - name: gbuffer_albedo
    format: rgba8
    size: viewport
  - name: gbuffer_normal
    format: rgba16f
    size: viewport
  - name: hdr_buffer
    format: rgba16f
    size: viewport
  - name: bloom_buffer
    format: rgba16f
    size: viewport/2

passes:
  - name: geometry_pass
    type: rasterize
    shader: builtin:gbuffer
    outputs:
      color: gbuffer_albedo
      normal: gbuffer_normal

  - name: lighting_pass
    type: fullscreen
    shader: builtin:deferred_light
    inputs:
      gbuffer_albedo: gbuffer_albedo
      gbuffer_normal: gbuffer_normal
    outputs:
      color: hdr_buffer

  - name: tonemap_pass
    type: fullscreen
    shader: builtin:tonemap
    outputs:
      color: swapchain

Built Different

A lean, modern stack designed for speed, composability, and AI-native workflows.

Runtime Core — Rust

  • WebGPU (wgpu 30) — Metal/Vulkan/DX12 backends
  • Entity Component System (hecs) — data-oriented design
  • Rapier3D physics — rigid bodies, character controllers
  • Kira spatial audio — 3D sound, doppler, attenuation
  • Slang shaders, precompiled to WGSL for shipping
  • GPU-free naive-sim crate shared by game and tests

Data Layer — YAML + glTF

  • YAML for scenes, pipelines, materials, input, events
  • glTF 2.0 mesh loading with procedural fallbacks
  • PLY Gaussian splat loading with SH extraction
  • Git-friendly, diffable, AI-generatable
  • No binary blobs, no proprietary formats

Scripting — Lua 5.4

  • Per-entity sandboxed environments
  • Lifecycle hooks: init, update, on_event, on_reload
  • Sandboxed: CPU, memory and time limits per call
  • Hot-reload preserves entity self tables
  • Health/damage, projectile spawning, entity.spawn_dynamic()

AI Integration — MCP

  • 20 typed tools over a Unix socket
  • Frame capture, screenshot diff, undo, benchmarks
  • Headless test runner — no GPU required
  • CI/CD ready with GitHub Actions
  • Built for Claude Code, Cursor, AI agents

Dev Feedback — Self-Improving

  • Structured dev.log in every project
  • AI agents maintain logs during development
  • naive submit-log → GitHub Issues with dev-log label
  • Engine agent reads all logs, improves engine
  • Virtuous cycle: more games = better engine

Demo System — 19 Embedded

  • All demos compiled via include_str!()
  • 6 categories: Getting Started → Showcase
  • Zero downloads — run any demo instantly
  • Each demo exercises specific engine features
  • Living documentation and regression tests

nAIVE vs. The Incumbents

How nAIVE stacks up against Unity 6, Unreal 5.7, Godot 4.5, and Bevy 0.18.

CapabilitynAIVEUnity 6Unreal 5.7Godot 4.5
Shader Hot-Reload<200ms5-15s10-30s1-3s
Script Hot-Reload<50ms2-10s5-15s<1s
Scene Hot-Reload<100ms30-60sN/A (binary)1-2s
Data FormatYAML (AI-readable)Binary blobsBinary .uassettscn (text)
Pipeline DefinitionOne YAML file~500 lines C#~800 lines C++Fixed pipeline
AI Control InterfaceNative MCPNoneNoneNone
Headless TestingBuilt-in, no GPUBatch mode (limited)Gauntlet (complex)GUT plugin
Gaussian SplatsFirst-classNo supportNo supportNo support
Built-in Demo Browser19 demos, one commandManual setupManual setupManual setup
Dev Feedback LoopStructured dev.log → auto-triageNoneNoneNone
LicenseMIT (open source)Free (revenue cap)5% royalty > $1MMIT

Dual License Model

The engine is fully open source. The platform adds optional server infrastructure.

MIT

🔓 nAIVE Engine

The core engine — rendering, physics, scripting, ECS, hot-reload, headless testing, MCP interface. Use it for anything. Commercial, personal, educational. No restrictions. No royalties. Forever.

BSL 1.1

🔐 nAIVE Platform

Server infrastructure for multiplayer, world registry, AI Director, LLM NPCs, Telegram bridge. Source-available with commercial use restrictions. Converts to MIT after 3 years.

Deep Dive

Full technical documentation — whitepaper, product requirements, architecture diagrams, and runnable demos.

Build the Future of Games

nAIVE is open source and ready for contributors. Dive in.