---
title: "FAQ: Spatial Compiler by Applied Manifold"
description: "Spatial Compiler FAQ: what it is, MCP and REST setup, spend controls for runaway agents, VPC and air-gapped deployment, pricing, architecture and engines."
canonical: https://appliedmanifold.com/faq/
site: "Applied Manifold: The spatial compute cloud for 3D reality."
---

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/)
