Text to 3D — From One Sentence to Game-Ready 3D
No mesh library, no downloads, no manual modeling — one line of description becomes a lit, textured, cinematically framed 3D asset in about a minute, right in the browser. Inside the zero-asset procedural engine where an LLM writes the spec and a VLM grades the render, with fully measured numbers.
Written by — NEXUS AI Labs
The first wall you hit when building a game prototype isn't code — it's assets. Every streetlight and park bench means digging through asset stores, checking licenses, fixing the scale and materials of a downloaded mesh, cleaning up polygons. Everyone has wished they could just describe an object in a sentence and get 3D back. The problem is that existing Text-to-3D never produced 3D you could actually use in a game.
Diffusion-based 3D generators make impressive demos, but the output is mostly a scan-like blob with messy topology. Generation takes minutes to tens of minutes, textures come baked and hard to edit, and there's no lighting at all. Getting it into a game engine still means retopology and material rework. We took a different approach — we don't generate meshes, we generate specs.
Don't generate the mesh — generate the spec
The LLM in Text to 3D never touches a vertex. Instead it writes a parametric spec in a compact JSON DSL: which primitives to combine and how, material roughness and metallic values, lathe profiles for revolved shapes like vases, building macros that describe structures as floors and window patterns, and even the camera framing for how the scene should be presented. The actual geometry and seamless procedural textures are assembled by a Three.js builder that reads the spec.
A self-correcting five-stage pipeline
From prompt to finished asset, the pipeline passes through five stages. Each stage corrects failures in place instead of passing them downstream.
- Prompt — one line of natural language, like 'a Japanese garden with a moss-covered stone lantern.'
- LLM parametric spec — a compact JSON DSL covering primitive composition, materials, lathe profiles, building macros, lights, and camera framing.
- Validation & auto-repair — the full spec is schema-validated; violations go back to the model, which returns a repaired spec.
- Procedural build — Three.js reads the spec, assembles the geometry, and applies PBR materials with seamless procedural textures.
- VLM refinement — a VLM art director grades the render and rewrites the spec to raise quality pass after pass.
{
"name": "moss_stone_lantern",
"parts": [
{ "kind": "lathe", "profile": [[0.4,0],[0.5,0.15],[0.3,0.9],[0.55,1.1]],
"mat": { "base": "#8a8f84", "rough": 0.92, "moss": 0.35 } },
{ "kind": "box", "size": [0.7,0.25,0.7], "pos": [0,1.2,0],
"mat": { "base": "#6f7468", "rough": 0.88 } }
],
"lights": [{ "type": "point", "pos": [0,0.95,0], "color": "#ffb45e", "intensity": 2.1 }],
"camera": { "orbit": [32,-14], "fov": 35, "framing": "hero" }
}The side effects of this structure are powerful. Because the asset is data — 4.7 KB of JSON on average — it can be diffed, version-controlled, and remixed: copy someone's asset from the gallery, tweak the spec, make it yours. None of that is possible with a 100 MB binary mesh.
The VLM art director — grade the render, rewrite the spec
Schema validation only guarantees the spec is valid. Whether it looks good is a separate question. That's why a VLM art director sits at the end of the pipeline. It's shown a render of the built scene, grades composition, materials, lighting, and silhouette, then feeds fixes for the weak areas back as a spec rewrite. On our test scenes we measured a score improvement from 4 to 5 every pass. It plays the role of the human saying 'a bit darker, camera to the left.'
Numbers — all of them measured
Generative AI product numbers are usually best-case cherry-picks. These aren't — we measured all 46 assets in the library, and rendering numbers were taken with the full post-processing stack (GTAO, Bloom, vignette-grain grade) turned on.
Into the game engine — one-click GLB
3D that only looks good inside a browser is half a product. Text to 3D exports GLB (binary glTF) in one click. Procedural textures are embedded as PNG, and lights ship inside the file via the KHR_lights_punctual extension. The largest 117-part scene exports in 145 ms at 3.2 MB — and opens directly in Blender, Unity, Unreal, and three.js. The chronic Text-to-3D problem of 'it generated, but I can't import it' is solved by standing on a format standard.
Limits and what comes next
Being honest: parametric primitive composition is strong for man-made things — architecture, props, furniture — but organic shapes like characters and animals are still hard. Procedural textures are seamless but fall short of photographic detail. And as specs grow, the LLM's spatial reasoning gets shaky, so part placement in very large scenes can look off.
Two things are next. First, part-hierarchy animation — adding rigging data to the spec so doors open and pinwheels spin. Second, multi-asset composition — an LLM planner that assembles larger scenes out of existing gallery assets.
The bottleneck in 3D isn't modeling skill — it's the time it takes to start. Text to 3D exists to shrink that time to a single sentence.
— NEXUS AI Labs
No install, no downloads. Type one prompt in the browser and about a minute later you're holding a GLB with the lights included. Start by opening other people's asset specs in the gallery.
