Documentation

Welcome. Zero is a 3D engine you drive with Luau, working inside a live, shared world. This is the orientation: what the engine is, the handful of ideas that everything rests on, and where to go for…

Everything you author in a world — a scene, a component, a module, a material, an asset type — is an asset in one shared, versioned graph that spans every published world. This guide teaches how that…

This is the one read that shows how the pieces fit together. Each system has its own guide; this walks the whole chain once — world → scene → players + camera → entities → components + assets —…

A world is the project you're working in — all of its entities, scenes, components, materials, and code. It's a shared, multi-user, persistent container backed by ZeroMind (the content backend).…

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. A scene is the unit of "level" or…

Working in Zero means working inside a live, shared world. Three things make up the engine's model, and understanding them up front saves a lot of confusion: the world is live and persistent, it runs…

You work with the ECS layer through ecs. and entity. — two views of the same thing. entity. spawns and finds the entities; ecs. attaches and reads the native components that give them their…

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. Every capability comes from the…

A component is the primary unit of gameplay code: a piece of behaviour + data attached to an entity. Movement, AI, animation drivers, UI panels, network sync, per-entity state — all of it lives in…

require is how one piece of Luau pulls in another. You hand it a string; it hands you back the table that module returned. The interesting part is the string — what you write decides how the engine…

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, a stone-tile texture, a walk animation, a whole…

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, saved builds, unlocks, per-player records, any…

The asset system is the backbone of a Zero world. Almost everything you work with — a component, a material, a scene, a tool, a mesh, a texture, a shader, a bundle — is an asset. Understanding what…

The engine's state is exposed as a filesystem under /zero. This is a genuine superpower for understanding what exists — you navigate entities, components, assets, and live runtime state with the same…

Tools are how the engine's capabilities become named, discoverable workflow operations. A tool composes a multi-step job (resolve an asset, spawn an entity, add a Model, add a collider, position it)…

Zero is multiplayer by default — in both edit mode and play mode. A world is a live, shared session: other people and agents may be connected to the same world at the same time, editing alongside you…

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, the kinds of thing it can make, the operations it already…

A world is a shared, multi-user editor session. Everyone connected sees your edits live and you see theirs — like a shared document, in both edit and play (the multiplayer guide). That shapes how…

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. Almost all performance work comes down to running…

Everything you write here is read by somebody else — another creator, another agent, or you in a month with none of today's context. This guide is the set of rules that make what you write usable by…

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 — and what that code creates is what the scene is made of: the entities…

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. The engine almost always already knows why: errors land in…

A world's history, branches and reviews are handled by ZeroMind — Zero's own version control system. If you have used git, the model will feel familiar: the verbs carry the same names and mean the…

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. Putting it on a surface is one call.

Animated models in Zero carry named clips (idle, walk, run, …). A clip plays on a skinned body through the AnimGraph — it retargets the clip from its source rig onto the body's rig and drives the…

Audio in Zero is built from two components. An Audio component makes an entity emit sound from a .soundClip asset. An AudioListener component makes an entity the "ears" of the scene. Both live on…

A game in Zero is a scene the world loads: its entities, their components, the player avatar, and the camera. The way you build that scene is the part worth learning, because it is not "place objects…

A world often needs to speak to something that is not part of it — a socket on another machine, an external process on localhost, a device reached through the program that drives its serial port, a…

A camera is an entity carrying a Camera component. The renderer draws the viewport from whichever camera wins it, and draws every camera naming a render target into that target. Which camera won,…

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. In Zero you write one as data — a table of…

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, built from the same Z. widgets and the same engine APIs…

Sometimes the rendered image has to leave the machine. You want to send pixels to another program — drive an LED panel or a physical display, feed a video encoder, hand a frame to a Python script,…

Sometimes something outside the engine has to reach in. You want a web page you can open in a browser to see what the world is doing, a control surface on a phone on the same wifi, a route another…

An animation clip stores joint angles. Play it and the character does the same thing every time, which is exactly what you want from a performance and exactly what fails the moment the world has a…

A player might be at a keyboard, holding a controller, or tapping a phone. Input in Zero is built so one piece of code answers to all three, and so a world cannot quietly end up working on only one…

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. A voice shouting at a puppet, someone speaking into a phone, a…

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. The engine builds the scene acceleration structure and exposes a small…

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"). Those two sides are what let geometry exist for lighting, shadows and physics…

A render texture is a camera's view drawn into a texture instead of onto the screen. That texture then becomes something you use elsewhere — a UI panel, a material map, a mirror, a minimap, a…

Most of how a scene looks comes from its content — meshes, materials, and lights. This guide is about the scene-wide controls on top of that: lighting, post-process effects, and the renderer's global…

Every visual property of a widget lives in one table — the style table on the widget node — and the vocabulary is CSS. If you know how a property behaves in a browser, it behaves the same way here:…

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. Text3D builds one per label and draws it on a quad. text.* is…

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, and the engine renders that description every frame. You never…

Explosions, muzzle flashes, smoke, sparks: the things that happen for a second and then are gone. The engine ships them as effect assets — finished, parameterised effects you play, rather than…

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

The agentSessions namespace — the engine's Luau API reference for agentSessions.

The animation namespace — the engine's Luau API reference for animation.

The asset namespace — the engine's Luau API reference for asset.

The audio namespace — the engine's Luau API reference for audio.

The av namespace — the engine's Luau API reference for av.

The base64 namespace — the engine's Luau API reference for base64.

The blend namespace — the engine's Luau API reference for blend.

The bundle namespace — the engine's Luau API reference for bundle.

The camera namespace — the engine's Luau API reference for camera.

The channel namespace — the engine's Luau API reference for channel.

The color namespace — the engine's Luau API reference for color.

The ColorSequence namespace — the engine's Luau API reference for ColorSequence.

The component namespace — the engine's Luau API reference for component.

The compute namespace — the engine's Luau API reference for compute.

The cursor namespace — the engine's Luau API reference for cursor.

The debugger namespace — the engine's Luau API reference for debugger.

The ecs namespace — the engine's Luau API reference for ecs.

The effects namespace — the engine's Luau API reference for effects.

The egress namespace — the engine's Luau API reference for egress.

The engine namespace — the engine's Luau API reference for engine.

The entity namespace — the engine's Luau API reference for entity.

The Entity namespace — the engine's Luau API reference for Entity.

The environment namespace — the engine's Luau API reference for environment.

The Field namespace — the engine's Luau API reference for Field.

The font namespace — the engine's Luau API reference for font.

The frameStream namespace — the engine's Luau API reference for frameStream.

The globals namespace — the engine's Luau API reference for globals.

The http namespace — the engine's Luau API reference for http.

The httpServer namespace — the engine's Luau API reference for httpServer.

The input namespace — the engine's Luau API reference for input.

The jobs namespace — the engine's Luau API reference for jobs.

The layers namespace — the engine's Luau API reference for layers.

The library namespace — the engine's Luau API reference for library.

The live namespace — the engine's Luau API reference for live.

The log namespace — the engine's Luau API reference for log.

The logs namespace — the engine's Luau API reference for logs.

The lsp namespace — the engine's Luau API reference for lsp.

The luau_codegen namespace — the engine's Luau API reference for luau_codegen.

The luau_profile namespace — the engine's Luau API reference for luau_profile.

The Material namespace — the engine's Luau API reference for Material.

The mathx namespace — the engine's Luau API reference for mathx.

The mcp namespace — the engine's Luau API reference for mcp.

The mcpLog namespace — the engine's Luau API reference for mcpLog.

The microphone namespace — the engine's Luau API reference for microphone.

The modelImport namespace — the engine's Luau API reference for modelImport.

The modules namespace — the engine's Luau API reference for modules.

The multiplayer namespace — the engine's Luau API reference for multiplayer.

The notices namespace — the engine's Luau API reference for notices.

The NumberRange namespace — the engine's Luau API reference for NumberRange.

The NumberSequence namespace — the engine's Luau API reference for NumberSequence.

The nx namespace — the engine's Luau API reference for nx.

The packages namespace — the engine's Luau API reference for packages.

The particles namespace — the engine's Luau API reference for particles.

The physics namespace — the engine's Luau API reference for physics.

The Physics namespace — the engine's Luau API reference for Physics.

The postprocess namespace — the engine's Luau API reference for postprocess.

The preset namespace — the engine's Luau API reference for preset.

The profiler namespace — the engine's Luau API reference for profiler.

The reflectionProbe namespace — the engine's Luau API reference for reflectionProbe.

The renderer namespace — the engine's Luau API reference for renderer.

The retarget namespace — the engine's Luau API reference for retarget.

The scopes namespace — the engine's Luau API reference for scopes.

The service namespace — the engine's Luau API reference for service.

The settings namespace — the engine's Luau API reference for settings.

The shader namespace — the engine's Luau API reference for shader.

The shell namespace — the engine's Luau API reference for shell.

The skeleton namespace — the engine's Luau API reference for skeleton.

The sky namespace — the engine's Luau API reference for sky.

The stream namespace — the engine's Luau API reference for stream.

The streaming namespace — the engine's Luau API reference for streaming.

The stringx namespace — the engine's Luau API reference for stringx.

The subscriptions namespace — the engine's Luau API reference for subscriptions.

The substrate namespace — the engine's Luau API reference for substrate.

The task namespace — the engine's Luau API reference for task.

The terminal namespace — the engine's Luau API reference for terminal.

The text namespace — the engine's Luau API reference for text.

The time namespace — the engine's Luau API reference for time.

The toml namespace — the engine's Luau API reference for toml.

The tools namespace — the engine's Luau API reference for tools.

The Transform namespace — the engine's Luau API reference for Transform.

The typed namespace — the engine's Luau API reference for typed.

The ui namespace — the engine's Luau API reference for ui.

The userfile namespace — the engine's Luau API reference for userfile.

The vfs namespace — the engine's Luau API reference for vfs.

The video namespace — the engine's Luau API reference for video.

The world namespace — the engine's Luau API reference for world.

The ws namespace — the engine's Luau API reference for ws.

A skill packages what an agent needs to do one job well: the instructions, the assets and toolboxes the job runs through, and — for jobs with distinct branches — subskills that go deeper.

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 <typename>.assetType/ folder declares a new asset type called…

A playable character, composed from three independent parts:

A bundle is a composable, spawnable entity assembly— a saved entity hierarchy plus its components, sub-assets (meshes, textures, animations, materials, sub-bundles), and any nested data, packaged…

A component is a reusable behavior + data unit attached to an entity. The component file declares public fields, methods, and lifecycle callbacks; the engine instantiates one per attachment and…

A .computeShader is a GPU compute (GPGPU) program with a zero-scaffolding authoring contract: you write only @compute fn main(...) plus a declarative bindings.yaml, and the engine GENERATES every…

A .data instance is a configured value binding to a dataType contract: values.yaml names the contract and supplies the field values the contract's schema declares. Instances carry values only —…

A dataType is a user-authored typed-data contract: it declares a set of fields — names, types, constraints, defaults — that any bound .data instance must satisfy. A contract can carry an optional…

A prompt-driven, self-regenerating 3D asset. A <name>.dynamicAsset/ folder holds a text prompt.json; the asset's model is generated from that prompt by the @builtin::services.meshy text-to-3D…

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

A finished, parameterised visual effect, authored as an asset. An explosion, a muzzle flash, a smoke plume: something an author reaches for and plays, rather than something they rebuild out of…

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

A photographic capture of a real place, stored as a cloud of oriented 3D Gaussians rather than as triangles. Drop a .spz or .ply into the world and the importer turns it into one of these.

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. Importers extend the engine's file-format knowledge…

One control in a scheme — jump, move, boost — expressed as an asset. A <name>.inputBinding/ folder whose init.luau returns the binding record, living inside a .inputMap/ parent the same way a .tool…

An input macro is a recorded or hand-authored sequence of input simulation events — keystrokes, mouse moves, button clicks, scroll wheel deltas — timestamped and played back via the sim toolbox…

A control scheme, expressed as an asset. A <name>.inputMap/ folder whose init.luau returns the map record, and whose controls are the <name>.inputBinding/ child folders beside it — the same…

A baked-lighting container: ONE asset per scene holding every baked lighting payload the GI bake flow produces — per-entity lightmaps and per-volume probe-field bricks. The container is what makes a…

A material is a named, configured instance of a .shader. The shader defines the surface look (lighting model, available property fields, texture slots); the material picks values for those fields and…

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 component that draws geometry references a mesh,…

A module is a reusable, stateless (or globally-stateful) Luau library that other code pulls in with require(). Modules are the unit of factored-out logic in a world: helpers, math libraries, format…

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, installed into a world as one unit.…

A saved, reusable pixel-art sheet. A <name>.pixelTemplate/ folder asset carries a JSON payload template.pixbin (width, height, pixelSize, plane, palette, the flat pixel array, and — for animated…

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 captured, named configuration of a single component. Instead of typing the same fields into every component.add call, you save a preset once and load it. Presets are component-scoped:…

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. Its init.luau returns proc.define(...) —…

A .procNode is a procedural operation authored as content: a folder whose init.luau returns a def table. When the asset registers, its def joins the proc op registry keyed by the asset's stable GUID,…

A .procPack is a FAMILY of procedural operations authored as content: a folder whose init.luau returns a pack table. When the asset registers, every def in its ops map joins the proc op registry…

A render feature inserts custom GPU passes into the frame pipeline. The engine provides one generic capability — a per-frame render-pass queue and a set of pipeline-phase insertion points — and a…

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, and a declared player intent, plus an auto-discovered startup…

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. Placing one runs the builder and lands…

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 — from the inputs each operation declares, landing…

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. Materials reference shaders and supply property values; renderable entities reference materials, not shaders directly. This README is the canonical…

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. It declares no entry point and is never…

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. Registered with the UI theme system, its classes cascade to every widget…

A landscape's baked data, as one asset.

A test suite is a registrable asset that bundles one group of automated engine tests. Each <name>.testSuite/ folder holds an init.luau whose body registers a suite (and its tests) against the test…

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. Tools are the workflow surface — composed Luau operations that bundle multiple engine APIs into one named…

A toolbox is a namespace folder that groups related .tool/ children plus shared helpers. Toolboxes are the addressing layer for tools — every tool's identity is <toolbox>.<name>, so the toolbox name…

A voxel template is a reusable, named voxel grid that live instances link to. It is the source of truth for a family of VoxelShape instances spawned via Voxel.fromTemplate(<name>) — every live…

A job whose shape is a program.