# Spatial Compiler by Applied Manifold (full text) > The spatial compute cloud for 3D reality. Applied Manifold builds cloud infrastructure for 3D physical reality, starting with Spatial Compiler. Spatial Compiler (`@spatial-compiler/mcp`, CLI `spatial-compiler`): Headless GPU compilation for 3D geometry and physics. Turn raw AI-generated meshes into production-ready, simulation-ready assets with one API call, delivered natively via MCP and REST. Its pyro module bakes fire, smoke, explosion and dust flipbook sheets for Godot 4 from `.pyro.toml` specs. Version 0.1.0. The hosted MCP server is https://mcp.spatialcompiler.dev, the local MCP server is the npm package `@spatial-compiler/mcp`, and the REST API host is https://api.spatialcompiler.dev. The local `spatial-compiler` program installs as a Claude plugin and builds from source on Windows. ## Set up with your agent Give this to your agent (Claude Code, Codex, Cursor, others): ``` Install the Spatial Compiler skill. If you're in Claude Code, run `claude plugin marketplace add applied-manifold/skills`, then `claude plugin install spatial-compiler@applied-manifold`. If you're in another agent, run `npx skills add applied-manifold/skills --skill spatial-compiler`. You can read the skill directly at https://github.com/applied-manifold/skills/blob/main/skills/spatial-compiler/SKILL.md (raw: https://raw.githubusercontent.com/applied-manifold/skills/main/skills/spatial-compiler/SKILL.md). Then use the Spatial Compiler skill when working on this project. ``` ## Connect over MCP or REST Hosted MCP server (https://mcp.spatialcompiler.dev, OAuth 2.1 browser login, no key in the config): ```json { "mcpServers": { "spatial-compiler": { "type": "http", "url": "https://mcp.spatialcompiler.dev" } } } ``` Local MCP server (`@spatial-compiler/mcp` over stdio, API key in `SPATIAL_API_KEY`): ```sh SPATIAL_API_KEY=sk_test_spatial_sandbox npx -y @spatial-compiler/mcp ``` ```json { "mcpServers": { "spatial-compiler": { "command": "npx", "args": [ "-y", "@spatial-compiler/mcp" ], "env": { "SPATIAL_API_KEY": "sk_test_spatial_sandbox" } } } } ``` REST, with the API key as a bearer token: ```sh curl -X POST https://api.spatialcompiler.dev/v1/compile \ -H "Authorization: Bearer sk_test_spatial_sandbox" \ -F "file=@model.glb" \ -F 'options={"target_tris":15000,"dry_run":true}' ``` `sk_test_spatial_sandbox` is an example key; replace it with your own. Sandbox keys include 500 free credits. Full guide: https://appliedmanifold.com/docs/index.md (sections "Install via MCP", "MCP tools", "REST overview", "Operations reference"). ## Install the local program Add the Claude plugin (Claude Code): ``` /plugin marketplace add applied-manifold/spatial-compiler /plugin install spatial-compiler@applied-manifold ``` Build the program from source (Windows, Visual Studio 2022 with the C++ workload, Python 3), from a clone of the repository: ``` python scripts\fetch_third_party.py scripts\build.bat scripts\install.bat ``` `install.bat` copies the program to `%USERPROFILE%\.spatial-compiler\bin`, where the plugin finds it. Bake and wire: ``` spatial-compiler bake .pyro.toml --out spatial-compiler wire --scene .tscn ``` Verified: Vulkan on one NVIDIA GeForce RTX 2070 Super under Windows: 19 tests, and the six pyro examples bake at final quality. --- Source: https://appliedmanifold.com/ **APPLIED MANIFOLD // SPATIAL COMPILER v0.1.0** MODULE: PYRO BACKEND: VULKAN SAME SPEC, SAME BYTES Applied Manifold The spatial compute cloud for 3D reality. # Headless GPU compilation for 3D geometry and physics. Turn raw AI-generated meshes into production-ready, simulation-ready assets with one API call, delivered natively via MCP and REST. Get Free API Key (500 Credits) [Read the Spec →](https://appliedmanifold.com/docs/) **Give this to your agent** (Claude Code, Codex, Cursor, others) ``` $ set up Spatial Compiler - https://appliedmanifold.com/llms.txt ``` Agent prompt: Install the Spatial Compiler skill. If you're in Claude Code, run `claude plugin marketplace add applied-manifold/skills`, then `claude plugin install spatial-compiler@applied-manifold`. If you're in another agent, run `npx skills add applied-manifold/skills --skill spatial-compiler`. You can read the skill directly at https://github.com/applied-manifold/skills/blob/main/skills/spatial-compiler/SKILL.md (raw: https://raw.githubusercontent.com/applied-manifold/skills/main/skills/spatial-compiler/SKILL.md). Then use the Spatial Compiler skill when working on this project. ## Connect your agent in 10 seconds mcp.json · hosted · oauth 2.1 login ```json { "mcpServers": { "spatial-compiler": { "type": "http", "url": "https://mcp.spatialcompiler.dev" } } } ``` terminal · local mcp server ```sh SPATIAL_API_KEY=sk_test_spatial_sandbox npx -y @spatial-compiler/mcp ``` terminal ```sh curl -X POST https://api.spatialcompiler.dev/v1/compile \ -H "Authorization: Bearer sk_test_spatial_sandbox" \ -F "file=@model.glb" \ -F 'options={"target_tris":15000,"dry_run":true}' ``` claude code · local cli ``` /plugin marketplace add applied-manifold/spatial-compiler /plugin install spatial-compiler@applied-manifold ``` cmd · visual studio 2022 · python 3 ``` python scripts\fetch_third_party.py scripts\build.bat scripts\install.bat ``` The hosted server signs you in with an OAuth 2.1 browser login. The local server and REST take an API key; replace the example key with your own, and sandbox keys include 500 free credits. The Claude plugin runs the local program, which `scripts\install.bat` copies to `%USERPROFILE%\.spatial-compiler\bin`. [Connection guide →](https://appliedmanifold.com/docs/#mcp) ## Built for Each of these four pipelines turns raw geometry into assets a machine can use, under its own budgets and failure modes. [All use cases →](https://appliedmanifold.com/use-cases/) - **01 // GEN3D** ### [Gen3D platforms](https://appliedmanifold.com/use-cases/gen3d/) Every text-to-3D or image-to-3D generation leaves your platform welded, on budget, UV-packed and ORM-baked. - weld - decimate - uv\_pack - orm\_bake - **02 // ROBOTICS · WORLD MODELS** ### [Robotics & world models](https://appliedmanifold.com/use-cases/robotics-world-models/) Get sim-ready convex colliders and a reproducible, content-addressed pipeline for synthetic data, hosted or in your own VPC. - convex\_hulls - seeded rollouts - sha-256 - air-gapped - **03 // E-COMMERCE 3D** ### [E-commerce configurators](https://appliedmanifold.com/use-cases/ecommerce-configurators/) Ship web-weight GLBs with LODs and baked materials for every SKU, inside your page-weight budget. - lod\_chain - orm\_bake - glb - page weight - **04 // GAMING · UGC · AEC** ### [AI gaming, UGC & AEC](https://appliedmanifold.com/use-cases/gaming-ugc-aec/) Pre-flight player uploads, AI-generated props and CAD/BIM geometry, clean them to engine budgets, and bake pyro effects for Godot 4. - dry\_run - decimate - convex\_hulls - pyro ## Let your agents ship 3D without opening Blender. For thirty years, 3D software was built for humans clicking inside heavy desktop viewports. AI models, coding agents and automated pipelines break when they use these legacy tools or drive Blender through computer-use agents. The agents burn vision tokens and wait seconds on CPU scripts, and the meshes still ship with broken topology. We built Spatial Compiler from the metal up as a headless, stateless Vulkan compute kernel wrapped in a memory-safe Rust gateway that speaks MCP and REST. It has no window and no editor, so software and AI agents can call it in a tight loop and check every result in code. - ### Typed telemetry Every compilation returns structured triangle counts, draw-call reductions and VRAM footprints, and every bake writes a JSON report whose warnings name the setting to change. - ### Deterministic bakes The same spec, seed, version and machine give the same bytes, and a new seed gives a new instance of the same effect. - ### More like a compiler A misspelled key fails and names the nearest valid key, and `spatial-compiler schema` prints every field, range and default. Dry runs cost 0 credits and SHA-256 cache hits are free. ## Built for autonomous loops **Spatial Compiler** `(@spatial-compiler/mcp)` gives Claude Code, Cursor or your CI/CD pipeline a GPU co-processor for 3D space, over MCP, REST or the local `spatial-compiler` program. One endpoint handles the entire last-mile pipeline: - ### [compile\_3d\_asset](https://appliedmanifold.com/docs/#tools) (Geometry & Materials) Welds non-manifold edges, decimates to exact triangle budgets via meshoptimizer, packs non-overlapping xatlas UV atlases, and bakes channel-packed ORM textures in a single VRAM pass. - ### [simulate\_fx\_vat](https://appliedmanifold.com/docs/#tools) (Physics) Runs parallel GPU XPBD cloth and Voronoi rigid-body fracture rollouts, exporting zero-CPU-cost Vertex Animated Textures (VATs) and drop-in engine shaders. - ### [pyro](https://appliedmanifold.com/modules/pyro/) (Fire, smoke, explosion, dust) Bakes fire, smoke, explosion and dust flipbook sheets from a `.pyro.toml` spec, lit from six directions so a game can relight the smoke from any sun angle. - ### wire (Godot 4) Installs the six-way shader `flipbook_6way.gdshader` into a Godot project and writes a ready scene for each bake. [Operations reference →](https://appliedmanifold.com/docs/#operations) [Pyro module →](https://appliedmanifold.com/modules/pyro/) [Use cases →](https://appliedmanifold.com/use-cases/) ## From $0.05 per asset, as low as $0.02 on Studio. - $0.05 Per standard compile (5 credits, pay-as-you-go) **$0.02** per compile on Studio - $0.00 On identical inputs (Automatic SHA-256 content-addressed cache hits cost zero credits.) - 0 Vision tokens wasted (Agents verify every result from typed JSON telemetry.) Signup includes 500 free sandbox credits (~100 compiles). [See pricing tiers →](https://appliedmanifold.com/pricing/) ## FAQ [All questions →](https://appliedmanifold.com/faq/) **README.FAQ** ### What is Spatial Compiler? Spatial Compiler is Applied Manifold's flagship GPU execution engine. Send raw .glb or CAD geometry over MCP or REST and get back decimated, UV-packed, physics-ready assets with structured telemetry. Its pyro module bakes fire, smoke, explosion and dust flipbook sheets from a spec file. ### Why not drive a desktop 3D tool from an agent? Spatial Compiler has no window, so an agent drives it from the command line and checks each result from a JSON report and one preview image. A misspelled key fails and names the nearest valid key, `spatial-compiler schema` lists every field, and each report warning names the setting to change. ### How do you prevent runaway AI agents from draining my credits? Every tool call supports `dry_run: true`, a zero-cost pre-flight estimate, and each key has an hourly velocity limit. When an agent re-runs unchanged geometry, the SHA-256 cache hit is free. Locally, `spatial-compiler check` validates a spec without touching the GPU, and draft bakes and `sweep` comparison sheets come before a final bake. ### Can we run this inside our own VPC or air-gapped cluster? Yes. Enterprise and robotics teams deploy our stripped Linux container (`libspatial_kernel.so` + Rust gateway) directly on their own NVIDIA L4/L40S/H100 hardware with zero external network calls. The local `spatial-compiler` program also keeps specs and bakes on your own machine. ### What comes after Spatial Compiler? Next is Spatial Runtime, a compressed GPU-native streaming SDK for real-time engines. After that comes Applied Manifold Cloud, high-throughput synthetic physics verification for robotics and world models. --- Source: https://appliedmanifold.com/docs/ 1. [Home](https://appliedmanifold.com/) 2. Docs DOCS // SPATIAL.COMPILER 0.1.0 # Spatial Compiler docs Headless GPU compilation for 3D geometry and physics. Turn raw AI-generated meshes into production-ready, simulation-ready assets with one API call, delivered natively via MCP and REST. Its [pyro module](https://appliedmanifold.com/modules/pyro/) bakes fire, smoke, explosion and dust flipbooks for Godot 4. **CONTENTS** 1. [What it does](https://appliedmanifold.com/docs/#overview) 2. [Install via MCP](https://appliedmanifold.com/docs/#mcp) 3. [MCP tools](https://appliedmanifold.com/docs/#tools) 4. [REST overview](https://appliedmanifold.com/docs/#rest) 5. [Operations reference](https://appliedmanifold.com/docs/#operations) 6. [dry\_run, cache & limits](https://appliedmanifold.com/docs/#controls) 7. [Telemetry fields](https://appliedmanifold.com/docs/#telemetry) 8. [Add it to Claude](https://appliedmanifold.com/docs/#install) 9. [Build from source](https://appliedmanifold.com/docs/#build) 10. [Bake and wire](https://appliedmanifold.com/docs/#usage) 11. [The spec file](https://appliedmanifold.com/docs/#spec) 12. [What a bake writes](https://appliedmanifold.com/docs/#outputs) 13. [The report](https://appliedmanifold.com/docs/#report) 14. [Verified setup](https://appliedmanifold.com/docs/#verified) 15. [Self-host](https://appliedmanifold.com/docs/#self-host) 16. [Machine-readable docs](https://appliedmanifold.com/docs/#machine-readable) ## What Spatial Compiler does Spatial Compiler is Applied Manifold's flagship GPU execution engine. Send raw .glb or CAD geometry over MCP or REST and get back decimated, UV-packed, physics-ready assets with structured telemetry. Applied Manifold built it from the metal up as a headless, stateless Vulkan compute kernel wrapped in a memory-safe Rust gateway. It has no windows or GUI overhead, so software and AI agents can call it in a tight loop. - The kernel is headless C++20 on Vulkan 1.3, with a persistent Buffer Device Address (BDA) arena kept warm in VRAM. - The gateway is memory-safe Rust and speaks MCP over stdio, MCP over HTTP at `https://mcp.spatialcompiler.dev`, and REST at `https://api.spatialcompiler.dev`. - A SHA-256 content-addressed cache makes results deterministic, so the same input gets the same key and the same output. - Every compilation returns typed JSON telemetry (triangle counts, draw-call reductions, VRAM footprint) that your agent verifies in code. The same core library, `spatial_kernel`, also runs as a local program, `spatial-compiler` (short name `sc`), that a Claude plugin drives. Each module makes one kind of asset, and the [pyro](https://appliedmanifold.com/modules/pyro/) module bakes fire, smoke, explosion and dust flipbook sheets from spec files named `*.pyro.toml`. - The program has no window or editor, so an agent runs each command and checks the result from files. - stdout carries the report JSON and nothing else, and logs go to stderr. - A misspelled key fails and names the nearest valid key, and `spatial-compiler schema` prints every field, range and default. - The same spec, seed, version and machine give the same bytes. ## Install via MCP Give Claude Code, Cursor or your CI/CD pipeline a GPU co-processor for 3D space. Spatial Compiler runs as a hosted MCP server at `https://mcp.spatialcompiler.dev` and as a local MCP server, the npm package `@spatial-compiler/mcp`, that runs over stdio through `npx`. ### Hosted MCP server Add the server URL to your MCP client. The hosted server uses an OAuth 2.1 browser login to your Applied Manifold account, with PKCE (S256), so the config holds no key: mcp.json ```json { "mcpServers": { "spatial-compiler": { "type": "http", "url": "https://mcp.spatialcompiler.dev" } } } ``` In Claude Code you can register it from the command line: terminal ```sh claude mcp add --transport http spatial-compiler https://mcp.spatialcompiler.dev ``` ### Local MCP server The local server reads your API key from the `SPATIAL_API_KEY` environment variable and runs no login flow: terminal ```sh SPATIAL_API_KEY=sk_test_spatial_sandbox npx -y @spatial-compiler/mcp ``` Most MCP clients (Claude Desktop, Cursor and others) accept the same JSON config block: mcp.json ```json { "//": "Local MCP server config (stdio via npx, credential in SPATIAL_API_KEY). Rendered at on /docs/#mcp and returned by the WebMCP get_mcp_config tool. The hosted config is derived from site.config.json MCP_URL (build/site.mjs hostedMcpConfig).", "mcpServers": { "spatial-compiler": { "command": "npx", "args": [ "-y", "@spatial-compiler/mcp" ], "env": { "SPATIAL_API_KEY": "sk_test_spatial_sandbox" } } } } ``` In Claude Code you can register it from the command line: terminal ```sh claude mcp add spatial-compiler -e SPATIAL_API_KEY=sk_test_spatial_sandbox -- npx -y @spatial-compiler/mcp ``` Replace the example key `sk_test_spatial_sandbox` with your own API key. Sandbox keys include 500 free credits. ## MCP tools One endpoint handles the entire last-mile pipeline: **`compile_3d_asset` Geometry & Materials** Welds non-manifold edges, decimates to exact triangle budgets via meshoptimizer, packs non-overlapping xatlas UV atlases, and bakes channel-packed ORM textures in a single VRAM pass. **`simulate_fx_vat` Physics** Runs parallel GPU XPBD cloth and Voronoi rigid-body fracture rollouts, exporting zero-CPU-cost Vertex Animated Textures (VATs) and drop-in engine shaders. **`bake`, `check`, `schema`, `sweep`, `wire` pyro** One typed tool per command of the `spatial-compiler` program, covered in [Bake and wire](https://appliedmanifold.com/docs/#usage). Each returns the same JSON report as the command. ## REST overview The Rust gateway exposes the same operations over REST. Authenticate with your API key as a bearer token in the `Authorization` header, and send the mesh as multipart form data with a JSON `options` field. terminal ```sh curl -X POST https://api.spatialcompiler.dev/v1/compile \ -H "Authorization: Bearer sk_test_spatial_sandbox" \ -F "file=@model.glb" \ -F 'options={"target_tris":15000,"dry_run":true}' ``` The OpenAPI description of `POST https://api.spatialcompiler.dev/v1/compile` is at [/openapi/spatial-compiler.json](https://appliedmanifold.com/openapi/spatial-compiler.json). ## Operations reference `target_tris` and `dry_run` are the core options. Other options in the examples on this site are illustrative. ### weld compile\_3d\_asset Welds non-manifold edges so downstream decimation, UV packing and baking operate on clean topology. ### decimate compile\_3d\_asset · meshoptimizer Decimates to an exact triangle budget (`target_tris`) using meshoptimizer. Telemetry reports triangles in and out. ### lod\_chain compile\_3d\_asset · optional Optionally emits a chain of levels of detail: the same source decimated to several triangle budgets, with telemetry for each level. ### uv\_pack compile\_3d\_asset · xatlas Packs non-overlapping UV atlases with xatlas, so the asset can carry baked textures. ### orm\_bake compile\_3d\_asset Bakes channel-packed ORM textures (ambient occlusion, roughness, metallic in one texture) in the same VRAM pass as decimation and UV packing. ### convex\_hulls physics-ready output Generates convex collision hulls so the compiled asset is physics-ready for engines and simulators. ### xpbd\_cloth simulate\_fx\_vat Runs GPU-native XPBD (extended position-based dynamics) cloth rollouts in parallel on the GPU. ### voronoi\_fracture simulate\_fx\_vat Splits a mesh into Voronoi cells and runs rigid-body fracture rollouts on the GPU. ### vat\_export simulate\_fx\_vat Exports simulation rollouts as Vertex Animated Textures (VATs) with drop-in engine shaders, so playback costs zero CPU at runtime. ## `dry_run`, cache and limits **`dry_run: true`** Every tool call supports a pre-flight estimate that costs 0 credits. **SHA-256 content-addressed cache** Results are keyed by a SHA-256 hash of the input. When an agent re-runs unchanged geometry it gets a cache hit, and cache hits cost 0 credits. **Per-key hourly velocity limits** Each API key has an hourly velocity limit, so a runaway agent loop cannot drain your credits. ## Telemetry fields Every compilation returns structured JSON with these fields, so your agent can verify the result in code. | Field | Meaning | | --- | --- | | `status` | Outcome of the call, e.g. `ok`. | | `dry_run` | Whether this was a zero-cost pre-flight estimate. | | `tris_in` | Triangle count of the input mesh. | | `target_tris` | Requested triangle budget. | | `tris_out` | Triangle count of the compiled mesh. | | `draw_calls` | Draw calls before → after compilation. | | `vram_bytes` | VRAM footprint of the compiled asset. | | `elapsed_ms` | Wall time of the compilation. | | `cache` | `HIT` or `MISS` on the SHA-256 content-addressed cache. | | `credits_est` | Estimated credits: 5 for a standard compile (1 credit = $0.01), 0 for dry runs and cache hits. See [how credits work](https://appliedmanifold.com/pricing/#credits). | ## Add it to Claude To run Spatial Compiler as a local program, add the Claude plugin. The Spatial Compiler repository is a Claude plugin marketplace, and the plugin carries the pyro guide and the six examples. In Claude Code, run: claude code ``` /plugin marketplace add applied-manifold/spatial-compiler /plugin install spatial-compiler@applied-manifold ``` The plugin looks for the program in `$SPATIAL_COMPILER_BIN`, then for `spatial-compiler` on `PATH`, then in `~/.spatial-compiler/bin`. Build the program once from source, as described next. ## Build from source The build runs on Windows with Visual Studio 2022 (the C++ workload) and Python 3. From a clone of the repository, run: cmd ``` python scripts\fetch_third_party.py scripts\build.bat scripts\install.bat ``` `fetch_third_party.py` runs once and downloads the pinned third-party code listed in `THIRD_PARTY.md`. `build.bat` builds the program, and `install.bat` copies it to `%USERPROFILE%\.spatial-compiler\bin`, where the plugin finds it. ## Bake and wire Bake a spec into a folder, then wire the bake into a Godot 4 scene. The scene must sit inside a Godot project, so put the bake folder inside the project first. terminal ``` spatial-compiler bake .pyro.toml --out spatial-compiler wire --scene .tscn ``` `wire` installs the six-way shader `flipbook_6way.gdshader` in the project, writes texture import settings and writes a scene sized in meters, with its origin on the ground under the effect. **`spatial-compiler schema`** Prints every field, range, default, warning and metric as JSON. **`spatial-compiler check `** Validates a spec without touching the GPU. Each error names the key and the nearest valid key or the range. **`spatial-compiler sweep --set key=v1,v2 --out `** Bakes variants at draft quality onto one labelled comparison sheet. **`spatial-compiler version`** Prints the version. Exit codes are 0 for done, 1 for an invalid spec or arguments, 2 for a GPU failure and 3 for a file error. ## The spec file A spec is a TOML file whose name ends in `.pyro.toml`. Units are meters, seconds and kelvin; the origin is the center of the box floor, and +Y is up. The sections are `[meta]`, `[domain]`, `[[emitters]]`, `[solver]`, `[look]`, `[[views]]` and `[export]`. Every field you leave out takes its default, and an unknown key is an error. This is the shipped fireball example: fireball.pyro.toml ``` # A ground burst that swells, rolls and rises. One-shot. [meta] name = "fireball" notes = "Ground burst that swells, rolls and rises" [domain] size_m = [12, 16, 12] voxel_m = 0.08 duration_s = 4.0 [[emitters]] shape = "sphere" position_m = [0, 0.7, 0] size_m = 1.2 start_s = 0.0 end_s = 0.18 fuel = 5 temperature_k = 1900 smoke = 1.5 velocity_mps = 7 [solver] # Burning needs air, so the ball burns at its rolling surface instead of all at once. air_limit = 0.88 burn_rate = 10 smoke_fade = 1.1 [export] pacing = "front" ``` The [pyro module page](https://appliedmanifold.com/modules/pyro/#examples) lists all six examples. ## What a bake writes | File | Holds | | --- | --- | | `_pos.png` | Lit from the right (R), from above (G) and from behind (B), with opacity in A. | | `_neg.png` | Lit from the left (R), from below (G) and from the front (B), with flame brightness in A. | | `_colour.png` | Flame color in RGB, with the smoke-to-dust mix in A. | | `_aux.png` | Motion to the next frame (R, G) and depth (B), with temperature in A when asked for. | | `layout.json` | Grid, tile size, frame times, loop flag, meters per tile, ground anchor and how to decode each channel. | | `preview_strip.png`, `preview_contact_sheet.png` | Still previews for the agent to open and judge the look. | | `preview_anim.png` | An animated preview that plays the clip at true speed in any browser. | | `bake_report.json` | The report, also written when a run fails. | Sheets are 8 x 8 tiles of 256 px by default. Six-direction lighting lets the game relight the smoke from any sun angle. ## The report Every command prints the same report to stdout and writes it to `/bake_report.json`. | Field | Meaning | | --- | --- | | `ok` | `true` when the command finished. | | `errors` | Each error has a `code`, the `key` at fault and a message. | | `warnings` | Each warning has a `code`, a `fix.key` to change and a `fix.hint`. | | `artifacts` | Every file written, with its kind, size and SHA-256. | | `metrics` | Clip metrics such as `life_s`, `rise_speed_mps` and `loop_seam`, plus per-frame lists. | | `timings_ms`, `gpu` | Stage timings, the GPU device and its peak memory. | A shipped effect ends with `"ok": true` and an empty `warnings` list. ## Verified setup Spatial Compiler 0.1.0 is verified on one Windows PC with an NVIDIA GeForce RTX 2070 Super, on Vulkan. 19 tests pass there, and the six pyro examples bake at final quality. ## Self-host (VPC / air-gapped) Enterprise and robotics teams deploy the stripped Linux container (`libspatial_kernel.so` + Rust gateway) directly on their own NVIDIA L4/L40S/H100 hardware with zero external network calls. See [Enterprise](https://appliedmanifold.com/pricing/#tier-enterprise). ## Machine-readable docs Agents can read this site without rendering it: - [/llms.txt](https://appliedmanifold.com/llms.txt) and [/llms-full.txt](https://appliedmanifold.com/llms-full.txt) hold the site index and the full text for LLMs. - Every page has a markdown alternate (this one: [/docs/index.md](https://appliedmanifold.com/docs/index.md)), also served for `Accept: text/markdown`. - The [MCP server card](https://appliedmanifold.com/.well-known/mcp/server-card.json), [API catalog](https://appliedmanifold.com/.well-known/api-catalog), [AI catalog](https://appliedmanifold.com/.well-known/ai-catalog.json), [agent skills](https://appliedmanifold.com/.well-known/agent-skills/index.json) and [auth.md](https://appliedmanifold.com/auth.md) describe the API for agent discovery. - [auth.md](https://appliedmanifold.com/auth.md) covers the credentials: an API key in `SPATIAL_API_KEY` for the local MCP server, an OAuth 2.1 browser login for the hosted server, and an API key as a bearer token for REST. --- Source: https://appliedmanifold.com/modules/pyro/ 1. [Home](https://appliedmanifold.com/) 2. Pyro module MODULE // PYRO 0.1.0 # Pyro bakes fire, smoke, explosions and dust. Pyro is the first Spatial Compiler module. It simulates gas on the GPU in a 3D grid and bakes flipbook sheets lit from six directions, so a game can relight the smoke from any sun angle. [Add it to Claude →](https://appliedmanifold.com/docs/#install) [Connect over MCP →](https://appliedmanifold.com/docs/#mcp) ## What goes in, what comes out **In a .pyro.toml spec** A TOML file that describes the simulated box, one or more emitters, the solver, the look, the camera views and the export settings. Every field you leave out takes its default. **Out sheets** Flipbook sheets with many animation frames packed into one image, ready for a game engine. Two sheets carry the six lighting directions, and two more carry flame color, motion and depth. **Out previews** A preview strip and a contact sheet for an agent to open, and an animated preview that plays the clip at true speed in any browser. **Out JSON report** `bake_report.json` lists every file, the clip metrics and any warnings, and each warning names the setting to change. The [docs](https://appliedmanifold.com/docs/#outputs) list every file a bake writes and every report field. ## Six example bakes Pyro ships six examples, and all six bake at final quality with no warnings. Each card shows an excerpt of the example spec. ### fire.pyro.toml LOOP A steady ground fire about a meter and a half across, which loops. ``` [[emitters]] shape = "disc" position_m = [0, 0.15, 0] size_m = 0.7 start_s = 0.0 end_s = 1000 fuel = 6 temperature_k = 1500 smoke = 0.2 velocity_mps = 1.5 direction = "up" ``` ### fireball.pyro.toml ONE-SHOT A ground burst that swells, rolls and rises. ``` [[emitters]] shape = "sphere" position_m = [0, 0.7, 0] size_m = 1.2 start_s = 0.0 end_s = 0.18 fuel = 5 temperature_k = 1900 smoke = 1.5 velocity_mps = 7 ``` ### smoke\_column.pyro.toml ONE-SHOT A burst of dark smoke that climbs, spreads and thins away. ``` [[emitters]] shape = "sphere" position_m = [0, 0.8, 0] size_m = 1.0 start_s = 0.0 end_s = 0.8 fuel = 0 temperature_k = 700 smoke = 6 velocity_mps = 3 direction = "up" ``` ### smoke\_plume.pyro.toml LOOP Dark smoke rising from a wreck and leaning downwind, which loops. ``` [solver] cooling = 0.25 smoke_fade = 0.45 swirl = 0.8 turbulence = 0.2 turbulence_size_m = 1.2 turbulence_where = "moving" wind_mps = [1.2, 0, 0] drag = 0.3 ``` ### dust\_ring.pyro.toml ONE-SHOT The ring of dust a blast kicks out along the ground. ``` [[emitters]] shape = "ring" position_m = [0, 0.3, 0] size_m = 1.5 start_s = 0.0 end_s = 0.15 fuel = 0 temperature_k = 293 smoke = 0 dust = 12 velocity_mps = 14 direction = "radial" ``` ### impact.pyro.toml ONE-SHOT A shell hitting dry ground, with a brief flash, earth thrown up and outward and a little smoke, from three emitters in one box. ``` # The flash. Little fuel and a short burn, so its heat does not carry the dust up as a column. [[emitters]] shape = "sphere" position_m = [0, 0.3, 0] size_m = 0.4 start_s = 0.0 end_s = 0.06 fuel = 3 temperature_k = 1900 smoke = 2.0 velocity_mps = 6 direction = "radial" ``` To start a new effect, copy the nearest example and change it, because every example already avoids the warnings its kind of effect tends to raise. ## Godot 4: the six-way shader and wire The six-way shader, `flipbook_6way.gdshader`, lights the smoke from the scene's sun and ambient light on six sides and adds the flame as HDR light of its own. It blends frames along the motion vectors and fades against scene depth. `spatial-compiler wire` installs the shader in a Godot project, writes texture import settings and writes a ready scene for a bake. Put the bake folder inside the project first, then run: terminal ``` spatial-compiler bake .pyro.toml --out spatial-compiler wire --scene .tscn ``` The scene's root is a quad sized in meters, with its origin on the ground under the effect. Instance the scene where the effect happens, and it plays on its own. ## The agent loop 1. Copy the nearest example and run `spatial-compiler check` on it. Each error names the key and the nearest valid key or the range. 2. Bake at draft quality and read the `warnings` in the report, then change the key each hint names. 3. Open `preview_strip.png` and judge the look, because the numbers cannot say whether it looks like fire. 4. Use `spatial-compiler sweep` to compare two or three values of a key on one sheet. 5. Bake at final quality until the report shows `"ok": true` and no warnings, then wire the bake into Godot. ## Verified setup Pyro is verified on one Windows PC with an NVIDIA GeForce RTX 2070 Super, on Vulkan. 19 tests pass there, and the six examples bake at final quality. --- Source: https://appliedmanifold.com/pricing/ 1. [Home](https://appliedmanifold.com/) 2. Pricing PRICING // CREDITS # From $0.05 per asset, as low as $0.02 on Studio. 1 credit = $0.01 pay-as-you-go, $10 per 1,000 credits. A standard compile is 5 credits ($0.05); SHA-256 cache hits and dry runs cost 0 credits. - ## Sandbox Free - 500 credits - ~100 compiles You get free sandbox credits on signup to wire Spatial Compiler into an agent or pipeline. - ## Pro $29/mo - 5,000 credits / month - ~1,000 compiles - **~$0.03 per compile** Pro is for individual developers who run agents and pipelines against the hosted API. - ## Studio $149/mo - 35,000 credits / month - ~7,000 compiles - **~$0.02 per compile** Studio is for teams that compile assets at higher volume. - ## Enterprise Custom - Custom credits Enterprise runs the stripped Linux container (libspatial\_kernel.so + Rust gateway) in your VPC or air-gapped cluster, on your own NVIDIA L4/L40S/H100 hardware. ## Every tier - SHA-256 content-addressed cache hits cost **0 credits**. - `dry_run: true` pre-flight estimates cost **0 credits**. - Per-key hourly velocity limits, so a runaway agent loop cannot drain your credits. - MCP (`@spatial-compiler/mcp` locally, or the hosted server at `https://mcp.spatialcompiler.dev`) and REST access. - Typed JSON telemetry on every compilation. ## How credits work **1 credit = $0.01 pay-as-you-go, $10 per 1,000 credits.** A standard compile (decimate + UV pack + ORM bake + convex collider) is **5 credits = $0.05**. Plans buy credits in bulk, down to about $0.02 per compile on Studio. Heavier modules cost more, and their rows carry indicative rates. | Operation | Credits | Pay-as-you-go | | --- | --- | --- | | **Standard compile** decimate + UV pack + ORM bake + convex collider | 5 | $0.05 | | **Fracture or VAT bake** INDICATIVE `simulate_fx_vat` Voronoi fracture or Vertex Animated Texture export | 10 to 20 | $0.10 to $0.20 | | **Cloth sim** INDICATIVE `simulate_fx_vat` XPBD cloth rollouts | 25+ | $0.25+ | | **Liquid sim** INDICATIVE `simulate_fx_vat` liquid rollouts | 25+ | $0.25+ | | **SHA-256 cache hit** re-running unchanged geometry | 0 | $0.00 | | **Dry run** `dry_run: true` pre-flight estimate | 0 | $0.00 | Every call returns `credits_est`, and a `dry_run: true` call shows the cost for free before you compile. **Enterprise** covers VPC and air-gapped deployment. You run the stripped Linux container (`libspatial_kernel.so` + Rust gateway) on your own NVIDIA L4/L40S/H100 hardware with zero external network calls. Questions? Read the [FAQ](https://appliedmanifold.com/faq/) or the [docs](https://appliedmanifold.com/docs/). --- Source: https://appliedmanifold.com/faq/ 1. [Home](https://appliedmanifold.com/) 2. FAQ §05 FAQ // README.FAQ # Frequently asked questions **README.FAQ** ### What is Spatial Compiler? Spatial Compiler is Applied Manifold's flagship GPU execution engine. Send raw .glb or CAD geometry over MCP or REST and get back decimated, UV-packed, physics-ready assets with structured telemetry. Its pyro module bakes fire, smoke, explosion and dust flipbook sheets from a spec file. ### Why not drive a desktop 3D tool from an agent? Spatial Compiler has no window, so an agent drives it from the command line and checks each result from a JSON report and one preview image. A misspelled key fails and names the nearest valid key, `spatial-compiler schema` lists every field, and each report warning names the setting to change. ### How do you prevent runaway AI agents from draining my credits? Every tool call supports `dry_run: true`, a zero-cost pre-flight estimate, and each key has an hourly velocity limit. When an agent re-runs unchanged geometry, the SHA-256 cache hit is free. Locally, `spatial-compiler check` validates a spec without touching the GPU, and draft bakes and `sweep` comparison sheets come before a final bake. ### Can we run this inside our own VPC or air-gapped cluster? Yes. Enterprise and robotics teams deploy our stripped Linux container (`libspatial_kernel.so` + Rust gateway) directly on their own NVIDIA L4/L40S/H100 hardware with zero external network calls. The local `spatial-compiler` program also keeps specs and bakes on your own machine. ### What comes after Spatial Compiler? Next is Spatial Runtime, a compressed GPU-native streaming SDK for real-time engines. After that comes Applied Manifold Cloud, high-throughput synthetic physics verification for robotics and world models. ### How do I connect Spatial Compiler to Claude Code, Cursor, or another MCP client? Point the client at the hosted MCP server, `https://mcp.spatialcompiler.dev`, which signs you in with an OAuth 2.1 browser login. For the local MCP server, add the `spatial-compiler` entry to your client's MCP config. The entry launches `npx -y @spatial-compiler/mcp` with your `SPATIAL_API_KEY` in the environment, and the docs page has the full JSON. ### How do I add Spatial Compiler to Claude Code? Run `/plugin marketplace add applied-manifold/spatial-compiler`, then `/plugin install spatial-compiler@applied-manifold`. The plugin carries the pyro guide and examples, and it finds the program that `scripts\install.bat` copies to `%USERPROFILE%\.spatial-compiler\bin`. ### Which operations does Spatial Compiler run? Two MCP tools cover the mesh pipeline. `compile_3d_asset` welds non-manifold edges, decimates to exact triangle budgets via meshoptimizer, packs xatlas UV atlases and bakes channel-packed ORM textures. `simulate_fx_vat` runs GPU XPBD cloth and Voronoi rigid-body fracture rollouts and exports Vertex Animated Textures (VATs). Convex collision hulls are part of the physics-ready output. ### Which commands does Spatial Compiler run? `spatial-compiler bake` turns a `.pyro.toml` spec into flipbook sheets, previews and a JSON report, and `spatial-compiler wire` writes a Godot 4 scene from a bake. `check` validates a spec without the GPU, `schema` prints every field, and `sweep` bakes variants onto one comparison sheet. ### What does it cost? Pricing starts at $0.05 per asset and goes as low as $0.02 on Studio. One credit is $0.01 pay-as-you-go, and a standard compile (decimate + UV pack + ORM bake + convex collider) is 5 credits ($0.05). Sandbox is free with 500 credits (~100 compiles). Pro is $29/mo for 5,000 credits (~1,000 compiles at ~$0.03 each), and Studio is $149/mo for 35,000 credits (~7,000 compiles at ~$0.02 each). Enterprise is custom, with VPC or air-gapped self-host. SHA-256 cache hits and dry runs cost 0 credits. ### How do credits work? One credit is $0.01, and a standard compile costs 5 credits. Heavier modules cost more, at indicative rates. A fracture or VAT bake is 10 to 20 credits, and a cloth or liquid sim is 25+ credits. SHA-256 cache hits and `dry_run: true` pre-flight estimates cost 0 credits. Every call returns `credits_est` in its telemetry. ### What architecture does Spatial Compiler use? Spatial Compiler runs a headless C++20 Vulkan 1.3 compute kernel, `spatial_kernel`, with a Buffer Device Address (BDA) arena. A memory-safe Rust gateway wraps the kernel and speaks MCP (over stdio and HTTP) and REST, and a SHA-256 content-addressed cache keys every result. The `spatial-compiler` command (short name `sc`) is a thin local program over the same library, verified on an NVIDIA GeForce RTX 2070 Super under Windows. ### Which engines can use the outputs? Mesh compiles return standard .glb (glTF 2.0) files that any engine loads. Pyro bakes go into Godot 4: `spatial-compiler wire` installs the six-way shader `flipbook_6way.gdshader` into a Godot project and writes a ready scene for a bake. ### Who builds Spatial Compiler? Applied Manifold, Inc. builds Spatial Compiler as its first product. The company builds cloud infrastructure for 3D physical reality. [Read the docs →](https://appliedmanifold.com/docs/) --- Source: https://appliedmanifold.com/use-cases/ 1. [Home](https://appliedmanifold.com/) 2. Use cases USE CASES // FOUR VERTICALS # Built for four pipelines Headless GPU compilation for 3D geometry and physics. Gen3D platforms, robotics teams, product catalogs and game, UGC and AEC tools each bring their own geometry, budgets and failure modes. - **01 // GEN3D** ## [Gen3D platforms](https://appliedmanifold.com/use-cases/gen3d/) Every text-to-3D or image-to-3D generation leaves your platform welded, on budget, UV-packed and ORM-baked. - weld - decimate - uv\_pack - orm\_bake - **02 // ROBOTICS · WORLD MODELS** ## [Robotics & world models](https://appliedmanifold.com/use-cases/robotics-world-models/) Get sim-ready convex colliders and a reproducible, content-addressed pipeline for synthetic data, hosted or in your own VPC. - convex\_hulls - seeded rollouts - sha-256 - air-gapped - **03 // E-COMMERCE 3D** ## [E-commerce configurators](https://appliedmanifold.com/use-cases/ecommerce-configurators/) Ship web-weight GLBs with LODs and baked materials for every SKU, inside your page-weight budget. - lod\_chain - orm\_bake - glb - page weight - **04 // GAMING · UGC · AEC** ## [AI gaming, UGC & AEC](https://appliedmanifold.com/use-cases/gaming-ugc-aec/) Pre-flight player uploads, AI-generated props and CAD/BIM geometry, clean them to engine budgets, and bake pyro effects for Godot 4. - dry\_run - decimate - convex\_hulls - pyro **COMMON TO ALL FOUR** - One API call per asset, over MCP (`@spatial-compiler/mcp`) or REST. - Typed JSON telemetry on every call, so pipelines verify results in code. - `dry_run: true` pre-flights and SHA-256 cache hits cost 0 credits. - The [pyro module](https://appliedmanifold.com/modules/pyro/) bakes fire, smoke, explosion and dust flipbooks for Godot 4. - From $0.05 per asset, as low as $0.02 on Studio. See [pricing](https://appliedmanifold.com/pricing/). Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) --- Source: https://appliedmanifold.com/use-cases/gen3d/ 1. [Home](https://appliedmanifold.com/) 2. [Use cases](https://appliedmanifold.com/use-cases/) 3. Gen3D platforms USE CASE // GEN3D PLATFORMS # Every generation, compiled to a production-ready asset. Text-to-3D and image-to-3D models emit dense, non-manifold meshes with no usable UVs. Put one API call after inference, and every output leaves your platform welded, decimated to budget, UV-packed, ORM-baked and collider-ready. Typed telemetry lets your pipeline check each one. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) From $0.05 per asset, as low as $0.02 on Studio. Sandbox includes 500 free credits. **PIPELINE // GEN3D ONE CALL** 1. IN gen\_0412.glb raw generation 2. [weld](https://appliedmanifold.com/docs/#op-weld) repair non-manifold edges 3. [decimate](https://appliedmanifold.com/docs/#op-decimate) target\_tris: 15,000 4. [uv\_pack](https://appliedmanifold.com/docs/#op-uv-pack) xatlas atlas 5. [orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) AO · roughness · metallic 6. [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) collider 7. OUT compiled .glb \+ telemetry.json Stages of one compile\_3d\_asset call (illustrative). 01 // PAIN → FIX ## Where raw generations break downstream Generation works well enough to ship, but the meshes users download usually need cleanup. 1. PAIN Raw generations are dense, non-manifold triangle soup. Users can’t drop them into an engine or a DCC tool without a cleanup pass. FIX `weld` repairs non-manifold edges, then `decimate` hits the exact `target_tris` of each export preset. 2. PAIN There are no usable UVs and no engine-ready materials, so “download” means an hour in someone else’s software. FIX `uv_pack` lays out a non-overlapping xatlas atlas and `orm_bake` packs occlusion, roughness and metallic into one texture. 3. PAIN Post-processing runs as headless Blender scripts on CPU workers, which adds another fleet to scale and maintain between inference and the user. FIX Each generation takes one MCP or REST call on a headless GPU kernel. Re-exporting an unchanged mesh is a SHA-256 cache hit at 0 credits. 4. PAIN You can’t tell an asset is broken without rendering it and looking. FIX Every call returns typed JSON telemetry (triangles in and out, draw calls, VRAM footprint), so your pipeline verifies each asset in code. 02 // OPERATIONS ## What runs on every generation One compile\_3d\_asset call runs five stages, and two controls keep a platform’s bill predictable. - ### [weld](https://appliedmanifold.com/docs/#op-weld) compile\_3d\_asset Closes the non-manifold edges generative models leave behind, so later stages work on clean topology. - ### [decimate](https://appliedmanifold.com/docs/#op-decimate) meshoptimizer Hits an exact `target_tris` per export preset: mobile, web or high detail from the same generation. - ### [uv\_pack](https://appliedmanifold.com/docs/#op-uv-pack) xatlas Lays out a non-overlapping UV atlas, so the asset can carry baked textures into any tool. - ### [orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) compile\_3d\_asset Packs occlusion, roughness and metallic into one texture in the same VRAM pass. - ### [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) physics-ready Adds convex colliders, so a generated prop can collide the moment it lands in a scene. - ### [dry\_run + cache](https://appliedmanifold.com/docs/#controls) 0 credits Pre-flight estimates and SHA-256 cache hits on re-exports cost nothing. 03 // EXAMPLE ILLUSTRATIVE ## Called from your generation pipeline An agent or worker calls the MCP tool right after inference and checks the telemetry before the asset reaches the user. mcp · tools/call · illustrative ```json { "jsonrpc": "2.0", "id": 412, "method": "tools/call", "params": { "name": "compile_3d_asset", "arguments": { "file": "generations/gen_0412.glb", "target_tris": 15000, "uv_pack": true, "bake": "orm", "collider": "convex", "dry_run": false } } } ``` telemetry.json · illustrative ```json { "status": "ok", "dry_run": false, "tris_in": 296000, "target_tris": 15000, "tris_out": 15000, "uv_atlas": "xatlas · non-overlapping", "textures": ["orm (packed)"], "collider": "convex", "cache": "MISS", "credits_est": 5 } ``` Illustrative output. Not measured. Numbers in the request are inputs and targets you choose. 04 // FAQ ## Gen3D questions [All questions →](https://appliedmanifold.com/faq/) **README.GEN3D** ### Which text-to-3D or image-to-3D models does it work with? It works with any model whose output you can export as .glb. Spatial Compiler operates on the mesh after inference, whichever generator produced it. ### Can each export preset use a different triangle budget? Yes. You set `target_tris` per call, so mobile, web and high-detail presets are different parameters on the same input. Each combination of input and options gets its own cache key. ### What does it cost per generation? A standard compile (decimate + UV pack + ORM bake + convex collider) is 5 credits: $0.05 pay-as-you-go, or about $0.02 on Studio. Re-exporting an unchanged mesh with the same options is a SHA-256 cache hit and costs 0 credits. ### How fast is a compile? Compiles run on a headless C++20 Vulkan kernel that keeps a persistent BDA arena warm in VRAM. Every call reports its wall time in the `elapsed_ms` telemetry field. ## Compile your next generation. From $0.05 per asset, as low as $0.02 on Studio. Signup includes 500 free sandbox credits (~100 compiles), and cache hits and dry runs cost 0 credits. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) [Pricing →](https://appliedmanifold.com/pricing/) [All use cases →](https://appliedmanifold.com/use-cases/) --- Source: https://appliedmanifold.com/use-cases/robotics-world-models/ 1. [Home](https://appliedmanifold.com/) 2. [Use cases](https://appliedmanifold.com/use-cases/) 3. Robotics & world models USE CASE // ROBOTICS · WORLD MODELS # Sim-ready assets for robotics and world models. Compile scanned and generated meshes into simulation-ready assets with convex colliders. The pipeline is content-addressed, so the same input and options always return the same output. Run it hosted, or self-host it inside your VPC or an air-gapped cluster. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) From $0.05 per asset, as low as $0.02 on Studio. Sandbox includes 500 free credits. **PIPELINE // SIM-READY REPRODUCIBLE** 1. IN shelf\_unit.glb scanned or generated 2. [weld](https://appliedmanifold.com/docs/#op-weld) repair non-manifold edges 3. [decimate](https://appliedmanifold.com/docs/#op-decimate) target\_tris: 20,000 4. [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) max\_hulls: 16 5. [voronoi\_fracture](https://appliedmanifold.com/docs/#op-voronoi-fracture) seed: 0x5EED 6. [sha-256](https://appliedmanifold.com/docs/#cache) same input → same output 7. OUT sim-ready .glb \+ colliders + telemetry.json Stages of compile\_3d\_asset + simulate\_fx\_vat (illustrative). 01 // PAIN → FIX ## Why raw meshes stall a simulation pipeline Synthetic data depends on clean assets and on your ability to regenerate the data exactly. 1. PAIN Scanned and generated meshes arrive non-manifold, far too dense for contact and without collision geometry. FIX `weld` and `decimate` to a contact-friendly budget, then `convex_hulls` emits convex colliders for your simulator. 2. PAIN Ad-hoc conversion scripts drift between runs, versions and machines, so a team cannot regenerate a dataset to debug it. FIX A SHA-256 hash of input and options keys every result, so the same input returns the same key and output. Fracture rollouts are seeded. 3. PAIN World models need many physically varied scenes, and CPU-bound asset prep becomes the bottleneck of the data pipeline. FIX Batch over REST from your data pipeline, add seeded Voronoi fracture and XPBD cloth rollouts for variation, and `dry_run` a large job first. 4. PAIN Robot logs, facility scans and proprietary CAD can’t leave your network. FIX Self-host the stripped Linux container (`libspatial_kernel.so` + Rust gateway) on your own NVIDIA L4/L40S/H100 hardware, with zero external network calls. 02 // OPERATIONS ## Operations for simulation assets Geometry cleanup, colliders and seeded physics rollouts all sit behind one content-addressed cache. - ### [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) physics-ready Builds convex collision hulls from the cleaned mesh, the collision geometry a rigid-body simulator expects. - ### [weld + decimate](https://appliedmanifold.com/docs/#op-decimate) compile\_3d\_asset Produces manifold topology at an explicit `target_tris`, so contact and collision stay tractable. - ### [voronoi\_fracture](https://appliedmanifold.com/docs/#op-voronoi-fracture) simulate\_fx\_vat Runs seeded Voronoi rigid-body fracture rollouts on the GPU for breakage and debris variation in synthetic scenes. - ### [xpbd\_cloth](https://appliedmanifold.com/docs/#op-xpbd-cloth) simulate\_fx\_vat Runs GPU XPBD cloth rollouts for deformables such as drapes, covers and soft goods. - ### [sha-256 cache](https://appliedmanifold.com/docs/#cache) reproducibility Keys results by a hash of input and options, so re-runs of unchanged inputs are cache hits at 0 credits. - ### [self-host](https://appliedmanifold.com/docs/#self-host) VPC · air-gapped Runs the same kernel and gateway as a stripped Linux container on your own GPUs (Enterprise plan). 03 // EXAMPLE ILLUSTRATIVE ## Same input, same output A data pipeline compiles a scanned asset over REST. Run it again with the same input and options and you get a cache hit with the same output hash. terminal · REST · illustrative ```sh curl -X POST https://api.spatialcompiler.dev/v1/compile \ -H "Authorization: Bearer sk_test_spatial_sandbox" \ -F "file=@shelf_unit.glb" \ -F 'options={"target_tris":20000,"collider":"convex","max_hulls":16,"dry_run":false}' ``` telemetry.json · illustrative ``` [ { "run": 1, "status": "ok", "input_sha256": "3f9a…c41e", "tris_in": 412000, "target_tris": 20000, "tris_out": 20000, "collider": "convex", "max_hulls": 16, "cache": "MISS", "credits_est": 5, "output_sha256": "b71d…09aa" }, { "run": 2, "status": "ok", "input_sha256": "3f9a…c41e", "cache": "HIT", "credits_est": 0, "output_sha256": "b71d…09aa" } ] ``` Illustrative output. Not measured. Numbers in the request are inputs and targets you choose. 04 // FAQ ## Robotics & world-model questions [All questions →](https://appliedmanifold.com/faq/) **README.SIM** ### Are outputs deterministic and reproducible? Yes. A SHA-256 hash of the input and options keys every result, so the same input returns the same key and the same output. Fracture rollouts are seeded. ### Can we run it inside our VPC or an air-gapped cluster? Yes, on the Enterprise plan. You deploy the stripped Linux container (`libspatial_kernel.so` + Rust gateway) on your own NVIDIA L4/L40S/H100 hardware with zero external network calls. ### Does it replace our simulator? No. Spatial Compiler prepares the assets your simulator loads. It cleans geometry, builds convex colliders and runs seeded physics rollouts, then returns standard .glb files with JSON telemetry. ### What does a sim-ready asset cost? A standard compile, with its convex collider, is 5 credits: $0.05 pay-as-you-go, or about $0.02 on Studio. Fracture or VAT bakes are 10 to 20 credits at indicative rates, and SHA-256 cache hits cost 0 credits. ## Make your next scene sim-ready. From $0.05 per asset, as low as $0.02 on Studio. Signup includes 500 free sandbox credits (~100 compiles), and cache hits and dry runs cost 0 credits. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) [Pricing →](https://appliedmanifold.com/pricing/) [All use cases →](https://appliedmanifold.com/use-cases/) --- Source: https://appliedmanifold.com/use-cases/ecommerce-configurators/ 1. [Home](https://appliedmanifold.com/) 2. [Use cases](https://appliedmanifold.com/use-cases/) 3. E-commerce configurators USE CASE // E-COMMERCE 3D · AR # Web-weight 3D for every SKU in the catalog. Compile heavy CAD and DCC product models into web-weight GLBs with LODs and baked materials for your 3D product configurator. Each SKU is one API call, and your pipeline reruns it automatically whenever the catalog changes. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) From $0.05 per asset, as low as $0.02 on Studio. Sandbox includes 500 free credits. **PIPELINE // PRODUCT 3D PER SKU** 1. IN sku\_4471\_armchair.glb CAD / DCC export 2. [weld](https://appliedmanifold.com/docs/#op-weld) clean CAD seams 3. [lod\_chain](https://appliedmanifold.com/docs/#op-lod-chain) 60k · 20k · 5k tris 4. [uv\_pack](https://appliedmanifold.com/docs/#op-uv-pack) one atlas 5. [orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) one packed texture 6. OUT web .glb × 3 LODs \+ telemetry.json Stages of one compile\_3d\_asset call (illustrative). 01 // PAIN → FIX ## Why product 3D is heavy to ship A configurator loads at the speed of its heaviest model, and the catalog keeps changing. 1. PAIN Product models arrive as CAD or DCC exports with millions of triangles, far too heavy for a mobile product page. FIX `decimate` to an exact `target_tris` per LOD. Telemetry reports triangles and VRAM so your pipeline enforces the page-weight budget before publishing. 2. PAIN Every colorway, material and variant multiplies the files someone has to optimize by hand. FIX Each SKU is one API call from your catalog pipeline. Unchanged models are SHA-256 cache hits and cost 0 credits when the pipeline reruns. 3. PAIN PBR materials ship as a pile of separate textures, adding requests and weight to every product view. FIX `uv_pack` lays out one clean atlas and `orm_bake` packs occlusion, roughness and metallic into a single texture. 02 // OPERATIONS ## Operations for product configurators These operations cover everything between a CAD export and a model that loads quickly on a phone. - ### [lod\_chain](https://appliedmanifold.com/docs/#op-lod-chain) compile\_3d\_asset Decimates the same product to several triangle budgets, so the viewer can load the light one first. - ### [decimate](https://appliedmanifold.com/docs/#op-decimate) meshoptimizer Sets an exact `target_tris` per LOD, so the triangle budget behind your page weight is a number you choose. - ### [weld](https://appliedmanifold.com/docs/#op-weld) compile\_3d\_asset Repairs the open seams and non-manifold edges CAD tessellation leaves behind. - ### [uv\_pack](https://appliedmanifold.com/docs/#op-uv-pack) xatlas Lays out one non-overlapping atlas per product, ready for baked materials. - ### [orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) compile\_3d\_asset Packs occlusion, roughness and metallic into one texture, so each product view makes fewer requests. - ### [cache + dry\_run](https://appliedmanifold.com/docs/#controls) 0 credits Unchanged SKUs are free cache hits; dry runs estimate a full catalog rebuild before you start it. 03 // EXAMPLE ILLUSTRATIVE ## One SKU, three LODs Your catalog pipeline sends a changed product over REST and checks every LOD against the page budget before it goes live. terminal · REST · illustrative ```sh curl -X POST https://api.spatialcompiler.dev/v1/compile \ -H "Authorization: Bearer sk_test_spatial_sandbox" \ -F "file=@sku_4471_armchair.glb" \ -F 'options={"lods":[60000,20000,5000],"bake":"orm","format":"glb","dry_run":false}' ``` telemetry.json · illustrative ```json { "status": "ok", "tris_in": 1840000, "lods": [ { "target_tris": 60000, "tris_out": 60000 }, { "target_tris": 20000, "tris_out": 20000 }, { "target_tris": 5000, "tris_out": 5000 } ], "textures": ["orm (packed)"], "cache": "MISS" } ``` Illustrative output. Not measured. Numbers in the request are inputs and targets you choose. 04 // FAQ ## E-commerce 3D questions [All questions →](https://appliedmanifold.com/faq/) **README.CATALOG** ### Which format does it export for the web? The output is .glb (glTF binary), which browser 3D viewers and configurators load directly. ### Can we enforce a page-weight budget per product? Yes. Set a `target_tris` budget for each LOD. Your catalog pipeline then checks the returned telemetry (triangle counts, draw calls, VRAM footprint) before it publishes a model. ### What happens when only a few SKUs change? Only the changed models cost credits. Unchanged models with unchanged options are SHA-256 cache hits at 0 credits. Before a full catalog rebuild, `dry_run: true` estimates its cost. ### What does it cost per SKU? A SKU costs from $0.05 pay-as-you-go (a standard compile is 5 credits) and as little as about $0.02 on Studio. Sandbox includes 500 free credits. ## Put your catalog on a page-weight budget. From $0.05 per asset, as low as $0.02 on Studio. Signup includes 500 free sandbox credits (~100 compiles), and cache hits and dry runs cost 0 credits. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) [Pricing →](https://appliedmanifold.com/pricing/) [All use cases →](https://appliedmanifold.com/use-cases/) --- Source: https://appliedmanifold.com/use-cases/gaming-ugc-aec/ 1. [Home](https://appliedmanifold.com/) 2. [Use cases](https://appliedmanifold.com/use-cases/) 3. AI gaming, UGC & AEC USE CASE // AI GAMING · UGC · AEC # Clean untrusted geometry to engine budgets. AI game engines, UGC platforms and AEC tools ingest geometry they don’t control: player uploads, AI-generated props, CAD and BIM exports. Pre-flight each file, clean it to a triangle budget and add colliders and VAT effects over MCP or REST, with spend capped per key. For fire, smoke and dust, the [pyro module](https://appliedmanifold.com/modules/pyro/) bakes flipbooks for Godot 4. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) From $0.05 per asset, as low as $0.02 on Studio. Sandbox includes 500 free credits. **PIPELINE // UGC · AEC PER UPLOAD** 1. IN upload\_88213.glb player · AI · BIM 2. [dry\_run](https://appliedmanifold.com/docs/#dry-run) pre-flight · 0 credits 3. [weld + decimate](https://appliedmanifold.com/docs/#op-decimate) target\_tris: 8,000 4. [uv\_pack + orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) one material 5. [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) collider 6. [vat\_export](https://appliedmanifold.com/docs/#op-vat-export) fracture · cloth, optional 7. OUT game-ready .glb \+ telemetry.json Stages of one upload (illustrative). 01 // PAIN → FIX ## Geometry you don’t control Uploads, generated content and CAD models arrive at sizes and in shapes you can’t predict. 1. PAIN Player uploads and AI-generated props arrive with unpredictable topology and triangle counts that blow frame budgets. FIX `weld` + `decimate` to the platform’s triangle budget, `uv_pack` + `orm_bake` into one material, and `convex_hulls` so props collide. 2. PAIN Untrusted upload volume or a runaway agent can run up the bill unnoticed. FIX `dry_run: true` pre-flights every upload at 0 credits so you can reject what doesn’t fit. Per-key hourly velocity limits cap spend; duplicates are cache hits. 3. PAIN CAD and BIM exports carry millions of triangles of fasteners, fillets and fine detail, far over a real-time budget for walkthroughs and design review. FIX Compile them to an explicit triangle budget with welded topology and baked materials, through the same API as every other asset. 4. PAIN Destruction and cloth effects cost CPU every frame at runtime. FIX `simulate_fx_vat` bakes Voronoi fracture and XPBD cloth into Vertex Animated Textures with drop-in shaders, so playback costs zero CPU. 5. PAIN Fire, smoke and explosions need flipbook sheets that someone has to simulate, render, pack and wire into the engine by hand. FIX The [pyro module](https://appliedmanifold.com/modules/pyro/) bakes six-way lit flipbook sheets from a `.pyro.toml` spec, and `spatial-compiler wire` installs `flipbook_6way.gdshader` into a Godot project and writes a ready scene for each bake. 02 // OPERATIONS ## Operations for live platforms These operations enforce budgets and add physics and effects for content that arrives at upload volume. - ### [dry\_run](https://appliedmanifold.com/docs/#dry-run) 0 credits Pre-flight every upload and reject what doesn’t fit before anything is billed. - ### [weld + decimate](https://appliedmanifold.com/docs/#op-decimate) compile\_3d\_asset Produces clean topology at the platform’s `target_tris` for player uploads and CAD/BIM alike. - ### [uv\_pack + orm\_bake](https://appliedmanifold.com/docs/#op-orm-bake) compile\_3d\_asset Builds one atlas and one packed ORM texture, so each asset uses one material and fewer draw calls. - ### [convex\_hulls](https://appliedmanifold.com/docs/#op-convex-hulls) physics-ready Adds colliders to uploaded props, so they take part in physics the moment they spawn. - ### [voronoi\_fracture + vat\_export](https://appliedmanifold.com/docs/#op-vat-export) simulate\_fx\_vat Bakes destruction and cloth to Vertex Animated Textures with drop-in shaders. - ### [velocity limits](https://appliedmanifold.com/docs/#limits) per key Caps each key per hour, so an upload spike or a looping agent can’t drain credits. 03 // EXAMPLE ILLUSTRATIVE ## Pre-flight, then compile A moderation worker dry-runs each upload over MCP, rejects what doesn’t fit, then compiles the rest to the platform budget. mcp · tools/call · illustrative ```json { "jsonrpc": "2.0", "id": 88213, "method": "tools/call", "params": { "name": "compile_3d_asset", "arguments": { "file": "uploads/u_88213/castle_gate.glb", "target_tris": 8000, "collider": "convex", "dry_run": true } } } ``` telemetry.json · illustrative ``` [ { "call": "dry_run", "status": "ok", "dry_run": true, "tris_in": 264000, "target_tris": 8000, "cache": "MISS", "credits_est": 0 }, { "call": "compile", "status": "ok", "dry_run": false, "tris_out": 8000, "collider": "convex", "credits_est": 5 } ] ``` Illustrative output. Not measured. Numbers in the request are inputs and targets you choose. 04 // FAQ ## Gaming, UGC & AEC questions [All questions →](https://appliedmanifold.com/faq/) **README.UGC** ### Which engines can load the output? Mesh compiles return standard .glb (glTF 2.0). Pyro bakes go into Godot 4: `spatial-compiler wire` installs the six-way shader `flipbook_6way.gdshader` into a Godot project and writes a ready scene for each bake. ### How do we stop upload spikes or runaway agents from draining credits? Pre-flight every upload with `dry_run: true` (0 credits) and reject what does not fit. Per-key hourly velocity limits cap spend, and duplicate uploads are SHA-256 cache hits that cost 0 credits. ### Does it handle CAD and BIM geometry for AEC? Yes. The same pipeline welds CAD and BIM geometry, decimates it to an explicit triangle budget and bakes its materials. Teams can then review the models in real-time viewers. ### What do fracture and VAT bakes cost? A standard compile is 5 credits ($0.05). Fracture or VAT bakes are 10 to 20 credits and cloth sims are 25+ credits, both at indicative rates. ## Pre-flight your next upload. From $0.05 per asset, as low as $0.02 on Studio. Signup includes 500 free sandbox credits (~100 compiles), and cache hits and dry runs cost 0 credits. Get Free API Key [Read the docs →](https://appliedmanifold.com/docs/) [Pyro module →](https://appliedmanifold.com/modules/pyro/) [Pricing →](https://appliedmanifold.com/pricing/) [All use cases →](https://appliedmanifold.com/use-cases/) --- Source: https://appliedmanifold.com/about/ 1. [Home](https://appliedmanifold.com/) 2. About ABOUT // APPLIED MANIFOLD, INC. # The spatial compute cloud for 3D reality. Applied Manifold builds cloud infrastructure for 3D physical reality, starting with Spatial Compiler. ## Company **Applied Manifold, Inc.** builds Spatial Compiler. For thirty years, 3D software was built for humans clicking inside heavy desktop viewports. We took the opposite engineering direction and built headless, stateless GPU compute that software and AI agents can call in a tight loop. ## Now: Spatial Compiler [Spatial Compiler](https://appliedmanifold.com/docs/) (`@spatial-compiler/mcp`) is a headless C++20 Vulkan 1.3 kernel with a Buffer Device Address (BDA) arena. A memory-safe Rust gateway wraps the kernel and speaks MCP over stdio, MCP over HTTP at `https://mcp.spatialcompiler.dev`, and REST. The kernel welds, decimates (meshoptimizer), UV-packs (xatlas) and ORM-bakes geometry, and it builds convex hulls. It also runs XPBD cloth and Voronoi fracture and exports VATs. A SHA-256 content-addressed cache, `dry_run: true` pre-flight and per-key hourly velocity limits control what agents spend. The same core library, `spatial_kernel`, runs as a local program, `spatial-compiler` (short name `sc`), with a Claude plugin that carries the guide and examples. Its [pyro](https://appliedmanifold.com/modules/pyro/) module bakes fire, smoke, explosion and dust flipbook sheets for Godot 4. ## Domains Our domains are appliedmanifold.com, appliedmanifold.dev and spatialcompiler.dev. --- Source: https://appliedmanifold.com/changelog/ 1. [Home](https://appliedmanifold.com/) 2. Changelog CHANGELOG // RELEASE NOTES # Changelog What changed in each Spatial Compiler release, newest first. Release notes appear here as versions ship. --- Source: https://appliedmanifold.com/terms/ 1. [Home](https://appliedmanifold.com/) 2. Terms (draft) LEGAL // DRAFT, NOT LEGAL TERMS # Terms of Service DRAFT, NOT LEGAL TERMS. This page is a placeholder. DRAFT **DRAFT, NOT LEGAL TERMS.** This placeholder creates no rights or obligations. These terms will govern use of Spatial Compiler, the API and this website once they are written and reviewed. Applied Manifold, Inc. (entity being formed). --- Source: https://appliedmanifold.com/privacy/ 1. [Home](https://appliedmanifold.com/) 2. Privacy (draft) LEGAL // DRAFT, NOT LEGAL TERMS # Privacy Policy DRAFT, NOT LEGAL TERMS. This page is a placeholder. DRAFT **DRAFT, NOT LEGAL TERMS.** This placeholder creates no rights or obligations. This website sets no cookies, loads no analytics and makes no third-party network requests. A full policy covering the API and accounts will replace this draft. Applied Manifold, Inc. (entity being formed).