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 whole surface is discoverable and readable. The engine exposes well over a hundred namespaces (asset, entity, layers, mesh, compute, vfs, camera, players,…

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…

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

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…

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…

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…

Input in Zero is built around named actions, not raw key polling. Rather than scattering is the W key down? checks through your code, you bind physical inputs (keys, mouse, gamepad, gestures) to…

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 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 knob a widget exposes lives in its style block — a plain table under the style key of the widget node — and the complete vocabulary of that block is one typed schema: ZuiStyle, defined…

UI in Zero is data, not drawing. You describe what you want as a tree of widget tables, register it as a named screen, and the engine renders it every frame. You never paint pixels — you declare…

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 Buffer namespace — the engine's Luau API reference for Buffer.

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 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 globals namespace — the engine's Luau API reference for globals.

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

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_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 modelImport namespace — the engine's Luau API reference for modelImport.

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 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 service namespace — the engine's Luau API reference for service.

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

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 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 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 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 panel for the editor, expressed as an asset. A <name>.editorPanel/ folder whose init.luau returns the panel spec; the asset system registers it into the editor live (no restart) via the…

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 = … }).

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…

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 sim.macro. Macros are…

An input binding map, expressed as an asset. A <name>.inputMap/ folder whose init.luau returns the map record: named actions and axes, each carrying bindings per device class (kbm / gamepad / touch),…

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 a shippable, heterogeneous library folder. It bundles components, modules, scenes, presets, tools, and any other typed assets under a single addressable identity (@<owner>::<name>) that…

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 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 serialized procedural graph (proc.graph.v1) — the compiled, composable form of a procedural generation definition. It is built from a .proc.lua builder source via proc.build…

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 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 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…

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…

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. Styles cascade through the UI theme system — engine default < per-screen style < per-panel style. Authoring a…

A terrain is a serialized heightmap — a flat width×depth array of floats plus the dimensions, world size, and an optional default material — that the Terrain component reads at startup to build a…

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…

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 with a YAML-declared schema. Tools are the workflow surface — composed Luau operations that bundle multiple engine APIs into one named call, suitable for…

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…