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.

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 repair non-manifold edges
  3. decimate target_tris: 15,000
  4. uv_pack xatlas atlas
  5. orm_bake AO · roughness · metallic
  6. 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 compile_3d_asset

    Closes the non-manifold edges generative models leave behind, so later stages work on clean topology.

  • decimate meshoptimizer

    Hits an exact target_tris per export preset: mobile, web or high detail from the same generation.

  • uv_pack xatlas

    Lays out a non-overlapping UV atlas, so the asset can carry baked textures into any tool.

  • orm_bake compile_3d_asset

    Packs occlusion, roughness and metallic into one texture in the same VRAM pass.

  • convex_hulls physics-ready

    Adds convex colliders, so a generated prop can collide the moment it lands in a scene.

  • dry_run + cache 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
{
  "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
{
  "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 →

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.

All use cases →