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.
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.
$ 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
Every architectural decision in nAIVE was made to enable AI collaboration. Not as a plugin — as the foundation.
Shaders in <200ms, scenes in <100ms, scripts in <50ms. Zero frame drops. State preserved across reloads. 100x faster than Unity/Unreal.
Scenes, render pipelines, materials, input bindings — all human-readable YAML. Git-friendly, diffable, and trivially generatable by LLMs.
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.
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.
One YAML file defines the deferred PBR pipeline: shadows, G-buffer, Gaussian splats, lighting, bloom, tonemap, FXAA. Topological sorting and cycle detection built in.
First-class engine feature. PLY loading, depth compositing with mesh geometry, hardware-accelerated rendering. Not a plugin — built in.
entity.spawn_dynamic() for runtime physics bodies. Physics materials with restitution/friction, CCD for fast projectiles, impulse/force/velocity API.
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.
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.
Cascaded shadow maps, frustum culling, and an optional sky with image-based lighting — all from the YAML pipeline and scene settings.
naive build packages a macOS app or Linux bundle with a player built without the shader compiler; shaders are precompiled to WGSL.
Every script call runs under CPU, memory and time limits — including pattern matching and library calls — so agent-written code cannot freeze the editor.
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.
Project + dev.log template
AI maintains dev.log
GitHub Issue · dev-log label
Engine agent reads all logs
Engine evolves
Better engine for all
Run naive demo to browse and launch any embedded demo. No downloads, no setup — everything is compiled into the binary via include_str!().
Hello Cube, basic scene setup — get running in seconds.
Rigid bodies, collisions, physics materials, CCD, spawn_dynamic().
PBR materials, lighting, Gaussian splats, camera effects.
Health/damage, projectiles, third-person camera, input handling.
Push the engine to its limits — mass spawning, particle storms.
Complete mini-games demonstrating full engine capabilities.
$ naive demo
Available demos (19):
Getting Started · Physics · Visual
Gameplay · Stress Test · Showcase
$ naive demo physics_materials
▶ Running: Physics Materials Demo...
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.
Albedo · Normal · Depth · Emission
3DGS Point Clouds
PBR · 32 Lights · Compositing
13-tap Tent Filter
ACES · Vignette · Output
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
A lean, modern stack designed for speed, composability, and AI-native workflows.
naive-sim crate shared by game and testsHow nAIVE stacks up against Unity 6, Unreal 5.7, Godot 4.5, and Bevy 0.18.
| Capability | nAIVE | Unity 6 | Unreal 5.7 | Godot 4.5 |
|---|---|---|---|---|
| Shader Hot-Reload | <200ms | 5-15s | 10-30s | 1-3s |
| Script Hot-Reload | <50ms | 2-10s | 5-15s | <1s |
| Scene Hot-Reload | <100ms | 30-60s | N/A (binary) | 1-2s |
| Data Format | YAML (AI-readable) | Binary blobs | Binary .uasset | tscn (text) |
| Pipeline Definition | One YAML file | ~500 lines C# | ~800 lines C++ | Fixed pipeline |
| AI Control Interface | Native MCP | None | None | None |
| Headless Testing | Built-in, no GPU | Batch mode (limited) | Gauntlet (complex) | GUT plugin |
| Gaussian Splats | First-class | No support | No support | No support |
| Built-in Demo Browser | 19 demos, one command | Manual setup | Manual setup | Manual setup |
| Dev Feedback Loop | Structured dev.log → auto-triage | None | None | None |
| License | MIT (open source) | Free (revenue cap) | 5% royalty > $1M | MIT |
The engine is fully open source. The platform adds optional server infrastructure.
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.
Server infrastructure for multiplayer, world registry, AI Director, LLM NPCs, Telegram bridge. Source-available with commercial use restrictions. Converts to MIT after 3 years.
Full technical documentation — whitepaper, product requirements, architecture diagrams, and runnable demos.
GDC 2026 white paper (February 2026). Technical overview of the architecture, innovations and positioning.
Product requirements including dev.log feedback system, demo browser specs, rendering, physics, audio, scripting, GPU compute.
Server infrastructure spec: multiplayer, world registry, AI Director, LLM NPCs, Telegram bridge, matchmaking.
19 embedded demos across 6 categories. Run any demo with a single command — no downloads required.
System architecture diagrams including dev feedback loop, demo browser internals, and engine component graph.
nAIVE is open source and ready for contributors. Dive in.