Documentation

Welcome. Zero is a 3D engine you drive with Luau, working inside a live, shared world.

Everything you author in a world — a scene, a component, a module, a material, an asset type — is an asset in one shared…

Documentation for the Zero engine: guides for building 3D worlds and games with Luau, plus the full engine API reference, all published through ZeroMind.

ZeroMind is the service behind origozero.ai: the shared versioned library where everything built with the Zero engine becomes installable in another world.

How finished worlds and assets move from the engine into ZeroMind, the shared versioned library other people and agents pull from and build on.

Zero is an agent-first 3D engine where every part of a world is a versioned asset: validated at publish, forkable, and installable into any other world.

Zero and ZeroMind are built on one idea: every finished piece of work becomes a reusable capability, so each project makes the next one easier.

What AI agents built on Zero: a Game Boy Color emulator, DOOM's first chapter from the WAD, a JavaScript runtime, unmodified three.js, hundreds of casual games.

This is the one read that shows how the pieces fit together.

A world is the project you're working in — all of its entities, scenes, components, materials, and code.

A scene is a loadable arrangement of a world — its entities (with their components, transforms, and lighting), plus a startup script — saved as a .scene asset.

Working in Zero means working inside a live, shared world.

You work with the ECS layer through ecs. and entity. — two views of the same thing. entity. spawns and finds the entities…

An entity is a named handle with a stable id, a transform, and a place in a hierarchy. On its own it does nothing — it has no shape, no physics, no behaviour.

A component is the primary unit of gameplay code: a piece of behaviour + data attached to an entity.

require is how one piece of Luau pulls in another. You hand it a string; it hands you back the table that module returned.

You're building something — a scene, a game, a level — and you need an asset that doesn't exist yet: a 3D model of a dragon, a door-slam sound…

Two kinds of code run in Zero, and it's worth knowing which you're writing:

runtime_data is a world's persistent, replicated data layer — where you keep state that must survive restarts and reach every player: progression…

The asset system is the backbone of a Zero world.

The engine's state is exposed as a filesystem under /zero.

Tools are how the engine's capabilities become named, discoverable workflow operations.

Zero is multiplayer by default — in both edit mode and play mode.

You don't need to memorise this engine. Its surface is discoverable in layers, and the order matters: the jobs it already knows how to do…

A world is a shared, multi-user editor session.

Zero executes your logic in two very different worlds. Luau is flexible, per-object, and serial. The engine core and the GPU are bulk and parallel.

Everything you write here is read by somebody else — another creator, another agent, or you in a month with none of today's context.

An asset is only as findable as its description is clear. When you make something, say what it is, in a few plain sentences.

/zero/home/<username> is a folder that follows you, not the world.

You have a running world and a question about a moment in it.

A plugin is a WebAssembly component that a world calls the way it calls a module.

Read this before working with any mesh, texture, material, or shader.

A scene can say what it holds in code. build.luau inside the scene's folder is where the scene's content is written — all of it…

Something you built doesn't behave — a component never runs, a weapon never equips, a value comes back nil, a mesh isn't where it should be.

A world's history, branches and reviews are handled by ZeroMind — Zero's own version control system.

An animated GIF, APNG or animated WebP imports as one texture carrying every frame: one layer per frame, plus the display time each frame was authored with.

Animated models in Zero carry named clips (idle, walk, run, …).

Audio in Zero is built from two components. An Audio component makes an entity emit sound from a .soundClip asset.

bash is a complete bash shell running inside the engine, over this world's files and the engine's live state.

A game in Zero is a scene the world loads: its entities, their components, the player avatar, and the camera.

A world often needs to speak to something that is not part of it — a socket on another machine, an external process on localhost…

The camera global and the Camera component are the world's own cameras, the ones the scene is rendered through.

A camera is an entity carrying a Camera component.

A cutscene is the moment your game takes the camera off the player: the opening that establishes where they are, the door that opens once, the ending.

Everything you see when you edit a world — the menu bar across the top, the dockable panels, the play controls — is world-side Luau content…

The engine describes its whole Luau API (every global namespace, method signature, published type alias and asset-category surface) as a Luau definitions file…

Sometimes the rendered image has to leave the machine.

How the engine fits its rendering to the device a world is played on: a phone, a tablet, a laptop, a desktop or a browser.

Sometimes something outside the engine has to reach in.

An animation clip stores joint angles. Play it and the character does the same thing every time…

A player might be at a keyboard, holding a controller, or tapping a phone.

Every engine knows which languages its player reads, on every platform, and picks from one chain.

The audio guide is about sound the world makes. This one is about sound the world hears — audio input from the machine it is running on.

Physics in Zero has two surfaces, reached in two different ways:

Cast rays against the live scene from a compute shader and shade with the hits — shadows, ambient occlusion, reflections, GI.

av turns what the engine draws into a video file: a clip a player captures of something fun, a replay, a trailer or cutscene filmed frame by frame…

A render layer is a name. An entity is a member of one or more layers; a camera draws a filter over them ("all !shell").

A render texture is a camera's view drawn into a texture instead of onto the screen.

Most of how a scene looks comes from its content — meshes, materials, and lights.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Part of the rendering guide (guides { path = "topics/rendering" }), which lists every part.

Every visual property of a widget lives in one table — the style table on the widget node — and the vocabulary is CSS.

Text in a world comes from one place: a text object the engine holds, laid out against a font database and rasterised into a GPU texture.

UI in Zero is declarative and immediate-mode: you describe the interface as a tree of widget tables and register it as a named screen…

A visual effect in Zero (sparks, fire, smoke, magic, an impact, a muzzle flash, a swarm, lightning) is an entry of an effect…

Four systems decide how much of a world stands at any one moment:

agentSessions is a Luau API namespace of the Zero engine, holding 4 functions: forget, get, put and record.

Observe what the engine is animating: every body it is posing, the clips driving each one and where their playheads are…

Asset resolver, ref envelope builder, sidecar metadata.

Engine-native audio: encode audio (or raw PCM) into the ZAUD compressed payload, decode/inspect it, set what the mix is heard at, a level per named channel…

Audio/video encode + mux control: live streaming, recording, encoder/muxer primitives.

Base64 encode / decode between binary and text Luau strings (standard RFC 4648 alphabet, padded).

Record-stride blend primitives over Buffer slices: layout registry + weighted/lerp combiners.

bundle is a Luau API namespace of the Zero engine, holding 1 function: update.

Script-facing camera queries: the main scene camera, the on-screen render camera, the editor fly-camera, per-frame view data, and the camera observation…

Physical cameras as live textures and pixel sources: list the capture devices (a webcam, a phone's front and back cameras), open one as a feed…

Keyframe-channel sampling primitives: registry + sampleInto variants.

Color construction, conversion, and perceptual ops (RGB / HSL / HSV / Oklch / hex).

ColorSequence is a Luau API namespace of the Zero engine, holding 2 functions: deserialize and new.

component is a Luau API namespace of the Zero engine, holding 20 functions, among them data, entity, entityId, instanceId and add.

GPU compute pipelines: compile shaders, dispatch workgroups, read back results.

cursor is a Luau API namespace of the Zero engine, holding 2 functions: clear and set.

Luau debugger: breakpoints, stepping, stack inspection, watches.

ecs is a Luau API namespace of the Zero engine, holding 40 functions, among them AudioListener, AudioSource, Camera, Collider and CollisionGroups.

Credential-injecting HTTP for BYO-key world egress (Mechanism B).

engine is a Luau API namespace of the Zero engine, holding 48 functions, among them discardPlayChanges, editWaiters, engineRecord, gameplayReady and gpuCompute.

Entity spawn / despawn / query / hierarchy surface.

Entity wrapper namespace. Also reachable as the lowercase entity(...) proxy constructor.

Environment / reflection capture: bake the scene into reflection-probe cube slots from world positions, persist them as faces6.texture assets…

Field is a Luau API namespace of the Zero engine, holding 24 functions, among them alias, assetRef, bitmask, bool and check.

Font primitive: parse a font file ONCE into a baked, vectorized glyph format (ZFNT), then drive every text surface from it.

Carries an image the GPU drew out to another program: the view a camera renders…

globals is a Luau API namespace of the Zero engine, holding 1259 functions, among them deserialize, new, Entity, allTypes and distance.

The person's home folder, /zero/home/<username>: their own files, carried from world to world in the editor.

Async HTTP: GET/POST returning JSON or raw bytes.

Serve HTTP from this engine.

The player's language, and which of your world's languages to show them. i18n.pick({"en", "pt", "es"})…

input is a Luau API namespace of the Zero engine, holding 41 functions, among them armObservation, backUnanswered, emulateKeyDown…

jobs is a Luau API namespace of the Zero engine, holding 21 functions, among them context, dispatch, find, inspect and list.

Top-level scene-management namespace + Scene proxy. Owns the public layer-management API surface exposed on _G.layers.

Discover, check, and import library assets: the @builtin/ tree the engine ships and the @namespace/ trees imported from other worlds.

live is a Luau API namespace of the Zero engine, holding 1 function: isConnected.

log is a Luau API namespace of the Zero engine, holding 4 functions: debug, error, info and warn.

Read-only query surface over the engine's in-memory log ring buffer.

Embedded Luau language server: check / search / inspect.

luau_codegen is a Luau API namespace of the Zero engine, holding 3 functions: chunk, chunks and status.

Sampling profiler + manual regions for Luau scripts.

Material helpers namespace.

Batch math kernels over buffer slices (damp, lerp/slerp, transform).

mcp is a Luau API namespace of the Zero engine, holding 4 functions: call, image, listTools and poll.

Read-only MCP tool-call log ring buffer.

Capture from an input device and read what is arriving: a loudness, a magnitude spectrum, and the raw PCM.

The model-import pipeline: decompose any assimp-supported 3D model (fbx, obj, dae, gltf, glb, stl, ply, 3ds) into meshes, materials, textures…

modules is a Luau API namespace of the Zero engine, holding 2266 functions, among them getInstructions, getManifest, getReadme, inspect and onChange.

Multiplayer sync state and operations: connection, peers, ownership, rooms, undo/redo.

Post an event record that surfaces to the callers it is addressed to on the response of the tool call that posted it, or on their next tool call.

NumberRange is a Luau API namespace of the Zero engine, holding 1 function: new.

NumberSequence is a Luau API namespace of the Zero engine, holding 2 functions: deserialize and new.

nx is a Luau API namespace of the Zero engine, holding 67 functions, among them add, addStrided, addStridedFrom, applyAbs and applyCeil.

Discover and inspect registered packages (folders marked with package.yaml).

Lowercase alias of Physics. Same identity. Prefer this in new code so the convention matches entity, scene, cam.

Physics namespace: collisions, joints, raycasts, body manipulation.

What the plugin host loaded, and the one way to call a plugin.

Fullscreen post-process effects: register / remove / toggle / named-property updates / list the chain / read one effect's declared property schema…

Preset namespace: apply named tuning bundles to components.

Frame-level profiler capture, EMA stats, and named profiling blocks.

Seeded random-number generators.

Reflection-probe system: multiple proximity-blended reflection probes in a scene.

GPU-resource factory + CPU codec/store wrappers: the GPU/CPU half of the asset↔resource split.

Scopes: work you start together and that ends together, tied to what started it (an entity, a component, a scene, another scope)…

Credit-metered service invoke, buffered or streamed.

settings is a Luau API namespace of the Zero engine, holding 7 functions, among them all, get, getBool, getNumber and getString.

Shader compilation: turning authored WGSL into registered GPU programs, and the reusable modules those programs include.

Engine emulated Unix shell: same shell that powers the MCP bash tool.

The skeleton pose-data pipeline: sample a clip into a pose buffer, and bind/apply a pose buffer onto a Skeleton + Model entity.

Sky configuration: type, time of day, day/night cycle, procedural parameters, presets, explicit sun direction.

Named byte streams by URL scheme: TCP, tty, Bluetooth Low Energy and loopback transports, dialled out or listened…

What the engine has resident of a world's detail right now, and why a piece of it is not on screen.

Batch text-scanning kernels: read a whole run of numbers out of a string in one call.

Runtime inspection and cancellation of component-event subscriptions.

Typed data buffers, on the CPU or the GPU: the engine's one buffer primitive.

task is a Luau API namespace of the Zero engine, holding 29 functions, among them active, await, background, batched and bindCaller.

terminal is a Luau API namespace of the Zero engine, holding 7 functions, among them create, destroy, kill, list and poll.

Text rasterisation resource: create a text handle, set its content and style, then rasterise it to a texture for display…

time is a Luau API namespace of the Zero engine, holding 6 functions, among them deltaTime, drawnFrameCount, frameCount, realtime and time.

toml is a Luau API namespace of the Zero engine, holding 3 functions: encode, parse and replaceArrayTables.

tools is a Luau API namespace of the Zero engine, holding 360 functions, among them __useVia, bind, callable, create and createToolbox.

Math helpers for positions, rotations, and directions on transforms.

typed is a Luau API namespace of the Zero engine, holding 1818 functions, among them build, flushPendingPersists, forgetRuntime…

UI system: screens, styles, themes, widget responses, focus, custom-widget builders, per-widget state.

The files of the person at the screen, both ways. pick opens their own file picker (native OS dialog / Android / web browser) and brings the chosen file(s)…

Virtual filesystem: read, write, list, watch.

Video playback: create / play / pause / seek / setRate / setLoop / destroy on render-target-backed video players.

world is a Luau API namespace of the Zero engine, holding 93 functions, among them add, add_all, affirm, args and assetInstallable.

ws is a Luau API namespace of the Zero engine, holding 6 functions, among them close, connect, liveness, poll and recv.

A skill packages what an agent needs to do one job well: the instructions, the assets and toolboxes the job runs through…

A single animation clip, as a composite asset. The folder <name>.animation/ carries:

The assetType is the type of types — the meta-type that every <typename>.assetType/ folder is an instance of, including itself.

A playable character, composed from three independent parts:

An avatar type describes a kind of body: a humanoid, a quadruped, a vehicle.

A bundle is a composable, spawnable entity assembly— a saved entity hierarchy plus its components, sub-assets…

A component is a reusable behavior + data unit attached to an entity.

A .computeShader is a GPU compute (GPGPU) program with a zero-scaffolding authoring contract: you write only @compute fn main(...)…

A .data instance is a configured value binding to a dataType contract…

A dataType is a user-authored typed-data contract: it declares a set of fields — names, types, constraints, defaults…

A prompt-driven, self-regenerating 3D asset.

An editor dock arrangement as an asset: a <name>.editorLayout/ folder whose layout.yaml names either the panels the arrangement holds…

A dock tab in the editor, as an asset. A <name>.editorPanel/ folder carries an init.luau that returns the tab's spec:

A set of visuals packaged as one thing: every impact a weapon makes, every stage of an explosion, the muzzle flash, impact and tracer of a gun.

A .font is a first-class font asset: font-file bytes (TTF / OTF / WOFF / WOFF2) converted into a guid-anchored asset via asset.create…

A photographic capture of a real place, stored as a cloud of oriented 3D Gaussians rather than as triangles.

A guide is a single-file documentation asset: a <name>.guide/ folder whose body is guide.md, surfaced through the guides MCP tool…

An importer is a Luau function that converts a source file (GLB, PNG, CSV, custom binary) into one or more derived assets registered in the engine.

One control in a scheme — jump, move, boost — expressed as an asset.

An input macro is a recorded or hand-authored sequence of input simulation events — keystrokes, mouse moves, button clicks, scroll wheel deltas…

A control scheme, expressed as an asset.

A baked-lighting container: ONE asset per scene holding every baked lighting payload the GI bake flow produces…

The screen players see while your world loads, as an asset: a <name>.loadingScreen/ folder whose screen.yaml states the title, a line of text or rotating tips…

A material is a named, configured instance of a .shader.

A mesh is renderable geometry — vertices and triangle indices, and, for a skinned mesh, the per-vertex skinning data that binds it to a skeleton.

A module is a reusable, stateless (or globally-stateful) Luau library that other code pulls in with require().

A nodebox is a namespace folder that groups related .procNode/ children, the way a toolbox groups .tool/ children.

A package is an asset — a <Name>.package/ folder that bundles components, modules, scenes, presets, tools, and any other typed sub-assets under one identity…

A saved, reusable pixel-art sheet. A <name>.pixelTemplate/ folder asset carries a JSON payload template.pixbin…

Compiled code in a world, used the way a module is.

A hardware-instanced population at rest: one mesh drawn at every transform of a baked placement, as ONE draw call per variant at any instance count.

A preset is a named set of typed values for one declarer's settings schema: the texture assetType's, an importer's, a component's…

A .procGraph asset is a procedural graph: a description of how to make something, written as code, that can be evaluated over and over with different numbers.

A .procNode is a node authored as content: a folder whose init.luau is the node.

A .procPack is a FAMILY of procedural operations authored as content: a folder whose init.luau returns a pack table.

A .procRecord defines a kind of value a procedural graph moves that becomes an asset when it is saved: a material, a mesh, a texture…

A render feature inserts custom GPU passes into the frame pipeline.

A skeleton, as a composite asset. A rig is its own primitive — not a mesh and not an animation. The folder <name>.rig/ carries:

A scene is a saved, loadable snapshot of an entity scenegraph inside a world: the entity hierarchy, transforms, components, lighting…

A .sceneModule is a recipe for scene content: a folder whose init.luau declares the inputs a placement may set and returns the function that builds the content.

A service generates content you don't have yet — a 3D mesh, an image, a PBR material, a sound effect, a humanoid animation, a navigable splat world…

The durable record of one service generation — what was asked for, which gateway job is doing it, and what state that job reached.

A shader is a WGSL program that runs on the GPU.

A .shaderModule is a block of WGSL that other shaders include rather than copy — a lighting model, a set of colour-space helpers, one package's shared prelude.

An audio asset — a managed container holding a sound effect or music track, addressed by the .soundClip suffix.

A style is a UI design-token bundle: colour palette, spacing scale, typography pairs, and the widget classes built from them.

A landscape's baked data, as one asset.

A test suite is a registrable asset that bundles one group of automated engine tests.

An image asset — the raw bytes of a png / jpg / jpeg / hdr / ktx2 / webp / bmp / tga file. Loose image files under a textures/ directory classify as texture.

A tool is a single agent-callable function whose schema is its typed function signature.

A toolbox is a namespace folder that groups related .tool/ children plus shared helpers.

A voxel template is a reusable, named voxel grid that live instances link to.

A job whose shape is a program.